package goblint

  1. Overview
  2. Docs
Static analysis framework for C

Install 

dune-project
 Dependency

goblint.in.tum.de Readme Changelog Edit opam file Versions (9)

Authors

  1. V
    Vesal Vojdani
  2. K
    Kalmer Apinis
  3. R
    Ralf Vogler
  4. M
    Michael Schwarz
  5. J
    Julian Erhard
  6. S
    Simmo Saan

Maintainers

  1. M
    Michael Schwarz <michael.schwarz93@gmail.com>
  2. S
    Simmo Saan <simmo.saan@gmail.com>
  3. R
    Ralf Vogler <ralf.vogler@gmail.com>

Sources

goblint-1.1.1.tbz
sha256=999272bfbd3b9b96fcd58987b237ac6e9fa6d92ef935cc89f1ea2b4205185141
sha512=f3bf6ab71cf8c258d3290da4bf9f6fe42d7c671822e0efeb0fc50afdff078ab15e352237e5c1db31c5aa3a9d430691268ed2e5e00da10f2615835f672f91683d

doc/goblint.lib/ContainDomain/Dom/index.html

Module ContainDomain.Dom

val final : bool ref
val report : string -> unit
module Danger : sig ... end
module StringPair : sig ... end
module InhRel : sig ... end
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 hash : (FuncName.t * Danger.t * Diff.t) -> int
val show : (FuncName.t * Danger.t * Diff.t) -> string
val pretty : unit -> (FuncName.t * Danger.t * Diff.t) -> Pretty.doc
val printXml : 'a BatInnerIO.output -> (FuncName.t * Danger.t * Diff.t) -> unit
val to_yojson : (FuncName.t * Danger.t * Diff.t) -> [> `Assoc of (string * Printable.json) list ]
val name : unit -> string
val arbitrary : unit -> (FuncName.t * Danger.t * Diff.t) QCheck.arbitrary
val bot : unit -> FuncName.t * Danger.t * Diff.t
val is_bot : (FuncName.t * Danger.t * Diff.t) -> bool
val top : unit -> FuncName.t * Danger.t * Diff.t
val is_top : (FuncName.t * Danger.t * Diff.t) -> bool
val leq : (FuncName.t * Danger.t * Diff.t) -> (FuncName.t * Danger.t * Diff.t) -> bool
val pretty_diff : unit -> (t * t) -> Pretty.doc
val op_scheme : ('a -> 'b -> FuncName.t) -> ('c -> 'd -> Danger.t) -> ('e -> 'f -> Diff.t) -> ('a * 'c * 'e) -> ('b * 'd * 'f) -> t
val join : (FuncName.t * Danger.t * Diff.t) -> (FuncName.t * Danger.t * Diff.t) -> t
val meet : (FuncName.t * Danger.t * Diff.t) -> (FuncName.t * Danger.t * Diff.t) -> t
val widen : (FuncName.t * Danger.t * Diff.t) -> (FuncName.t * Danger.t * Diff.t) -> t
val narrow : (FuncName.t * Danger.t * Diff.t) -> (FuncName.t * Danger.t * Diff.t) -> 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 set_name : FuncName.t -> ('a * Danger.t * Diff.t) -> t
val get_name : 'a -> ([> `Lifted of FuncName.t ] * 'b * 'c) -> 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 * ClassNameSet.t) -> unit
val isnot_localclass : Basetype.RawStrings.t -> (Cil.varinfo -> 'a * 'b * ClassNameSet.t) -> bool
val islocal_notmainclass : Basetype.RawStrings.t -> (Cil.varinfo -> 'a * 'b * ClassNameSet.t) -> bool
val is_ext : string -> (Cil.varinfo -> 'a * 'b * 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 used_args : Danger.t -> Cil.exp -> ArgSet.t
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 -> FieldSet.t
val used_ptrs : Danger.t -> Cil.exp -> ArgSet.t
val is_tainted : 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) -> 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 danger_propagate : Danger.key -> ArgSet.t -> ('a * Danger.t * Diff.t) -> bool -> FieldSet.t -> (Cil.varinfo -> 'b * 'c * ClassNameSet.t) -> string -> 'a * Danger.t * Diff.t
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 * ClassNameSet.t) -> bool
val warn_bad_reachables : 'a -> Cil.exp list -> bool -> ('b * Danger.t * 'c) -> 'd -> string -> (Cil.varinfo -> 'e * 'f * ClassNameSet.t) -> unit
val get_this : Danger.t -> Cil.exp -> CilType.Varinfo.t
val join_this_fs_to_args : CilType.Varinfo.t -> FieldSet.t -> ArgSet.t
val get_lval_from_exp : Cil.exp -> Cil.lhost * Cil.offset
val filter_argset_self : Cil.exp -> ArgSet.t -> Danger.t -> ArgSet.t
val assign_to_lval : FieldSet.t -> Cil.lval -> ('a * Danger.t * Diff.t) -> ArgSet.t -> bool -> (Cil.varinfo -> 'b * 'c * ClassNameSet.t) -> string -> 'a * Danger.t * Diff.t
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 * 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 * Diff.t) -> 'a * 'b * Diff.t
val get_vfunc_set : string -> int -> ('a * 'b * Diff.t) -> ('a * 'b * Diff.t) * string list
val muid : int ref
val assign_argmap : FieldSet.t -> Cil.lval -> Cil.exp -> ('a * Danger.t * Diff.t) -> bool -> (Cil.varinfo -> 'b * 'c * ClassNameSet.t) -> 'a * Danger.t * Diff.t
val is_method : Cil.exp option -> bool
val assign_to_local : 'a -> Cil.lval -> Cil.exp option -> ('b * Danger.t * Diff.t) -> FieldSet.t -> (Cil.varinfo -> 'c * 'd * ClassNameSet.t) -> 'b * Danger.t * Diff.t
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 * Diff.t) -> 'a * 'b * Diff.t
val warn_tainted : 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