Module Concurrency.RacerDDomain

module AccessExpression = Absint.HilExp.AccessExpression
module F = Stdlib.Format
val pp_exp : F.formatter -> AccessExpression.t -> unit

language sensitive pretty-printer

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

Overapproximation of number of time 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 : sig ... end
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