Module Concurrency.RacerDDomain

module AccessExpression = Absint.HilExp.AccessExpression
module F = Stdlib.Format
val apply_to_first_actual : Absint.HilExp.t list -> 'a -> f:(Absint.HilExp.access_expression -> 'a) -> 'a
val pp_exp : F.formatter -> AccessExpression.t -> unit

language sensitive pretty-printer

module Access : sig ... end
module LockDomain : sig ... end

Overapproximation of number of times the lock has been acquired

module ThreadsDomain : sig ... end

Abstraction of threads that may run in parallel with the current thread. NoThread < AnyThreadExceptSelf < AnyThread

module OwnershipAbstractValue : sig ... end
module AccessSnapshot : sig ... end

snapshot of the relevant state at the time of a heap access: concurrent thread(s), lock(s) held, ownership precondition

module AccessDomain : Absint.AbstractDomain.FiniteSetS with type FiniteSetS.elt = AccessSnapshot.t
module OwnershipDomain : sig ... end
module Attribute : sig ... end
module AttributeMapDomain : sig ... end
type t = {
threads : ThreadsDomain.t;

current thread: main, background, or unknown

locks : LockDomain.t;

boolean that is true if a lock must currently be held

accesses : AccessDomain.t;

read and writes accesses performed without ownership permissions

ownership : OwnershipDomain.t;

map of access paths to ownership predicates

attribute_map : AttributeMapDomain.t;

map of access paths to attributes such as owned, functional, ...

}
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val add_unannotated_call_access : Absint.FormalMap.t -> IR.Procname.t -> Absint.HilExp.t list -> IBase.Location.t -> t -> t
type summary = {
threads : ThreadsDomain.t;
locks : LockDomain.t;
accesses : AccessDomain.t;
return_ownership : OwnershipAbstractValue.t;
return_attribute : Attribute.t;
attributes : AttributeMapDomain.t;
}

same as astate, but without attribute_map (since these involve locals) and with the addition of the ownership/attributes associated with the return value as well as the set of formals which may escape

val empty_summary : summary
val pp_summary : F.formatter -> summary -> unit
val astate_to_summary : IR.Procdesc.t -> Absint.FormalMap.t -> t -> summary
val add_access : IR.Tenv.t -> Absint.FormalMap.t -> IBase.Location.t -> is_write:bool -> t -> Absint.HilExp.t -> t
val add_container_access : IR.Tenv.t -> Absint.FormalMap.t -> is_write:bool -> Absint.AccessPath.base -> IR.Procname.t -> Absint.HilExp.t list -> IBase.Location.t -> t -> t
val add_reads_of_hilexps : IR.Tenv.t -> Absint.FormalMap.t -> Absint.HilExp.t list -> IBase.Location.t -> t -> t
val integrate_summary : Absint.FormalMap.t -> callee_proc_desc:IR.Procdesc.t -> summary -> Absint.HilExp.access_expression -> IR.Procname.t -> Absint.HilExp.t list -> IBase.Location.t -> t -> t