Functor Store_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

val unsupported : ?model:string -> ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
type decl = F.decl 
val t_data : Formula.tau
type m_memory = Formula.m_array 
val t_memory : Formula.tau
type store = m_memory F.term 
type m_alloc = Formula.m_array 
val t_alloc : Formula.tau
type alloc = m_alloc F.term 
type m_dzone 
type dzone = m_dzone F.term 
val data_of_int : Ctypes.c_int -> 'a F.term -> 'b F.term
val int_of_data : Ctypes.c_int -> 'a F.term -> 'b F.term
val data_of_float : Ctypes.c_float -> 'a F.term -> 'b F.term
val float_of_data : Ctypes.c_float -> 'a F.term -> 'b F.term
val addr_of_data : Formula.m_abstract F.term -> Formula.m_integer F.term
val data_of_addr : F.integer -> Formula.m_abstract F.term
val model_addr : F.integer -> F.integer -> F.integer
val model_base : F.integer -> F.integer
val model_offset : F.integer -> F.integer
val model_addr_shift : F.integer -> F.integer -> F.integer
val model_valid : alloc -> F.integer -> F.integer -> F.pred
val model_isfresh : store -> alloc -> F.integer -> F.pred
val model_alloc : alloc -> F.integer -> F.integer -> alloc
val model_free : alloc -> F.integer -> alloc
val model_block : alloc -> F.integer -> F.integer
val model_zempty : dzone
val model_zunion : dzone -> dzone -> dzone
val model_included : dzone -> dzone -> F.pred
val model_zrange : F.integer -> F.integer -> F.integer -> dzone
val model_zrange_of_addr_range : F.integer -> F.integer -> F.integer -> dzone
val model_separated : dzone -> dzone -> F.pred
val model_update_range : store ->
dzone -> F.abstract -> store
val model_access_range : store -> dzone -> F.abstract
val model_update_havoc : store ->
dzone -> F.abstract -> store
val model_ishavoc : alloc ->
store ->
dzone -> store -> F.pred

type mem = {
   x_store : F.var;
   x_alloc : F.var;
   store : store;
   alloc : alloc;
}
val encode : 'a F.term -> 'b F.term -> 'c F.term
val decode : 'a F.term -> 'b F.term -> 'c F.term
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
module Globals: F.DRegister(sig
include F.Varinfo
val declare : F.Xindex.t -> 'a -> ('b, 'c, 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)
module Data: sig .. end
module DF: Data_mem.Create(Data)
include Data
val startof : 'a -> 'b -> 'a
val base_address : 'a -> Model.loc -> Model.loc
val block_length : 'a -> Model.loc -> Model.F.integer
val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> 'a -> 'a
val zrange : Model.loc -> F.integer -> dzone
module SofData: Model.F.DRegister(sig
include Model.F.Compinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Cil_types.compinfo -> unit
val declare : Cil_types.compinfo -> 'a -> ('b, 'c, 'd) Formula.item
end)
module DataofS: Model.F.DRegister(sig
include Model.F.Compinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Cil_types.compinfo -> unit
val declare : Cil_types.compinfo -> 'a -> ('b, 'c, 'd) Formula.item
end)
val s_of_data : SofData.t ->
'a Model.F.term -> 'b Model.F.term
val data_of_s : SofData.t ->
'a Model.F.term -> 'b Model.F.term
module Ax2SofData: Model.F.DRegister(sig
include Model.F.Compinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Cil_types.compinfo -> unit
val declare : Store_mem.Create.SofData.t ->
'a -> ('b, 'c, Store_mem.Create.Model.F.pred) Formula.item
end)
module Ax3IsSofData: Model.F.DRegister(sig
include Model.F.Compinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Cil_types.compinfo -> unit
val declare : Store_mem.Create.SofData.t ->
'a -> ('b, 'c, Store_mem.Create.Model.F.pred) Formula.item
end)
val coerce_comp : SofData.t -> unit
val s_of_data : SofData.t ->
'a Model.F.term -> 'b Model.F.term
val data_of_s : SofData.t ->
'a Model.F.term -> 'b Model.F.term
module AofData: Model.F.DRegister(sig
include Model.F.Arrayinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Ctypes.arrayinfo -> unit
val declare : Ctypes.arrayinfo -> 'a -> ('b, 'c, 'd) Formula.item
end)
module DataofA: Model.F.DRegister(sig
include Model.F.Arrayinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Ctypes.arrayinfo -> unit
val declare : Ctypes.arrayinfo -> 'a -> ('b, 'c, 'd) Formula.item
end)
val a_of_data : AofData.t ->
'a Model.F.term -> 'b Model.F.term
val data_of_a : AofData.t ->
'a Model.F.term -> 'b Model.F.term
module Ax2AofData: Model.F.DRegister(sig
include Model.F.Arrayinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Ctypes.arrayinfo -> unit
val declare : Store_mem.Create.AofData.t ->
'a -> ('b, 'c, Store_mem.Create.Model.F.pred) Formula.item
end)
module Ax3IsAofData: Model.F.DRegister(sig
include Model.F.Arrayinfo
val prefix : string
val section : Formula.section
val clear : unit -> unit
val pp_title : Format.formatter -> Ctypes.arrayinfo -> unit
val declare : Store_mem.Create.AofData.t ->
'a -> ('b, 'c, Store_mem.Create.Model.F.pred) Formula.item
end)
val coerce_arr : AofData.t -> unit
val a_of_data : AofData.t ->
'a Model.F.term -> 'b Model.F.term
val data_of_a : AofData.t ->
'a Model.F.term -> 'b Model.F.term
val load_with : 'a F.term ->
Model.F.array -> Model.loc -> 'b F.term
val load_mem : Model.F.array ->
Ctypes.c_object -> Model.loc -> value
val store_with : Model.F.array ->
Model.loc ->
'a F.term -> 'b F.term -> Model.F.array
val store_mem : Model.F.array ->
Ctypes.c_object ->
Model.loc -> value -> Model.F.array
val load : mem ->
Ctypes.c_object -> Model.loc -> value
val tau_of_dzone : Formula.tau

type assignable =
| Xrange of Model.F.integer * Model.F.integer
* Model.F.integer
| Arange of Model.F.integer * Model.F.integer
* Model.F.integer
| Ablock of Model.F.integer
val addr_of_assignable : assignable -> F.integer
val zone_of_assignable : assignable -> dzone
val assignable_loc : Ctypes.c_object -> Model.loc -> assignable
val assignable_range : mem ->
Ctypes.c_object ->
Model.loc ->
Model.F.interval -> assignable
val assignable : mem ->
Model.loc Model.F.assigned ->
assignable
val dzone_assigned : mem ->
Model.loc Model.F.assigned ->
dzone
val dzone_subset : dzone -> dzone -> F.pred
val dzone_union : dzone -> dzone -> dzone
val dzone_empty : unit -> dzone
val effect_supported : bool
val assignable_sizeof : 'a Model.F.assigned -> F.integer
val valid : mem ->
Model.loc Model.F.assigned -> F.pred
val get_zrange_opt : Model.loc Model.F.assigned ->
(Model.loc * F.integer) option
val separated : mem ->
Model.loc Model.F.assigned ->
Model.loc Model.F.assigned ->
Model.F.pred
val update : at:mem -> here:mem -> L.F.pred -> L.F.pred
val quantify : mem -> L.F.pred -> L.F.pred
val subst_lval : mem ->
Ctypes.c_object ->
Model.loc -> value -> L.F.pred -> L.F.pred
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 fresh_vars : mem ->
Model.F.Xindex.t list ->
Model.F.pred -> Model.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 filter_scope : Model.F.pred ->
Model.F.Xindex.t list ->
Model.F.Xindex.t list
val local_scope : mem ->
Model.F.Xindex.t list ->
Mcfg.scope -> Model.F.pred -> Model.F.pred
val subst_havoc : mem ->
Model.loc Model.F.assigned ->
Model.F.havoc list
val region : mem ->
Model.loc Model.F.assigned list ->
dzone
val assigns_goal : mem ->
Model.loc Model.F.assigned list ->
mem -> F.pred
val assigns_supported : bool

type closure =
| Mem
| Alloc
val pp_closure : Format.formatter -> closure -> unit
val userdef_mem_signature : mem -> (F.var * closure) list
val userdef_mem_apply : mem ->
closure -> Model.F.abstract
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