Functor Hoare_mem.Create


module Create: 
functor (F : Formula.S) ->
functor (A : Mint.S with module F = F) ->
functor (R : Mfloat.S with module F = F) -> sig .. end
Parameters:
F : Formula.S
A : Mint.S with module F = F
R : Mfloat.S with module F = F

type m_pointer 
type pointer = m_pointer F.term 
type decl = F.decl 
val unsupported : ?model:string -> ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
type m_alloc = Formula.m_array 
val t_alloc : Formula.tau
type alloc = m_alloc F.term 
val model_ptr : Formula.m_integer F.term ->
Formula.m_integer F.term -> m_pointer F.term
val model_base : pointer -> Formula.m_integer F.term
val model_offset : pointer -> Formula.m_integer F.term
val model_shift : pointer -> F.integer -> m_pointer F.term
val model_range : F.integer -> F.integer -> F.integer -> '_a F.term
val model_rbase : '_a F.term -> '_b F.term
val model_roffset : '_a F.term -> '_b F.term
val model_range_of_ptr : pointer -> F.integer -> '_a F.term
val model_range_of_ptr_range : '_a F.term -> '_b F.term -> '_c F.term -> '_d F.term
val model_separated : '_a F.term -> '_a F.term -> F.pred
val model_valid : alloc -> '_a F.term -> F.pred
val sizeof : Ctypes.c_object -> F.integer
val n_size : F.integer -> Ctypes.c_object -> F.integer
val add_offset : F.integer -> Ctypes.c_object -> F.integer -> F.integer
val cardinal : F.integer -> F.integer -> F.integer
val offset_of_field : Cil_datatype.Fieldinfo.t -> F.integer
module Model: sig .. end
val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> 'a -> 'a
module V: Datalib.Cvalues(Model)
module L: Datalib.Create(V)
include V
module Globals: Model.F.DRegister(sig
include Model.F.Varinfo
val declare : Hoare_mem.Create.Model.F.Xindex.t ->
'a -> ('b, 'c, Hoare_mem.Create.Model.F.pred) Formula.item
val section : Formula.section
val prefix : string
val basename : Cil_types.varinfo -> string
val clear : unit -> unit
val pp_descr : Format.formatter -> 'a -> unit
end)
val global : Globals.t -> unit
val cvar : 'a -> Globals.t -> Model.loc
val inner_loc : 'a -> 'b
val lvar : 'a ->
Cil_types.logic_var ->
Model.F.var -> Model.loc
val offset : Model.loc ->
Ctypes.c_object -> F.integer -> Model.loc
val field : Model.loc ->
Cil_datatype.Fieldinfo.t -> Model.loc
val shift : Model.loc ->
Ctypes.c_object -> F.integer -> Model.loc
val index : Model.loc ->
Ctypes.c_object -> F.integer -> Model.loc
val startof : 'a -> 'b -> 'a

type mem = {
   vars : Model.F.var Cil_datatype.Varinfo.Hashtbl.t;
   x_alloc : Model.F.var;
   alloc : alloc;
}
val mem : unit -> mem
val get_var : L.F.var Cil_datatype.Varinfo.Hashtbl.t ->
Cil_datatype.Varinfo.Hashtbl.key -> L.F.var
Get the wp variable of the C variable.
val load : 'a -> 'b -> 'c -> 'd
val base_address : 'a -> Model.loc -> Model.loc
val block_length : mem ->
Model.loc -> 'a Model.F.term
val update : at:mem ->
here:mem ->
L.F.pred -> L.F.pred
val quantify : mem ->
L.F.pred -> L.F.pred
val subst_lval : 'a -> 'b -> 'c -> 'd -> 'e -> 'f
val alloc : Model.F.array ->
Model.F.integer ->
Model.F.abstract -> Model.F.array
val free : Model.F.array ->
Model.F.integer -> Model.F.array
val alloc_vars : mem ->
Model.F.Xindex.t list ->
L.F.pred -> L.F.pred
val free_vars : mem ->
Model.F.Xindex.t list ->
L.F.pred -> L.F.pred
val notexists_vars : mem ->
Model.F.Xindex.t list ->
Model.F.pred -> Model.F.pred
val global_scope : mem ->
L.F.pred -> Model.F.pred
val local_scope : mem ->
Model.F.Xindex.t list ->
Mcfg.scope -> L.F.pred -> L.F.pred
val range_of_assignable : Model.loc Model.F.assigned -> '_a F.term
val valid : mem ->
Model.loc Model.F.assigned -> F.pred
val separated : 'a ->
Model.loc Model.F.assigned ->
Model.loc Model.F.assigned -> F.pred
type m_dzone 
type dzone = m_dzone Model.F.term 
val tau_of_dzone : Formula.tau
val dzone_assigned : 'a -> 'b -> 'c
val dzone_subset : 'a -> 'b -> 'c
val dzone_union : 'a -> 'b -> 'c
val dzone_empty : unit -> 'a
val effect_supported : bool
val assigns_goal : 'a -> 'b -> 'c -> 'd
val assigns_supported : bool
val subst_havoc : 'a -> 'b -> 'c

type closure =
| Var of Cil_types.varinfo
| Alloc
val pp_closure : Format.formatter -> closure -> unit
val userdef_mem_signature : mem ->
(Model.F.var * closure) list
val userdef_mem_apply : mem ->
closure -> Formula.m_abstract Model.F.term
type formal = unit 
val pp_formal : Format.formatter -> 'a -> unit
val userdef_is_ref_param : Cil_types.logic_var -> bool
val userdef_ref_signature : mem ->
(Model.F.var * Cil_types.logic_var * formal)
list
val userdef_ref_apply : mem ->
formal -> Model.loc -> value
val userdef_ref_has_cvar : Cil_types.logic_var -> bool