module Create:
module F: M.F
module L: M.L
type
user_formal =
type
userdef = {
}
type
axiomlabel = {
|
a_name : string ; |
|
a_defname : string ; |
|
a_property : F.pred ; |
|
a_memory : user_formal list ; |
}
module Hdef: Cil_datatype.Logic_var.Hashtbl
val user_axioms : (string, F.pred option) Hashtbl.t
val user_axiomlabels : (string, axiomlabel option) Hashtbl.t
val user_definitions : userdef Hdef.t
val pp_closures : Format.formatter ->
F.var list * (M.closure * string) list -> unit
val pp_formals : Format.formatter -> F.var list -> unit
module UserDefinition: sig
.. end
module UserAxiom: F.DRegister
(
sig
end
)
module UserAxiomDefs: sig
.. end
module Lmap: Map.Make
(
sig
end
)
type
frame = {
|
mutable states : M.mem Lmap.t ; |
|
mutable result : F.var option ; |
|
mutable status : F.var option ; |
|
mutable return : Cil_types.typ option ; |
}
val new_frame : Kernel_function.t ->
?m_here:M.mem ->
?m_pre:M.mem ->
?m_post:M.mem ->
?x_result:F.var ->
?x_status:F.var -> unit -> frame
val user_frame : unit -> frame
val result : frame -> F.var
val status : frame -> F.var
type
lvar_kind =
| |
Logic_cvar of Cil_types.varinfo |
| |
Logic_value of M.value |
| |
Logic_term of F.abstract |
| |
Logic_var of F.var |
| |
Logic_byref |
type
env = {
|
formals_in_pre : bool ; |
|
frame : frame ; |
|
label : Clabels.c_label ; |
|
xvars : M.value Cil_datatype.Varinfo.Map.t ; |
|
lvars : lvar_kind Cil_datatype.Logic_var.Map.t ; |
|
mutable laddr : F.var Cil_datatype.Logic_var.Map.t ; |
}
val fresh_addr : Cil_types.logic_var -> F.var
val addr_of_ref : env ->
Cil_datatype.Logic_var.Map.key -> F.var
val rec_apply_function : (env ->
Cil_types.logic_info ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
Cil_types.term list -> F.abstract)
Pervasives.ref
val lvar : env ->
Cil_datatype.Logic_var.Map.key -> lvar_kind
val xvar : env -> Cil_datatype.Varinfo.Map.key -> M.value option
val fresh_local : Cil_types.logic_var -> F.var
val fresh_logic_var : F.pool ->
Cil_types.logic_var -> F.var
val add_logic_vars : env ->
F.pool ->
Cil_datatype.Logic_var.Map.key list -> env
val collect_logic_vars : env -> F.var list
to be used to retreive variable add through add_logic_vars
.
val bind_lvars : env ->
(Cil_datatype.Logic_var.Map.key * F.abstract) list ->
env
val bind_lvar : env ->
Cil_datatype.Logic_var.Map.key ->
F.abstract -> env
val bind_fresh : env ->
Cil_datatype.Logic_var.Map.key ->
F.var * env
val env_at : env -> Clabels.c_label -> env
val find_mem : env -> Lmap.key -> M.mem option
val mem_at : env -> Lmap.key -> M.mem
val mem_at_env : env -> M.mem
val subst_result : env ->
M.value option ->
L.F.pred -> L.F.pred
val result_type : env -> Cil_types.typ
val exit_status : env -> F.var
val env : Kernel_function.t ->
?m_here:M.mem ->
?m_pre:M.mem ->
?m_post:M.mem ->
?x_result:F.var -> unit -> env
val bind_formals : Kernel_function.t -> 'a list -> 'a Cil_datatype.Varinfo.Map.t
val call_pre : env ->
Kernel_function.t -> M.value list -> M.mem -> env
val call_post : env ->
Kernel_function.t ->
M.value list ->
M.mem ->
M.mem -> F.var option -> env
val call_exit : env ->
Kernel_function.t ->
M.value list ->
M.mem -> M.mem -> F.var -> env
type
kind =
val kind_equal : kind -> kind -> bool
val pp_kind : Format.formatter -> kind -> unit
type
data =
| |
Data of F.abstract |
| |
Loc of M.loc |
| |
Value of M.value |
| |
Interval of F.interval |
| |
Range of Ctypes.c_object * M.loc * F.interval |
| |
List of data list |
| |
Set of F.set |
val pp_data : Format.formatter -> data -> unit
val data_of_integer : F.integer -> data
val data_of_real : F.real -> data
val data_of_boolean : F.boolean -> data
val integer_of_value : M.value -> M.F.integer
val real_of_value : M.value -> M.F.real
: data -> 'a F.term
val boolean_of_data : data -> F.boolean
val array_of_data : data -> F.array
val record_of_data : data -> F.record
val urecord_of_data : data -> F.urecord
val loc_of_data : Ctypes.c_object -> data -> M.loc
val integer_of_data : kind ->
data -> F.integer
val real_of_data : kind ->
data -> F.real
val set_of : data -> F.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 -> F.abstract
val neg_interval : F.interval -> F.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 assigned_of_data : Ctypes.c_object ->
M.loc F.assigned list ->
data -> M.loc F.assigned list
val data_valid : M.mem ->
kind ->
data -> F.pred
val data_separated : M.mem ->
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 ->
F.abstract ->
Cil_types.term_offset -> data
val loc_offset : env ->
M.loc -> Ctypes.c_object -> 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_ref : env ->
Cil_datatype.Logic_var.Map.key ->
Cil_types.term_offset -> 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 ->
F.integer ->
F.integer -> F.integer
val real_op : Cil_types.binop ->
F.real ->
F.real -> F.real
val rel_op : Cil_types.relation -> Cil_types.binop
val real_cmp : Cil_types.binop ->
F.real ->
F.real -> F.boolean
val int_cmp : Cil_types.binop ->
F.integer ->
F.integer -> F.boolean
val preal_cmp : Cil_types.binop ->
F.real ->
F.real -> F.pred
val pint_cmp : Cil_types.binop ->
F.integer ->
F.integer -> F.pred
val ptr_rel : Cil_types.binop -> M.loc -> M.loc -> F.pred
val ptr_cmp : Cil_types.binop -> M.loc -> M.loc -> M.F.boolean
val plus : F.integer ->
F.integer -> F.integer
val plus_interval : F.interval ->
F.integer -> F.interval
val plus_interval_interval : F.interval ->
F.interval -> data
val add_integer : kind ->
data ->
kind ->
data -> data
val data_cmp : Cil_types.binop ->
kind ->
data ->
kind ->
data -> F.boolean
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 -> F.abstract
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 F.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_definition : (Cil_types.logic_info ->
userdef *
(string *
(F.var, F.abstract,
F.pred)
Formula.item)
list) ->
Cil_types.logic_info -> userdef
val push_context : string -> L.context
val flush_context : string ->
L.context ->
L.F.pred -> L.F.pred
val kill_context : string -> L.context -> unit
val user_default_label : Cil_types.logic_label list -> Clabels.c_label
val user_env : Cil_types.logic_info ->
L.context * user_formal list *
env
val collect_signature : user_formal list ->
(F.var -> bool) ->
env -> user_formal list
val flatten_formals : user_formal list -> F.var list
val flatten_references : (F.var * M.formal * string) list ->
user_formal list -> F.var list
val all_filter : F.var -> bool
val term_filter : 'a F.term -> F.var -> bool
val pred_filter : F.pred -> F.var -> bool
val compile_predicate : Cil_types.logic_info ->
userdef *
(string * ('a, 'b, L.F.pred) Formula.item) list
val compile_function : Cil_types.logic_info ->
userdef *
(string * ('a, 'b, F.pred) Formula.item) list
val axiom_env : string -> env
val compile_user_axiom : 'a -> Cil_types.predicate Cil_types.named -> L.F.pred
val compile_user_axiom_labels : string ->
Cil_types.logic_label list * Cil_types.predicate Cil_types.named ->
axiomlabel
val compile_and_define : ('a, 'b option) Hashtbl.t ->
'a -> 'c -> ('a -> 'c -> 'b) -> ('a -> 'b -> unit) -> 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 bool_of_option : 'a option -> bool
val apply_formals : env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
user_formal list ->
data list -> F.abstract list
val apply_references : env ->
(Cil_types.logic_label * Cil_types.logic_label) list ->
(F.var * M.formal * string) list ->
data ->
user_formal list ->
data list -> F.abstract list
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 -> F.abstract