package goblint

  1. Overview
  2. Docs
package goblint
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include ContainDomain.Dom end
val final : bool ref
val report : string -> unit
module Danger = ContainDomain.Dom.Danger
module StringPair = ContainDomain.Dom.StringPair
module InhRel = ContainDomain.Dom.InhRel
val inc : InhRel.t ref
include sig ... end
val equal : t -> t -> Ppx_deriving_runtime.bool
val compare : t -> t -> Ppx_deriving_runtime.int
type group = Printable.Std.group = |
val show_group : group -> 'a
val to_group : 'a -> 'b option
val trace_enabled : bool
val tag : 'a -> 'b
val to_yojson : (ContainDomain.FuncName.t * Danger.t * ContainDomain.Diff.t) -> [> `Assoc of (string * Printable.json) list ]
val name : unit -> string
val pretty_diff : unit -> (t * t) -> Pretty.doc
val op_scheme : ('a -> 'b -> ContainDomain.FuncName.t) -> ('c -> 'd -> Danger.t) -> ('e -> 'f -> ContainDomain.Diff.t) -> ('a * 'c * 'e) -> ('b * 'd * 'f) -> t
val public_vars : (string, string list) Hashtbl.t
val private_vars : (string, string list) Hashtbl.t
val public_methods : (string, string list) Hashtbl.t
val func_ptrs : (string, string list) Hashtbl.t
val private_methods : (string, string list) Hashtbl.t
val friends : (string, string list) Hashtbl.t
val derived : (string, string list) Hashtbl.t
val vtbls : (string, string list) Hashtbl.t
val analyzed_funs : (string, unit) Hashtbl.t
val required_non_public_funs : (string, string list) Hashtbl.t
val reentrant_funs : (string, unit) Hashtbl.t
val danger_funs : (string, string list) Hashtbl.t
val local_classes : (string, unit) Hashtbl.t
val safe_methods : (string, Str.regexp list) Hashtbl.t
val safe_vars : (string, Str.regexp list) Hashtbl.t
val enable_dbg : bool
val dbg_line_start : int
val dbg_line_end : int
val dbg_report : string -> unit
val error : string -> unit
val taintedFunDec : Cil.varinfo
val get_tainted_fields : (Cil.varinfo -> 'a * 'b * 'c) -> 'a
val get_fptr_items : (Cil.varinfo -> 'a * 'b * 'c) -> 'b
val get_class_items : (Cil.varinfo -> 'a * 'b * 'c) -> 'c
val unresFunDec : Cil.fundec
val set_funname : Cil.fundec -> ('a * 'b * 'c) -> [> `Lifted of Cil.fundec ] * 'b * 'c
val get_name : 'a -> ([> `Lifted of ContainDomain.FuncName.t ] * 'b * 'c) -> ContainDomain.FuncName.t option
val unkown_this : Cil.varinfo
val return_var : Cil.varinfo
val isnot_mainclass : string -> bool
val dump_local_classes : (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> unit
val isnot_localclass : Basetype.RawStrings.t -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val islocal_notmainclass : Basetype.RawStrings.t -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val is_ext : string -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val get_inherited_from : string -> string list
val remove_formals : CilType.Varinfo.t list -> ('a * Danger.t * 'b) -> 'a * Danger.t * 'b
val add_formals : Cil.fundec -> ('a * Danger.t * 'b) -> 'a * Danger.t * 'b
val empty_formals : Cil.fundec -> CilType.Varinfo.t list -> ('a * Danger.t * 'b) -> 'a * Danger.t * 'b
val must_be_constructed_from_this : Danger.t -> Cil.exp -> bool
val may_be_constructed_from_this_direct : 'a -> Cil.exp -> bool
val may_be_constructed_from_this : Danger.t -> Cil.exp -> bool
val get_field_from_this : Cil.exp -> Danger.t -> ContainDomain.FieldSet.t
val is_tainted : ContainDomain.FieldSet.t -> Danger.t -> Cil.exp -> bool
val get_globals : Cil.exp -> Cil.varinfo list
val get_vars : Cil.exp -> Cil.varinfo list
val check_safety : (string, Str.regexp list) Hashtbl.t -> string -> bool
val is_safe : Cil.exp -> bool
val is_safe_name : string -> bool
val is_public_method_name : string -> bool
val is_private_method_name : string -> bool
val is_public_method : t -> bool
val is_private_method : t -> bool
val may_be_a_perfectly_normal_global : Cil.exp -> 'a -> ('b * Danger.t * 'c) -> ContainDomain.FieldSet.t -> bool
val maybe_deref : Cil.exp -> bool
val danger_assign : Danger.key -> Danger.value -> ('a * Danger.t * 'b) -> bool -> 'c -> 'a * Danger.t * 'b
val uid : int ref
val dumpDomSize : Danger.t -> unit
val dangerDump : string -> Danger.t -> unit
val is_bad_reachable : Danger.key -> Danger.t -> bool
val warn_bad_dereference : Cil.exp -> bool -> ('a * Danger.t * 'b) -> 'c -> string -> unit
val has_bad_reachables : 'a -> Cil.exp list -> bool -> ('b * Danger.t * 'c) -> 'd -> 'e -> bool
val is_loc_method : Cil.exp option -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val warn_bad_reachables : 'a -> Cil.exp list -> bool -> ('b * Danger.t * 'c) -> 'd -> string -> (Cil.varinfo -> 'e * 'f * ContainDomain.ClassNameSet.t) -> unit
val get_this : Danger.t -> Cil.exp -> CilType.Varinfo.t
val get_lval_from_exp : Cil.exp -> Cil.lhost * Cil.offset
val assign_to_lval_no_prop : 'a -> Cil.lval -> ('b * Danger.t * 'c) -> Danger.value -> bool -> 'd -> 'b * Danger.t * 'c
val string_of_int64 : int64 -> string
val filter_type : Str.regexp
val split : string -> string -> string list
val gen_vtbl_name : string -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> string
val add_required_fun : string -> (string, string list) Hashtbl.t -> unit
val add_required_fun_priv : string -> unit
val add_local_class : string -> ('a * 'b * ContainDomain.Diff.t) -> 'a * 'b * ContainDomain.Diff.t
val get_vfunc_set : string -> int -> ('a * 'b * ContainDomain.Diff.t) -> ('a * 'b * ContainDomain.Diff.t) * string list
val muid : int ref
val is_method : Cil.exp option -> bool
val remove_htbl_entry : ('a, 'b list) Hashtbl.t -> 'a -> 'b -> unit
val add_htbl_entry : ('a, 'b list) Hashtbl.t -> 'a -> 'b -> unit
val filter_vtbl : Str.regexp
val add_func_ptr : Basetype.Variables.t -> ('a * 'b * ContainDomain.Diff.t) -> 'a * 'b * ContainDomain.Diff.t
val warn_tainted : ContainDomain.FieldSet.t -> ('a * Danger.t * 'b) -> Cil.exp -> string -> unit
val may_be_fp : Cil.exp -> Danger.t -> bool -> bool
val warn_glob : Cil.exp -> string -> unit
val show : t -> 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