module Create:
type
addr = A.addr
module D: D
module F: D.F
type
base =
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:
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