Module Store_mem.Create.Z


module Z: Region.Create(D)(sig
module F: D.F
type addr = D.integer 
val pp_addr : Format.formatter -> 'a F.term -> unit
val closed : 'a F.term -> bool
val equal : 'a F.term ->
'a F.term -> F.pred
val fresh : F.pool ->
F.var * 'a F.term
end)

type addr = A.addr 
module D: D
module F: D.F

type base =
| Cvar of Cil_types.varinfo * A.addr
| Root of int * A.addr
| Base of A.addr

type range =
| Block
| Index of D.integer
| Range of D.integer * D.integer
val range_empty : range -> F.pred
val range_subset : range -> range -> F.pred
val range_disjoint : range -> range -> F.pred
type path = D.integer * D.integer 
val e_sizeof : Ctypes.c_object -> Formula.integer F.term
val e_field : Cil_types.fieldinfo -> Formula.integer F.term
val a_sizeof : Ctypes.c_object -> Formula.integer F.term
val sizeof : atomic:bool -> Ctypes.c_object -> Formula.integer F.term
val is_atomic : Ctypes.c_object -> bool
val p_block : atomic:bool ->
Ctypes.c_object ->
Formula.integer F.term * Formula.integer F.term
val p_field : atomic:bool ->
Formula.integer F.term * 'a ->
Cil_types.fieldinfo ->
Formula.integer F.term * Formula.integer F.term
val p_index : atomic:bool ->
Formula.integer F.term * 'a ->
Ctypes.c_object ->
offset:Formula.integer F.term ->
Formula.integer F.term * Formula.integer F.term
val p_range : atomic:bool ->
Formula.integer F.term * 'a ->
Ctypes.c_object ->
offset:Formula.integer F.term ->
length:Formula.integer F.term ->
Formula.integer F.term * Formula.integer F.term
val p_interval : atomic:bool ->
Formula.integer F.term * Formula.integer F.term ->
Ctypes.c_object ->
D.interval ->
Formula.integer F.term * Formula.integer F.term
module Vmap: Cil_datatype.Varinfo.Map
module Imap: Datatype.Int.Map
exception Trivial
module Merge: 
functor (M : Map.S) -> sig .. end
module Vmerge: Merge(Vmap)
module Imerge: Merge(Imap)
val forall : ('a -> F.pred) -> 'a list -> F.pred
val exists : ('a -> F.pred) -> 'a list -> F.pred
val roots : int Pervasives.ref

type region = {
   cvars : (A.addr * range list) Vmap.t;
   roots : (A.addr * range list) Imap.t;
   bases : (A.addr * range) list;
}
val pp_range : Format.formatter -> range -> unit
val pp_region : Format.formatter -> region -> unit
val empty : region
The empty region
val union_range : 'a * range list ->
'b * range list -> 'a * range list
val union : region -> region -> region
Union of arbitrary regions
val cvar : A.addr -> Cil_types.varinfo -> base
Base of a C-variable. cvar p x is the base of variable x, with p its base-address
val root : A.addr -> base
Create a fresh root, separated from base address of all variables. root p is a new root equal to pointer p.
val base : A.addr -> base
An arbitrary base-address of any allocated C memory-block.
val zone : base -> range -> region
val block : base -> region
The full block at given block
val index : base -> D.integer -> region
index b k is the cell at index k in block k. Internally, same as range b k 1. It is a safe abstraction of range b (k * s) s when all memory cells in the block have the same size in the underlying memory model.
val range : base ->
D.integer -> D.integer -> region
range b k n builds a region of length n starting at offset k in the block of base b.
val path : base ->
D.integer * D.integer -> region
val iter_others : (A.addr -> range -> unit) -> region -> unit
val iter_bases : (A.addr -> range -> unit) -> region -> unit
val is_empty : region -> F.pred
val included_ranges : range list -> range list -> F.pred
val included_find : 'a ->
A.addr ->
range list ->
('a -> 'b -> 'c * range list) ->
'b -> (A.addr * range) list -> F.pred
val included_cvars : region -> region -> F.pred
val included_roots : region -> region -> F.pred
val included_zone_in_bases : A.addr -> range -> region -> F.pred
val included_zone_in_cvars : A.addr -> range -> region -> F.pred
val included_zone_in_roots : A.addr -> range -> region -> F.pred
val included_bases : region -> region -> F.pred
val included : region -> region -> F.pred
val separated_ranges : range list -> range list -> F.pred
val separated_find : 'a ->
range list ->
('a -> 'b -> 'c * range list) -> 'b -> F.pred
val separated_cvars : region -> region -> F.pred
val separated_roots : region -> region -> F.pred
val all_separated : ((A.addr -> range -> 'a) -> 'b -> 'c) ->
((A.addr -> range -> unit) -> 'd -> 'a) ->
'b -> 'd -> F.pred
val separated_bases : region -> region -> F.pred
val separated_others_bases : region -> region -> F.pred
val separated_bases_others : region -> region -> F.pred
val separated : region -> region -> F.pred

type env = {
   pool : F.pool;
   mutable vars : F.var list;
   mutable ctxt : F.pred;
}
val fp_offset : env -> 'a F.term -> 'a F.term
val fp_size : env -> 'a F.term -> 'a F.term
val fp_addr : env -> A.addr -> A.addr
val fp_range : env -> range -> range
val fp_base : env ->
A.addr * range -> A.addr * range
val fp_map : env ->
A.addr * range list -> A.addr * range list
val fingerprint : F.pool ->
region ->
F.var list * F.pred * region