Module Create.Numeric

include Domains.Domain_sig.Minimal
include Domains.Domain_sig.Minimal_No_Boolean
include Domains.Domain_sig.With_Id
val name : string
include Domains.Domain_sig.With_Context
val root_context : unit -> Context.t
val context_pretty : Stdlib.Format.formatter -> Context.t -> unit
type boolean
include Domains.Domain_sig.With_Assume with module Context := Context and type boolean := boolean
val assume : Context.t -> boolean -> Context.t option

Corresponds to the creation of a new basic block, accessible only if the condition is met. None means bottom.

val imperative_assume : Context.t -> boolean -> unit

Because the transfer functions imperatively change the context, they cannot use assume, that returns a new context. Temporarily, we provide this instead (it should be applied only to fresh symbolic variables and not modify the set of valuations of the other symbolic variables. In particular, the condition must never make the context bottom).

The good long-term solution would be to make every transfer function return a new Context.t option, viewing the context as some state monad.

include Domains.Domain_sig.With_Nondet with module Context := Context
val typed_nondet2 : Context.t -> Context.t -> 'a Context.in_tuple -> Context.t * 'a Context.out_tuple
val nondet_same_context : Context.t -> 'a Context.in_tuple -> 'a Context.out_tuple
include Domains.Domain_sig.With_Fixpoint_Computation with module Context := Context
val mu_context_open : Context.t -> Context.t
val typed_fixpoint_step : init:Context.t -> arg:Context.t -> body:Context.t -> (bool * 'a Context.in_tuple) -> bool * (close:bool -> 'a Context.out_tuple * Context.t)
include Domains.Domain_sig.With_Boolean with module Context := Context and type boolean := boolean
module Boolean : Datatype_sig.S with type t = boolean
val boolean_pretty : Context.t -> Stdlib.Format.formatter -> boolean -> unit
val serialize_boolean : Context.t -> boolean -> Context.t -> boolean -> 'a Context.in_acc -> (boolean, 'a) Context.result
val boolean_empty : Context.t -> boolean
val boolean_unknown : Context.t -> boolean
val query_boolean : Context.t -> boolean -> Lattices.Quadrivalent.t
type binary
type memory
include Domains.Domain_sig.With_Queries with module Context := Context and type binary := binary and type memory := memory
module Query : sig ... end
val should_focus : size:int -> Context.t -> memory -> binary -> (binary * int * int) option

should_focus ~size ctx mem addr asks the domain whether it is useful to "focus" (or "unfold", i.e. try to represent precisely the memory region pointed to by addr, as long as aliasing info ensures that it is sound) a loaded value. size should be the size of addr. If the answer is yes, then the returned value should contain three things about the region to focus: its base, its size (in bits) and the offset of addr in it (in bits).

val may_alias : ptr_size:int -> Context.t -> size1:int -> size2:int -> binary -> binary -> bool

may_alias ~ptr_size ~size1 ~size2 ctx addr1 addr2 should return whether the region starting at addr1 of size size1 bytes and the region starting at addr2 of size size2 bytes may have a non-empty intersection. This function is used by focusing abstractions to discard a focused region when writing in a possibly aliased address. ptr_size is the size in bits of both addr1 and addr2.

include Domains.Domain_sig.With_Types with module Context := Context and type binary := binary
val binary_unknown_typed : size:int -> Context.t -> Types.Ctypes.typ -> binary

Returns an unknown value with a given type.

include Domains.Domain_sig.With_Binary with module Context := Context and type binary := binary and type boolean := boolean
module Binary : Datatype_sig.S with type t = binary
val binary_pretty : size:int -> Context.t -> Stdlib.Format.formatter -> binary -> unit
val serialize_binary : size:int -> Context.t -> binary -> Context.t -> binary -> 'a Context.in_acc -> (binary, 'a) Context.result
val binary_empty : size:int -> Context.t -> binary
val binary_unknown : size:int -> Context.t -> binary
include Domains.Domain_sig.With_Memory with module Context := Context and type memory := memory and type binary := binary and type boolean := boolean
val serialize_memory : Context.t -> memory -> Context.t -> memory -> 'a Context.in_acc -> (memory, 'a) Context.result
val memory_pretty : Context.t -> Stdlib.Format.formatter -> memory -> unit
include Transfer_functions.Builtin.With_Builtin with type binary := binary and type boolean := boolean and type memory := memory and module Context := Context
val builtin_show_each_in : string -> Context.t -> (int * binary) list -> memory -> memory