package goblint

  1. Overview
  2. Docs
package goblint
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include All end
include module type of Batteries with module Format := Batteries.Format
module Legacy = All.Legacy
module Array = All.Array
module Buffer = All.Buffer
module Bytes = All.Bytes
type bytes = Bytes.t
module Char = All.Char
module Complex = All.Complex
module Digest = All.Digest
module Either = All.Either
module Gc = All.Gc
module Genlex = All.Genlex
module Hashtbl = All.Hashtbl
module Int32 = All.Int32
module Int64 = All.Int64
module Lexing = All.Lexing
module List = All.List
module Map = All.Map
module Marshal = All.Marshal
module Nativeint = All.Nativeint
module Printexc = All.Printexc
module Printf = All.Printf
module Queue = All.Queue
module Random = All.Random
module Scanf = All.Scanf
module Set = All.Set
module Stack = All.Stack
module Stream = All.Stream
module String = All.String
module Sys = All.Sys
module Unix = All.Unix
module Big_int = All.Big_int
module Num = All.Num
module Bigarray = All.Bigarray
module Base64 = All.Base64
module BitSet = All.BitSet
module Bit_set = All.Bit_set
module Dllist = All.Dllist
module DynArray = All.DynArray
module Enum = All.Enum
module File = All.File
module Global = All.Global
module IO = All.IO
module LazyList = All.LazyList
module MultiPMap = All.MultiPMap
module Option = All.Option
module RefList = All.RefList
module Ref = All.Ref
module Cache = All.Cache
module CharParser = All.CharParser
module Deque = All.Deque
module Hashcons = All.Hashcons
module Heap = All.Heap
module FingerTree = All.FingerTree
module Logger = All.Logger
module MultiMap = All.MultiMap
module ParserCo = All.ParserCo
module Result = All.Result
module Return = All.Return
module Seq = All.Seq
module Substring = All.Substring
module Tuple = All.Tuple
module Tuple2 = All.Tuple2
module Tuple3 = All.Tuple3
module Tuple4 = All.Tuple4
module Tuple5 = All.Tuple5
module Vect = All.Vect
module ISet = All.ISet
module IMap = All.IMap
module Splay = All.Splay
module Uref = All.Uref
module UChar = All.UChar
module UTF8 = All.UTF8
module Text = All.Text
module Concurrent = All.Concurrent
module Interfaces = All.Interfaces
module Number = All.Number
module Float = All.Float
module Int = All.Int
module Bool = All.Bool
module Unit = All.Unit
module Filename = All.Filename
module Incubator = All.Incubator
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
  • deprecated Use (&&) instead.
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
  • deprecated Use (||) instead.
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
val min_int : int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val lnot : int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type nonrec fpclass = Stdlib.Pervasives.fpclass =
  1. | FP_normal
  2. | FP_subnormal
  3. | FP_zero
  4. | FP_infinite
  5. | FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val ignore : 'a -> unit
val string_of_bool : bool -> string
val bool_of_string : string -> bool
val bool_of_string_opt : string -> bool option
val string_of_int : int -> string
val int_of_string : string -> int
val int_of_string_opt : string -> int option
val string_of_float : float -> string
val float_of_string : string -> float
val float_of_string_opt : string -> float option
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
type nonrec in_channel = Stdlib.Pervasives.in_channel
type nonrec out_channel = Stdlib.Pervasives.out_channel
val print_char : char -> unit
val print_string : string -> unit
val print_bytes : bytes -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_bytes : bytes -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val read_line : unit -> string
val read_int : unit -> int
val read_int_opt : unit -> int option
val read_float : unit -> float
val read_float_opt : unit -> float option
type nonrec open_flag = Stdlib.Pervasives.open_flag =
  1. | Open_rdonly
  2. | Open_wronly
  3. | Open_append
  4. | Open_creat
  5. | Open_trunc
  6. | Open_excl
  7. | Open_binary
  8. | Open_text
  9. | Open_nonblock
val output_bytes : Stdlib.out_channel -> bytes -> unit
val seek_out : Stdlib.out_channel -> int -> unit
val pos_out : Stdlib.out_channel -> int
val out_channel_length : Stdlib.out_channel -> int
val set_binary_mode_out : Stdlib.out_channel -> bool -> unit
val really_input_string : Stdlib.in_channel -> int -> string
val seek_in : Stdlib.in_channel -> int -> unit
val pos_in : Stdlib.in_channel -> int
val in_channel_length : Stdlib.in_channel -> int
val set_binary_mode_in : Stdlib.in_channel -> bool -> unit
module LargeFile = All.LargeFile
type nonrec !'a ref = 'a Stdlib.Pervasives.ref = {
  1. mutable contents : 'a;
}
val ref : 'a -> 'a ref
val (!) : 'a ref -> 'a
val (:=) : 'a ref -> 'a -> unit
val incr : int ref -> unit
val decr : int ref -> unit
type (!'a, !'b, !'c, !'d, !'e, !'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.Pervasives.format6
type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'd) Stdlib.Pervasives.format4
type (!'a, !'b, !'c) format = ('a, 'b, 'c) Stdlib.Pervasives.format
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6
val exit : int -> 'a
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val do_at_exit : unit -> unit
val input_lines : Stdlib.Pervasives.in_channel -> string BatEnum.t
val input_chars : Stdlib.Pervasives.in_channel -> char BatEnum.t
val input_list : Stdlib.Pervasives.in_channel -> string list
val input_all : Stdlib.Pervasives.in_channel -> string
val dump : 'a -> string
val print_any : 'b BatIO.output -> 'a -> unit
val (@) : 'a list -> 'a list -> 'a list
val stdin : BatIO.input
val stdout : unit BatIO.output
val stderr : unit BatIO.output
val stdnull : unit BatIO.output
val flush_all : unit -> unit
val print_bool : bool -> unit
val print_guess : 'a BatIO.output -> 'b -> unit
val print_all : BatIO.input -> unit
val prerr_bool : bool -> unit
val prerr_guess : 'a -> unit
val prerr_all : BatIO.input -> unit
val output_file : filename:string -> text:string -> unit
val open_out : ?mode:BatFile.open_out_flag list -> ?perm:BatFile.permission -> string -> unit BatIO.output
val open_out_bin : string -> unit BatIO.output
val open_out_gen : Stdlib.open_flag list -> int -> string -> unit BatIO.output
val flush : unit BatIO.output -> unit
val output_char : unit BatIO.output -> char -> unit
val output_string : unit BatIO.output -> string -> unit
val output : unit BatIO.output -> Stdlib.Bytes.t -> int -> int -> unit
val output_substring : unit BatIO.output -> string -> int -> int -> unit
val output_byte : unit BatIO.output -> int -> unit
val output_binary_int : unit BatIO.output -> int -> unit
val output_binary_float : unit BatIO.output -> float -> unit
val output_value : unit BatIO.output -> 'a -> unit
val close_out : unit BatIO.output -> unit
val close_out_noerr : unit BatIO.output -> unit
val input_file : ?bin:bool -> string -> string
val open_in : ?mode:BatFile.open_in_flag list -> ?perm:BatFile.permission -> string -> BatIO.input
val open_in_bin : string -> BatIO.input
val open_in_gen : Stdlib.open_flag list -> int -> string -> BatIO.input
val input_char : BatIO.input -> char
val input_line : BatIO.input -> string
val input : BatIO.input -> Stdlib.Bytes.t -> int -> int -> int
val really_input : BatIO.input -> Stdlib.Bytes.t -> int -> int -> unit
val input_byte : BatIO.input -> int
val input_binary_int : BatIO.input -> int
val input_binary_float : BatIO.input -> float
val input_value : BatIO.input -> 'a
val close_in : BatIO.input -> unit
val close_in_noerr : BatIO.input -> unit
val identity : 'a -> 'a
val undefined : ?message:string -> 'a -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (%) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val (|>) : 'a -> ('a -> 'b) -> 'b
val (%>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val (|?) : 'a option -> 'a -> 'a
val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val curry : (('a * 'b) -> 'c) -> 'a -> 'b -> 'c
val uncurry : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
val neg : ('a -> bool) -> 'a -> bool
val neg2 : ('a -> 'b -> bool) -> 'a -> 'b -> bool
val const : 'a -> 'b -> 'a
val unique : unit -> int
val tap : ('a -> unit) -> 'a -> 'a
val finally : (unit -> unit) -> ('a -> 'b) -> 'a -> 'b
val with_dispose : dispose:('a -> unit) -> ('a -> 'b) -> 'a -> 'b
val forever : ('a -> 'b) -> 'a -> unit
val ignore_exceptions : ('a -> 'b) -> 'a -> unit
val verify_arg : bool -> string -> unit
val args : unit -> string BatEnum.t
val invisible_args : int Stdlib.ref
val exe : string
val foreach : 'a BatEnum.t -> ('a -> unit) -> unit
val iter : ('a -> unit) -> 'a BatEnum.t -> unit
val map : ('a -> 'b) -> 'a BatEnum.t -> 'b BatEnum.t
val filter_map : ('a -> 'b option) -> 'a BatEnum.t -> 'b BatEnum.t
val reduce : ('a -> 'a -> 'a) -> 'a BatEnum.t -> 'a
val fold : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b
val scanl : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b BatEnum.t
val (/@) : 'a BatEnum.t -> ('a -> 'b) -> 'b BatEnum.t
val (@/) : ('a -> 'b) -> 'a BatEnum.t -> 'b BatEnum.t
val (//@) : 'a BatEnum.t -> ('a -> 'b option) -> 'b BatEnum.t
val (@//) : ('a -> 'b option) -> 'a BatEnum.t -> 'b BatEnum.t
val exists : ('a -> bool) -> 'a BatEnum.t -> bool
val for_all : ('a -> bool) -> 'a BatEnum.t -> bool
val find : ('a -> bool) -> 'a BatEnum.t -> 'a
val peek : 'a BatEnum.t -> 'a option
val get : 'a BatEnum.t -> 'a option
val push : 'a BatEnum.t -> 'a -> unit
val junk : 'a BatEnum.t -> unit
val filter : ('a -> bool) -> 'a BatEnum.t -> 'a BatEnum.t
val (//) : 'a BatEnum.t -> ('a -> bool) -> 'a BatEnum.t
val (--) : int -> int -> int BatEnum.t
val (--^) : int -> int -> int BatEnum.t
val (--.) : (float * float) -> float -> float BatEnum.t
val (---) : int -> int -> int BatEnum.t
val (--~) : char -> char -> char BatEnum.t
val print : ?first:string -> ?last:string -> ?sep:string -> ('a BatInnerIO.output -> 'b -> unit) -> 'a BatInnerIO.output -> 'b BatEnum.t -> unit
type (!'a, !'e) result = ('a, 'e) BatInnerPervasives.result =
  1. | Ok of 'a
  2. | Error of 'e
val ignore_ok : ('a, exn) result -> unit
val ok : ('a, exn) result -> 'a
val wrap : ('a -> 'b) -> 'a -> ('b, exn) result
val lock : BatConcurrent.lock Stdlib.ref
module Format = All.Format
val comp2 : ('a -> 'a -> 'b) -> ('c -> 'a) -> 'c -> 'c -> 'b
val compareBy : ?cmp:('a -> 'a -> int) -> ('b -> 'a) -> 'b -> 'b -> int
val str_remove : string -> string -> string
val split_time : unit -> int * int * int * int
val string_of_time : unit -> string
val localtime : unit -> string
include module type of struct include GoblintCil end
val initCIL : unit -> unit
val cilVersion : string
type file = GoblintCil__Cil.file = {
  1. mutable fileName : string;
  2. mutable globals : global list;
  3. mutable globinit : fundec option;
  4. mutable globinitcalled : bool;
}
and comment = location * string
and global = GoblintCil__Cil.global =
  1. | GType of typeinfo * location
  2. | GCompTag of compinfo * location
  3. | GCompTagDecl of compinfo * location
  4. | GEnumTag of enuminfo * location
  5. | GEnumTagDecl of enuminfo * location
  6. | GVarDecl of varinfo * location
  7. | GVar of varinfo * initinfo * location
  8. | GFun of fundec * location
  9. | GAsm of string * location
  10. | GPragma of attribute * location
  11. | GText of string
and typ = GoblintCil__Cil.typ =
  1. | TVoid of attributes
  2. | TInt of ikind * attributes
  3. | TFloat of fkind * attributes
  4. | TPtr of typ * attributes
  5. | TArray of typ * exp option * attributes
  6. | TFun of typ * (string * typ * attributes) list option * bool * attributes
  7. | TNamed of typeinfo * attributes
  8. | TComp of compinfo * attributes
  9. | TEnum of enuminfo * attributes
  10. | TBuiltin_va_list of attributes
and ikind = GoblintCil__Cil.ikind =
  1. | IChar
  2. | ISChar
  3. | IUChar
  4. | IBool
  5. | IInt
  6. | IUInt
  7. | IShort
  8. | IUShort
  9. | ILong
  10. | IULong
  11. | ILongLong
  12. | IULongLong
  13. | IInt128
  14. | IUInt128
and fkind = GoblintCil__Cil.fkind =
  1. | FFloat
  2. | FDouble
  3. | FLongDouble
  4. | FComplexFloat
  5. | FComplexDouble
  6. | FComplexLongDouble
and attribute = GoblintCil__Cil.attribute =
  1. | Attr of string * attrparam list
and attributes = attribute list
and attrparam = GoblintCil__Cil.attrparam =
  1. | AInt of int
  2. | AStr of string
  3. | ACons of string * attrparam list
  4. | ASizeOf of typ
  5. | ASizeOfE of attrparam
  6. | ASizeOfS of typsig
  7. | AAlignOf of typ
  8. | AAlignOfE of attrparam
  9. | AAlignOfS of typsig
  10. | AUnOp of unop * attrparam
  11. | ABinOp of binop * attrparam * attrparam
  12. | ADot of attrparam * string
  13. | AStar of attrparam
  14. | AAddrOf of attrparam
  15. | AIndex of attrparam * attrparam
  16. | AQuestion of attrparam * attrparam * attrparam
and compinfo = GoblintCil__Cil.compinfo = {
  1. mutable cstruct : bool;
  2. mutable cname : string;
  3. mutable ckey : int;
  4. mutable cfields : fieldinfo list;
  5. mutable cattr : attributes;
  6. mutable cdefined : bool;
  7. mutable creferenced : bool;
}
and fieldinfo = GoblintCil__Cil.fieldinfo = {
  1. mutable fcomp : compinfo;
  2. mutable fname : string;
  3. mutable ftype : typ;
  4. mutable fbitfield : int option;
  5. mutable fattr : attributes;
  6. mutable floc : location;
}
and enuminfo = GoblintCil__Cil.enuminfo = {
  1. mutable ename : string;
  2. mutable eitems : (string * exp * location) list;
  3. mutable eattr : attributes;
  4. mutable ereferenced : bool;
  5. mutable ekind : ikind;
}
and typeinfo = GoblintCil__Cil.typeinfo = {
  1. mutable tname : string;
  2. mutable ttype : typ;
  3. mutable treferenced : bool;
}
and varinfo = GoblintCil__Cil.varinfo = {
  1. mutable vname : string;
  2. mutable vtype : typ;
  3. mutable vattr : attributes;
  4. mutable vstorage : storage;
  5. mutable vglob : bool;
  6. mutable vinline : bool;
  7. mutable vdecl : location;
  8. vinit : initinfo;
  9. mutable vid : int;
  10. mutable vaddrof : bool;
  11. mutable vreferenced : bool;
  12. mutable vdescr : GoblintCil__.Pretty.doc;
  13. mutable vdescrpure : bool;
  14. mutable vhasdeclinstruction : bool;
}
and storage = GoblintCil__Cil.storage =
  1. | NoStorage
  2. | Static
  3. | Register
  4. | Extern
and exp = GoblintCil__Cil.exp =
  1. | Const of constant
  2. | Lval of lval
  3. | SizeOf of typ
  4. | Real of exp
  5. | Imag of exp
  6. | SizeOfE of exp
  7. | SizeOfStr of string
  8. | AlignOf of typ
  9. | AlignOfE of exp
  10. | UnOp of unop * exp * typ
  11. | BinOp of binop * exp * exp * typ
  12. | Question of exp * exp * exp * typ
  13. | CastE of typ * exp
  14. | AddrOf of lval
  15. | AddrOfLabel of stmt Stdlib.ref
  16. | StartOf of lval
and wstring_type = GoblintCil__Cil.wstring_type =
  1. | Wchar_t
  2. | Char16_t
  3. | Char32_t
and encoding = GoblintCil__Cil.encoding =
  1. | No_encoding
  2. | Utf8
and constant = GoblintCil__Cil.constant =
  1. | CStr of string * encoding
  2. | CWStr of int64 list * wstring_type
  3. | CChr of char
  4. | CReal of float * fkind * string option
  5. | CEnum of exp * string * enuminfo
and unop = GoblintCil__Cil.unop =
  1. | Neg
  2. | BNot
  3. | LNot
and binop = GoblintCil__Cil.binop =
  1. | PlusA
  2. | PlusPI
  3. | IndexPI
  4. | MinusA
  5. | MinusPI
  6. | MinusPP
  7. | Mult
  8. | Div
  9. | Mod
  10. | Shiftlt
  11. | Shiftrt
  12. | Lt
  13. | Gt
  14. | Le
  15. | Ge
  16. | Eq
  17. | Ne
  18. | BAnd
  19. | BXor
  20. | BOr
  21. | LAnd
  22. | LOr
and lval = lhost * offset
and lhost = GoblintCil__Cil.lhost =
  1. | Var of varinfo
  2. | Mem of exp
and offset = GoblintCil__Cil.offset =
  1. | NoOffset
  2. | Field of fieldinfo * offset
  3. | Index of exp * offset
and init = GoblintCil__Cil.init =
  1. | SingleInit of exp
  2. | CompoundInit of typ * (offset * init) list
and initinfo = GoblintCil__Cil.initinfo = {
  1. mutable init : init option;
}
and fundec = GoblintCil__Cil.fundec = {
  1. mutable svar : varinfo;
  2. mutable sformals : varinfo list;
  3. mutable slocals : varinfo list;
  4. mutable smaxid : int;
  5. mutable sbody : block;
  6. mutable smaxstmtid : int option;
  7. mutable sallstmts : stmt list;
}
and block = GoblintCil__Cil.block = {
  1. mutable battrs : attributes;
  2. mutable bstmts : stmt list;
}
and stmt = GoblintCil__Cil.stmt = {
  1. mutable labels : label list;
  2. mutable skind : stmtkind;
  3. mutable sid : int;
  4. mutable succs : stmt list;
  5. mutable preds : stmt list;
  6. mutable fallthrough : stmt option;
}
and label = GoblintCil__Cil.label =
  1. | Label of string * location * bool
  2. | Case of exp * location * location
  3. | CaseRange of exp * exp * location * location
  4. | Default of location * location
and stmtkind = GoblintCil__Cil.stmtkind =
  1. | Instr of instr list
  2. | Return of exp option * location
  3. | Goto of stmt Stdlib.ref * location
  4. | ComputedGoto of exp * location
  5. | Break of location
  6. | Continue of location
  7. | If of exp * block * block * location * location
  8. | Switch of exp * block * stmt list * location * location
  9. | Loop of block * location * location * stmt option * stmt option
  10. | Block of block
and instr = GoblintCil__Cil.instr =
  1. | Set of lval * exp * location * location
  2. | VarDecl of varinfo * location
  3. | Call of lval option * exp * exp list * location * location
  4. | Asm of attributes * string list * (string option * string * lval) list * (string option * string * exp) list * string list * location
and location = GoblintCil__Cil.location = {
  1. line : int;
  2. file : string;
  3. byte : int;
  4. column : int;
  5. endLine : int;
  6. endByte : int;
  7. endColumn : int;
  8. synthetic : bool;
}
and typsig = GoblintCil__Cil.typsig =
  1. | TSPtr of typsig * attribute list
  2. | TSComp of bool * string * attribute list
  3. | TSFun of typsig * typsig list option * bool * attribute list
  4. | TSEnum of string * attribute list
  5. | TSBase of typ
val lowerConstants : bool Stdlib.ref
val removeBranchingOnConstants : bool Stdlib.ref
val insertImplicitCasts : bool Stdlib.ref
val compareLoc : location -> location -> int
val emptyFunction : string -> fundec
val setFormals : fundec -> varinfo list -> unit
val setFunctionType : fundec -> typ -> unit
val setFunctionTypeMakeFormals : fundec -> typ -> unit
val setMaxId : fundec -> unit
val dummyFunDec : fundec
val dummyFile : file
val saveBinaryFile : file -> string -> unit
val saveBinaryFileChannel : file -> Stdlib.out_channel -> unit
val loadBinaryFile : string -> file
val getGlobInit : ?main_name:string -> file -> fundec
val iterGlobals : file -> (global -> unit) -> unit
val foldGlobals : file -> ('a -> global -> 'a) -> 'a -> 'a
val mapGlobals : file -> (global -> global) -> unit
val findOrCreateFunc : file -> string -> typ -> varinfo
val new_sid : unit -> int
val prepareCFG : fundec -> unit
val computeCFGInfo : fundec -> bool -> unit
val copyFunction : fundec -> string -> fundec
val pushGlobal : global -> types:global list Stdlib.ref -> variables:global list Stdlib.ref -> unit
val invalidStmt : stmt
val builtinFunctions : (string, typ * typ list * bool) Stdlib.Hashtbl.t
val builtinLoc : location
val makeZeroInit : typ -> init
val foldLeftCompound : implicit:bool -> doinit:(offset -> init -> typ -> 'a -> 'a) -> ct:typ -> initl:(offset * init) list -> acc:'a -> 'a
val voidType : typ
val isVoidType : typ -> bool
val isVoidPtrType : typ -> bool
val typeOfRealAndImagComponents : typ -> typ
val getComplexFkind : fkind -> fkind
val intType : typ
val uintType : typ
val longType : typ
val ulongType : typ
val charType : typ
val charPtrType : typ
val stringLiteralType : typ
val wcharKind : ikind Stdlib.ref
val wcharType : typ Stdlib.ref
val char16Kind : ikind Stdlib.ref
val char16Type : typ Stdlib.ref
val char32Kind : ikind Stdlib.ref
val char32Type : typ Stdlib.ref
val charConstPtrType : typ
val voidPtrType : typ
val intPtrType : typ
val uintPtrType : typ
val doubleType : typ
val upointType : typ Stdlib.ref
val ptrdiffType : typ Stdlib.ref
val typeOfSizeOf : typ Stdlib.ref
val kindOfSizeOf : ikind Stdlib.ref
val isSigned : ikind -> bool
val mkCompInfo : bool -> string -> (compinfo -> (string * typ * int option * attributes * location) list) -> attributes -> compinfo
val copyCompInfo : compinfo -> string -> compinfo
val missingFieldName : string
val compFullName : compinfo -> string
val isCompleteType : typ -> bool
val unrollType : typ -> typ
val unrollTypeDeep : typ -> typ
val isIntegralType : typ -> bool
val isArithmeticType : typ -> bool
val isPointerType : typ -> bool
val isScalarType : typ -> bool
val isFunctionType : typ -> bool
val argsToList : (string * typ * attributes) list option -> (string * typ * attributes) list
val isArrayType : typ -> bool
exception LenOfArray
val lenOfArray : exp option -> int
val getCompField : compinfo -> string -> fieldinfo
type existsAction = GoblintCil__Cil.existsAction =
  1. | ExistsTrue
  2. | ExistsFalse
  3. | ExistsMaybe
val existsType : (typ -> existsAction) -> typ -> bool
val splitFunctionType : typ -> typ * (string * typ * attributes) list option * bool * attributes
val splitFunctionTypeVI : varinfo -> typ * (string * typ * attributes) list option * bool * attributes
val d_typsig : unit -> typsig -> GoblintCil__.Pretty.doc
val typeSig : typ -> typsig
val typeSigWithAttrs : ?ignoreSign:bool -> (attributes -> attributes) -> typ -> typsig
val setTypeSigAttrs : attributes -> typsig -> typsig
val typeSigAttrs : typsig -> attributes
val makeVarinfo : bool -> string -> ?init:init -> typ -> varinfo
val makeFormalVar : fundec -> ?where:string -> string -> typ -> varinfo
val makeLocalVar : fundec -> ?insert:bool -> string -> ?init:init -> typ -> varinfo
val makeTempVar : fundec -> ?insert:bool -> ?name:string -> ?descr:GoblintCil__.Pretty.doc -> ?descrpure:bool -> typ -> varinfo
val makeGlobalVar : string -> typ -> varinfo
val copyVarinfo : varinfo -> string -> varinfo
val newVID : unit -> int
val addOffsetLval : offset -> lval -> lval
val addOffset : offset -> offset -> offset
val removeOffsetLval : lval -> lval * offset
val removeOffset : offset -> offset * offset
val typeOfLval : lval -> typ
val typeOffset : typ -> offset -> typ
val zero : exp
val one : exp
val mone : exp
val kintegerCilint : ikind -> GoblintCil__.Cilint.cilint -> exp
val kinteger64 : ikind -> int64 -> exp
val kinteger : ikind -> int -> exp
val integer : int -> exp
val getInteger : exp -> GoblintCil__.Cilint.cilint option
val i64_to_int : int64 -> int
val cilint_to_int : GoblintCil__.Cilint.cilint -> int
val isConstant : exp -> bool
val isConstantOffset : offset -> bool
val isZero : exp -> bool
val isNullPtrConstant : exp -> bool
val charConstToInt : char -> constant
val constFold : bool -> exp -> exp
val constFoldBinOp : bool -> binop -> exp -> exp -> typ -> exp
val increm : exp -> int -> exp
val var : varinfo -> lval
val mkAddrOf : lval -> exp
val mkAddrOrStartOf : lval -> exp
val mkMem : addr:exp -> off:offset -> lval
val mkString : string -> exp
val mkCastT : e:exp -> oldt:typ -> newt:typ -> exp
val mkCast : e:exp -> newt:typ -> exp
val stripCasts : exp -> exp
val typeOf : exp -> typ
val parseInt : string -> exp
val mkStmt : stmtkind -> stmt
val mkBlock : stmt list -> block
val mkStmtOneInstr : instr -> stmt
val compactStmts : stmt list -> stmt list
val mkEmptyStmt : unit -> stmt
val dummyInstr : instr
val dummyStmt : stmt
val mkWhile : guard:exp -> body:stmt list -> stmt list
val mkForIncr : iter:varinfo -> first:exp -> stopat:exp -> incr:exp -> body:stmt list -> stmt list
val mkFor : start:stmt list -> guard:exp -> next:stmt list -> body:stmt list -> stmt list
type attributeClass = GoblintCil__Cil.attributeClass =
  1. | AttrName
  2. | AttrFunType
  3. | AttrType
val attributeHash : (string, attributeClass) Stdlib.Hashtbl.t
val partitionAttributes : default:attributeClass -> attributes -> attribute list * attribute list * attribute list
val addAttribute : attribute -> attributes -> attributes
val addAttributes : attribute list -> attributes -> attributes
val dropAttribute : string -> attributes -> attributes
val dropAttributes : string list -> attributes -> attributes
val filterAttributes : string -> attributes -> attributes
val hasAttribute : string -> attributes -> bool
val typeAttrs : typ -> attribute list
val typeAttrsOuter : typ -> attribute list
val setTypeAttrs : typ -> attributes -> typ
val typeAddAttributes : attribute list -> typ -> typ
val typeRemoveAttributes : string list -> typ -> typ
val partitionQualifierAttributes : attribute list -> attribute list * attribute list
val removeOuterQualifierAttributes : typ -> typ
val expToAttrParam : exp -> attrparam
exception NotAnAttrParam of exp
type !'a visitAction = 'a GoblintCil__Cil.visitAction =
  1. | SkipChildren
  2. | DoChildren
  3. | ChangeTo of 'a
  4. | ChangeDoChildrenPost of 'a * 'a -> 'a
class type cilVisitor = object ... end
val visitCilFile : cilVisitor -> file -> unit
val visitCilFileSameGlobals : cilVisitor -> file -> unit
val visitCilGlobal : cilVisitor -> global -> global list
val visitCilFunction : cilVisitor -> fundec -> fundec
val visitCilExpr : cilVisitor -> exp -> exp
val visitCilLval : cilVisitor -> lval -> lval
val visitCilOffset : cilVisitor -> offset -> offset
val visitCilInitOffset : cilVisitor -> offset -> offset
val visitCilInstr : cilVisitor -> instr -> instr list
val visitCilStmt : cilVisitor -> stmt -> stmt
val visitCilBlock : cilVisitor -> block -> block
val visitCilType : cilVisitor -> typ -> typ
val visitCilVarDecl : cilVisitor -> varinfo -> varinfo
val visitCilInit : cilVisitor -> varinfo -> offset -> init -> init
val visitCilAttributes : cilVisitor -> attribute list -> attribute list
val msvcMode : bool Stdlib.ref
val makeStaticGlobal : bool Stdlib.ref
val useLogicalOperators : bool Stdlib.ref
val useComputedGoto : bool Stdlib.ref
val useCaseRange : bool Stdlib.ref
val caseRangeFold : label list -> label list
val oldstyleExternInline : bool Stdlib.ref
val constFoldVisitor : bool -> cilVisitor
type lineDirectiveStyle = GoblintCil__Cil.lineDirectiveStyle =
  1. | LineComment
  2. | LineCommentSparse
  3. | LinePreprocessorInput
  4. | LinePreprocessorOutput
val lineDirectiveStyle : lineDirectiveStyle option Stdlib.ref
val print_CIL_Input : bool Stdlib.ref
val printCilAsIs : bool Stdlib.ref
val lineLength : int Stdlib.ref
val forgcc : string -> string
val currentLoc : location Stdlib.ref
val currentExpLoc : location Stdlib.ref
val currentGlobal : global Stdlib.ref
val d_loc : unit -> location -> GoblintCil__.Pretty.doc
val d_thisloc : unit -> GoblintCil__.Pretty.doc
val d_ikind : unit -> ikind -> GoblintCil__.Pretty.doc
val d_fkind : unit -> fkind -> GoblintCil__.Pretty.doc
val d_storage : unit -> storage -> GoblintCil__.Pretty.doc
val d_const : unit -> constant -> GoblintCil__.Pretty.doc
val derefStarLevel : int
val indexLevel : int
val arrowLevel : int
val addrOfLevel : int
val additiveLevel : int
val comparativeLevel : int
val bitwiseLevel : int
val getParenthLevel : exp -> int
class type cilPrinter = object ... end
val defaultCilPrinter : cilPrinter
val plainCilPrinter : cilPrinter
class type descriptiveCilPrinter = object ... end
val descriptiveCilPrinter : descriptiveCilPrinter
val printerForMaincil : cilPrinter Stdlib.ref
val printType : cilPrinter -> unit -> typ -> GoblintCil__.Pretty.doc
val printExp : cilPrinter -> unit -> exp -> GoblintCil__.Pretty.doc
val printLval : cilPrinter -> unit -> lval -> GoblintCil__.Pretty.doc
val printGlobal : cilPrinter -> unit -> global -> GoblintCil__.Pretty.doc
val printAttr : cilPrinter -> unit -> attribute -> GoblintCil__.Pretty.doc
val printAttrs : cilPrinter -> unit -> attributes -> GoblintCil__.Pretty.doc
val printInstr : cilPrinter -> unit -> instr -> GoblintCil__.Pretty.doc
val printStmt : cilPrinter -> unit -> stmt -> GoblintCil__.Pretty.doc
val printBlock : cilPrinter -> unit -> block -> GoblintCil__.Pretty.doc
val dumpStmt : cilPrinter -> Stdlib.out_channel -> int -> stmt -> unit
val dumpBlock : cilPrinter -> Stdlib.out_channel -> int -> block -> unit
val printInit : cilPrinter -> unit -> init -> GoblintCil__.Pretty.doc
val dumpInit : cilPrinter -> Stdlib.out_channel -> int -> init -> unit
val d_type : unit -> typ -> GoblintCil__.Pretty.doc
val d_exp : unit -> exp -> GoblintCil__.Pretty.doc
val d_lval : unit -> lval -> GoblintCil__.Pretty.doc
val d_offset : GoblintCil__.Pretty.doc -> unit -> offset -> GoblintCil__.Pretty.doc
val d_init : unit -> init -> GoblintCil__.Pretty.doc
val d_binop : unit -> binop -> GoblintCil__.Pretty.doc
val d_unop : unit -> unop -> GoblintCil__.Pretty.doc
val d_attr : unit -> attribute -> GoblintCil__.Pretty.doc
val d_attrparam : unit -> attrparam -> GoblintCil__.Pretty.doc
val d_attrlist : unit -> attributes -> GoblintCil__.Pretty.doc
val d_instr : unit -> instr -> GoblintCil__.Pretty.doc
val d_label : unit -> label -> GoblintCil__.Pretty.doc
val d_stmt : unit -> stmt -> GoblintCil__.Pretty.doc
val d_block : unit -> block -> GoblintCil__.Pretty.doc
val d_global : unit -> global -> GoblintCil__.Pretty.doc
val dn_exp : unit -> exp -> GoblintCil__.Pretty.doc
val dn_lval : unit -> lval -> GoblintCil__.Pretty.doc
val dn_init : unit -> init -> GoblintCil__.Pretty.doc
val dn_type : unit -> typ -> GoblintCil__.Pretty.doc
val dn_global : unit -> global -> GoblintCil__.Pretty.doc
val dn_attrlist : unit -> attributes -> GoblintCil__.Pretty.doc
val dn_attr : unit -> attribute -> GoblintCil__.Pretty.doc
val dn_attrparam : unit -> attrparam -> GoblintCil__.Pretty.doc
val dn_stmt : unit -> stmt -> GoblintCil__.Pretty.doc
val dn_instr : unit -> instr -> GoblintCil__.Pretty.doc
val d_shortglobal : unit -> global -> GoblintCil__.Pretty.doc
val dumpGlobal : cilPrinter -> Stdlib.out_channel -> global -> unit
val dumpFile : cilPrinter -> Stdlib.out_channel -> string -> file -> unit
val bug : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val unimp : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val error : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val errorLoc : location -> ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val warn : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val warnOpt : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val warnContext : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val warnContextOpt : ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val warnLoc : location -> ('a, unit, GoblintCil__.Pretty.doc) Stdlib.format -> 'a
val d_plainexp : unit -> exp -> GoblintCil__.Pretty.doc
val d_plaininit : unit -> init -> GoblintCil__.Pretty.doc
val d_plainlval : unit -> lval -> GoblintCil__.Pretty.doc
val d_plaintype : unit -> typ -> GoblintCil__.Pretty.doc
val dd_exp : unit -> exp -> GoblintCil__.Pretty.doc
val dd_lval : unit -> lval -> GoblintCil__.Pretty.doc
val uniqueVarNames : file -> unit
val peepHole2 : ((instr * instr) -> instr list option) -> stmt list -> unit
val peepHole1 : (instr -> instr list option) -> stmt list -> unit
exception SizeOfError of string * typ
val unsignedVersionOf : ikind -> ikind
val signedVersionOf : ikind -> ikind
val intRank : ikind -> int
val commonIntKind : ikind -> ikind -> ikind
val intKindForSize : int -> bool -> ikind
val floatKindForSize : int -> fkind
val bytesSizeOfInt : ikind -> int
val bitsSizeOf : typ -> int
val truncateCilint : ikind -> GoblintCil__.Cilint.cilint -> GoblintCil__.Cilint.cilint * GoblintCil__.Cilint.truncation
val fitsInInt : ikind -> GoblintCil__.Cilint.cilint -> bool
val intKindForValue : GoblintCil__.Cilint.cilint -> bool -> ikind
val mkCilint : ikind -> int64 -> GoblintCil__.Cilint.cilint
val mkCilintIk : ikind -> GoblintCil__.Cilint.cilint -> GoblintCil__.Cilint.cilint
val const_if_not_overflow : exp -> ikind -> GoblintCil__.Cilint.cilint -> exp
val sizeOf : typ -> exp
val alignOf_int : typ -> int
val bitsOffset : typ -> offset -> int * int
val char_is_unsigned : bool Stdlib.ref
val little_endian : bool Stdlib.ref
val underscore_name : bool Stdlib.ref
val locUnknown : location
val get_instrLoc : instr -> location
val get_globalLoc : global -> location
val get_stmtLoc : stmtkind -> location
val dExp : GoblintCil__.Pretty.doc -> exp
val dInstr : GoblintCil__.Pretty.doc -> location -> instr
val dGlobal : GoblintCil__.Pretty.doc -> location -> global
val mapNoCopy : ('a -> 'a) -> 'a list -> 'a list
val mapNoCopyList : ('a -> 'a list) -> 'a list -> 'a list
val startsWith : string -> string -> bool
val endsWith : string -> string -> bool
val stripUnderscores : string -> string
val freshLabel : string -> string
val populateLabelAlphaTable : fundec -> unit
type formatArg = GoblintCil__Cil.formatArg =
  1. | Fe of exp
  2. | Feo of exp option
  3. | Fu of unop
  4. | Fb of binop
  5. | Fk of ikind
  6. | FE of exp list
  7. | Ff of string * typ * attributes
  8. | FF of (string * typ * attributes) list
  9. | Fva of bool
  10. | Fv of varinfo
  11. | Fl of lval
  12. | Flo of lval option
  13. | Fo of offset
  14. | Fc of compinfo
  15. | Fi of instr
  16. | FI of instr list
  17. | Ft of typ
  18. | Fd of int
  19. | Fg of string
  20. | Fs of stmt
  21. | FS of stmt list
  22. | FA of attributes
  23. | Fp of attrparam
  24. | FP of attrparam list
  25. | FX of string
val d_formatarg : unit -> formatArg -> GoblintCil__.Pretty.doc
val warnTruncate : bool Stdlib.ref
val envMachine : GoblintCil__.Machdep.mach option Stdlib.ref
val gccBuiltins : (string, typ * typ list * bool) Stdlib.Hashtbl.t
module Cfg : sig ... end
module Check : sig ... end
module Cil : sig ... end
module Cilint : sig ... end
module Cillower : sig ... end
module Ciltools : sig ... end
module Cilutil : sig ... end
module Dataflow : sig ... end
module Dominators : sig ... end
module Escape : sig ... end
module Expcompare : sig ... end
module Feature : sig ... end
module Formatcil : sig ... end
module Machdep : sig ... end
module Machdepenv : sig ... end
module Mergecil : sig ... end
module Rmtmps : sig ... end
module Cabs : sig ... end
module Cabs2cil : sig ... end
module Cabshelper : sig ... end
module Cabsvisit : sig ... end
module Cprint : sig ... end
module Frontc : sig ... end
module Patch : sig ... end
module Whitetrack : sig ... end
module Alpha : sig ... end
module Errormsg : sig ... end
module GrowArray : sig ... end
module Inthash : sig ... end
module Pretty : sig ... end
module Stats : sig ... end
module Trace : sig ... end
module Util : sig ... end
val d_varinfo : unit -> varinfo -> GoblintCil__.Pretty.doc
include module type of struct include Pretty end
type doc = GoblintCil__Pretty.doc
val nil : doc
val (++) : doc -> doc -> doc
val concat : doc -> doc -> doc
val text : string -> doc
val num : int -> doc
val num64 : int64 -> doc
val real : float -> doc
val chr : char -> doc
val line : doc
val leftflush : doc
val break : doc
val align : doc
val unalign : doc
val mark : doc
val unmark : doc
val indent : int -> doc -> doc
val markup : doc -> doc
val seq : sep:doc -> doit:('a -> doc) -> elements:'a list -> doc
val docList : ?sep:doc -> ('a -> doc) -> unit -> 'a list -> doc
val d_list : string -> (unit -> 'a -> doc) -> unit -> 'a list -> doc
val docArray : ?sep:doc -> (int -> 'a -> doc) -> unit -> 'a array -> doc
val docOpt : ('a -> doc) -> unit -> 'a option -> doc
val d_int32 : int32 -> doc
val f_int32 : unit -> int32 -> doc
val d_int64 : int64 -> doc
val f_int64 : unit -> int64 -> doc
module MakeMapPrinter : sig ... end
module MakeSetPrinter : sig ... end
val insert : unit -> doc -> doc
val dprintf : ('a, unit, doc, doc) Stdlib.format4 -> 'a
val gprintf : (doc -> 'b) -> ('a, unit, doc, 'b) Stdlib.format4 -> 'a
val fprint : Stdlib.out_channel -> width:int -> doc -> unit
val fprintf : Stdlib.out_channel -> ('a, unit, doc) Stdlib.format -> 'a
val printf : ('a, unit, doc) Stdlib.format -> 'a
val eprintf : ('a, unit, doc) Stdlib.format -> 'a
val withPrintDepth : int -> (unit -> unit) -> unit
val printDepth : int Stdlib.ref
val printIndent : bool Stdlib.ref
val fastMode : bool Stdlib.ref
val flushOften : bool Stdlib.ref
val flattenBeforePrint : bool Stdlib.ref
val countNewLines : int Stdlib.ref
val auto_printer : string -> 'b
val sprint : (unit -> 'a -> Pretty.doc) -> 'a -> string
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct