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. S
    Simmo Saan
  2. M
    Michael Schwarz
  3. J
    Julian Erhard
  4. S
    Sarah Tilscher
  5. K
    Karoliine Holter
  6. R
    Ralf Vogler
  7. K
    Kalmer Apinis
  8. V
    Vesal Vojdani

Maintainers

  1. S
    Simmo Saan <simmo.saan@gmail.com>
  2. M
    Michael Schwarz <michael.schwarz93@gmail.com>
  3. K
    Karoliine Holter <karoliine.holter@ut.ee>

Sources

goblint-2.5.0.tbz
sha256=452d8491527aea21f2cbb11defcc14ba0daf9fdb6bdb9fc0af73e56eac57b916
sha512=1993cd45c4c7fe124ca6e157f07d17ec50fab5611b270a434ed1b7fb2910aa85a8e6eaaa77dad770430710aafb2f6d676c774dd33942d921f23e2f9854486551

doc/goblint.lib/Goblint_lib/ThreadId/Spec/index.html

Module ThreadId.Spec

include module type of struct include Analyses.IdentitySpec end
include module type of struct include Analyses.DefaultSpec end
module G = Lattice.Unit
module V = Analyses.EmptyV
val vdecl : ('a, 'b, 'c, 'd) Analyses.ctx -> 'e -> 'a
val asm : ('a, 'b, 'c, 'd) Analyses.ctx -> 'a
val skip : ('a, 'b, 'c, 'd) Analyses.ctx -> 'a
val event : ('a, 'b, 'c, 'd) Analyses.ctx -> 'e -> 'f -> 'a
val sync : ('a, 'b, 'c, 'd) Analyses.ctx -> 'e -> 'a
val paths_as_set : ('a, 'b, 'c, 'd) Analyses.ctx -> 'a list
val assign : ('a, 'b, 'c, 'd) Analyses.ctx -> GoblintCil.lval -> GoblintCil.exp -> 'a
val branch : ('a, 'b, 'c, 'd) Analyses.ctx -> GoblintCil.exp -> bool -> 'a
val body : ('a, 'b, 'c, 'd) Analyses.ctx -> GoblintCil.fundec -> 'a
val return : ('a, 'b, 'c, 'd) Analyses.ctx -> GoblintCil.exp option -> GoblintCil.fundec -> 'a
val combine_assign : ('a, 'b, 'c, 'd) Analyses.ctx -> GoblintCil.lval option -> 'e -> GoblintCil.fundec -> GoblintCil.exp list -> 'f -> 'g -> Queries.ask -> 'a
val special : ('a, 'b, 'c, 'd) Analyses.ctx -> GoblintCil.lval option -> GoblintCil.varinfo -> GoblintCil.exp list -> 'a
module N : sig ... end
module TD = Thread.D
module Created : sig ... end
module D : sig ... end

Uniqueness Counter * TID * (All thread creates of current thread * All thread creates of the current function and its callees)

include sig ... end
module C : sig ... end
val startcontext : unit -> D.t
module P : sig ... end
val tids : (Thread.t, unit) Batteries.Hashtbl.t ref
val name : unit -> string
val context : 'a -> 'b -> ('c * 'd * (TD.t * TD.t)) -> 'c * 'd * (TD.t * TD.t)
val startstate : 'a -> [> `Bot ] * [> `Bot ] * (TD.t * TD.t)
val exitstate : GoblintCil.varinfo -> [> `Bot ] * [> `Lifted of Thread.t ] * (TD.t * TD.t)
val morphstate : GoblintCil.varinfo -> 'a -> [> `Bot ] * [> `Lifted of Thread.t ] * (TD.t * TD.t)
val create_tid : ?multiple:bool -> ('a * [> `Lifted of Thread.t ] * (Thread.D.t * 'b)) -> (Node.t * int option) -> GoblintCil.varinfo -> [> `Lifted of Thread.t ] list
val is_unique : ('a, 'b, 'c, 'd) Analyses.ctx -> BoolDomain.MustBool.t Queries.result
val enter : ('a * 'b * ('c * 'd), 'e, 'f, 'g) Analyses.ctx -> 'h -> 'i -> 'j -> (('a * 'b * ('c * 'd)) * ('a * 'b * ('c * TD.t))) list
val combine_env : ('a * 'b * (TD.t * TD.t), 'c, 'd, 'e) Analyses.ctx -> 'f -> 'g -> 'h -> 'i -> 'j -> ('k * 'l * (TD.t * TD.t)) -> 'm -> 'k * 'l * (TD.t * TD.t)
val created : ('a * [> `Lifted of Thread.t ] * (Thread.D.t * 'b)) -> ConcDomain.ThreadSet.t
val query : (D.t, 'b, 'c, 'd) Analyses.ctx -> 'a Queries.t -> 'a Queries.result
module A : sig ... end
val access : ('a * 'b * 'c, 'd, 'e, 'f) Analyses.ctx -> 'g -> 'b option
val indexed_node_for_ctx : ('a, 'b, 'c, 'd) Analyses.ctx -> Node.t * WrapperFunctionAnalysis0.ThreadCreateUniqueCount.t option

get the node that identifies the current context, possibly that of a wrapper function

val threadenter : ('a * [> `Lifted of Thread.t ] * (Thread.D.t * 'b), 'c, 'd, 'e) Analyses.ctx -> multiple:bool -> 'f -> GoblintCil.varinfo -> 'g -> D.t list
val threadspawn : ('a * 'b * (Thread.D.t * Thread.D.t), 'c, 'd, 'e) Analyses.ctx -> multiple:bool -> 'f -> 'g -> 'h -> ([> `Lifted of GoblintCil.varinfo * Node.t * int option ] * 'i * 'j, 'k, 'l, 'm) Analyses.ctx -> 'a * 'b * (Thread.D.t * Thread.D.t)
type marshal = (Thread.t, unit) Batteries.Hashtbl.t
val init : marshal option -> unit
val print_tid_info : unit -> unit
val finalize : unit -> (Thread.t, unit) Batteries.Hashtbl.t