module L: Translate_prop.Create
(
WpModel
)
module F: M.D.F
module D: M.D
type
userdef = {
|
d_info : Cil_types.logic_info ; |
|
d_callname : string ; |
|
d_implicit : F.var list ; |
|
d_closure : M.closure list ; |
|
d_formals : F.var list ; |
}
type
axiomdef = {
|
a_name : string ; |
|
a_labels : string list ; |
|
a_hyp_name : string ; |
|
a_def_name : string ; |
|
a_implicit : F.var list ; |
|
a_closure : M.closure list ; |
|
a_property : F.pred ; |
}
module Hdef: Cil_datatype.Logic_var.Hashtbl
val user_axioms : (string, D.F.pred) Hashtbl.t
val user_axiomdefs : (string, axiomdef option) Hashtbl.t
val user_variables : Formula.abstract F.term Hdef.t
val user_definitions : (userdef *
(string * D.F.pred Formula.item) list)
Hdef.t
module UserVariable: D.Register
(
sig
end
)
val get_user_variable : Hdef.key ->
Formula.abstract F.term
val pp_closures : Format.formatter ->
F.var list -> M.closure list -> unit
val pp_formals : Format.formatter -> F.var list -> unit
module UserAxiom: D.Register
(
sig
end
)
module UserDefinition: sig
.. end
module UserAxiomDefs: sig
.. end
type
xvar =
| |
PrmVar of M.value |
| |
MemVar |
type
env = {
|
formals_in_pre : bool ; |
|
frame : M.frame ; |
|
label : Clabels.c_label ; |
|
lvars : Formula.abstract F.term Cil_datatype.Logic_var.Map.t ; |
|
xvars : M.value Cil_datatype.Varinfo.Map.t ; |
}
val env_at : env -> Clabels.c_label -> env
val get_frame : env -> M.frame
val mem_at_env : env -> M.mem
val quant_env : env ->
(Cil_datatype.Logic_var.Map.key *
Formula.abstract F.term)
list -> env
val env_body : M.frame -> env
val call_post : Kernel_function.t ->
M.value list ->
M.mem -> M.mem -> M.D.F.var option -> env
val call_pre : Kernel_function.t -> M.value list -> M.mem -> env
val call_exit : env -> M.D.F.var -> env
val assigns_clause : M.frame -> env
val lvar : Formula.abstract F.term Cil_datatype.Logic_var.Map.t ->
Cil_datatype.Logic_var.Map.key ->
Formula.abstract F.term
val add_lvar : env ->
Cil_datatype.Logic_var.Map.key ->
Formula.abstract F.term -> env
val xvar_of_varinfo : env ->
Cil_datatype.Varinfo.Map.key -> xvar
type
kind =
val pp_kind : Format.formatter -> kind -> unit
type
data =
| |
Data of Formula.abstract F.term |
| |
Loc of M.loc |
| |
Value of M.value |
| |
Interval of D.interval |
| |
Range of Ctypes.c_object * M.loc * D.interval |
| |
List of data list |
| |
Set of D.set |
val pp_data : Format.formatter -> data -> unit
val data_of_integer : Formula.integer F.term -> data
val data_of_real : Formula.real F.term -> data
val data_of_boolean : Formula.boolean F.term -> data
val integer_of_value : M.value -> M.D.integer
val real_of_value : M.value -> M.D.real
val extract_from_data : data -> 'a F.term
val boolean_of_data : data -> Formula.boolean F.term
val array_of_data : data -> D.array
val record_of_data : data -> D.record
val urecord_of_data : data -> D.urecord
val loc_of_data : Ctypes.c_object -> data -> M.loc
val integer_of_data : kind ->
data -> Formula.integer F.term
val real_of_data : kind ->
data -> Formula.real F.term
val set_of : data -> D.set
val list_of : data -> data list
val union_data : data ->
data -> data
val union_map : ('a -> data) -> 'a list -> data
val term_of_data : data -> Formula.abstract F.term
val neg_interval : D.interval -> D.interval
val object_of_pointed : kind -> Ctypes.c_object
val kind_of_typ : Cil_types.typ -> kind
val kind_of_data : Cil_types.typ -> data -> kind
val kind_of : Cil_types.logic_type -> kind
val typ_of_elements : Cil_types.logic_type -> Cil_types.typ
val data_rec : (env -> Cil_types.term -> data)
Pervasives.ref
val rec_apply_function : (env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Formula.abstract F.term)
Pervasives.ref
val assigned_of_data : Ctypes.c_object ->
M.loc D.assigned list ->
data -> M.loc D.assigned list
val data_valid : M.mem ->
kind ->
data -> F.pred
val data_separated : Ctypes.c_object * data ->
Ctypes.c_object * data -> F.pred
val data_shift_range : Ctypes.c_object ->
M.loc ->
kind ->
data -> is_pos:bool -> data
val data_index_range : Ctypes.c_object ->
M.loc ->
kind ->
data -> data
val data_shift : kind ->
data ->
kind ->
data -> is_pos:bool -> data
val data_index : Ctypes.c_object ->
kind ->
data ->
kind ->
data -> data
val data_field : kind ->
data ->
Cil_types.fieldinfo -> data
val data_startof_set : Ctypes.c_object -> data -> data
val data_startof : Ctypes.c_object ->
kind ->
data -> data
val data_load : env ->
Cil_types.typ -> data -> data
val logic_offset : env ->
Formula.abstract F.term ->
Cil_types.term_offset -> data
val loc_offset : env ->
M.loc -> Cil_types.typ -> Cil_types.term_offset -> M.loc
val memory_offset : env ->
Cil_types.typ ->
data ->
Cil_types.term_offset -> Cil_types.typ * data
val gaddress_of_cvar : env ->
Cil_types.varinfo ->
Cil_types.term_offset -> Cil_types.typ * data
val gaddress_of_mem : env ->
Cil_types.term ->
Cil_types.term_offset -> Cil_types.typ * data
val gstartof : Cil_types.typ * data -> data
val gstartof_cvar : env ->
Cil_types.varinfo -> Cil_types.term_offset -> data
val gstartof_mem : env ->
Cil_types.term -> Cil_types.term_offset -> data
val gstartof_value : env ->
Cil_types.typ ->
M.value -> Cil_types.term_offset -> data
val cast : data ->
kind ->
kind -> data
val int_op : Cil_types.binop ->
Formula.integer F.term ->
Formula.integer F.term ->
Formula.integer F.term
val real_op : Cil_types.binop ->
Formula.real F.term ->
Formula.real F.term ->
Formula.real F.term
val rel_op : Cil_types.relation -> Cil_types.binop
val real_cmp : Cil_types.binop ->
Formula.real F.term ->
Formula.real F.term ->
Formula.boolean F.term
val int_cmp : Cil_types.binop ->
Formula.integer F.term ->
Formula.integer F.term ->
Formula.boolean F.term
val preal_cmp : Cil_types.binop ->
Formula.real F.term ->
Formula.real F.term -> F.pred
val pint_cmp : Cil_types.binop ->
Formula.integer F.term ->
Formula.integer F.term -> F.pred
val ptr_rel : Cil_types.binop ->
D.pointer ->
D.pointer -> D.F.pred
val ptr_cmp : Cil_types.binop ->
D.pointer ->
D.pointer -> D.boolean
val plus : Formula.integer F.term ->
Formula.integer F.term ->
Formula.integer F.term
val plus_interval : D.interval ->
Formula.integer F.term ->
D.interval
val plus_interval_interval : D.interval ->
D.interval -> data
val add_integer : kind ->
data ->
kind ->
data -> data
val data_cmp : Cil_types.binop ->
kind ->
data ->
kind ->
data -> Formula.boolean F.term
val data_binop : kind ->
Cil_types.binop ->
kind ->
data ->
kind ->
data -> data
val data_unop : kind ->
Cil_types.unop ->
kind ->
data -> data
val data_const : Cil_types.constant -> data
val data_of_term : env -> Cil_types.term -> data
val term : env ->
Cil_types.term -> Formula.abstract F.term
term e t
interprets the C terms t
in memory model environment e
as a logic term.*
val data_of_assignable : env -> Cil_types.term -> data
val assigned : env ->
Cil_types.term -> M.loc D.assigned list
Compiles an arbitrary term representing a set of left-values into a zone
val rec_apply_predicate : (env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> F.pred)
Pervasives.ref
val pred_cmp : Cil_types.binop ->
kind ->
data ->
kind ->
data -> F.pred
val prop : env ->
Cil_types.predicate Cil_types.named -> F.pred
prop e p
interprets an ACSL predicate as a logic predicats
in memory model environment e
. *
val prop_body : env ->
Cil_types.predicate Cil_types.named -> F.pred
val get_axiom : string -> axiomdef option
type
partial =
val hints : int Pervasives.ref
val pp_partial : Format.formatter -> partial -> unit
val apply_sigma : env ->
(string * Clabels.c_label) list -> M.closure -> partial
class instance : axiomdef -> partial list ->
object
.. end
val instance_of_hint : env ->
Axiomatics.hint -> instance option
val saturate : instance list ->
env ->
Axiomatics.hint list -> instance list
val hint_context : instance list option Pervasives.ref
val push_instances : string -> instance list -> unit
val pop_instances : string -> instance list
val apply_hints : env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list -> unit
val do_instantiate : (< alive : bool; instantiate : F.pred option; .. >
as 'a)
list ->
F.pred ->
'a list -> 'a list * F.pred
val instantiate : (< alive : bool; instantiate : F.pred option; .. >
as 'a)
list ->
F.pred -> 'a list * F.pred
val as_hint : instance -> D.hint
val merge : (< alive : bool; id : Datatype.Int.t; .. > as 'a) list -> 'a list -> 'a list
val get_definition : (Cil_types.logic_info ->
userdef *
(string * D.F.pred Formula.item) list) ->
Cil_types.logic_info -> userdef
val push_context : string ->
instance list option * D.context
val flush_context : string ->
instance list option * D.context ->
D.F.pred -> D.F.pred
val kill_context : string ->
instance list option * D.context ->
unit
val user_env : Cil_types.logic_info ->
(instance list option * D.context) *
(Cil_types.logic_var * D.F.var) list *
env
val compile_predicate : Cil_types.logic_info ->
userdef *
(string * D.F.pred Formula.item) list
val compile_function : Cil_types.logic_info ->
userdef *
(string * F.pred Formula.item) list
val axiom_env : string -> env
val compile_user_axiom : string -> Cil_types.predicate Cil_types.named -> unit
val compile_user_hypothesis : string ->
Cil_types.logic_label list -> Cil_types.predicate Cil_types.named -> unit
val add_axiom : string ->
Cil_types.logic_label list -> Cil_types.predicate Cil_types.named -> unit
Compile an axiom and add it to the list of global declarations.
val apply_closure : env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
M.closure -> Formula.abstract M.D.F.term
val apply_predicate : env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> F.pred
val apply_function : env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> Formula.abstract F.term