Frama-C:
Plug-ins:
Libraries:

Frama-C API - Make_Memory

Parameters

module _ : sig ... end
module Value : Value

Signature

include Frama_c_kernel.Datatype.S_with_collections
include Frama_c_kernel.Datatype.S
include Frama_c_kernel.Datatype.S_no_copy
include Frama_c_kernel.Datatype.Ty
type t
val datatype_name : string

Unique name of the datatype.

val datatype_descr : t Frama_c_kernel.Descr.t

Datatype descriptor.

Packed version of the descriptor.

val reprs : t list

List of representants of the descriptor.

val equal : t -> t -> bool

Equality: same spec than Stdlib.(=).

val compare : t -> t -> int

Comparison: same spec than Stdlib.compare.

val hash : t -> int

Hash function: same spec than Hashtbl.hash.

val pretty : Stdlib.Format.formatter -> t -> unit

Pretty print each value in an user-friendly way.

val mem_project : (Frama_c_kernel.Project_skeleton.t -> bool) -> t -> bool

mem_project f x must return true iff there is a value p of type Project.t in x such that f p returns true.

val copy : t -> t

Deep copy: no possible sharing between x and copy x.

module Set : Frama_c_kernel.Datatype.Set with type elt = t
module Map : Frama_c_kernel.Datatype.Map with type key = t
include S with type t := t and type value := Value.t

add loc typ v state binds loc to v in state. If typ does not match the effective type of the location pointed, V.top is bound instead. This function automatically handles the case where loc abstracts multiple locations, or when some locations are not tracked by the domain.

find loc typ state returns the join of the abstract values stored in the locations abstracted to by loc in state, assuming the result has type typ. When loc includes untracked locations, or when typ does not match the type of the locations in loc, the result is approximated.

remove loc state drops all information on the locations pointed to by loc from state.

val remove_variables : Frama_c_kernel.Cil_types.varinfo list -> t -> t

remove_variables list state drops all information about the variables in list from state.

val fold : (Frama_c_kernel.Base.t -> Value.t -> 'a -> 'a) -> t -> 'a -> 'a

Fold on base value pairs.

val top : t

The top abstraction, which maps all variables to V.top.

val join : t -> t -> t
val is_included : t -> t -> bool