package goblint

  1. Overview
  2. Docs
Static analysis framework for C

Install

Dune Dependency

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

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
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