diff --git a/nix/default.nix b/nix/default.nix
index 756bdf1c202ea70444b800bc42c1d78cdacb68ce..0d009e770468eb9641ab54d1309c618baf303d22 100644
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -253,7 +253,9 @@ pkgs.lib.makeExtensible
HOME=$(pwd)/home
why3 config detect
make src/plugins/aorai/tests/ptests_config
- make PTESTS_OPTS="-config prove -error-code" Aorai_TESTS
+ export AORAI_WP_CACHE=replay
+ export AORAI_WP_CACHEDIR=${plugins.wp-cache.src}
+ make PTESTS_OPTS="-error-code" aorai-test-prove
'';
installPhase = ''
diff --git a/src/kernel_services/ast_queries/cil.ml b/src/kernel_services/ast_queries/cil.ml
index dbc7926e884bfe459f87308bc0668ecf9f95eca6..231a898d58b03a79d88aaf049d1e37c0792776cc 100644
--- a/src/kernel_services/ast_queries/cil.ml
+++ b/src/kernel_services/ast_queries/cil.ml
@@ -5884,7 +5884,11 @@ let mkBinOp ~loc op e1 e2 =
if isIntegralType tres then
make_expr tres tres
else
- Kernel.fatal ~current:true "mkBinOp: %a" !pp_exp_ref (dummy_exp(BinOp(op,e1,e2,intType)))
+ Kernel.fatal
+ ~current:true
+ "@[mkBinOp: unsupported non integral result type for integral \
+ arithmetic@ %a@]"
+ !pp_exp_ref (dummy_exp(BinOp(op,e1,e2,intType)))
in
let compare_pointer op ?cast1 ?cast2 e1 e2 =
let do_cast e = function
@@ -5945,8 +5949,13 @@ let mkBinOp ~loc op e1 e2 =
compare_pointer ~cast1:theMachine.upointType ~cast2:theMachine.upointType
op e1 e2
| _ ->
- Kernel.fatal ~current:true "mkBinOp: %a"
+ Kernel.fatal
+ ~current:true
+ "@[mkBinOp: unsupported operator for such operands@ \
+ %a@ (type of e1: %a,@ type of e2: %a)@]"
!pp_exp_ref (dummy_exp(BinOp(op,e1,e2,intType)))
+ !pp_typ_ref t1
+ !pp_typ_ref t2
let mkBinOp_safe_ptr_cmp ~loc op e1 e2 =
let e1, e2 =
diff --git a/src/plugins/aorai/Makefile.in b/src/plugins/aorai/Makefile.in
index 09c2c11c2455fe62508c0a8ab76766ff5245e8e9..944a500bab9091dba2766758958f44328e3e0196 100644
--- a/src/plugins/aorai/Makefile.in
+++ b/src/plugins/aorai/Makefile.in
@@ -117,6 +117,27 @@ CONFIG_STATUS_DIR=.
AORAI_WP_SHARE=
endif
+TEST_DEPENDENCIES:= \
+ $(Aorai_DIR)/tests/Aorai_test.cmxs \
+ $(Aorai_DIR)/tests/Aorai_test.cmo \
+ $(Aorai_DIR)/tests/ya/name_projects.cmxs \
+ $(Aorai_DIR)/tests/ya/name_projects.cmo
+
+Aorai_DEFAULT_TESTS: $(TEST_DEPENDENCIES)
+
+# 'prove' ptests config: ensure ACSL and C instrumentation coincide
+# Launch this configuration for all tests with
+# make aorai-test-prove
+# To launch only one test, you can use PTESTS_OPTS, as in
+# PTESTS_OPTS="tests/ya/stack.i -add-options '-wp-verbose 1'" make aorai-test-prove
+#
+# This requires to have a copy of the wp-cache repository
+# (see ../wp/tests/README.md for more information). If it is not
+# in its default place of ../wp-cache, use AORAI_WP_CACHE variable to give the
+# proper absolute path.
+# Don't forget to add the new cache files to the repo if needed,
+# in particular if CI complains about its aorai-prove target.
+
$(Aorai_DIR)/tests/ptests_config: $(Aorai_DIR)/tests/test_config_prove
$(Aorai_DIR)/tests/test_config_prove: \
@@ -126,7 +147,15 @@ $(Aorai_DIR)/tests/test_config_prove: \
$(SED) -e 's!@AORAI_WP_SHARE@!$(AORAI_WP_SHARE)!' $< > $@
$(CHMOD_RO) $@
-Aorai_DEFAULT_TESTS: $(Aorai_DIR)/tests/Aorai_test.cmxs $(Aorai_DIR)/tests/Aorai_test.cmo $(Aorai_DIR)/tests/ya/name_projects.cmxs $(Aorai_DIR)/tests/ya/name_projects.cmo
+AORAI_WP_CACHEDIR?=$(abspath $(Aorai_DIR)/../wp-cache)
+AORAI_WP_CACHE?=update
+
+.PHONY: aorai-test-prove
+aorai-test-prove: $(TEST_DEPENDENCIES) $(Aorai_DIR)/tests/test_config_prove
+ FRAMAC_WP_CACHE=$(AORAI_WP_CACHE) \
+ FRAMAC_WP_CACHEDIR=$(AORAI_WP_CACHEDIR) \
+ PTESTS_OPTS="$$PTESTS_OPTS -config prove" \
+ $(MAKE) Aorai_TESTS
# Regenerating the Makefile on need
diff --git a/src/plugins/aorai/tests/Aorai_test.ml b/src/plugins/aorai/tests/Aorai_test.ml
index 661d97503828b87e72e82c04f716ab97a387577c..397ae1e9f09f6236806909308121e29296101e7a 100644
--- a/src/plugins/aorai/tests/Aorai_test.ml
+++ b/src/plugins/aorai/tests/Aorai_test.ml
@@ -97,7 +97,15 @@ let extend () =
File.pretty_ast ~prj:aorai_prj ~fmt ();
close_out chan;
let selection =
- State_selection.of_list [ InternalWpShare.self; ProveAuxSpec.self ]
+ List.fold_left
+ (fun selection state ->
+ State_selection.union
+ (State_selection.with_codependencies state) selection)
+ State_selection.empty
+ [ InternalWpShare.self; ProveAuxSpec.self;
+ Wp.Wp_parameters.CacheEnv.self;
+ Wp.Wp_parameters.Verbose.self;
+ ]
in
Project.copy ~selection my_project;
Project.set_current my_project;
@@ -114,7 +122,8 @@ let extend () =
Wp.Wp_parameters.Let.off();
Wp.Wp_parameters.Split.on();
Wp.Wp_parameters.SplitMax.set 32;
- Wp.Wp_parameters.Verbose.set 0;
+ if not (Wp.Wp_parameters.Verbose.is_set()) then
+ Wp.Wp_parameters.Verbose.set 0;
Globals.Functions.iter check_auto_func;
end else begin
File.pretty_ast ();
diff --git a/src/plugins/aorai/tests/test_config_prove.in b/src/plugins/aorai/tests/test_config_prove.in
index d4b6b4fda2b33bbecfa86e992ebdd7ab94d8a79b..ae55e4b9462edc364bdedae55565fd7485e11342 100644
--- a/src/plugins/aorai/tests/test_config_prove.in
+++ b/src/plugins/aorai/tests/test_config_prove.in
@@ -3,4 +3,4 @@ PLUGIN: aorai eva,from,scope report wp,rtegen
COMMENT: Path to the library from the test file
LIBS: @PTEST_SUITE_DIR@/../Aorai_test
-MACRO: PROVE_OPTIONS @AORAI_WP_SHARE@ -aorai-test-prove-aux-spec
+MACRO: PROVE_OPTIONS @AORAI_WP_SHARE@ -wp-cache-env -aorai-test-prove-aux-spec
diff --git a/src/plugins/e-acsl/Makefile.in b/src/plugins/e-acsl/Makefile.in
index f73d51faec339ec281bc3ce71f9e1d7e1d706642..f94df7c5d9f6d94473ba28416185e3721ebd8221 100644
--- a/src/plugins/e-acsl/Makefile.in
+++ b/src/plugins/e-acsl/Makefile.in
@@ -61,15 +61,15 @@ ANALYSES_CMI:= \
ANALYSES_CMI:=$(addprefix src/analyses/, $(ANALYSES_CMI))
SRC_ANALYSES:= \
+ lscope \
analyses_datatype \
- label \
rte \
- lscope \
e_acsl_visitor \
logic_normalizer \
bound_variables \
interval \
typing \
+ labels \
literal_strings \
memory_tracking \
exit_points \
@@ -94,10 +94,10 @@ SRC_CODE_GENERATOR:= \
logic_functions \
loops \
quantif \
- at_with_lscope \
memory_translate \
logic_array \
translate_utils \
+ translate_ats \
translate_terms \
translate_predicates \
translate_rtes \
diff --git a/src/plugins/e-acsl/doc/Changelog b/src/plugins/e-acsl/doc/Changelog
index 78f90c6978a4fa2d30a866460bde9fd493777145..3b262b37e1f647056b42aeab1b2c63a051537576 100644
--- a/src/plugins/e-acsl/doc/Changelog
+++ b/src/plugins/e-acsl/doc/Changelog
@@ -25,6 +25,8 @@
Plugin E-ACSL <next-release>
############################
+- E-ACSL [2022-03-04] Improve translation of `\at()` terms and
+ predicates (frama-c/e-acsl#108).
-* E-ACSL [2022-03-01] Fix normalization of global annotations that
may lead to crashes (frama-c/e-acsl#195).
- E-ACSL [2022-01-28] Add Linux's pthread concurrency support.
diff --git a/src/plugins/e-acsl/headers/header_spec.txt b/src/plugins/e-acsl/headers/header_spec.txt
index 802dc2a40f546fc51414f5feedf73ac15ec21c90..602a0802d6d7e4bf656ad55aadd5a8bd91dc0b27 100644
--- a/src/plugins/e-acsl/headers/header_spec.txt
+++ b/src/plugins/e-acsl/headers/header_spec.txt
@@ -92,8 +92,8 @@ src/analyses/exit_points.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/analyses/exit_points.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/analyses/interval.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/analyses/interval.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
-src/analyses/label.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
-src/analyses/label.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
+src/analyses/labels.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
+src/analyses/labels.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/analyses/literal_strings.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/analyses/literal_strings.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/analyses/logic_normalizer.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
@@ -110,8 +110,6 @@ src/code_generator/assert.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/assert.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/assigns.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/assigns.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
-src/code_generator/at_with_lscope.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
-src/code_generator/at_with_lscope.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/contract.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/contract.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/contract_types.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
@@ -149,6 +147,8 @@ src/code_generator/temporal.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/temporal.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/translate_annots.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/translate_annots.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
+src/code_generator/translate_ats.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
+src/code_generator/translate_ats.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/translate_predicates.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/translate_predicates.mli: CEA_LGPL_OR_PROPRIETARY.E_ACSL
src/code_generator/translate_rtes.ml: CEA_LGPL_OR_PROPRIETARY.E_ACSL
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.c b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.c
index 03338d3f3e01e0012a5da1a02055009d0d0cae43..494e869d14c900dbad98a96c5c0f808f408113e0 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.c
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.c
@@ -37,7 +37,7 @@ int eacsl_runtime_sound_verdict = 1;
void eacsl_print_values(eacsl_assert_data_t *data) {
eacsl_assert_data_value_t *value = data->values;
if (value != NULL) {
- STDERR("\tWith values:\n");
+ STDERR("\tWith values at failure point:\n");
}
while (value != NULL) {
eacsl_print_value(value);
diff --git a/src/plugins/e-acsl/src/analyses/analyses.ml b/src/plugins/e-acsl/src/analyses/analyses.ml
index 39761bba6e9ca99eea1e8abfb933d08825448aca..eeaa2dc9da43da2b12e3c869d07b65738c80e633 100644
--- a/src/plugins/e-acsl/src/analyses/analyses.ml
+++ b/src/plugins/e-acsl/src/analyses/analyses.ml
@@ -30,7 +30,10 @@ let preprocess () =
analyses_feedback "normalizing quantifiers";
Bound_variables.preprocess ast;
analyses_feedback "typing annotations";
- Typing.type_program ast
+ Typing.type_program ast;
+ analyses_feedback
+ "computing future locations of labeled predicates and terms";
+ Labels.preprocess ast
let reset () =
Memory_tracking.reset ();
@@ -38,4 +41,5 @@ let reset () =
Bound_variables.clear_guards ();
Logic_normalizer.clear ();
Interval.Env.clear();
- Typing.clear ()
+ Typing.clear ();
+ Labels.reset ()
diff --git a/src/plugins/e-acsl/src/analyses/analyses_datatype.ml b/src/plugins/e-acsl/src/analyses/analyses_datatype.ml
index b638097ad1f4515525721ceb90d1be5a8e13b1b8..99645c1fefece09541eeab47ee7f74a0e3412235 100644
--- a/src/plugins/e-acsl/src/analyses/analyses_datatype.ml
+++ b/src/plugins/e-acsl/src/analyses/analyses_datatype.ml
@@ -22,15 +22,34 @@
(** Datatypes for analyses types *)
+open Cil_types
open Cil_datatype
open Analyses_types
-module PredOrTerm =
+module Annotation_kind =
+ Datatype.Make
+ (struct
+ type t = annotation_kind
+ let name = "E_ACSL.Annotation_kind"
+ let reprs = [ Assertion ]
+ include Datatype.Undefined
+
+ let pretty fmt akind =
+ match akind with
+ | Assertion -> Format.fprintf fmt "Assertion"
+ | Precondition -> Format.fprintf fmt "Precondition"
+ | Postcondition -> Format.fprintf fmt "Postcondition"
+ | Invariant -> Format.fprintf fmt "Invariant"
+ | Variant -> Format.fprintf fmt "Variant"
+ | RTE -> Format.fprintf fmt "RTE"
+ end)
+
+module Pred_or_term =
Datatype.Make_with_collections
(struct
type t = pred_or_term
- let name = "E_ACSL.PredOrTerm"
+ let name = "E_ACSL.Pred_or_term"
let reprs =
let reprs =
@@ -65,3 +84,167 @@ module PredOrTerm =
let varname _ = "pred_or_term"
end)
+
+(** [Ext_logic_label] associates a statement to a label when necessary. For
+ instance, the label `Old` is associated with its contract statement to
+ distinguish two `Old` annotations in the same function. On the contrary, the
+ `Pre` label does not have an associated statement because this label
+ represents the same location for all contracts in the same function. *)
+module Ext_logic_label: sig
+ include Datatype.S_with_collections with type t = logic_label * stmt option
+
+ val get: kinstr -> logic_label -> logic_label * stmt option
+ (** @return an extended logic label from a [kinstr] and a [logic_label]. *)
+
+end = struct
+
+ include Datatype.Pair_with_collections
+ (Logic_label)
+ (Datatype.Option_with_collections
+ (Stmt)
+ (struct
+ let module_name = "E_ACSL.Labels.Ext_logic_label.StmtOption"
+ end))
+ (struct let module_name = "E_ACSL.Labels.Ext_logic_label" end)
+
+ (* Override [pretty] to print a more compact representation of
+ [Ext_logic_label] for debugging purposes. *)
+ let pretty fmt (label, from_stmt_opt) =
+ match from_stmt_opt with
+ | Some from_stmt ->
+ Format.fprintf fmt "%a from stmt %d at %a"
+ Logic_label.pretty label
+ from_stmt.sid
+ Printer.pp_location (Stmt.loc from_stmt)
+ | None ->
+ Format.fprintf fmt "%a"
+ Logic_label.pretty label
+
+ let get kinstr label =
+ let from_stmt_opt =
+ match kinstr, label with
+ | Kglobal, _
+ | Kstmt _, (BuiltinLabel (Pre | Here | Init)
+ | FormalLabel _ | StmtLabel _) ->
+ None
+ | Kstmt _, BuiltinLabel (LoopCurrent | LoopEntry) ->
+ (* [None] for now because these labels are unsupported, but the
+ statement before the loop and the first statement of the loop should
+ probably be used once they are supported. *)
+ Error.print_not_yet
+ (Format.asprintf "label %a" Printer.pp_logic_label label);
+ None
+ | Kstmt s, BuiltinLabel (Old | Post) -> Some s
+ in
+ label, from_stmt_opt
+
+end
+
+(** Basic printer for a [kinstr]. Contrary to [Cil_datatype.Kinstr.pretty], the
+ stmt of [Kstmt] is not printed. *)
+let basic_pp_kinstr fmt kinstr =
+ Format.fprintf fmt "%s"
+ (match kinstr with
+ | Kglobal -> "Kglobal"
+ | Kstmt _ -> "Kstmt")
+
+(** Basic comparison for two [kinstr], i.e. two [Kstmt] are always equal
+ regardless of the statement value (contrary to [Cil_datatype.Kinstr.compare]
+ where two [Kstmt] are compared with their included statement's [sid]). *)
+let basic_kinstr_compare kinstr1 kinstr2 =
+ match kinstr1, kinstr2 with
+ | Kglobal, Kglobal | Kstmt _, Kstmt _ -> 0
+ | Kglobal, _ -> 1
+ | _, Kglobal -> -1
+
+(** Basic hash function for a [kinstr], i.e. contrary to
+ [Cil_datatype.Kinstr.hash] the statement of the [Kstmt] is not considered
+ for the hash. *)
+let basic_kinstr_hash kinstr =
+ match kinstr with
+ | Kglobal -> 1 lsl 29
+ | Kstmt _ -> 1 lsl 31
+
+module At_data = struct
+ let create ?error kf kinstr lscope pot label =
+ { kf; kinstr; lscope; pot; label; error }
+
+ include Datatype.Make_with_collections
+ (struct
+ type t = at_data
+ let name = "E_ACSL.At_data"
+
+ let reprs =
+ List.fold_left
+ (fun acc kf ->
+ List.fold_left
+ (fun acc kinstr ->
+ List.fold_left
+ (fun acc pot ->
+ List.fold_left
+ (fun acc label ->
+ create kf kinstr Lscope.empty pot label :: acc)
+ acc
+ Logic_label.reprs)
+ acc
+ Pred_or_term.reprs)
+ acc
+ Kinstr.reprs)
+ []
+ Kf.reprs
+
+ include Datatype.Undefined
+
+ let compare
+ { kf = kf1;
+ kinstr = kinstr1;
+ lscope = lscope1;
+ pot = pot1;
+ label = label1 }
+ { kf = kf2;
+ kinstr = kinstr2;
+ lscope = lscope2;
+ pot = pot2;
+ label = label2 }
+ =
+ let cmp = Kf.compare kf1 kf2 in
+ let cmp =
+ if cmp = 0 then
+ basic_kinstr_compare kinstr1 kinstr2
+ else cmp
+ in
+ let cmp =
+ if cmp = 0 then Lscope.D.compare lscope1 lscope2
+ else cmp
+ in
+ let cmp =
+ if cmp = 0 then Pred_or_term.compare pot1 pot2
+ else cmp
+ in
+ if cmp = 0 then
+ let elabel1 = Ext_logic_label.get kinstr1 label1 in
+ let elabel2 = Ext_logic_label.get kinstr2 label2 in
+ Ext_logic_label.compare elabel1 elabel2
+ else cmp
+
+ let equal = Datatype.from_compare
+
+ let hash { kf; kinstr; lscope; pot; label } =
+ let elabel = Ext_logic_label.get kinstr label in
+ Hashtbl.hash
+ (Kf.hash kf,
+ basic_kinstr_hash kinstr,
+ Lscope.D.hash lscope,
+ Pred_or_term.hash pot,
+ Ext_logic_label.hash elabel)
+
+ let pretty fmt { kf; kinstr; lscope; pot; label } =
+ let elabel = Ext_logic_label.get kinstr label in
+ Format.fprintf fmt "@[(%a, %a, %a, %a, %a)@]"
+ Kf.pretty kf
+ basic_pp_kinstr kinstr
+ Lscope.D.pretty lscope
+ Pred_or_term.pretty pot
+ Ext_logic_label.pretty elabel
+ end)
+end
diff --git a/src/plugins/e-acsl/src/analyses/analyses_datatype.mli b/src/plugins/e-acsl/src/analyses/analyses_datatype.mli
index 212b5887cd5e0eec1b4acbb766b7b28a05ef1c75..097cd6c01dff9a1362159430168823edee7e681d 100644
--- a/src/plugins/e-acsl/src/analyses/analyses_datatype.mli
+++ b/src/plugins/e-acsl/src/analyses/analyses_datatype.mli
@@ -22,6 +22,24 @@
(** Datatypes for analyses types *)
+open Cil_types
open Analyses_types
-module PredOrTerm: Datatype.S_with_collections with type t = pred_or_term
+module Annotation_kind: Datatype.S with type t = annotation_kind
+
+module Pred_or_term: Datatype.S_with_collections with type t = pred_or_term
+
+module At_data: sig
+ include Datatype.S_with_collections with type t = at_data
+
+ val create:
+ ?error:exn ->
+ kernel_function ->
+ kinstr ->
+ lscope ->
+ pred_or_term ->
+ logic_label ->
+ at_data
+ (** [create ?error kf kinstr lscope pot label] creates an [at_data] from the
+ given arguments. *)
+end
diff --git a/src/plugins/e-acsl/src/analyses/analyses_types.ml b/src/plugins/e-acsl/src/analyses/analyses_types.ml
index d670f9d0e2052217223c588532bda38eb7f278e4..357f0dda4d19e382bae81bf1ffb09287f0c46da7 100644
--- a/src/plugins/e-acsl/src/analyses/analyses_types.ml
+++ b/src/plugins/e-acsl/src/analyses/analyses_types.ml
@@ -35,3 +35,35 @@ type lscope = lscope_var list
type pred_or_term =
| PoT_pred of predicate
| PoT_term of term
+
+(** Type uniquely representing a [predicate] or [term] with an associated
+ [label], and the necessary information for its translation. *)
+type at_data = {
+ (** [kernel_function] englobing the [pred_or_term]. *)
+ kf: kernel_function;
+
+ (** [kinstr] where the [pred_or_term] is used. *)
+ kinstr: kinstr;
+
+ (** Current state of the [lscope] for the [pred_or_term]. *)
+ lscope: lscope;
+
+ (** [pred_or_term] to translate. *)
+ pot: pred_or_term;
+
+ (** Label of the [pred_or_term]. *)
+ label: logic_label;
+
+ (** Error raised during the pre-analysis.
+ This field does not contribute to the equality and comparison between two
+ [at_data]. *)
+ error: exn option
+}
+
+type annotation_kind =
+ | Assertion
+ | Precondition
+ | Postcondition
+ | Invariant
+ | Variant
+ | RTE
diff --git a/src/plugins/e-acsl/src/analyses/bound_variables.ml b/src/plugins/e-acsl/src/analyses/bound_variables.ml
index 3afb018482d3cbf0e297d62feebafeb48de66b3e..9db23dccc336b8794c111e0552f860375aee763a 100644
--- a/src/plugins/e-acsl/src/analyses/bound_variables.ml
+++ b/src/plugins/e-acsl/src/analyses/bound_variables.ml
@@ -35,7 +35,8 @@
open Cil_types
open Cil_datatype
-module Error = Error.Make(struct let phase = Options.Dkey.bound_variables end)
+let dkey = Options.Dkey.bound_variables
+module Error = Error.Make(struct let phase = dkey end)
(** [error_msg quantif msg pp x] creates an error message from the string [msg]
containing the value [x] pretty-printed by [pp] and the predicate [quantif]
@@ -697,7 +698,7 @@ end
| _ -> ()
let preprocessor = object
- inherit E_acsl_visitor.visitor
+ inherit E_acsl_visitor.visitor dkey
method !vannotation annot =
match annot with
@@ -713,21 +714,13 @@ end
end
let compute ast =
- Visitor.visitFramacFileSameGlobals
- (preprocessor :> Visitor.frama_c_inplace)
- ast
+ preprocessor#visit_file ast
let compute_annot annot =
- ignore
- (Visitor.visitFramacCodeAnnotation
- (preprocessor :> Visitor.frama_c_inplace)
- annot)
+ ignore @@ preprocessor#visit_code_annot annot
let compute_predicate p =
- ignore
- (Visitor.visitFramacPredicate
- (preprocessor :> Visitor.frama_c_inplace)
- p)
+ ignore @@ preprocessor#visit_predicate p
end
let preprocess = Preprocessor.compute
diff --git a/src/plugins/e-acsl/src/analyses/e_acsl_visitor.ml b/src/plugins/e-acsl/src/analyses/e_acsl_visitor.ml
index fab6c7ffcec22d641aa65aa69b9a2ed591936801..b5dd27c351e3c552616af1c16f8d0ae865d6e09e 100644
--- a/src/plugins/e-acsl/src/analyses/e_acsl_visitor.ml
+++ b/src/plugins/e-acsl/src/analyses/e_acsl_visitor.ml
@@ -21,6 +21,21 @@
(**************************************************************************)
open Cil_types
+open Analyses_types
+
+(**************************************************************************)
+(********************** Forward references ********************************)
+(**************************************************************************)
+
+let must_translate_ppt_ref : (Property.t -> bool) ref =
+ Extlib.mk_fun "must_translate_ppt_ref"
+
+let must_translate_ppt_opt_ref : (Property.t option -> bool) ref =
+ Extlib.mk_fun "must_translate_ppt_opt_ref"
+
+(**************************************************************************)
+(************************* Case globals ***********************************)
+(**************************************************************************)
let case_globals
~default
@@ -82,10 +97,17 @@ let case_globals
->
default ()
-class visitor
+(**************************************************************************)
+(****************************** Visitor ***********************************)
+(**************************************************************************)
+
+class visitor cat
= object(self)
inherit Visitor.frama_c_inplace
+ (* Functions for [case_globals] *)
+ (* ---------------------------- *)
+
method private default : unit -> global list Cil.visitAction =
fun _ -> Cil.SkipChildren
@@ -117,6 +139,284 @@ class visitor
let kf = try Globals.Functions.get vi with Not_found -> assert false in
if Functions.check kf then Cil.DoChildren else Cil.SkipChildren
+ (* Visit error *)
+ (* ----------- *)
+
+ (** Error module to use when creating E-ACSL errors. *)
+ val error_module: (module Error.S) =
+ (module Error.Make(struct let phase = cat end): Error.S)
+
+ (** Visit error *)
+ val mutable visit_error: exn option = None
+
+ (** Reset the visit error to [None], or [force] if it is provided. *)
+ method private reset_visit_error ?force:visit_error_opt () =
+ match visit_error_opt with
+ | Some visit_error_opt -> visit_error <- visit_error_opt
+ | None -> visit_error <- None
+
+ (** Set the visit error to [e] if it was [None], keep the existing visit
+ error otherwise. *)
+ method private set_visit_error e =
+ match visit_error with
+ | None -> visit_error <- Some e
+ | Some _ -> ()
+
+ (** @return the current visit error. *)
+ method get_visit_error () = visit_error
+
+ (* Annotation kind *)
+ (* --------------- *)
+
+ (** Annotation kind *)
+ val mutable akind: annotation_kind = Assertion
+
+ (** Set the annotation kind to [a]. *)
+ method private set_akind a = akind <- a
+
+ (** @return the current annotation kind. *)
+ method get_akind () = akind
+
+ (* Starting AST visits *)
+ (* ------------------- *)
+
+ (** Indicates if the current visit has been run from this visitor (with
+ [visit_xxx] methods) or from a generic [Visitor.visitFramacxxx]
+ function.
+ If this boolean is [false] when passing through the methods [vspec]
+ or [vcode_annot], then a fatal error is raised because the children will
+ be skipped without the knowledge of the caller. *)
+ val mutable run_from_visitor: bool = false
+
+ (** If [true], the method [vcode_annot] will visit its children, otherwise
+ they are skipped. *)
+ val mutable do_visit_code_annot: bool = false
+
+ (** If [true], the method [vspec] will visit its children, otherwise they
+ are skipped. *)
+ val mutable do_visit_spec: bool = false
+
+ (** Set the [run_from_visitor] field to [value] and return its old value. *)
+ method private set_run_from_visitor value =
+ let old = run_from_visitor in
+ run_from_visitor <- value;
+ old
+
+ (** Check if [run_from_visitor] is [true], otherwise raise a fatal error. *)
+ method private check_run_from_visitor () =
+ if not run_from_visitor then
+ Options.fatal
+ "E_acsl_visitors should be run with methods 'visit_xyz' to correctly \
+ visit each node."
+
+ (** If [value_opt] is [Some value], then set field [do_visit_code_annot] to
+ [value] and return the old value of [do_visit_code_annot] in an option.
+ Otherwise do nothing and return [None]. *)
+ method private set_do_visit_code_annot value_opt =
+ match value_opt with
+ | Some value ->
+ let old = do_visit_code_annot in
+ do_visit_code_annot <- value;
+ Some old
+ | None -> None
+
+ (** If [value_opt] is [Some value], then set field [do_visit_spec] to
+ [value] and return the old value of [do_visit_spec] in an option.
+ Otherwise do nothing and return [None]. *)
+ method private set_do_visit_funspec value_opt =
+ match value_opt with
+ | Some value ->
+ let old = do_visit_spec in
+ do_visit_spec <- value;
+ Some old
+ | None -> None
+
+ (* see documentation in e_acsl_visitor.mli *)
+ method visit
+ : 'a 'b. ?vcode_annot:bool -> ?vspec:bool
+ -> (Visitor.frama_c_visitor -> 'a -> 'b)
+ -> 'a -> 'b
+ = fun ?vcode_annot ?vspec visit_func item ->
+ let old_run_from_visitor = self#set_run_from_visitor true in
+ let old_vcode_annot = self#set_do_visit_code_annot vcode_annot in
+ let old_vfunspec = self#set_do_visit_funspec vspec in
+ let finally () =
+ ignore @@ self#set_do_visit_code_annot old_vcode_annot;
+ ignore @@ self#set_do_visit_funspec old_vfunspec;
+ ignore @@ self#set_run_from_visitor old_run_from_visitor
+ in
+ Extlib.try_finally
+ ~finally
+ (fun item -> visit_func (self :> Visitor.frama_c_inplace) item)
+ item
+
+ (** see documentation in e_acsl_visitor.mli *)
+ method visit_file file =
+ self#visit Visitor.visitFramacFileSameGlobals file
+
+ (** see documentation in e_acsl_visitor.mli *)
+ method visit_code_annot code_annot =
+ self#visit ~vcode_annot:true Visitor.visitFramacCodeAnnotation code_annot
+
+ (** [visit_assigns assigns] starts a visit of the AST from the given
+ [assigns] node. *)
+ method private visit_assigns assigns =
+ (* private method, we do not need to use self#visit, the field
+ [run_from_visitor] is already set. *)
+ ignore @@ Visitor.visitFramacAssigns
+ (self :> Visitor.frama_c_inplace)
+ assigns
+
+ (** [visit_allocates allocates] starts a visit of the AST from the given
+ [allocation] node. *)
+ method private visit_allocates allocates =
+ (* private method, we do not need to use self#visit, the field
+ [run_from_visitor] is already set. *)
+ ignore @@ Visitor.visitFramacAllocation
+ (self :> Visitor.frama_c_inplace)
+ allocates
+
+ (** [visit_id_predicate idp] starts a visit of the AST from the given
+ [identified_predicate] node. *)
+ method private visit_id_predicate idp =
+ (* private method, we do not need to use self#visit, the field
+ [run_from_visitor] is already set. *)
+ ignore @@ Visitor.visitFramacIdPredicate
+ (self :> Visitor.frama_c_inplace)
+ idp
+
+ (** [visit_id_predicates idps] starts a visit of the AST for each given
+ [identified_predicate] node. *)
+ method private visit_id_predicates idps =
+ (* private method, we do not need to use self#visit, the field
+ [run_from_visitor] is already set. *)
+ List.iter
+ self#visit_id_predicate
+ idps
+
+ (** see documentation in e_acsl_visitor.mli *)
+ method visit_predicate p =
+ (* We know that from a predicate node, we will not use the visit methods
+ [vcode_annot] and [vspec], so we do not need to use [self#visit].
+ This saves us some indirection when calling
+ [Visitor.visitFramacPredicate]. *)
+ Visitor.visitFramacPredicate (self :> Visitor.frama_c_inplace) p
+
+ (** [visit_term t] starts a visit of the AST from the given [term] node. *)
+ method private visit_term t =
+ (* private method, we do not need to use self#visit, the field
+ [run_from_visitor] is already set. *)
+ ignore @@ Visitor.visitFramacTerm (self :> Visitor.frama_c_inplace) t
+
+ (* Override visit methods *)
+ (* ---------------------- *)
+
+ (** [do_with ?not_yet ?akind ~f arg] changes the visit error to [not_yet]
+ and changes the annotation kind to [akind] if provided, then execute
+ [f arg]. Finally, it restores the visit error and annotation kind to
+ their old values and returns the result of [f arg]. *)
+ method private do_with: 'a 'b.
+ ?not_yet:string ->
+ ?akind:annotation_kind ->
+ f:('a -> 'b) ->
+ 'a ->
+ 'b
+ =
+ fun ?not_yet ?akind ~f arg ->
+ let module Error = (val error_module: Error.S) in
+ let old_akind = self#get_akind () in
+ let old_visit_error = self#get_visit_error () in
+ (match akind with
+ | Some akind -> self#set_akind akind
+ | None -> ());
+ (match not_yet with
+ | Some not_yet -> self#set_visit_error (Error.make_not_yet not_yet)
+ | None -> ());
+ let finally () =
+ self#reset_visit_error ~force:old_visit_error ();
+ self#set_akind old_akind
+ in
+ Extlib.try_finally ~finally f arg
+
+ (** [process_spec spec] visits the given [spec] in the same manner than
+ the E-ACSL injector, setting the annotation kind to its correct value as
+ it visits the different nodes. *)
+ method private process_spec spec =
+ let kf = Option.get self#current_kf in
+ let kinstr = self#current_kinstr in
+ List.iter
+ (fun bhv ->
+ self#do_with
+ ~akind:Precondition
+ ~f:self#visit_id_predicates
+ bhv.b_assumes;
+ self#do_with
+ ~akind:Precondition
+ ~f:(List.iter
+ (fun requires ->
+ if !must_translate_ppt_ref
+ (Property.ip_of_requires kf kinstr bhv requires) then
+ self#visit_id_predicate requires))
+ bhv.b_requires;
+ (* The links between the [identified_property]s and the [assigns] or
+ [allocates] clauses are not clear. For now, store a [not_yet]
+ error for every term of the clauses. Update the code to add the
+ relevant [must_translate] calls once the [assigns] or [allocates]
+ clauses translation are supported. *)
+ self#do_with
+ ~akind:Postcondition
+ ~not_yet:"assigns clause in behavior"
+ ~f:self#visit_assigns
+ bhv.b_assigns;
+ self#do_with
+ ~akind:Postcondition
+ ~not_yet:"allocates clause in behavior"
+ ~f:self#visit_allocates
+ bhv.b_allocation;
+ List.iter
+ (fun ((termination, post_cond) as tp) ->
+ if !must_translate_ppt_ref
+ (Property.ip_of_ensures kf kinstr bhv tp) then
+ let not_yet =
+ match termination with
+ | Normal ->
+ None
+ | Exits | Breaks | Continues | Returns ->
+ Some "abnormal termination case in behavior"
+ in
+ self#do_with
+ ~akind:Postcondition
+ ?not_yet
+ ~f:self#visit_id_predicate
+ post_cond)
+ bhv.b_post_cond
+ )
+ spec.spec_behavior
+
+ (** [set_global_kinstr ()] sets the [current_kinstr] field of the visitor
+ to [Kglobal] and returns the old value of [current_kinstr]. This
+ function is used in [vstmt_aux] to process the function specification
+ with a [current_kinstr] correctly set. *)
+ method private set_global_kinstr () =
+ let rec aux acc =
+ match self#current_stmt with
+ | Some stmt ->
+ self#pop_stmt stmt;
+ aux (stmt :: acc)
+ | None ->
+ acc
+ in
+ aux []
+
+ (** [reset_kinstr stmts] resets the [current_kinstr] field of the visitor
+ to the given statement list. The list given as parameter is the value
+ returned by [set_global_kinstr ()]. *)
+ method private reset_kinstr stmts =
+ List.iter
+ (fun stmt -> self#push_stmt stmt)
+ stmts
+
+ (** Visit AST globals according to the provided methods. *)
method !vglob_aux =
case_globals
~default:self#default
@@ -129,4 +429,124 @@ class visitor
~var_def:self#var_def
~glob_annot:self#glob_annot
~fun_def:self#fun_def
+
+ (** Visit the annotations of the statement in the same manner than the
+ E-ACSL injector. *)
+ method! vstmt_aux stmt =
+ let kf = Option.get self#current_kf in
+
+ if Kernel_function.is_first_stmt kf stmt then begin
+ (* Analyze the funspec before visiting the first statement *)
+ if Annotations.has_funspec kf then begin
+ let old_kinstr_stmts = self#set_global_kinstr () in
+ self#process_spec (Annotations.funspec kf);
+ self#reset_kinstr old_kinstr_stmts
+ end
+ end;
+
+ (* Analyze the code annotation of the current statement *)
+ Annotations.iter_code_annot
+ (fun _ annot ->
+ (* Reset the visit error before starting to analyze an annotation. *)
+ self#reset_visit_error ();
+
+ match annot.annot_content with
+ | AAssert(l, p) ->
+ if !must_translate_ppt_ref
+ (Property.ip_of_code_annot_single kf stmt annot) then begin
+ let not_yet =
+ match l with
+ | [] -> None
+ | _ :: _ -> Some "assertion applied only on some behaviors"
+ in
+ ignore @@ self#do_with
+ ~akind:Assertion
+ ?not_yet
+ ~f:self#visit_predicate
+ p.tp_statement
+ end
+ | AStmtSpec(l, spec) ->
+ let not_yet =
+ match l with
+ | [] -> None
+ | _ :: _ ->
+ Some "statement contract applied only on some behaviors"
+ in
+ self#do_with
+ ?not_yet
+ ~f:self#process_spec
+ spec
+ | AInvariant(l, _, p) ->
+ if !must_translate_ppt_ref
+ (Property.ip_of_code_annot_single kf stmt annot) then begin
+ let not_yet =
+ match l with
+ | [] -> None
+ | _ :: _ -> Some "invariant applied only on some behaviors"
+ in
+ ignore @@ self#do_with
+ ~akind:Invariant
+ ?not_yet
+ ~f:self#visit_predicate
+ p.tp_statement
+ end
+ | AVariant(t, _) ->
+ if !must_translate_ppt_ref
+ (Property.ip_of_code_annot_single kf stmt annot) then begin
+ self#do_with
+ ~akind:Variant
+ ~f:self#visit_term
+ t
+ end
+ | AAssigns (_, assigns) ->
+ (* The link between the [identified_property] and the [assigns]
+ clause is not clear. For now store a [not_yet] error for every
+ term of the clause. Update the code to add the relevant
+ [must_translate] calls once the [assigns] clause translation is
+ supported. *)
+ self#do_with
+ ~akind:Postcondition
+ ~not_yet:"assigns"
+ ~f:self#visit_assigns
+ assigns
+ | AAllocation (_, allocates) ->
+ (* The link between the [identified_property] and the [allocates]
+ clause is not clear. For now store a [not_yet] error for every
+ term of the clause. Update the code to add the relevant
+ [must_translate] calls once the [allocates] clause translation
+ is supported. *)
+ self#do_with
+ ~akind:Postcondition
+ ~not_yet:"allocates"
+ ~f:self#visit_allocates
+ allocates
+ | APragma _ -> ()
+ | AExtended _ -> ()
+ )
+ stmt;
+
+ (* Once the annotations of the statements have been analyzed, reset the
+ visit error. *)
+ self#reset_visit_error ();
+
+ Cil.DoChildren
+
+ (** [vspec spec] visits its children if [do_visit_spec] is [true] and skips
+ them otherwise. *)
+ method! vspec _ =
+ self#check_run_from_visitor ();
+ if do_visit_spec then
+ Cil.DoChildren
+ else
+ Cil.SkipChildren
+
+ (** [vcode_annot ca] visits its children if [do_visit_code_annot] is [true]
+ and skips them otherwise. *)
+ method! vcode_annot _ =
+ self#check_run_from_visitor ();
+ if do_visit_code_annot then
+ Cil.DoChildren
+ else
+ Cil.SkipChildren
+
end
diff --git a/src/plugins/e-acsl/src/analyses/e_acsl_visitor.mli b/src/plugins/e-acsl/src/analyses/e_acsl_visitor.mli
index 21ca0fea5d1ed32bcbd3adf7d10867cd4539f41c..30e62a8eb27ba4f528a62d3f3bda1a8f13b0be5a 100644
--- a/src/plugins/e-acsl/src/analyses/e_acsl_visitor.mli
+++ b/src/plugins/e-acsl/src/analyses/e_acsl_visitor.mli
@@ -21,6 +21,7 @@
(**************************************************************************)
open Cil_types
+open Analyses_types
val case_globals :
default:(unit -> 'a) ->
@@ -51,13 +52,35 @@ val case_globals :
- [glob_annot] is the case for global annotations
- [fun_def] is the case for function definition. *)
-(** Visitor for managing the root of the AST, on the globals level, with the
- cases that are relevant to E-ACSL. Each case is handled by a method of
- the visitor. The cases are similar, and similarly named as the ones of
- the function [case_globals]. *)
+(** Visitor to visit the AST in the same manner than the injector.
+
+ [new visitor cat] creates a visitor with [cat] as the category to use for
+ the [Error] module in the visitor.
+
+ For the root of the AST, not the global level, only visit the cases that
+ are relevant to E-ACSL. Each case is handled by a method of the visitor. The
+ cases are similar, and similarly named as the ones of the function
+ [case_globals].
+
+ For the rest of the AST, the kind of the visited annotation is recorded and
+ accessed through the method [get_akind]. While visiting annotations
+ currently not supported by E-ACSL, the [get_visit_error] returns a [not_yet]
+ exception. Any visitor that inherits from [E_acsl_visitor.visitor] can
+ decide wether continue its processing or not as it sees fit.
+
+ As a result of the custom visit of the AST, the methods [vcode_annot] and
+ [vspec] skip their children, since they are already visited by [vstmt_aux].
+ Be sure to use the method [visit] (and associated methods) if you need to
+ visit the children of those nodes.
+
+ To support these functionalities, the methods [vglob_aux] and [vstmt_aux]
+ have been heavily modified and should not be overriden further. *)
class visitor :
+ Options.category ->
object
inherit Visitor.frama_c_inplace
+
+ (* Functions for [case_globals] *)
method private default: unit -> global list Cil.visitAction
method builtin: varinfo -> global list Cil.visitAction
method fc_compiler_builtin: varinfo -> global list Cil.visitAction
@@ -68,4 +91,54 @@ class visitor :
method var_def: varinfo -> init -> global list Cil.visitAction
method glob_annot: global_annotation -> global list Cil.visitAction
method fun_def: fundec -> global list Cil.visitAction
+
+ method get_visit_error: unit -> exn option
+ (** @return a potential error during the visit of the AST (for instance a
+ [not_yet] error while visiting assigns clause in behaviors). *)
+
+ method get_akind: unit -> annotation_kind
+ (** @return The current kind of annotation being visited. *)
+
+ method visit: 'a 'b.
+ ?vcode_annot:bool ->
+ ?vspec:bool ->
+ (Visitor.frama_c_visitor -> 'a -> 'b) ->
+ 'a ->
+ 'b
+ (** [visit ?vode_annot ?vspec visit_func item] starts a visit of the AST
+ from [item] with the Frama-C visit function [visit_func].
+
+ If [vcode_annot] is true, then the method [vcode_annot] will visit its
+ children, otherwise they are skipped and will only be visited through
+ [vstmt_aux].
+
+ If [vspec] is true, then the method [vspec] will visit its children,
+ otherwise they are skipped and will only be visited through
+ [vstmt_aux]. *)
+
+ method visit_file: file -> unit
+ (** [visit file] starts a visit of the AST from the given [file] node. *)
+
+ method visit_code_annot: code_annotation -> code_annotation
+ (** [visit code_annot] starts a visit of the AST from the given [code_annot]
+ node. *)
+
+ method visit_predicate: predicate -> predicate
+ (** [visit_predicate p] starts a visit of the AST from the given [predicate]
+ node. *)
end
+
+
+(**************************************************************************)
+(********************** Forward references ********************************)
+(**************************************************************************)
+
+val must_translate_ppt_ref: (Property.t -> bool) ref
+
+val must_translate_ppt_opt_ref: (Property.t option -> bool) ref
+
+(*
+Local Variables:
+compile-command: "make -C ../../../../.."
+End:
+*)
diff --git a/src/plugins/e-acsl/src/analyses/exit_points.ml b/src/plugins/e-acsl/src/analyses/exit_points.ml
index be83e43663fa571fbd4f79b37d0abe9a112fe997..7ad18f7575ec73a6863573f34d3c9673b8833a9d 100644
--- a/src/plugins/e-acsl/src/analyses/exit_points.ml
+++ b/src/plugins/e-acsl/src/analyses/exit_points.ml
@@ -20,7 +20,6 @@
(* *)
(**************************************************************************)
-module E_acsl_label = Label
open Cil_types
open Cil_datatype
@@ -37,7 +36,7 @@ end = struct
let tbl = Stmt.Hashtbl.create 17
let add s x =
- let s = E_acsl_label.get_first_inner_stmt s in
+ let s = Labels.get_first_inner_stmt s in
Stmt.Hashtbl.add tbl s x
let find stmt =
@@ -81,7 +80,7 @@ module Exits = Build_env(struct
(* Use [Labeled_stmts.get_first_inner_stmt] so that [find] and [get_all]
return the first statement of the labeled block instead of the labeled
statement. *)
- let map_opt = Some E_acsl_label.get_first_inner_stmt
+ let map_opt = Some Labels.get_first_inner_stmt
end)
(* Map labelled statements back to gotos which lead to them and case statements
@@ -91,7 +90,7 @@ module LJumps = Build_env(struct
(* Use [Labeled_stmts.get_first_inner_stmt] so that [find] and [get_all]
return the first statement of the labeled block instead of the labeled
statement. *)
- let map_opt = Some E_acsl_label.get_first_inner_stmt
+ let map_opt = Some Labels.get_first_inner_stmt
end)
let clear () =
diff --git a/src/plugins/e-acsl/src/analyses/label.ml b/src/plugins/e-acsl/src/analyses/label.ml
deleted file mode 100644
index 05f6715748a31b690aa110b17a67c53281cd4dde..0000000000000000000000000000000000000000
--- a/src/plugins/e-acsl/src/analyses/label.ml
+++ /dev/null
@@ -1,59 +0,0 @@
-(**************************************************************************)
-(* *)
-(* This file is part of the Frama-C's E-ACSL plug-in. *)
-(* *)
-(* Copyright (C) 2012-2021 *)
-(* CEA (Commissariat à l'énergie atomique et aux énergies *)
-(* alternatives) *)
-(* *)
-(* you can redistribute it and/or modify it under the terms of the GNU *)
-(* Lesser General Public License as published by the Free Software *)
-(* Foundation, version 2.1. *)
-(* *)
-(* It is distributed in the hope that it will be useful, *)
-(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
-(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
-(* GNU Lesser General Public License for more details. *)
-(* *)
-(* See the GNU Lesser General Public License version 2.1 *)
-(* for more details (enclosed in the file licenses/LGPLv2.1). *)
-(* *)
-(**************************************************************************)
-
-open Cil_types
-module Error = Error.Make(struct let phase = Options.Dkey.translation end)
-
-let get_first_inner_stmt stmt =
- match stmt.labels, stmt.skind with
- | [], _ -> stmt
- | _ :: _, Block { bstmts = dest_stmt :: _ } ->
- dest_stmt
- | labels, _ ->
- Options.fatal "Unexpected stmt:\nlabels: [%a]\nstmt: %a"
- (Pretty_utils.pp_list ~sep:"; " Cil_types_debug.pp_label) labels
- Printer.pp_stmt stmt
-
-let get_stmt kf llabel =
- let stmt = match llabel with
- | StmtLabel { contents = stmt } -> stmt
- | BuiltinLabel Here -> Error.not_yet "Label 'Here'"
- | BuiltinLabel(Old | Pre) ->
- (try Kernel_function.find_first_stmt kf
- with Kernel_function.No_Statement -> assert false (* Frama-C invariant*))
- | BuiltinLabel(Post) ->
- (try Kernel_function.find_return kf
- with Kernel_function.No_Statement -> assert false (* Frama-C invariant*))
- | BuiltinLabel _ ->
- Error.not_yet (Format.asprintf "Label '%a'" Printer.pp_logic_label llabel)
- | FormalLabel _ ->
- Error.not_yet "FormalLabel"
- in
- (* the pointed statement has been visited and modified by the injector:
- get its new version. *)
- get_first_inner_stmt stmt
-
-(*
-Local Variables:
-compile-command: "make -C ../../../../.."
-End:
-*)
diff --git a/src/plugins/e-acsl/src/analyses/labels.ml b/src/plugins/e-acsl/src/analyses/labels.ml
new file mode 100644
index 0000000000000000000000000000000000000000..423e630b1ab8de860350f50d9d6ba3cce30075c3
--- /dev/null
+++ b/src/plugins/e-acsl/src/analyses/labels.ml
@@ -0,0 +1,573 @@
+(**************************************************************************)
+(* *)
+(* This file is part of the Frama-C's E-ACSL plug-in. *)
+(* *)
+(* Copyright (C) 2012-2021 *)
+(* CEA (Commissariat à l'énergie atomique et aux énergies *)
+(* alternatives) *)
+(* *)
+(* you can redistribute it and/or modify it under the terms of the GNU *)
+(* Lesser General Public License as published by the Free Software *)
+(* Foundation, version 2.1. *)
+(* *)
+(* It is distributed in the hope that it will be useful, *)
+(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
+(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
+(* GNU Lesser General Public License for more details. *)
+(* *)
+(* See the GNU Lesser General Public License version 2.1 *)
+(* for more details (enclosed in the file licenses/LGPLv2.1). *)
+(* *)
+(**************************************************************************)
+
+(** Pre-analysis for Labeled terms and predicates. *)
+
+open Cil_types
+open Cil_datatype
+open Analyses_types
+open Analyses_datatype
+let dkey = Options.Dkey.labels
+module Error = Error.Make(struct let phase = dkey end)
+
+(**************************************************************************)
+(********************** Forward references ********************************)
+(**************************************************************************)
+
+let has_empty_quantif_ref: ((term * logic_var * term) list -> bool) ref =
+ Extlib.mk_fun "has_empty_quantif_ref"
+
+(**************************************************************************)
+(************************** Labeled stmts *********************************)
+(**************************************************************************)
+
+let get_first_inner_stmt stmt =
+ match stmt.labels, stmt.skind with
+ | [], _ -> stmt
+ | _ :: _, Block { bstmts = dest_stmt :: _ } ->
+ dest_stmt
+ | labels, _ ->
+ Options.fatal "Unexpected stmt:\nlabels: [%a]\nstmt: %a"
+ (Pretty_utils.pp_list ~sep:"; " Cil_types_debug.pp_label) labels
+ Printer.pp_stmt stmt
+
+(**************************************************************************)
+(*************************** Translation **********************************)
+(**************************************************************************)
+
+let preprocess_done = ref false
+
+(** Associate a statement with the [at_data] that need to be translated on
+ this statement. *)
+let at_data_for_stmts: At_data.Set.t ref Stmt.Hashtbl.t =
+ Stmt.Hashtbl.create 17
+
+(** Add [data] to the list of [at_data] that must be translated on the
+ statement [stmt]. *)
+let add_at_for_stmt data stmt =
+ let stmt = get_first_inner_stmt stmt in
+ let ats_ref =
+ try
+ Stmt.Hashtbl.find at_data_for_stmts stmt
+ with Not_found ->
+ let ats_ref = ref At_data.Set.empty in
+ Stmt.Hashtbl.add at_data_for_stmts stmt ats_ref;
+ ats_ref
+ in
+ let old_data =
+ try
+ At_data.Set.find data !ats_ref
+ with Not_found ->
+ ats_ref := At_data.Set.add data !ats_ref;
+ data
+ in
+ match old_data.error, data.error with
+ | Some _, None ->
+ (* Replace the old data that has an error with the new data that do not
+ have one. *)
+ ats_ref := At_data.Set.remove old_data !ats_ref;
+ ats_ref := At_data.Set.add data !ats_ref
+ | Some _, Some _
+ | None, Some _
+ | None, None ->
+ (* Either the new data has an error and not the old one, or both data are
+ the same, keep the old data. *)
+ ()
+
+(* see documentation in .mli *)
+let at_for_stmt stmt =
+ if !preprocess_done then
+ let ats_ref =
+ Stmt.Hashtbl.find_def at_data_for_stmts stmt (ref At_data.Set.empty)
+ in
+ Result.Ok !ats_ref
+ else
+ Error.not_memoized ()
+
+(**************************************************************************)
+(************************** AST traversal *********************************)
+(**************************************************************************)
+
+module Process: sig
+ module Env: sig
+ type t
+ (** Environment to propagate during the traversal. *)
+
+ val create:
+ kernel_function ->
+ kinstr ->
+ annotation_kind ->
+ t
+ (** [create clabels kf kinstr akind] creates an environment for the
+ traversal.
+ - [kf]: Enclosing function of the predicate or term being analysed.
+ - [kinstr]: Kinstr of the predicate or term being analysed.
+ - [akind]: Kind of annotation for the predicate or term being
+ analysed. *)
+ end
+
+ val term: ?error:exn -> Env.t -> term -> unit
+ (** Traverse the given term to analyze its labeled predicates and terms. *)
+
+ val predicate: ?error:exn -> Env.t -> predicate -> unit
+ (** Traverse the given predicate to analyze its labeled predicates and
+ terms. *)
+
+end = struct
+ module Env = struct
+ type t = {
+ (** Enclosing function of the predicate or term being analysed. *)
+ kf: kernel_function;
+ (** Kinstr of the predicate or term being analysed. *)
+ kinstr: kinstr;
+ (** Kind of annotation for the predicate or term being analysed. *)
+ akind: annotation_kind;
+ (** Logic scope for the predicate or term being analysed. *)
+ lscope: Lscope.t;
+ }
+
+ let create kf kinstr akind =
+ { kf; kinstr; akind; lscope = Lscope.empty }
+ end
+
+ (** @return either the given error if it is provided, or [Some e] if not. *)
+ let set_error ?error e =
+ match error with
+ | None -> Some e
+ | Some _ -> error
+
+ (** Create and return a [Not_yet] exception with the given message. If [error]
+ is provided, return this error instead. *)
+ let not_yet ?error s =
+ set_error ?error (Error.make_not_yet s)
+
+ (** Apply [fct ?error env] on every element of the list [args]. *)
+ let do_list fct ?error env args =
+ List.fold_left
+ (fun error a -> fct ?error env a)
+ error
+ args
+
+ (** Apply [fct ?error env] on [arg] if [arg_opt] is [Some arg], return
+ directly [error] otherwise. *)
+ let do_opt fct ?error env arg_opt =
+ match arg_opt with
+ | Some arg -> fct ?error env arg
+ | None -> error
+
+ (** Analyse the predicate or term [pot] and the label [label] to decide where
+ the predicate or term must be translated. *)
+ let process ?error env pot label =
+ Env.( (* locally open Env to access to the fields of Env.t *)
+ let msg s =
+ Format.asprintf
+ "%s '%a' within %s annotation '%a' in '%a'"
+ s
+ Printer.pp_logic_label label
+ (match env.kinstr with
+ | Kglobal -> "function"
+ | Kstmt _ -> "statement")
+ Annotation_kind.pretty env.akind
+ Pred_or_term.pretty pot
+ in
+ let error, dest_stmt_opt =
+ match env.kinstr, env.akind, label with
+ (* C label, translate on the given statement regardless of the kind of
+ annotation. *)
+ | Kstmt _, _, StmtLabel { contents = stmt } ->
+ error, Some stmt
+ | Kglobal, _, StmtLabel _ ->
+ Options.fatal "%s" (msg "invalid use of C label")
+
+ (* Assertions *)
+ (* - Pre label corresponding to the first statement of the function *)
+ | Kstmt _, Assertion, BuiltinLabel Pre ->
+ error, Some (Kernel_function.find_first_stmt env.kf)
+ (* - In-place translation for label Here *)
+ | Kstmt _, Assertion, BuiltinLabel Here ->
+ error, None
+ (* - Not yet supported labels *)
+ | Kstmt _, Assertion, BuiltinLabel (LoopCurrent | LoopEntry | Init) ->
+ not_yet ?error (msg "label"), None
+ (* - Invalid labels in assertions *)
+ | Kstmt _, Assertion, BuiltinLabel (Old | Post) ->
+ Options.fatal "%s" (msg "invalid label")
+ (* - Invalid use of assertion in function contract *)
+ | Kglobal, Assertion, _ ->
+ Options.fatal "invalid use of assertion in fonction contract"
+
+ (* Function contracts *)
+ (* - Preconditions *)
+ (* -- In-place translation for labels Pre, Old and Here *)
+ | Kglobal, Precondition, BuiltinLabel (Pre | Old | Here) ->
+ error, None
+ (* -- Not yet supported labels *)
+ | Kglobal, Precondition, BuiltinLabel Init ->
+ not_yet ?error (msg "label"), None
+ (* -- Invalid labels *)
+ | Kglobal, Precondition, BuiltinLabel (Post | LoopEntry | LoopCurrent)
+ ->
+ Options.fatal "%s" (msg "invalid label")
+ (* - Postconditions *)
+ (* -- Pre and Old are equivalent and correspond to the first statement
+ of the function. *)
+ | Kglobal, Postcondition, BuiltinLabel (Pre | Old) ->
+ error, Some (Kernel_function.find_first_stmt env.kf)
+ (* -- In-place translation for labels Here and Post *)
+ | Kglobal, Postcondition, BuiltinLabel (Here | Post) ->
+ error, None
+ (* -- Not yet supported labels *)
+ | Kglobal, Postcondition, BuiltinLabel Init ->
+ not_yet ?error (msg "label"), None
+ (* -- Invalid labels *)
+ | Kglobal, Postcondition, BuiltinLabel (LoopEntry | LoopCurrent) ->
+ Options.fatal "%s" (msg "invalid label")
+ (* - Variant *)
+ | Kglobal, Variant, _ ->
+ Options.fatal "invalid use of label in decreases clause"
+ (* - Invariant *)
+ | Kglobal, Invariant, _ ->
+ Options.fatal "invalid invariant annotation in function contract"
+
+ (* Statement contracts *)
+ (* - Preconditions *)
+ (* -- Pre correspond to the first statement of the function *)
+ | Kstmt _, Precondition, BuiltinLabel Pre ->
+ error, Some (Kernel_function.find_first_stmt env.kf)
+ (* -- In-place translation for Old and Here *)
+ | Kstmt _, Precondition, BuiltinLabel (Old | Here) ->
+ error, None
+ (* -- Not yet supported labels *)
+ | Kstmt _, Precondition, BuiltinLabel (Init | LoopEntry | LoopCurrent)
+ ->
+ not_yet ?error (msg "label"), None
+ (* -- Invalid labels *)
+ | Kstmt _, Precondition, BuiltinLabel Post ->
+ Options.fatal "%s" (msg "invalid label")
+ (* - Postconditions *)
+ (* -- Pre correspond to the first statement of the function *)
+ | Kstmt _, Postcondition, BuiltinLabel Pre ->
+ error, Some (Kernel_function.find_first_stmt env.kf)
+ (* -- Old correspond to the current statement *)
+ | Kstmt stmt, Postcondition, BuiltinLabel Old ->
+ error, Some stmt
+ (* -- In-place tranlsation for Here and Post *)
+ | Kstmt _, Postcondition, BuiltinLabel (Here | Post) ->
+ error, None
+ (* -- Not yet supported labels *)
+ | Kstmt _, Postcondition, BuiltinLabel (Init | LoopEntry | LoopCurrent)
+ ->
+ not_yet ?error (msg "label"), None
+ (* - Variant *)
+ | Kstmt _, Variant, _ ->
+ not_yet ?error "label in loop variant", None
+ (* - Invariant *)
+ | Kstmt _, Invariant, _ ->
+ not_yet ?error "label in loop invariant", None
+
+ (* Global annotation labels are not supported in E-ACSL *)
+ | _, _, FormalLabel _ ->
+ not_yet ?error (msg "formal label"), None
+
+ | _, RTE, _ ->
+ Options.fatal "%s" (msg "invalid annotation kind in")
+ in
+ begin match dest_stmt_opt with
+ | Some dest_stmt ->
+ (* Register the current labeled pred_or_term to the destination
+ statement for a later translation *)
+ let at =
+ At_data.create ?error env.kf env.kinstr env.lscope pot label
+ in
+ add_at_for_stmt at dest_stmt;
+ | None ->
+ ()
+ end;
+ error
+ )
+
+ (** Term traversal *)
+ let rec do_term ?error env t =
+ let t = Logic_normalizer.get_term t in
+ match t.term_node with
+ | Tat (t', l) ->
+ let error = do_term ?error env t' in
+ process ?error env (PoT_term t) l
+ | Tbase_addr (l, t') | Tblock_length (l, t') | Toffset (l, t') ->
+ let error = do_term ?error env t' in
+ (* E-ACSL semantic: \base_addr{L}(p) == \at(\base_addr(p), L) *)
+ process ?error env (PoT_term t) l
+ | Tlet (li, t) ->
+ let lv_term = Misc.term_of_li li in
+ let error = do_term ?error env lv_term in
+ let lvs = Lvs_let (li.l_var_info, lv_term) in
+ let env = { env with lscope = Lscope.add lvs env.lscope } in
+ do_term ?error env t
+ | TLval lv | TAddrOf lv | TStartOf lv ->
+ do_term_lval ?error env lv
+ | TSizeOfE t | TAlignOfE t | TUnOp (_, t) | TCastE (_, t) | Tlambda (_, t)
+ | TLogic_coerce (_, t) ->
+ do_term ?error env t
+ | TBinOp (_, t1, t2) ->
+ let error = do_term ?error env t1 in
+ do_term ?error env t2
+ | Tif (t1, t2, t3) ->
+ let error = do_term ?error env t1 in
+ let error = do_term ?error env t2 in
+ do_term ?error env t3
+ | Tapp (_, [], targs) ->
+ do_list do_term ?error env targs
+ | Tapp (_, labels, targs) ->
+ let error = not_yet "logic functions with labels" in
+ do_labeled_app ?error env labels targs
+ | Trange (t1_opt, t2_opt) ->
+ let error = do_opt do_term ?error env t1_opt in
+ do_opt do_term ?error env t2_opt
+ | TDataCons (_, targs) ->
+ (* Register a not_yet error for each labeled pred or term in the
+ arguments *)
+ let error = not_yet "constructor" in
+ do_list do_term ?error env targs
+ | TUpdate (t1, toff, t2) ->
+ (* Register a not_yet error for each labeled pred or term used in the
+ functional update *)
+ let error = not_yet "functional update" in
+ let error = do_term ?error env t1 in
+ let error = do_term_offset ?error env toff in
+ do_term ?error env t2
+ | Ttypeof t ->
+ (* Register a not_yet error for each labeled pred or term used with the
+ typeof operator *)
+ let error = not_yet "typeof" in
+ do_term ?error env t
+ | Tunion ts | Tinter ts ->
+ (* Register a not_yet error for each labeled pred or term used in the
+ manipulation of tsets *)
+ let error = not_yet "union or intersection of tsets" in
+ do_list do_term ?error env ts
+ | Tcomprehension (t, _, p_opt) ->
+ (* Register a not_yet error for each labeled pred or term used in the
+ comprehension *)
+ let error = not_yet "tset comprehension" in
+ let error = do_term ?error env t in
+ do_opt do_predicate ?error env p_opt
+ | TConst _ | TSizeOf _ | TAlignOf _ | TSizeOfStr _ | Tnull | Ttype _
+ | Tempty_set ->
+ error
+
+ (** Lval traversal *)
+ and do_term_lval ?error env (tlhost, toffset) =
+ let error = do_term_lhost ?error env tlhost in
+ do_term_offset ?error env toffset
+
+ (** Lhost traversal *)
+ and do_term_lhost ?error env = function
+ | TMem t -> do_term ?error env t
+ | TVar _ | TResult _ -> error
+
+ (** Offset traversal *)
+ and do_term_offset ?error env = function
+ | TIndex (t, next) ->
+ let error = do_term ?error env t in
+ do_term_offset ?error env next
+ | TField (_, next) | TModel (_, next) ->
+ do_term_offset ?error env next
+ | TNoOffset -> error
+
+ (** Predicate traversal *)
+ and do_predicate ?error env p =
+ let p = Logic_normalizer.get_pred p in
+ match p.pred_content with
+ | Pat (p', l) ->
+ let error = do_predicate ?error env p' in
+ process ?error env (PoT_pred p) l
+ | Pfreeable (l, t) | Pvalid (l, t) | Pvalid_read (l, t)
+ | Pinitialized (l, t) ->
+ let error = do_term ?error env t in
+ (* E-ACSL semantic: \freeable{L}(p) == \at(\freeable(p), L) *)
+ process ?error env (PoT_pred p) l
+ | Pallocable (l, t) ->
+ let error = not_yet "\\allocate" in
+ let error = do_term ?error env t in
+ process ?error env (PoT_pred p) l
+ | Pdangling (l, t) ->
+ let error = not_yet "\\dangling" in
+ let error = do_term ?error env t in
+ process ?error env (PoT_pred p) l
+ | Pobject_pointer (l, t) ->
+ let error = not_yet "\\object_pointer" in
+ let error = do_term ?error env t in
+ process ?error env (PoT_pred p) l
+ | Plet (li, p) ->
+ let lv_term = Misc.term_of_li li in
+ let error = do_term ?error env lv_term in
+ let lvs = Lvs_let (li.l_var_info, lv_term) in
+ let env = { env with lscope = Lscope.add lvs env.lscope } in
+ do_predicate ?error env p
+ | Pforall _ | Pexists _ -> begin
+ let preprocessed_quantifier_or_error =
+ try
+ Bound_variables.get_preprocessed_quantifier p
+ with Error.Not_memoized _ ->
+ Options.fatal
+ "preprocessing of quantifier '%a' has not been performed"
+ Printer.pp_predicate p
+ in
+ match preprocessed_quantifier_or_error with
+ | Result.Ok (bound_vars, goal) ->
+ if !has_empty_quantif_ref bound_vars then
+ error
+ else begin
+ (* We want to process the bounds and the predicate with the same
+ environment as the translation (done in [Quantif.convert]). As a
+ result, the [lscope] is first built with a [fold_right] on the
+ [bound_vars], then once the [lscope] is entirely built, the terms
+ of the bounds and the predicate of the goal are analyzed. *)
+ let env =
+ List.fold_right
+ (fun (t1, lv, t2) env ->
+ let lvs = Lvs_quantif (t1, Rle, lv, Rlt, t2) in
+ { env with Env.lscope = Lscope.add lvs env.Env.lscope })
+ bound_vars
+ env
+ in
+ let do_it ?error env (t1, _, t2) =
+ let error = do_term ?error env t1 in
+ do_term ?error env t2
+ in
+ let error = do_list do_it ?error env bound_vars in
+ do_predicate ?error env goal
+ end
+ | Result.Error exn -> set_error ?error exn
+ end
+ | Pnot p ->
+ do_predicate ?error env p
+ | Pand (p1, p2) | Por (p1, p2) | Pxor (p1, p2) | Pimplies (p1, p2)
+ | Piff (p1, p2) ->
+ let error = do_predicate ?error env p1 in
+ do_predicate ?error env p2
+ | Pif (t, p1, p2) ->
+ let error = do_term ?error env t in
+ let error = do_predicate ?error env p1 in
+ do_predicate ?error env p2
+ | Prel (_, t1, t2) ->
+ let error = do_term ?error env t1 in
+ do_term ?error env t2
+ | Papp (_, [], targs) | Pseparated (targs) ->
+ do_list do_term ?error env targs
+ | Papp (_, labels, targs) ->
+ let error = not_yet "predicate with labels" in
+ do_labeled_app ?error env labels targs
+ | Pvalid_function t ->
+ let error = not_yet "\\valid_function" in
+ do_term ?error env t
+ | Pfresh (l1, l2, t, _) ->
+ let error = not_yet "\\fresh" in
+ let error = process ?error env (PoT_term t) l1 in
+ process ?error env (PoT_term t) l2
+ | Pfalse | Ptrue -> error
+
+ (** Function application with labels traversal *)
+ and do_labeled_app ?error env labels targs =
+ let do_it ?error env t =
+ (* Register a not_yet error for each labeled pred or term in the
+ arguments *)
+ let error = do_term ?error env t in
+ (* Since we do not know how the labels are used with the arguments,
+ for each argument, register a [Not_yet] error with each label of the
+ function so that each possible combination gracefully raises an error
+ to the user. *)
+ List.fold_left
+ (fun error label -> process ?error env (PoT_term t) label)
+ error
+ labels
+ in
+ do_list do_it ?error env targs
+
+ (* see documentation in module signature *)
+ let term ?error env t =
+ ignore @@ do_term ?error env t
+
+ (* see documentation in module signature *)
+ let predicate ?error env p =
+ ignore @@ do_predicate ?error env p
+
+end
+
+class vis_at_labels () = object (self)
+
+ inherit E_acsl_visitor.visitor dkey
+
+ method! glob_annot _ = Cil.SkipChildren
+
+ (** Launch the analysis on the given predicate. *)
+ method! vpredicate p =
+ let kf = Option.get self#current_kf in
+ let kinstr = self#current_kinstr in
+ let akind = self#get_akind ()in
+ let error = self#get_visit_error () in
+ let env = Process.Env.create kf kinstr akind in
+ Process.predicate ?error env p;
+ Cil.SkipChildren
+
+ (** Launch the analysis on the given term. *)
+ method !vterm t =
+ let kf = Option.get self#current_kf in
+ let kinstr = self#current_kinstr in
+ let akind = self#get_akind ()in
+ let error = self#get_visit_error () in
+ let env = Process.Env.create kf kinstr akind in
+ Process.term ?error env t;
+ Cil.SkipChildren
+
+end
+
+let preprocess ast =
+ let vis = new vis_at_labels () in
+ vis#visit_file ast;
+ preprocess_done := true
+
+let reset () =
+ preprocess_done := false;
+ Stmt.Hashtbl.clear at_data_for_stmts
+
+let _debug () =
+ Options.feedback ~level:2 "Labels preprocessing";
+ Options.feedback ~level:2 "|Locations:";
+ Stmt.Hashtbl.iter
+ (fun stmt ats_ref ->
+ Options.feedback ~level:2 "| - stmt %d at %a"
+ stmt.sid
+ Printer.pp_location (Stmt.loc stmt);
+ At_data.Set.iter
+ (fun at ->
+ Options.feedback ~level:2 "| - at %a"
+ At_data.pretty at)
+ !ats_ref
+ )
+ at_data_for_stmts
+
+(*
+Local Variables:
+compile-command: "make -C ../../../../.."
+End:
+*)
diff --git a/src/plugins/e-acsl/src/analyses/label.mli b/src/plugins/e-acsl/src/analyses/labels.mli
similarity index 62%
rename from src/plugins/e-acsl/src/analyses/label.mli
rename to src/plugins/e-acsl/src/analyses/labels.mli
index 6244536ac724e0684d3f48ffe90deeb7a999aec1..a53f15aa67246ba3ba72fb7e2e75d47c0ef5499c 100644
--- a/src/plugins/e-acsl/src/analyses/label.mli
+++ b/src/plugins/e-acsl/src/analyses/labels.mli
@@ -20,15 +20,42 @@
(* *)
(**************************************************************************)
-open Cil_types
+(** Pre-analysis for Labeled terms and predicates.
+
+ This pre-analysis records, for each labeled term or predicate, the place
+ where the translation must happen.
+
+ The list of labeled terms or predicates to be translated for a given
+ statement is provided by [Labels.at_for_stmt]. *)
-val get_stmt: kernel_function -> logic_label -> stmt
-(** @return the statement where the logic label points to. *)
+open Cil_types
+open Analyses_datatype
val get_first_inner_stmt: stmt -> stmt
(** If the given statement has a label, return the first statement of the block.
Otherwise return the given statement. *)
+val at_for_stmt: stmt -> At_data.Set.t Error.result
+(** @return the set of labeled predicates and terms to be translated on the
+ given statement.
+ @raise Not_memoized if the labels pre-analysis was not run. *)
+
+val preprocess: file -> unit
+(** Analyse sources to find the statements where a labeled predicate or term
+ should be translated. *)
+
+val reset: unit -> unit
+(** Reset the results of the pre-anlaysis. *)
+
+val _debug: unit -> unit
+(** Print internal state of labels translation. *)
+
+(**************************************************************************)
+(********************** Forward references ********************************)
+(**************************************************************************)
+
+val has_empty_quantif_ref: ((term * logic_var * term) list -> bool) ref
+
(*
Local Variables:
compile-command: "make -C ../../../../.."
diff --git a/src/plugins/e-acsl/src/analyses/logic_normalizer.ml b/src/plugins/e-acsl/src/analyses/logic_normalizer.ml
index eb5b5fb88651fe092b6ac3b77bff2892bedab363..e804f513e96e26f8a302fc25488d3af68250b3fb 100644
--- a/src/plugins/e-acsl/src/analyses/logic_normalizer.ml
+++ b/src/plugins/e-acsl/src/analyses/logic_normalizer.ml
@@ -22,6 +22,8 @@
open Cil_types
+let dkey = Options.Dkey.logic_normalizer
+
module Id_predicate =
Datatype.Make_with_collections
(struct
@@ -123,7 +125,7 @@ let preprocess_term ~loc t =
| _ -> None
let preprocessor = object
- inherit E_acsl_visitor.visitor
+ inherit E_acsl_visitor.visitor dkey
method !vannotation annot =
match annot with
@@ -142,19 +144,13 @@ let preprocessor = object
end
let preprocess ast =
- Visitor.visitFramacFileSameGlobals
- (preprocessor :> Visitor.frama_c_inplace)
- ast
+ preprocessor#visit_file ast
let preprocess_annot annot =
- ignore
- (Visitor.visitFramacCodeAnnotation
- (preprocessor :> Visitor.frama_c_inplace)
- annot)
+ ignore @@ preprocessor#visit_code_annot annot
let preprocess_predicate p =
- ignore
- (Visitor.visitFramacPredicate (preprocessor :> Visitor.frama_c_inplace) p)
+ ignore @@ preprocessor#visit_predicate p
let get_pred = Memo.get_pred
let get_term = Memo.get_term
diff --git a/src/plugins/e-acsl/src/analyses/lscope.ml b/src/plugins/e-acsl/src/analyses/lscope.ml
index 028975a80ec08477a3ccf59b476897ab3ab131a5..331cb1c4ca5fcdb9877faa9deddeba3b61d1c470 100644
--- a/src/plugins/e-acsl/src/analyses/lscope.ml
+++ b/src/plugins/e-acsl/src/analyses/lscope.ml
@@ -135,11 +135,11 @@ module D = Datatype.Make(struct
in
let c =
if c <> 0 then c
- else compare lr1 lr2
+ else Stdlib.compare lr1 lr2
in
let c =
if c <> 0 then c
- else compare rr1 rr2
+ else Stdlib.compare rr1 rr2
in
c
| Lvs_formal (lv1, li1), Lvs_formal (lv2, li2) ->
@@ -154,6 +154,8 @@ module D = Datatype.Make(struct
lscope_vars1
lscope_vars2
+ let equal = Datatype.from_compare
+
let hash lscope =
let lscope_vars = get_all lscope in
hash_list
diff --git a/src/plugins/e-acsl/src/analyses/typing.ml b/src/plugins/e-acsl/src/analyses/typing.ml
index 5a714336460373d6ec0a4d5771ca763329427c31..b83df3af03d5057e99008e835e66ffca5ab850f3 100644
--- a/src/plugins/e-acsl/src/analyses/typing.ml
+++ b/src/plugins/e-acsl/src/analyses/typing.ml
@@ -979,7 +979,7 @@ let get_cast_of_predicate ~lenv p =
let clear = Memo.clear
let typing_visitor lenv = object
- inherit E_acsl_visitor.visitor
+ inherit E_acsl_visitor.visitor dkey
(* global logic functions and predicates are evaluated are callsites *)
method !glob_annot _ = Cil.SkipChildren
@@ -995,23 +995,18 @@ let typing_visitor lenv = object
end
let type_program ast =
- Visitor.visitFramacFileSameGlobals
- (typing_visitor [] :> Visitor.frama_c_inplace)
- ast
+ let visitor = typing_visitor [] in
+ visitor#visit_file ast
let type_code_annot lenv annot =
- ignore
- (Visitor.visitFramacCodeAnnotation
- (typing_visitor lenv :> Visitor.frama_c_inplace)
- annot)
+ let visitor = typing_visitor lenv in
+ ignore @@ visitor#visit_code_annot annot
let preprocess_predicate lenv p =
Logic_normalizer.preprocess_predicate p;
Bound_variables.preprocess_predicate p;
- ignore
- (Visitor.visitFramacPredicate
- (typing_visitor lenv :> Visitor.frama_c_inplace)
- p)
+ let visitor = typing_visitor lenv in
+ ignore @@ visitor#visit_predicate p
let preprocess_rte ~lenv rte =
Logic_normalizer.preprocess_annot rte;
diff --git a/src/plugins/e-acsl/src/code_generator/assert.ml b/src/plugins/e-acsl/src/code_generator/assert.ml
index f2528e9c6dfabee5d8a98719a5063c08ee2abc38..c10e0bab5ce9bfcd0f6c412e003d4b01c9ecfc42 100644
--- a/src/plugins/e-acsl/src/code_generator/assert.ml
+++ b/src/plugins/e-acsl/src/code_generator/assert.ml
@@ -24,6 +24,8 @@
general functions to create assertion statements. *)
open Cil_types
+open Analyses_types
+open Analyses_datatype
(** Type holding information about the C variable representing the assertion
data. *)
@@ -186,7 +188,7 @@ let register_term ~loc env ?force t e adata =
register ~loc env name ?force e adata
let register_pred ~loc env ?force p e adata =
- if Env.annotation_kind env == Smart_stmt.RTE then
+ if Env.annotation_kind env == RTE then
(* When translating RTE, we do not want to print the result of the predicate
because they should be the only predicate in an assertion clause. *)
adata, env
@@ -194,16 +196,15 @@ let register_pred ~loc env ?force p e adata =
let name = Format.asprintf "@[%a@]" Printer.pp_predicate p in
register ~loc env name ?force e adata
+let register_pred_or_term ~loc env ?force pot e adata =
+ match pot with
+ | PoT_term t -> register_term ~loc env ?force t e adata
+ | PoT_pred p -> register_pred ~loc env ?force p e adata
+
let kind_to_string loc k =
Cil.mkString
~loc
- (match k with
- | Smart_stmt.Assertion -> "Assertion"
- | Smart_stmt.Precondition -> "Precondition"
- | Smart_stmt.Postcondition -> "Postcondition"
- | Smart_stmt.Invariant -> "Invariant"
- | Smart_stmt.Variant -> "Variant"
- | Smart_stmt.RTE -> "RTE")
+ (Format.asprintf "%a" Annotation_kind.pretty k)
let runtime_check_with_msg ~adata ~loc ?(name="") msg ~pred_kind kind kf env predicate_e =
let env = Env.push env in
diff --git a/src/plugins/e-acsl/src/code_generator/assert.mli b/src/plugins/e-acsl/src/code_generator/assert.mli
index 30ae0b268d0f09f5e14dbea4654f98576a5fdbe5..d52e907cb1e4cd33bc5fab84823232b49a6799b6 100644
--- a/src/plugins/e-acsl/src/code_generator/assert.mli
+++ b/src/plugins/e-acsl/src/code_generator/assert.mli
@@ -24,6 +24,7 @@
general functions to create assertion statements. *)
open Cil_types
+open Analyses_types
type t
(** Type to hold the data contributing to an assertion. *)
@@ -96,10 +97,23 @@ val register_pred:
parameter [force] has the same signification than for the function
[register]. *)
+val register_pred_or_term:
+ loc:location ->
+ Env.t ->
+ ?force:bool ->
+ pred_or_term ->
+ exp ->
+ t ->
+ t * Env.t
+(** [register_pred_or_term ~loc kf env ?force pot e adata] registers the data
+ [e] corresponding to the predicate or term [pot] to the assertion context
+ [adata]. The parameter [force] has the same signification than for the
+ function [register]. *)
+
val runtime_check:
adata:t ->
pred_kind:predicate_kind ->
- Smart_stmt.annotation_kind ->
+ annotation_kind ->
kernel_function ->
Env.t ->
exp ->
@@ -121,7 +135,7 @@ val runtime_check_with_msg:
?name:string ->
string ->
pred_kind:predicate_kind ->
- Smart_stmt.annotation_kind ->
+ annotation_kind ->
kernel_function ->
Env.t ->
exp ->
diff --git a/src/plugins/e-acsl/src/code_generator/contract.ml b/src/plugins/e-acsl/src/code_generator/contract.ml
index 69d7b48a5e6034bc13368eb23ce15ea6384c1a8c..879ee0ceadfc5a822ca7515f0b529720b7ff8d18 100644
--- a/src/plugins/e-acsl/src/code_generator/contract.ml
+++ b/src/plugins/e-acsl/src/code_generator/contract.ml
@@ -374,7 +374,7 @@ let check_other_requires kf env contract =
Assert.runtime_check
~adata
~pred_kind
- Smart_stmt.Precondition
+ Precondition
kf
env
requires_e
@@ -697,7 +697,7 @@ let check_post_conds kf env contract =
Assert.runtime_check
~adata
~pred_kind
- Smart_stmt.Postcondition
+ Postcondition
kf
env
post_cond_e
@@ -754,7 +754,7 @@ let check_post_conds kf env contract =
contract.spec.spec_behavior
let translate_preconditions kf env contract =
- let env = Env.set_annotation_kind env Smart_stmt.Precondition in
+ let env = Env.set_annotation_kind env Precondition in
let env = Env.push_contract env contract in
let env = init kf env contract in
(* Start with translating the requires predicate of the default behavior. *)
@@ -775,7 +775,7 @@ let translate_preconditions kf env contract =
Env.handle_error do_it env
let translate_postconditions kf env =
- let env = Env.set_annotation_kind env Smart_stmt.Postcondition in
+ let env = Env.set_annotation_kind env Postcondition in
let contract, env = Env.pop_and_get_contract env in
let do_it env =
let env = check_post_conds kf env contract in
diff --git a/src/plugins/e-acsl/src/code_generator/env.ml b/src/plugins/e-acsl/src/code_generator/env.ml
index a090072fb28e3b72c263c20a6e231490bb921049..505ee2bc23b336f25ab4338945cbabccead2a3da 100644
--- a/src/plugins/e-acsl/src/code_generator/env.ml
+++ b/src/plugins/e-acsl/src/code_generator/env.ml
@@ -20,9 +20,9 @@
(* *)
(**************************************************************************)
-module E_acsl_label = Label
open Cil_types
open Cil_datatype
+open Analyses_types
open Contract_types
module Error = Translation_error
@@ -63,7 +63,7 @@ type loop_env = {
type t = {
lscope: Lscope.t;
lscope_reset: bool;
- annotation_kind: Smart_stmt.annotation_kind;
+ annotation_kind: annotation_kind;
new_global_vars: (varinfo * localized_scope) list;
(* generated variables. The scope indicates the level where the variable
should be added. *)
@@ -104,7 +104,7 @@ let empty_loop_env =
let empty =
{ lscope = Lscope.empty;
lscope_reset = true;
- annotation_kind = Smart_stmt.Assertion;
+ annotation_kind = Assertion;
new_global_vars = [];
global_mp_tbl = empty_mp_tbl;
env_stack = [];
@@ -399,7 +399,7 @@ let add_stmt ?(post=false) env stmt =
{ env with env_stack = local_env :: tl }
let extend_stmt_in_place env stmt ~label block =
- let stmt = E_acsl_label.get_first_inner_stmt stmt in
+ let stmt = Labels.get_first_inner_stmt stmt in
let new_stmt = Smart_stmt.block_stmt block in
let sk = stmt.skind in
stmt.skind <- Block (Cil.mkBlock [ new_stmt; Smart_stmt.stmt sk ]);
diff --git a/src/plugins/e-acsl/src/code_generator/env.mli b/src/plugins/e-acsl/src/code_generator/env.mli
index 29e34613a77f4c50e93b1c5b87dd77d7216e5bdf..b71b062e18dbb5fae50975c9239208bdb28d1c79 100644
--- a/src/plugins/e-acsl/src/code_generator/env.mli
+++ b/src/plugins/e-acsl/src/code_generator/env.mli
@@ -152,8 +152,8 @@ end
(** {2 Current annotation kind} *)
(* ************************************************************************** *)
-val annotation_kind: t -> Smart_stmt.annotation_kind
-val set_annotation_kind: t -> Smart_stmt.annotation_kind -> t
+val annotation_kind: t -> annotation_kind
+val set_annotation_kind: t -> annotation_kind -> t
(* ************************************************************************** *)
(** {2 Loop annotations} *)
@@ -186,6 +186,10 @@ end
(** {2 Context for error handling} *)
(* ************************************************************************** *)
+module Context: sig
+ val save: t -> unit
+end
+
val handle_error: (t -> t) -> t -> t
(** Run the closure with the given environment and handle potential errors.
Restore the globals of the environment to the last time [Env.Context.save]
@@ -200,7 +204,6 @@ val handle_error_with_args: (t * 'a -> t * 'a) -> t * 'a -> t * 'a
val not_yet: t -> string -> 'a
(** Save the current context and raise [Error.Not_yet] exception. *)
-
(* ************************************************************************** *)
(** {2 Current environment kinstr} *)
(* ************************************************************************** *)
diff --git a/src/plugins/e-acsl/src/code_generator/injector.ml b/src/plugins/e-acsl/src/code_generator/injector.ml
index 0870eb32d4fe2b820344fee2229b2849eb0d786b..50b878a67e9cb41875b9e1cd9c5750d5e3906bdb 100644
--- a/src/plugins/e-acsl/src/code_generator/injector.ml
+++ b/src/plugins/e-acsl/src/code_generator/injector.ml
@@ -443,7 +443,7 @@ and inject_in_stmt env kf stmt =
in
let env = Env.set_kinstr env (Kstmt stmt) in
(* initial environment *)
- let env =
+ let env, translate_pre_funspec =
if Kernel_function.is_first_stmt kf stmt then
let env =
if Kernel_function.is_main kf then
@@ -454,11 +454,18 @@ and inject_in_stmt env kf stmt =
in
Temporal.handle_function_parameters kf env
in
- (* translate the precondition of the function *)
- if Functions.check kf then
- let funspec = Annotations.funspec kf in
- Translate_annots.pre_funspec kf env funspec
- else env
+ (* check if the precondition of the function needs to be translated *)
+ env, Functions.check kf
+ else
+ env, false
+ in
+ (* translate all \at() predicates and terms that reference the current stmt *)
+ let env = Translate_ats.for_stmt env kf stmt in
+ (* translate the precondition of the function *)
+ let env =
+ if translate_pre_funspec then
+ let funspec = Annotations.funspec kf in
+ Translate_annots.pre_funspec kf env funspec
else
env
in
@@ -497,7 +504,7 @@ and inject_in_block (env: Env.t) kf blk =
(* now inject code that de-allocates the necessary observation variables and
blocks of the runtime memory that have been previously allocated *)
(* calls to [free] for de-allocating variables observing \at(_,_) *)
- let free_stmts = At_with_lscope.Free.find_all kf in
+ let free_stmts = Translate_ats.Free.find_all kf in
match blk.blocals, free_stmts with
| [], [] ->
env
@@ -511,7 +518,7 @@ and inject_in_block (env: Env.t) kf blk =
(* now that [free] stmts for [kf] have been inserted,
there is no more need to keep the corresponding entries in the
table managing them. *)
- At_with_lscope.Free.remove_all kf;
+ Translate_ats.Free.remove_all kf;
(* The free statements are passed in the same order than the malloc
ones. In order to free the variable in the reverse order, the list
is reversed before appending the return statement. Moreover,
@@ -573,12 +580,12 @@ let add_generated_variables_in_function env fundec =
(* Memory management for \at on purely logic variables: put [malloc] stmts at
proper locations *)
let add_malloc_and_free_stmts kf fundec =
- let malloc_stmts = At_with_lscope.Malloc.find_all kf in
+ let malloc_stmts = Translate_ats.Malloc.find_all kf in
let fstmts = malloc_stmts @ fundec.sbody.bstmts in
fundec.sbody.bstmts <- fstmts;
(* now that [malloc] stmts for [kf] have been inserted, there is no more need
to keep the corresponding entries in the table managing them. *)
- At_with_lscope.Malloc.remove_all kf
+ Translate_ats.Malloc.remove_all kf
let inject_in_fundec main fundec =
let vi = fundec.svar in
@@ -830,6 +837,7 @@ let reset_all ast =
(* by default, do not run E-ACSL on the generated code *)
Options.Run.off ();
(* reset all the E-ACSL environments to their original states *)
+ Translate_ats.reset ();
Logic_functions.reset ();
Global_observer.reset ();
Analyses.reset ();
diff --git a/src/plugins/e-acsl/src/code_generator/libc.ml b/src/plugins/e-acsl/src/code_generator/libc.ml
index 9214791359cf7aea33e40780c45623d6a4f7c4a4..2121d7141963e9c668069251db79a57dbd062707 100644
--- a/src/plugins/e-acsl/src/code_generator/libc.ml
+++ b/src/plugins/e-acsl/src/code_generator/libc.ml
@@ -229,7 +229,7 @@ let term_to_sizet_exp ~loc ~name ?(check_lower_bound=true) kf env t =
Assert.runtime_check
~adata
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
lower_guard
@@ -256,7 +256,7 @@ let term_to_sizet_exp ~loc ~name ?(check_lower_bound=true) kf env t =
Assert.runtime_check
~adata
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
upper_guard
diff --git a/src/plugins/e-acsl/src/code_generator/logic_array.ml b/src/plugins/e-acsl/src/code_generator/logic_array.ml
index d9a75dce63582b6e62faef1a030c5c4b0bfbf77d..a156e946340427dfc179e1dc8d4b500aef6f8805 100644
--- a/src/plugins/e-acsl/src/code_generator/logic_array.ml
+++ b/src/plugins/e-acsl/src/code_generator/logic_array.ml
@@ -249,7 +249,7 @@ let comparison_to_exp ~loc kf env ~name bop array1 array2 =
Assert.register ~loc env "current length" len_orig adata
in
let stmt, env =
- Assert.runtime_check ~adata ~pred_kind:Assert Smart_stmt.RTE kf env e p
+ Assert.runtime_check ~adata ~pred_kind:Assert RTE kf env e p
in
stmt :: stmts, env
in
diff --git a/src/plugins/e-acsl/src/code_generator/loops.ml b/src/plugins/e-acsl/src/code_generator/loops.ml
index 0166604f9e73e238d5b69042cee73d2e2d39b218..44d5e8fdc770257ba1368a413631d1b127aafd78 100644
--- a/src/plugins/e-acsl/src/code_generator/loops.ml
+++ b/src/plugins/e-acsl/src/code_generator/loops.ml
@@ -64,7 +64,7 @@ let handle_annotations env kf stmt =
(fun (stmts, env, _) ->
match Env.top_loop_variant env with
| Some (t, measure_opt) ->
- let env = Env.set_annotation_kind env Smart_stmt.Variant in
+ let env = Env.set_annotation_kind env Variant in
let env = Env.push env in
(* There cannot be bound logical variables since we cannot write
loops inside logic functions or predicates, hence lenv is []*)
@@ -98,7 +98,7 @@ let handle_annotations env kf stmt =
let rec aux (stmts, env) = function
| [] -> begin
(* No statements remaining in the loop: variant check *)
- let env = Env.set_annotation_kind env Smart_stmt.Variant in
+ let env = Env.set_annotation_kind env Variant in
let lenv = Env.Local_vars.get env in
match variant with
| Some (t, e_old, Some measure) ->
@@ -153,7 +153,7 @@ let handle_annotations env kf stmt =
~loc
msg
~pred_kind:Assert
- Smart_stmt.Variant
+ Variant
kf
env
e_tapp
@@ -194,7 +194,7 @@ let handle_annotations env kf stmt =
~loc
msg1
~pred_kind:Assert
- Smart_stmt.Variant
+ Variant
kf
env
variant_pos_e
@@ -236,7 +236,7 @@ let handle_annotations env kf stmt =
~loc
msg2
~pred_kind:Assert
- Smart_stmt.Variant
+ Variant
kf
env
variant_dec_e
@@ -258,7 +258,7 @@ let handle_annotations env kf stmt =
(* Last statement of the loop: invariant check *)
(* Optimisation to only verify invariant on a non-empty body loop. *)
let invariants = Env.top_loop_invariants env in
- let env = Env.set_annotation_kind env Smart_stmt.Invariant in
+ let env = Env.set_annotation_kind env Invariant in
let env = Env.push env in
let env =
let translate_named_predicate = !translate_predicate_ref in
@@ -392,7 +392,7 @@ let rec mk_nested_loops ~loc mk_innermost_block kf env lscope_vars =
Assert.runtime_check
~adata
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
e
diff --git a/src/plugins/e-acsl/src/code_generator/quantif.ml b/src/plugins/e-acsl/src/code_generator/quantif.ml
index c1cb81ab441fa93f6c8003f647c03e9fae613e4f..65c42387ff3705d9001348ecc7c2f0cbeef1f309 100644
--- a/src/plugins/e-acsl/src/code_generator/quantif.ml
+++ b/src/plugins/e-acsl/src/code_generator/quantif.ml
@@ -61,6 +61,8 @@ let rec has_empty_quantif_with_false_negative = function
has_empty_quantif_with_false_negative guards
end
+let () =
+ Labels.has_empty_quantif_ref := has_empty_quantif_with_false_negative
module Label_ids =
State_builder.Counter(struct let name = "E_ACSL.Label_ids" end)
diff --git a/src/plugins/e-acsl/src/code_generator/smart_stmt.ml b/src/plugins/e-acsl/src/code_generator/smart_stmt.ml
index 6bcc645ed33146fae568d5f28a990776299f511a..e76366fa4ce2ca8d087bd63fb7b84d4b05fa98cb 100644
--- a/src/plugins/e-acsl/src/code_generator/smart_stmt.ml
+++ b/src/plugins/e-acsl/src/code_generator/smart_stmt.ml
@@ -210,14 +210,6 @@ let mark_readonly vi =
let loc = vi.vdecl in
rtl_call ~loc "mark_readonly" [ Cil.evar ~loc vi ]
-type annotation_kind =
- | Assertion
- | Precondition
- | Postcondition
- | Invariant
- | Variant
- | RTE
-
(*
Local Variables:
compile-command: "make -C ../../../../.."
diff --git a/src/plugins/e-acsl/src/code_generator/smart_stmt.mli b/src/plugins/e-acsl/src/code_generator/smart_stmt.mli
index 165e815258911e1370a11a8796656f7a13749fe5..887cf852e0adfe9266f87387e661b7f0d693e917 100644
--- a/src/plugins/e-acsl/src/code_generator/smart_stmt.mli
+++ b/src/plugins/e-acsl/src/code_generator/smart_stmt.mli
@@ -109,14 +109,6 @@ val mark_readonly: varinfo -> stmt
(** Same as [store_stmt] for [__e_acsl_markreadonly] that observes the
read-onlyness of the given varinfo. *)
-type annotation_kind =
- | Assertion
- | Precondition
- | Postcondition
- | Invariant
- | Variant
- | RTE
-
(*
Local Variables:
compile-command: "make -C ../../../../.."
diff --git a/src/plugins/e-acsl/src/code_generator/translate_annots.ml b/src/plugins/e-acsl/src/code_generator/translate_annots.ml
index a1d1cfb14b6e6fdd0a37f9550faf6ce526faa0b7..bc00c99360a6a95884679508a1908f1fb4da7ccd 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_annots.ml
+++ b/src/plugins/e-acsl/src/code_generator/translate_annots.ml
@@ -70,7 +70,7 @@ let pre_code_annotation kf stmt env annot =
| AAssert(l, p) ->
if Translate_utils.must_translate
(Property.ip_of_code_annot_single kf stmt annot) then
- let env = Env.set_annotation_kind env Smart_stmt.Assertion in
+ let env = Env.set_annotation_kind env Assertion in
if l <> [] then
Env.not_yet env "@[assertion applied only on some behaviors@]";
Env.with_params
@@ -93,7 +93,7 @@ let pre_code_annotation kf stmt env annot =
| AInvariant(l, loop_invariant, p) ->
if Translate_utils.must_translate
(Property.ip_of_code_annot_single kf stmt annot) then
- let env = Env.set_annotation_kind env Smart_stmt.Invariant in
+ let env = Env.set_annotation_kind env Invariant in
if l <> [] then
Env.not_yet env "@[invariant applied only on some behaviors@]";
let env =
diff --git a/src/plugins/e-acsl/src/code_generator/at_with_lscope.ml b/src/plugins/e-acsl/src/code_generator/translate_ats.ml
similarity index 60%
rename from src/plugins/e-acsl/src/code_generator/at_with_lscope.ml
rename to src/plugins/e-acsl/src/code_generator/translate_ats.ml
index 674db880444e18115a40915d30826b1f76888979..db66a9ec78bcd2655af75017c84f7dfdafd4f432 100644
--- a/src/plugins/e-acsl/src/code_generator/at_with_lscope.ml
+++ b/src/plugins/e-acsl/src/code_generator/translate_ats.ml
@@ -20,62 +20,72 @@
(* *)
(**************************************************************************)
+(** Generate C implementations of E-ACSL [\at()] terms and predicates. *)
+
open Cil_types
+open Cil_datatype
open Analyses_types
+open Analyses_datatype
+module Error = Translation_error
(**************************************************************************)
(********************** Forward references ********************************)
(**************************************************************************)
-let predicate_to_exp_ref
+let term_to_exp_ref
: (adata:Assert.t ->
+ ?inplace:bool ->
kernel_function ->
Env.t ->
- predicate ->
+ term ->
exp * Assert.t * Env.t) ref
=
- ref (fun ~adata:_ _kf _env _p ->
- Extlib.mk_labeled_fun "predicate_to_exp_ref")
+ ref (fun ~adata:_ ?inplace:_ _kf _env _t ->
+ Extlib.mk_labeled_fun "term_to_exp_ref")
-let term_to_exp_ref
+let predicate_to_exp_ref
: (adata:Assert.t ->
+ ?inplace:bool ->
+ ?name:string ->
kernel_function ->
+ ?rte:bool ->
Env.t ->
- term ->
+ predicate ->
exp * Assert.t * Env.t) ref
=
- ref (fun ~adata:_ _kf _env _t -> Extlib.mk_labeled_fun "term_to_exp_ref")
+ ref (fun ~adata:_ ?inplace:_ ?name:_ _kf ?rte:_ _env _p ->
+ Extlib.mk_labeled_fun "predicate_to_exp_ref")
(*****************************************************************************)
(**************************** Handling memory ********************************)
(*****************************************************************************)
-(* Remove all the bindings for [kf]. [Cil_datatype.Kf.Hashtbl] does not
- provide the [remove_all] function. Thus we need to keep calling [remove]
- until all entries are removed. *)
+(** Remove all the bindings for [kf]. [Kf.Hashtbl] does not provide the
+ [remove_all] function. Thus we need to keep calling [remove] until all
+ entries are removed. *)
let rec remove_all tbl kf =
- if Cil_datatype.Kf.Hashtbl.mem tbl kf then begin
- Cil_datatype.Kf.Hashtbl.remove tbl kf;
+ if Kf.Hashtbl.mem tbl kf then begin
+ Kf.Hashtbl.remove tbl kf;
remove_all tbl kf
end
module Malloc = struct
- let tbl = Cil_datatype.Kf.Hashtbl.create 7
- let add kf stmt = Cil_datatype.Kf.Hashtbl.add tbl kf stmt
- let find_all kf = Cil_datatype.Kf.Hashtbl.find_all tbl kf
+ let tbl = Kf.Hashtbl.create 7
+ let add kf stmt = Kf.Hashtbl.add tbl kf stmt
+ let find_all kf = Kf.Hashtbl.find_all tbl kf
let remove_all kf = remove_all tbl kf
end
module Free = struct
- let tbl = Cil_datatype.Kf.Hashtbl.create 7
- let add kf stmt = Cil_datatype.Kf.Hashtbl.add tbl kf stmt
- let find_all kf = Cil_datatype.Kf.Hashtbl.find_all tbl kf
+ let tbl = Kf.Hashtbl.create 7
+ let add kf stmt = Kf.Hashtbl.add tbl kf stmt
+ let find_all kf = Kf.Hashtbl.find_all tbl kf
let remove_all kf = remove_all tbl kf
end
-(**************************************************************************)
-(*************************** Translation **********************************)
-(**************************************************************************)
+(* ************************************************************************** *)
+(* Helper functions for "with lscope" translation *)
+(* ************************************************************************** *)
(* Builds the terms [t_size] and [t_shifted] from each
[Lvs_quantif(tmin, lv, tmax)] from [lscope]
@@ -171,7 +181,7 @@ let size_from_sizes_and_shifts ~loc = function
sizes_and_shifts
(* Build the left-value corresponding to [*(at + index)]. *)
-let lval_at_index ~loc kf env (e_at, vi_at, t_index) =
+let lval_at_index ~loc kf env (e_at, t_index) =
Typing.type_term
~use_gmp_opt:false
~ctx:Typing.c_int
@@ -181,7 +191,7 @@ let lval_at_index ~loc kf env (e_at, vi_at, t_index) =
let e_index, _, env = term_to_exp ~adata:Assert.no_data kf env t_index in
let e_index = Cil.constFold false e_index in
let e_addr =
- Cil.new_exp ~loc (BinOp(PlusPI, e_at, e_index, vi_at.vtype))
+ Cil.new_exp ~loc (BinOp(PlusPI, e_at, e_index, Cil.typeOf e_at))
in
let lval_at_index = Mem e_addr, NoOffset in
lval_at_index, env
@@ -219,23 +229,80 @@ let index_from_sizes_and_shifts ~loc sizes_and_shifts =
in
sum
-let put_block_at_label env kf block label =
- let stmt = Label.get_stmt kf label in
- let env_ref = ref env in
- let o = object
- inherit Visitor.frama_c_inplace
- method !vstmt_aux stmt =
- assert (!env_ref == env);
- env_ref := Env.extend_stmt_in_place env stmt ~label block;
- Cil.ChangeTo stmt
- end
+(* [indexed_exp ~loc kf env e_at]
+ [e_at] represents an array generated by [pretranslate_to_exp_with_lscope]
+ and filled during the traversal of the [lscope].
+ The function returns an expression indexing the array [e_at] using the
+ variables created when traversing the [lscope] to retrieve the [\at] value
+ during the traversal. *)
+let indexed_exp ~loc kf env e_at =
+ let lscope_vars = Lscope.get_all (Env.Logic_scope.get env) in
+ let lscope_vars = List.rev lscope_vars in
+ let sizes_and_shifts =
+ sizes_and_shifts_from_quantifs ~loc kf lscope_vars []
in
- ignore (Visitor.visitFramacStmt o stmt);
- !env_ref
+ let t_index = index_from_sizes_and_shifts ~loc sizes_and_shifts in
+ let lval_at_index, env = lval_at_index ~loc kf env (e_at, t_index) in
+ let e = Smart_exp.lval ~loc lval_at_index in
+ e, env
+
+(* ************************************************************************** *)
+(* Translation *)
+(* ************************************************************************** *)
+
+(* Table storing the [varinfo] with the translation of a given [at_data]. *)
+let translations: varinfo Error.result At_data.Hashtbl.t =
+ At_data.Hashtbl.create 17
-let to_exp ~loc kf env pot label =
+(* [pretranslate_to_exp ~loc kf env pot] immediately translates the given
+ [pred_or_term] in the current environment and returns the translated
+ expression. *)
+let pretranslate_to_exp ~loc kf env pot =
+ Options.debug ~level:4 "pre-translating %a in local environment '%a'"
+ Pred_or_term.pretty pot
+ Typing.Function_params_ty.pretty (Env.Local_vars.get env);
+ let e, env, t_opt =
+ let adata = Assert.no_data in
+ match pot with
+ | PoT_term t ->
+ let e, _, env = !term_to_exp_ref ~adata ~inplace:true kf env t in
+ e, env, Some t
+ | PoT_pred p ->
+ let e, _, env = !predicate_to_exp_ref ~adata ~inplace:true kf env p in
+ e, env, None
+ in
+ let ty = Cil.typeOf e in
+ let var_vi, _, env =
+ Env.new_var
+ ~loc
+ ~scope:Function
+ ~name:"at"
+ env
+ kf
+ t_opt
+ ty
+ (fun var_vi var_e ->
+ let init_set =
+ if Gmp_types.Q.is_t ty then Rational.init_set else Gmp.init_set
+ in
+ [ init_set ~loc (Cil.var var_vi) var_e e ])
+ in
+ var_vi, env
+
+(* [pretranslate_to_exp_with_lscope ~loc ~lscope kf env pot] immediately
+ translates the given [pred_or_term] in the current environment for each value
+ of the given [lscope]. The result is stored in a dynamically allocated array
+ and the expression returned is a pointer to this array.
+ The function [indexed_exp] can later be used to retrieve the translation for
+ a specific value of the [lscope]. *)
+let pretranslate_to_exp_with_lscope ~loc ~lscope kf env pot =
+ Options.debug ~level:4
+ "pre-translating %a in local environment '%a' with lscope '%a'"
+ Pred_or_term.pretty pot
+ Typing.Function_params_ty.pretty (Env.Local_vars.get env)
+ Lscope.D.pretty lscope;
let term_to_exp = !term_to_exp_ref in
- let lscope_vars = Lscope.get_all (Env.Logic_scope.get env) in
+ let lscope_vars = Lscope.get_all lscope in
let lscope_vars = List.rev lscope_vars in
let sizes_and_shifts =
sizes_and_shifts_from_quantifs ~loc kf lscope_vars []
@@ -309,13 +376,15 @@ let to_exp ~loc kf env pot label =
let t_index = index_from_sizes_and_shifts ~loc sizes_and_shifts in
(* Innermost block *)
let mk_innermost_block env =
- let term_to_exp = !term_to_exp_ref ~adata:Assert.no_data in
- let named_predicate_to_exp = !predicate_to_exp_ref ~adata:Assert.no_data in
+ let term_to_exp = !term_to_exp_ref ~adata:Assert.no_data ~inplace:true in
+ let predicate_to_exp =
+ !predicate_to_exp_ref ~adata:Assert.no_data ~inplace:true
+ in
match pot with
| PoT_pred p ->
let env = Env.push env in
- let lval, env = lval_at_index ~loc kf env (e_at, vi_at, t_index) in
- let e, _, env = named_predicate_to_exp kf env p in
+ let lval, env = lval_at_index ~loc kf env (e_at, t_index) in
+ let e, _, env = predicate_to_exp kf env p in
let e = Cil.constFold false e in
let storing_stmt =
Smart_stmt.assigns ~loc ~result:lval e
@@ -330,7 +399,7 @@ let to_exp ~loc kf env pot label =
begin match Typing.get_number_ty ~lenv:(Env.Local_vars.get env) t with
| Typing.(C_integer _ | C_float _ | Nan) ->
let env = Env.push env in
- let lval, env = lval_at_index ~loc kf env (e_at, vi_at, t_index) in
+ let lval, env = lval_at_index ~loc kf env (e_at, t_index) in
let e, _, env = term_to_exp kf env t in
let e = Cil.constFold false e in
let storing_stmt =
@@ -349,7 +418,7 @@ let to_exp ~loc kf env pot label =
end
in
(* Storing loops *)
- let lscope_vars = Lscope.get_all (Env.Logic_scope.get env) in
+ let lscope_vars = Lscope.get_all lscope in
let lscope_vars = List.rev lscope_vars in
let env = Env.push env in
let storing_loops_stmts, env =
@@ -362,15 +431,125 @@ let to_exp ~loc kf env pot label =
~global_clear:false
Env.After
in
- (* Put at label *)
- let env = put_block_at_label env kf storing_loops_block label in
+ (* Put block in the current env *)
+ let env = Env.add_stmt env (Smart_stmt.block_stmt storing_loops_block) in
(* Returning *)
- let lval_at_index, env = lval_at_index ~loc kf env (e_at, vi_at, t_index) in
- let e = Smart_exp.lval ~loc lval_at_index in
- e, env
+ vi_at, env
+
+(* Set holding the C labels defined in the function currently being visited. *)
+let clabels_ref: Logic_label.Set.t ref = ref Logic_label.Set.empty
+
+(* [is_label_defined label] returns [true] if [label] is either a C label that
+ has been defined, a built-in label or a formal label, and returns [false] if
+ [label] is a C label that has not been defined. *)
+let is_label_defined label =
+ match label with
+ | StmtLabel _ when Logic_label.Set.mem label !clabels_ref ->
+ true
+ | StmtLabel _ ->
+ false
+ | BuiltinLabel _ | FormalLabel _ ->
+ true
+
+let for_stmt env kf stmt =
+ Options.debug ~level:4 "pre-translating ats for stmt %d at %a"
+ stmt.sid
+ Printer.pp_location (Stmt.loc stmt);
+
+ (* At the start of a function, reset the set of defined C labels. *)
+ if Kernel_function.is_first_stmt kf stmt then
+ clabels_ref := Logic_label.Set.empty;
+
+ (* If the current statement has labels, add the C label to the set. *)
+ begin match stmt.labels with
+ | [] -> ()
+ | _ :: _ ->
+ clabels_ref := Logic_label.Set.add (StmtLabel (ref stmt)) !clabels_ref
+ end;
+
+ (* Retrieve the set of [\at()] to translate for the given statement. *)
+ let at_for_stmt =
+ Error.retrieve_preprocessing
+ "labels pre-analysis"
+ Labels.at_for_stmt
+ stmt
+ Printer.pp_stmt
+ in
+
+ (* Translate the [\at()]. *)
+ let stmt_translations = Pred_or_term.Hashtbl.create 7 in
+ At_data.Set.fold
+ (fun ({ lscope; pot; error } as at_data) env ->
+ let vi_or_err, env =
+ let vi_or_err = Pred_or_term.Hashtbl.find_opt stmt_translations pot in
+ match error, vi_or_err with
+ | Some exn, (Some _ | None) ->
+ (* If there was an error during the pre-analysis, then store it
+ instead of the translation. *)
+ Result.Error exn, env
+ | None, Some vi_or_err ->
+ (* If the same [pred_or_term] has already been translated on this
+ statement, return its translation. *)
+ vi_or_err, env
+ | None, None ->
+ (* Otherwise translate it. *)
+ try
+ let loc = Stmt.loc stmt in
+ let vi, env =
+ if Lscope.is_used lscope pot then
+ pretranslate_to_exp_with_lscope ~loc ~lscope kf env pot
+ else
+ pretranslate_to_exp ~loc kf env pot
+ in
+ Result.Ok vi, env
+ with Error.(Typing_error _ | Not_yet _) as exn ->
+ Result.Error exn, env
+ in
+ Pred_or_term.Hashtbl.replace stmt_translations pot vi_or_err;
+ At_data.Hashtbl.replace translations at_data vi_or_err;
+ env)
+ at_for_stmt
+ env
+
+let to_exp ~loc ~adata kf env pot label =
+ let kinstr = Env.get_kinstr env in
+ let lscope = Env.Logic_scope.get env in
+ let at = At_data.create kf kinstr lscope pot label in
+ if is_label_defined label then
+ try
+ let vi_or_err = At_data.Hashtbl.find translations at in
+ match vi_or_err with
+ | Result.Ok vi ->
+ let e, env =
+ if Lscope.is_used lscope pot then
+ indexed_exp ~loc kf env (Smart_exp.lval ~loc (Cil.var vi))
+ else
+ Smart_exp.lval ~loc (Cil.var vi), env
+ in
+ let adata, env=
+ Assert.register_pred_or_term ~loc env pot e adata
+ in
+ e, adata, env
+ | Result.Error exn ->
+ Env.Context.save env;
+ raise exn
+ with Not_found -> begin
+ match pot with
+ | PoT_term t -> !term_to_exp_ref ~adata ~inplace:true kf env t
+ | PoT_pred p -> !predicate_to_exp_ref ~adata ~inplace:true kf env p
+ end
+ else
+ let potstr =
+ match pot with PoT_term _ -> "Term" | PoT_pred _ -> "Predicate"
+ in
+ Options.abort ~source:(fst loc)
+ "%s '%a' was used before being translated.@ \
+ This usually happens when using a label defined after the place@ \
+ where the %s should be translated"
+ potstr
+ Pred_or_term.pretty pot
+ potstr
-(*
-Local Variables:
-compile-command: "make -C ../../../../.."
-End:
-*)
+let reset () =
+ At_data.Hashtbl.clear translations;
+ clabels_ref := Logic_label.Set.empty
diff --git a/src/plugins/e-acsl/src/code_generator/at_with_lscope.mli b/src/plugins/e-acsl/src/code_generator/translate_ats.mli
similarity index 74%
rename from src/plugins/e-acsl/src/code_generator/at_with_lscope.mli
rename to src/plugins/e-acsl/src/code_generator/translate_ats.mli
index 989404e5a2b5a37d99db7b89b8c3a16f4d9a172d..a975de1732c06192ec9e98e953016d240525d133 100644
--- a/src/plugins/e-acsl/src/code_generator/at_with_lscope.mli
+++ b/src/plugins/e-acsl/src/code_generator/translate_ats.mli
@@ -20,61 +20,79 @@
(* *)
(**************************************************************************)
+(** Generate C implementations of E-ACSL [\at()] terms and predicates. *)
+
open Cil_types
-open Cil_datatype
open Analyses_types
-(* Convert \at on terms or predicates in which we can find purely
- logic variable. *)
-
(**************************************************************************)
(*************************** Translation **********************************)
(**************************************************************************)
+val for_stmt: Env.t -> kernel_function -> stmt -> Env.t
+(** Translate all [\at()] predicates and terms for the given statement in the
+ current environment. *)
+
val to_exp:
- loc:Location.t -> kernel_function -> Env.t ->
- pred_or_term -> logic_label -> exp * Env.t
+ loc:location ->
+ adata:Assert.t ->
+ kernel_function ->
+ Env.t ->
+ pred_or_term ->
+ logic_label ->
+ exp * Assert.t * Env.t
+(** @return the C expression corresponding to the given [pred_or_term].
+
+ The expression is either translated in-place or retrieved from a
+ pre-translation phase. *)
+
+val reset: unit -> unit
+(** Clear the stored translations. *)
(*****************************************************************************)
(**************************** Handling memory ********************************)
(*****************************************************************************)
(* The different possible evaluations of the [\at] under study are
- stored in a memory location that needs to be alloted then freed.
+ stored in a memory location that needs to be allocated then freed.
This part is designed for that purpose. *)
module Malloc: sig
val find_all: kernel_function -> stmt list
- (* Return the list of [malloc] stmts that need to be inserted into [kf]. *)
+ (** @return the list of [malloc] stmts that need to be inserted into [kf]. *)
val remove_all: kernel_function -> unit
- (* Remove all [malloc] stmts for [kf] from the internal table. *)
+ (** Remove all [malloc] stmts for [kf] from the internal table. *)
end
module Free: sig
val find_all: kernel_function -> stmt list
- (* Return the list of [free] stmts that need to be inserted into [kf]. *)
+ (** @return the list of [free] stmts that need to be inserted into [kf]. *)
val remove_all: kernel_function -> unit
- (* Remove all [free] stmts for [kf] from the internal table. *)
+ (** Remove all [free] stmts for [kf] from the internal table. *)
end
(**************************************************************************)
(********************** Forward references ********************************)
(**************************************************************************)
-val predicate_to_exp_ref:
+val term_to_exp_ref:
(adata:Assert.t ->
+ ?inplace:bool ->
kernel_function ->
Env.t ->
- predicate ->
+ term ->
exp * Assert.t * Env.t) ref
-val term_to_exp_ref:
+val predicate_to_exp_ref:
(adata:Assert.t ->
+ ?inplace:bool ->
+ ?name:string ->
kernel_function ->
+ ?rte:bool ->
Env.t ->
- term ->
+ predicate ->
exp * Assert.t * Env.t) ref
(*
diff --git a/src/plugins/e-acsl/src/code_generator/translate_predicates.ml b/src/plugins/e-acsl/src/code_generator/translate_predicates.ml
index 333bd7115dd1da25c44cad16fe731c2901c9d226..bbfd3a767701130246363136fa348942176a641b 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_predicates.ml
+++ b/src/plugins/e-acsl/src/code_generator/translate_predicates.ml
@@ -66,8 +66,11 @@ let relation_to_binop = function
(* Convert an ACSL predicate into a corresponding C expression (if any) in the
given environment. Also extend this environment which includes the generating
- constructs. *)
-let rec predicate_content_to_exp ~adata ?name kf env p =
+ constructs.
+ If [inplace] is true, then the root predicate is immediately translated
+ regardless of its label. Otherwise [Translate_ats] is used to retrieve the
+ translation. *)
+let rec predicate_content_to_exp ~adata ?(inplace=false) ?name kf env p =
let loc = p.pred_loc in
let lenv = Env.Local_vars.get env in
Cil.CurrentLoc.set loc;
@@ -202,25 +205,11 @@ let rec predicate_content_to_exp ~adata ?name kf env p =
let e, env = Quantif.quantif_to_exp kf env p in
let adata, env = Assert.register_pred ~loc env p e adata in
e, adata, env
- | Pat(p, BuiltinLabel Here) ->
- to_exp ~adata kf env p
| Pat(p', label) ->
- let lscope = Env.Logic_scope.get env in
- let pot = PoT_pred p' in
- if Lscope.is_used lscope pot then
- let e, env = At_with_lscope.to_exp ~loc kf env pot label in
- let adata, env = Assert.register_pred ~loc env p e adata in
- e, adata, env
- else begin
- (* convert [t'] to [e] in a separated local env *)
- let e, adata, env = to_exp ~adata kf (Env.push env) p' in
- let e, env, sty =
- Translate_utils.at_to_exp_no_lscope kf env None label e
- in
- assert (sty = Typed_number.C_number);
- let adata, env = Assert.register_pred ~loc env p e adata in
- e, adata, env
- end
+ if inplace then
+ to_exp ~adata kf env p'
+ else
+ Translate_ats.to_exp ~loc ~adata kf env (PoT_pred p) label
| Pvalid_read(BuiltinLabel Here, t) as pc
| (Pvalid(BuiltinLabel Here, t) as pc) ->
let call_valid ~adata t p =
@@ -309,7 +298,19 @@ let rec predicate_content_to_exp ~adata ?name kf env p =
| Pfreeable _ -> Env.not_yet env "labeled \\freeable"
| Pfresh _ -> Env.not_yet env "\\fresh"
-and to_exp ~adata ?name kf ?rte env p =
+(** [to_exp ~adata ?inplace ?name kf ?rte env p] converts an ACSL predicate into
+ a corresponding C expression.
+ - [adata]: assertion context.
+ - [inplace]: if the root predicate has a label, indicates if it should be
+ immediately translated or if [Translate_ats] should be used to retrieve
+ the translation.
+ - [name]: name to use for generated variables.
+ - [kf]: the enclosing function.
+ - [rte]: if true, generate and translate RTE before translating the
+ predicate.
+ - [env]: the current environment.
+ - [p]: the predicate to translate. *)
+and to_exp ~adata ?inplace ?name kf ?rte env p =
let p = Logic_normalizer.get_pred p in
let rte = match rte with None -> Env.generate_rte env | Some b -> b in
Extlib.flatten
@@ -317,7 +318,7 @@ and to_exp ~adata ?name kf ?rte env p =
~rte:false
~f:(fun env ->
let e, adata, env =
- predicate_content_to_exp ~adata ?name kf env p
+ predicate_content_to_exp ?inplace ~adata ?name kf env p
in
let env = if rte then !translate_rte_exp_ref kf env e else env in
let cast =
@@ -385,12 +386,15 @@ let predicate_to_exp_without_rte ~adata kf env p =
(* forget optional argument ?rte and ?name*)
to_exp ~adata kf env p
+let predicate_to_exp_without_inplace ~adata ?name kf ?rte env p =
+ to_exp ~adata ?name kf ?rte env p
+
let () =
- Translate_utils.predicate_to_exp_ref := to_exp;
+ Translate_utils.predicate_to_exp_ref := predicate_to_exp_without_inplace;
+ Translate_ats.predicate_to_exp_ref := to_exp;
Loops.translate_predicate_ref := do_it;
Loops.predicate_to_exp_ref := predicate_to_exp_without_rte;
Quantif.predicate_to_exp_ref := predicate_to_exp_without_rte;
- At_with_lscope.predicate_to_exp_ref := predicate_to_exp_without_rte;
Memory_translate.predicate_to_exp_ref := predicate_to_exp_without_rte;
Logic_functions.predicate_to_exp_ref := predicate_to_exp_without_rte
diff --git a/src/plugins/e-acsl/src/code_generator/translate_rtes.ml b/src/plugins/e-acsl/src/code_generator/translate_rtes.ml
index cb05e6165e836d1d4af09838076e50a3e24df24c..8e76febe0cc5a5403e3088fff370b91a1504f631 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_rtes.ml
+++ b/src/plugins/e-acsl/src/code_generator/translate_rtes.ml
@@ -27,7 +27,7 @@ let dkey = Options.Dkey.translation
let rte_annots pp elt kf env l =
let old_kind = Env.annotation_kind env in
- let env = Env.set_annotation_kind env Smart_stmt.RTE in
+ let env = Env.set_annotation_kind env RTE in
let env =
List.fold_left
(fun env a -> match a.annot_content with
diff --git a/src/plugins/e-acsl/src/code_generator/translate_terms.ml b/src/plugins/e-acsl/src/code_generator/translate_terms.ml
index a1e55e5d0eb17749669e4a9642917b3f3e50c198..b9ace500b655ca11fbdac5f02eb7ba040be7d369 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_terms.ml
+++ b/src/plugins/e-acsl/src/code_generator/translate_terms.ml
@@ -261,7 +261,7 @@ and extended_quantifier_to_exp ~adata ~loc kf env t t_min t_max lambda name =
| _ ->
assert false
-and context_insensitive_term_to_exp ~adata kf env t =
+and context_insensitive_term_to_exp ~adata ?(inplace=false) kf env t =
let loc = t.term_loc in
let lenv = Env.Local_vars.get env in
match t.term_node with
@@ -525,7 +525,7 @@ and context_insensitive_term_to_exp ~adata kf env t =
Assert.runtime_check
~adata:adata2
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
coerce_guard
@@ -605,7 +605,7 @@ and context_insensitive_term_to_exp ~adata kf env t =
Assert.runtime_check
~adata:adata1
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
e1_guard
@@ -799,23 +799,14 @@ and context_insensitive_term_to_exp ~adata kf env t =
env)
in
e, adata, env, Typed_number.C_number, ""
- | Tat(t, BuiltinLabel Here) ->
- let e, adata, env = to_exp ~adata kf env t in
- e, adata, env, Typed_number.C_number, ""
| Tat(t', label) ->
- let lscope = Env.Logic_scope.get env in
- let pot = PoT_term t' in
- if Lscope.is_used lscope pot then
- let e, env = At_with_lscope.to_exp ~loc kf env pot label in
- let adata, env = Assert.register_term ~loc env t e adata in
- e, adata, env, Typed_number.C_number, ""
- else
- let e, _, env = to_exp ~adata:Assert.no_data kf (Env.push env) t' in
- let e, env, sty =
- Translate_utils.at_to_exp_no_lscope kf env (Some t) label e
- in
- let adata, env = Assert.register_term ~loc env t e adata in
- e, adata, env, sty, ""
+ let e, adata, env =
+ if inplace then
+ to_exp ~adata kf env t'
+ else
+ Translate_ats.to_exp ~loc ~adata kf env (PoT_term t) label
+ in
+ e, adata, env, Typed_number.C_number, ""
| Tbase_addr(BuiltinLabel Here, t') ->
let name = "base_addr" in
let e, _, env =
@@ -876,7 +867,7 @@ and context_insensitive_term_to_exp ~adata kf env t =
(* Convert an ACSL term into a corresponding C expression (if any) in the given
environment. Also extend this environment in order to include the generating
constructs. *)
-and to_exp ~adata kf env t =
+and to_exp ~adata ?inplace kf env t =
let generate_rte = Env.generate_rte env in
Options.feedback ~dkey ~level:4 "translating term %a (rte? %b)in local \
environment '%a'"
@@ -888,7 +879,7 @@ and to_exp ~adata kf env t =
~rte:false
~f:(fun env ->
let e, adata, env, sty, name =
- context_insensitive_term_to_exp ~adata kf env t
+ context_insensitive_term_to_exp ?inplace ~adata kf env t
in
let env =
if generate_rte then !translate_rte_exp_ref kf env e else env
@@ -909,12 +900,14 @@ and to_exp ~adata kf env t =
)
env)
+let term_to_exp_without_inplace ~adata kf env t = to_exp ~adata kf env t
+
let () =
- Translate_utils.term_to_exp_ref := to_exp;
- Loops.term_to_exp_ref := to_exp;
- At_with_lscope.term_to_exp_ref := to_exp;
- Memory_translate.term_to_exp_ref := to_exp;
- Logic_functions.term_to_exp_ref := to_exp
+ Translate_utils.term_to_exp_ref := term_to_exp_without_inplace;
+ Translate_ats.term_to_exp_ref := to_exp;
+ Loops.term_to_exp_ref := term_to_exp_without_inplace;
+ Memory_translate.term_to_exp_ref := term_to_exp_without_inplace;
+ Logic_functions.term_to_exp_ref := term_to_exp_without_inplace
exception No_simple_translation of term
diff --git a/src/plugins/e-acsl/src/code_generator/translate_terms.mli b/src/plugins/e-acsl/src/code_generator/translate_terms.mli
index 0bb31e3c4b26fbb4f51e155fbc3ef7d8d2bd7898..18545ea6da217b5f9db1332cb6cdd3eb830d419d 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_terms.mli
+++ b/src/plugins/e-acsl/src/code_generator/translate_terms.mli
@@ -26,11 +26,20 @@ open Cil_types
val to_exp:
adata:Assert.t ->
+ ?inplace:bool ->
kernel_function ->
Env.t ->
term ->
exp * Assert.t * Env.t
-(** Convert an ACSL term into a corresponding C expression. *)
+(** [to_exp ~adata ?inplace kf env t] converts an ACSL term into a
+ corresponding C expression.
+ - [adata]: assertion context.
+ - [inplace]: if the root term has a label, indicates if it should be
+ immediately translated or if [Translate_ats] should be used to retrieve
+ the translation.
+ - [kf]: The enclosing function.
+ - [env]: The current environment.
+ - [t]: The term to translate. *)
exception No_simple_translation of term
(** Exceptin raised if [untyped_to_exp] would generate new statements in
diff --git a/src/plugins/e-acsl/src/code_generator/translate_utils.ml b/src/plugins/e-acsl/src/code_generator/translate_utils.ml
index 89fe539c7f5edc1fc697376d49c057f9becc6d76..d1333eb9695747e96aa2e661ea95e934f57bd323 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_utils.ml
+++ b/src/plugins/e-acsl/src/code_generator/translate_utils.ml
@@ -22,9 +22,7 @@
(** Utility functions for generating C implementations. *)
-module E_acsl_label = Label
open Cil_types
-open Cil_datatype
module Error = Translation_error
(**************************************************************************)
@@ -75,6 +73,10 @@ let must_translate_opt = function
| None -> false
| Some ppt -> must_translate ppt
+let () =
+ E_acsl_visitor.must_translate_ppt_ref := must_translate;
+ E_acsl_visitor.must_translate_ppt_opt_ref := must_translate_opt
+
let gmp_to_sizet ~adata ~loc ~name ?(check_lower_bound=true) ?pp kf env t =
let lenv = Env.Local_vars.get env in
let pp = match pp with Some size_pp -> size_pp | None -> t in
@@ -100,7 +102,7 @@ let gmp_to_sizet ~adata ~loc ~name ?(check_lower_bound=true) ?pp kf env t =
Assert.runtime_check
~adata:adata_lower_guard
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
lower_guard
@@ -130,7 +132,7 @@ let gmp_to_sizet ~adata ~loc ~name ?(check_lower_bound=true) ?pp kf env t =
Assert.runtime_check
~adata:adata_upper_guard
~pred_kind:Assert
- Smart_stmt.RTE
+ RTE
kf
env
upper_guard
@@ -298,51 +300,6 @@ let env_of_li ~adata ~loc kf env li =
| Larrow _ ->
Env.not_yet env "lambda-abstraction"
-let at_to_exp_no_lscope kf env t_opt label e =
- let stmt = E_acsl_label.get_stmt kf label in
- (* generate a new variable denoting [\at(t',label)].
- That is this variable which is the resulting expression.
- ACSL typing rule ensures that the type of this variable is the same as
- the one of [e]. *)
- let loc = Stmt.loc stmt in
- let res_v, res, new_env =
- Env.new_var
- ~loc
- ~name:"at"
- ~scope:Varname.Function
- env
- kf
- t_opt
- (Cil.typeOf e)
- (fun _ _ -> [])
- in
- let env_ref = ref new_env in
- (* visitor modifying in place the labeled statement in order to store [e]
- in the resulting variable at this location (which is the only correct
- one). *)
- let o = object
- inherit Visitor.frama_c_inplace
- method !vstmt_aux stmt =
- (* either a standard C affectation or a call to an initializer according
- to the type of [e] *)
- let ty = Cil.typeOf e in
- let init_set =
- if Gmp_types.Q.is_t ty then Rational.init_set else Gmp.init_set
- in
- let new_stmt = init_set ~loc (Cil.var res_v) res e in
- assert (!env_ref == new_env);
- (* generate the new block of code for the labeled statement and the
- corresponding environment *)
- let block, new_env =
- Env.pop_and_get new_env new_stmt ~global_clear:false Env.Middle
- in
- env_ref := Env.extend_stmt_in_place new_env stmt ~label block;
- Cil.ChangeTo stmt
- end
- in
- ignore (Visitor.visitFramacStmt o stmt);
- res, !env_ref, Typed_number.C_number
-
(*
Local Variables:
compile-command: "make -C ../../../../.."
diff --git a/src/plugins/e-acsl/src/code_generator/translate_utils.mli b/src/plugins/e-acsl/src/code_generator/translate_utils.mli
index a7a7489ab8ea085c71eab0fafdc2164e4e2631c8..66a1ee99831eef27e063e2f1f8ecdf1c757b312e 100644
--- a/src/plugins/e-acsl/src/code_generator/translate_utils.mli
+++ b/src/plugins/e-acsl/src/code_generator/translate_utils.mli
@@ -96,17 +96,6 @@ val env_of_li:
(** [env_of_li ~adata ~loc kf env li] translates the logic info [li] in the
given environment with the given assertion context. *)
-val at_to_exp_no_lscope:
- kernel_function ->
- Env.t ->
- term option ->
- logic_label ->
- exp ->
- exp * Env.t * Typed_number.strnum
-(** [at_to_exp_no_lscope kf env t_opt llabel e] generates an expression
- representing the expression [e] at the label [llabel].
- [t_opt] is the term representing [\at(e, llabel)]. *)
-
(**************************************************************************)
(********************** Forward references ********************************)
(**************************************************************************)
diff --git a/src/plugins/e-acsl/src/options.ml b/src/plugins/e-acsl/src/options.ml
index 7752a5ccf2c1812b52f3e6223842214650bec556..6936e54b2626408f490122f9acd14f9a13966222 100644
--- a/src/plugins/e-acsl/src/options.ml
+++ b/src/plugins/e-acsl/src/options.ml
@@ -182,10 +182,12 @@ let must_visit () = Run.get ()
module Dkey = struct
let prepare = register_category "preparation"
+ let logic_normalizer = register_category "analysis:logic_normalizer"
let bound_variables = register_category "analysis:bound_variables"
let interval = register_category "analysis:interval_inference"
let mtracking = register_category "analysis:memory_tracking"
let typing = register_category "analysis:typing"
+ let labels = register_category "analysis:labels"
let translation = register_category "translation"
end
diff --git a/src/plugins/e-acsl/src/options.mli b/src/plugins/e-acsl/src/options.mli
index 3fe0a48115f17cfdd0dcd6907429f8a54da6b37f..393c91e5a046dcc7ba7c75b3d31367dea8e6af07 100644
--- a/src/plugins/e-acsl/src/options.mli
+++ b/src/plugins/e-acsl/src/options.mli
@@ -44,10 +44,12 @@ val must_visit: unit -> bool
module Dkey: sig
val prepare: category
+ val logic_normalizer: category
val bound_variables: category
val interval: category
val mtracking: category
val typing: category
+ val labels: category
val translation: category
end
diff --git a/src/plugins/e-acsl/tests/arith/at.i b/src/plugins/e-acsl/tests/arith/at.i
index 700be22bf0e01fa9fff701c7cc3584ab165370b2..8146990ad6252c4856bba5bf18f9c9d762de31f1 100644
--- a/src/plugins/e-acsl/tests/arith/at.i
+++ b/src/plugins/e-acsl/tests/arith/at.i
@@ -4,7 +4,11 @@
int A = 0;
-/*@ ensures \at(A,Post) == 3; */
+/*@
+ requires \at(A,Here) == 0;
+ requires \at(A,Pre) == 0;
+ ensures \at(A,Pre) == \at(A,Old) == 0;
+ ensures \at(A,Post) == 4; */
void f(void) {
A = 1;
F:
@@ -14,6 +18,12 @@ F:
/*@ assert \at(A,Here) == 2; */
/*@ assert \at(\at(A,Pre),F) == 0; */
A = 3;
+ /*@ requires \at(A,Here) == 3;
+ ensures \at(A,Pre) == 0;
+ ensures \at(A,Old) == 3;
+ ensures \at(A,Post) == 4;
+ */
+ A = 4;
}
void g(int *p, int *q) {
@@ -30,8 +40,8 @@ L2:
L3:
/*@ assert (\at(*(p+\at(*q,L1)),Here) == 2); */
- // /*@ assert (\at(*(p+\at(*q,L1)),L3) == 2); */ // doesn't work yet
- // /*@ assert (\at(*(p+\at(*q,L2)),L1)) == 1; */
+ /*@ assert (\at(*(p+\at(*q,L1)),L3) == 2); */
+ /* @ assert (\at(*(p+\at(*q,L2)),L1)) == 1; */ // should be an error
return;
}
@@ -40,6 +50,19 @@ int h(int x) {
return x;
}
+void i() {
+ // Check that \old() used in two different statements in the same function is
+ // correctly translated into two different variables
+
+ int a = 0;
+
+ /*@ ensures \old(a) + 1 == \at(a, Post); */
+ ++a;
+
+ /*@ ensures \old(a) + 1 == \at(a, Post); */
+ ++a;
+}
+
int main(void) {
int x;
@@ -58,5 +81,7 @@ L: /*@ assert x == 0; */
int t[2];
g(t, &x);
+ i();
+
return 0;
}
diff --git a/src/plugins/e-acsl/tests/arith/at_on-purely-logic-variables.c b/src/plugins/e-acsl/tests/arith/at_on-purely-logic-variables.c
index 1f29ad1a608dc817f537cfec6eb65e84a07d3273..77c01346a483be7de1dff158e35e0e8aedf7a1e7 100644
--- a/src/plugins/e-acsl/tests/arith/at_on-purely-logic-variables.c
+++ b/src/plugins/e-acsl/tests/arith/at_on-purely-logic-variables.c
@@ -43,7 +43,7 @@ G:;
/*@ assert
\exists integer u; 9 <= u < 21 &&
\forall integer v; -5 < v <= (u < 15 ? u + 6 : 3) ==>
- \at(n + u + v > 0, K); */
+ \at(n + u + v, K) > 0; */
;
// Function calls:
diff --git a/src/plugins/e-acsl/tests/arith/oracle/at.res.oracle b/src/plugins/e-acsl/tests/arith/oracle/at.res.oracle
index f3865d1f2f042441bd3124fed3575f1b75e91b29..422529ed4132579b993634938b304577bfc29d2a 100644
--- a/src/plugins/e-acsl/tests/arith/oracle/at.res.oracle
+++ b/src/plugins/e-acsl/tests/arith/oracle/at.res.oracle
@@ -1,27 +1,43 @@
[e-acsl] beginning translation.
[e-acsl] translation done in project "e-acsl".
-[eva:alarm] at.i:38: Warning:
+[eva:alarm] at.i:48: Warning:
function __e_acsl_assert_register_int: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] at.i:13: Warning: assertion got status unknown.
-[eva:alarm] at.i:15: Warning: assertion got status unknown.
-[eva:alarm] at.i:54: Warning: assertion got status unknown.
-[eva:alarm] at.i:55: Warning: assertion got status unknown.
-[eva:alarm] at.i:56: Warning: assertion got status unknown.
-[eva:alarm] at.i:31: Warning:
+[eva:alarm] at.i:17: Warning: assertion got status unknown.
+[eva:alarm] at.i:19: Warning: assertion got status unknown.
+[eva:alarm] at.i:10: Warning:
+ function __e_acsl_assert_register_int: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
+[eva:alarm] at.i:77: Warning: assertion got status unknown.
+[eva:alarm] at.i:78: Warning: assertion got status unknown.
+[eva:alarm] at.i:79: Warning: assertion got status unknown.
+[eva:alarm] at.i:39: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] at.i:29: Warning:
+[eva:alarm] at.i:39: Warning:
+ function __e_acsl_assert_register_int: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
+[eva:alarm] at.i:39: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] :0: Warning:
+[eva:alarm] at.i:39: Warning: assertion got status unknown.
+[eva:alarm] at.i:43: Warning:
function __e_acsl_assert_register_int: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] at.i:29: Warning:
+[eva:alarm] at.i:43: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] at.i:29: Warning: assertion got status unknown.
-[eva:alarm] at.i:31: Warning:
+[eva:alarm] at.i:41: Warning:
+ function __e_acsl_assert_register_int: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
+[eva:alarm] at.i:41: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] at.i:31: Warning: assertion got status unknown.
+[eva:alarm] at.i:41: Warning: assertion got status unknown.
+[eva:alarm] at.i:43: Warning: assertion got status unknown.
+[eva:alarm] at.i:59: Warning:
+ function __e_acsl_assert_register_int: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
+[eva:alarm] at.i:62: Warning:
+ function __e_acsl_assert_register_int: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
diff --git a/src/plugins/e-acsl/tests/arith/oracle/at_on-purely-logic-variables.res.oracle b/src/plugins/e-acsl/tests/arith/oracle/at_on-purely-logic-variables.res.oracle
index 2079be04d3c5a8254e004dbe5575667d74c81959..483ee2e7ba01554a0dd943dfc1aaa0df551c7306 100644
--- a/src/plugins/e-acsl/tests/arith/oracle/at_on-purely-logic-variables.res.oracle
+++ b/src/plugins/e-acsl/tests/arith/oracle/at_on-purely-logic-variables.res.oracle
@@ -4,7 +4,7 @@
`\at on purely logic variables that needs to allocate too much memory (bigger than int_max bytes)'
is not yet supported.
Ignoring annotation.
-[e-acsl] at_on-purely-logic-variables.c:69: Warning:
+[e-acsl] at_on-purely-logic-variables.c:70: Warning:
E-ACSL construct `\at with logic variable linked to C variable'
is not yet supported.
Ignoring annotation.
@@ -57,8 +57,8 @@
accessing uninitialized left-value.
assert
\initialized(__gen_e_acsl_at_6 +
- (int)((int)((int)(__gen_e_acsl_u_3 - 9) * 32) +
- (int)(__gen_e_acsl_v_3 - -4)));
+ (int)((int)((int)(__gen_e_acsl_u_7 - 9) * 32) +
+ (int)(__gen_e_acsl_v_5 - -4)));
[eva:alarm] at_on-purely-logic-variables.c:44: Warning:
assertion got status unknown.
[eva:alarm] at_on-purely-logic-variables.c:8: Warning:
diff --git a/src/plugins/e-acsl/tests/arith/oracle/gen_at.c b/src/plugins/e-acsl/tests/arith/oracle/gen_at.c
index 888d2c9fac9ba632c1a45380d70b369d72548fbe..fc16d53dd1fc412895d4b1ea4afbe73552f7f2b7 100644
--- a/src/plugins/e-acsl/tests/arith/oracle/gen_at.c
+++ b/src/plugins/e-acsl/tests/arith/oracle/gen_at.c
@@ -9,7 +9,11 @@
extern __attribute__((__FC_BUILTIN__)) int __e_acsl_sound_verdict;
int A = 0;
-/*@ ensures \at(A,Post) == 3; */
+/*@ requires \at(A,Here) == 0;
+ requires \at(A,Pre) == 0;
+ ensures \at(A,Pre) == \old(A) == 0;
+ ensures \at(A,Post) == 4;
+ */
void __gen_e_acsl_f(void);
void f(void)
@@ -18,14 +22,11 @@ void f(void)
int __gen_e_acsl_at_3;
int __gen_e_acsl_at_2;
int __gen_e_acsl_at;
- __gen_e_acsl_at_3 = A;
__gen_e_acsl_at = A;
A = 1;
- F: {
- __gen_e_acsl_at_4 = __gen_e_acsl_at_3;
- __gen_e_acsl_at_2 = A;
- A = 2;
- }
+ F: __gen_e_acsl_at_2 = A;
+ __gen_e_acsl_at_3 = __gen_e_acsl_at;
+ A = 2;
{
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"\\at(A,Pre)",0,
@@ -35,7 +36,7 @@ void f(void)
__gen_e_acsl_assert_data.pred_txt = "\\at(A,Pre) == 0";
__gen_e_acsl_assert_data.file = "at.i";
__gen_e_acsl_assert_data.fct = "f";
- __gen_e_acsl_assert_data.line = 12;
+ __gen_e_acsl_assert_data.line = 16;
__e_acsl_assert(__gen_e_acsl_at == 0,& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
@@ -50,7 +51,7 @@ void f(void)
__gen_e_acsl_assert_data_2.pred_txt = "\\at(A,F) == 1";
__gen_e_acsl_assert_data_2.file = "at.i";
__gen_e_acsl_assert_data_2.fct = "f";
- __gen_e_acsl_assert_data_2.line = 13;
+ __gen_e_acsl_assert_data_2.line = 17;
__e_acsl_assert(__gen_e_acsl_at_2 == 1,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
@@ -64,7 +65,7 @@ void f(void)
__gen_e_acsl_assert_data_3.pred_txt = "\\at(A,Here) == 2";
__gen_e_acsl_assert_data_3.file = "at.i";
__gen_e_acsl_assert_data_3.fct = "f";
- __gen_e_acsl_assert_data_3.line = 14;
+ __gen_e_acsl_assert_data_3.line = 18;
__e_acsl_assert(A == 2,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
}
@@ -73,18 +74,75 @@ void f(void)
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
- "\\at(\\at(A,Pre),F)",0,__gen_e_acsl_at_4);
+ "\\at(\\at(A,Pre),F)",0,__gen_e_acsl_at_3);
__gen_e_acsl_assert_data_4.blocking = 1;
__gen_e_acsl_assert_data_4.kind = "Assertion";
__gen_e_acsl_assert_data_4.pred_txt = "\\at(\\at(A,Pre),F) == 0";
__gen_e_acsl_assert_data_4.file = "at.i";
__gen_e_acsl_assert_data_4.fct = "f";
- __gen_e_acsl_assert_data_4.line = 15;
- __e_acsl_assert(__gen_e_acsl_at_4 == 0,& __gen_e_acsl_assert_data_4);
+ __gen_e_acsl_assert_data_4.line = 19;
+ __e_acsl_assert(__gen_e_acsl_at_3 == 0,& __gen_e_acsl_assert_data_4);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
}
/*@ assert \at(\at(A,Pre),F) == 0; */ ;
A = 3;
+ {
+ {
+ __gen_e_acsl_at_4 = A;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"A",0,A);
+ __gen_e_acsl_assert_data_5.blocking = 1;
+ __gen_e_acsl_assert_data_5.kind = "Precondition";
+ __gen_e_acsl_assert_data_5.pred_txt = "\\at(A,Here) == 3";
+ __gen_e_acsl_assert_data_5.file = "at.i";
+ __gen_e_acsl_assert_data_5.fct = "f";
+ __gen_e_acsl_assert_data_5.line = 21;
+ __e_acsl_assert(A == 3,& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
+ }
+ /*@ requires \at(A,Here) == 3;
+ ensures \at(A,Pre) == 0;
+ ensures \old(A) == 3;
+ ensures \at(A,Post) == 4;
+ */
+ A = 4;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"\\at(A,Pre)",
+ 0,__gen_e_acsl_at);
+ __gen_e_acsl_assert_data_6.blocking = 1;
+ __gen_e_acsl_assert_data_6.kind = "Postcondition";
+ __gen_e_acsl_assert_data_6.pred_txt = "\\at(A,Pre) == 0";
+ __gen_e_acsl_assert_data_6.file = "at.i";
+ __gen_e_acsl_assert_data_6.fct = "f";
+ __gen_e_acsl_assert_data_6.line = 22;
+ __e_acsl_assert(__gen_e_acsl_at == 0,& __gen_e_acsl_assert_data_6);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"\\old(A)",0,
+ __gen_e_acsl_at_4);
+ __gen_e_acsl_assert_data_7.blocking = 1;
+ __gen_e_acsl_assert_data_7.kind = "Postcondition";
+ __gen_e_acsl_assert_data_7.pred_txt = "\\old(A) == 3";
+ __gen_e_acsl_assert_data_7.file = "at.i";
+ __gen_e_acsl_assert_data_7.fct = "f";
+ __gen_e_acsl_assert_data_7.line = 23;
+ __e_acsl_assert(__gen_e_acsl_at_4 == 3,& __gen_e_acsl_assert_data_7);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,"A",0,A);
+ __gen_e_acsl_assert_data_8.blocking = 1;
+ __gen_e_acsl_assert_data_8.kind = "Postcondition";
+ __gen_e_acsl_assert_data_8.pred_txt = "\\at(A,Post) == 4";
+ __gen_e_acsl_assert_data_8.file = "at.i";
+ __gen_e_acsl_assert_data_8.fct = "f";
+ __gen_e_acsl_assert_data_8.line = 24;
+ __e_acsl_assert(A == 4,& __gen_e_acsl_assert_data_8);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
+ }
return;
}
@@ -103,137 +161,145 @@ void g(int *p, int *q)
*q = 0;
L1:
{
- {
- int __gen_e_acsl_valid_read_3;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
- {.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,"q",
- (void *)q);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
- "sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)q,sizeof(int),
- (void *)q,
- (void *)(& q));
- __gen_e_acsl_assert_data_5.blocking = 1;
- __gen_e_acsl_assert_data_5.kind = "RTE";
- __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(q)";
- __gen_e_acsl_assert_data_5.file = "at.i";
- __gen_e_acsl_assert_data_5.fct = "g";
- __gen_e_acsl_assert_data_5.line = 31;
- __gen_e_acsl_assert_data_5.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_3,& __gen_e_acsl_assert_data_5);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
- __gen_e_acsl_at_3 = *q;
- }
- {
- int __gen_e_acsl_valid_read;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
- {.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"q",
- (void *)q);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
- "sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)q,sizeof(int),
- (void *)q,(void *)(& q));
- __gen_e_acsl_assert_data_2.blocking = 1;
- __gen_e_acsl_assert_data_2.kind = "RTE";
- __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(q)";
- __gen_e_acsl_assert_data_2.file = "at.i";
- __gen_e_acsl_assert_data_2.fct = "g";
- __gen_e_acsl_assert_data_2.line = 29;
- __gen_e_acsl_assert_data_2.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_2);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
- __gen_e_acsl_at = *q;
- }
+ int __gen_e_acsl_valid_read;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"q",(void *)q);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,"sizeof(int)",
+ 0,sizeof(int));
+ __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)q,sizeof(int),
+ (void *)q,(void *)(& q));
+ __gen_e_acsl_assert_data.blocking = 1;
+ __gen_e_acsl_assert_data.kind = "RTE";
+ __gen_e_acsl_assert_data.pred_txt = "\\valid_read(q)";
+ __gen_e_acsl_assert_data.file = "at.i";
+ __gen_e_acsl_assert_data.fct = "g";
+ __gen_e_acsl_assert_data.line = 39;
+ __gen_e_acsl_assert_data.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
+ __gen_e_acsl_at = *q;
__e_acsl_initialize((void *)p,sizeof(int));
- *p = 2;
}
+ *p = 2;
__e_acsl_initialize((void *)(p + 1),sizeof(int));
*(p + 1) = 3;
__e_acsl_initialize((void *)q,sizeof(int));
*q = 1;
L2:
{
- {
- int __gen_e_acsl_valid_read_2;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
- {.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"p",
- (void *)p);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
- "__gen_e_acsl_at",0,__gen_e_acsl_at);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
- "sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(p + __gen_e_acsl_at),
- sizeof(int),(void *)p,
- (void *)(& p));
- __gen_e_acsl_assert_data_3.blocking = 1;
- __gen_e_acsl_assert_data_3.kind = "RTE";
- __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(p + __gen_e_acsl_at)";
- __gen_e_acsl_assert_data_3.file = "at.i";
- __gen_e_acsl_assert_data_3.fct = "g";
- __gen_e_acsl_assert_data_3.line = 29;
- __gen_e_acsl_assert_data_3.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_3);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
- __gen_e_acsl_at_2 = *(p + __gen_e_acsl_at);
- }
- A = 4;
+ int __gen_e_acsl_valid_read_2;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"p",(void *)p);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
+ "__gen_e_acsl_at",0,__gen_e_acsl_at);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
+ "sizeof(int)",0,sizeof(int));
+ __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(p + __gen_e_acsl_at),
+ sizeof(int),(void *)p,
+ (void *)(& p));
+ __gen_e_acsl_assert_data_2.blocking = 1;
+ __gen_e_acsl_assert_data_2.kind = "RTE";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(p + __gen_e_acsl_at)";
+ __gen_e_acsl_assert_data_2.file = "at.i";
+ __gen_e_acsl_assert_data_2.fct = "g";
+ __gen_e_acsl_assert_data_2.line = 39;
+ __gen_e_acsl_assert_data_2.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_2);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
+ __gen_e_acsl_at_2 = *(p + __gen_e_acsl_at);
}
+ A = 4;
{
- __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\at(*(p + \\at(*q,L1)),L2)",0,
__gen_e_acsl_at_2);
- __gen_e_acsl_assert_data.blocking = 1;
- __gen_e_acsl_assert_data.kind = "Assertion";
- __gen_e_acsl_assert_data.pred_txt = "\\at(*(p + \\at(*q,L1)),L2) == 2";
- __gen_e_acsl_assert_data.file = "at.i";
- __gen_e_acsl_assert_data.fct = "g";
- __gen_e_acsl_assert_data.line = 29;
- __e_acsl_assert(__gen_e_acsl_at_2 == 2,& __gen_e_acsl_assert_data);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
+ __gen_e_acsl_assert_data_3.blocking = 1;
+ __gen_e_acsl_assert_data_3.kind = "Assertion";
+ __gen_e_acsl_assert_data_3.pred_txt = "\\at(*(p + \\at(*q,L1)),L2) == 2";
+ __gen_e_acsl_assert_data_3.file = "at.i";
+ __gen_e_acsl_assert_data_3.fct = "g";
+ __gen_e_acsl_assert_data_3.line = 39;
+ __e_acsl_assert(__gen_e_acsl_at_2 == 2,& __gen_e_acsl_assert_data_3);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
}
/*@ assert \at(*(p + \at(*q,L1)),L2) == 2; */ ;
L3:
{
+ int __gen_e_acsl_valid_read_3;
int __gen_e_acsl_valid_read_4;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"p",(void *)p);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
+ "__gen_e_acsl_at",0,__gen_e_acsl_at);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
+ "sizeof(int)",0,sizeof(int));
+ __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(p + __gen_e_acsl_at),
+ sizeof(int),(void *)p,
+ (void *)(& p));
+ __gen_e_acsl_assert_data_4.blocking = 1;
+ __gen_e_acsl_assert_data_4.kind = "RTE";
+ __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(p + __gen_e_acsl_at)";
+ __gen_e_acsl_assert_data_4.file = "at.i";
+ __gen_e_acsl_assert_data_4.fct = "g";
+ __gen_e_acsl_assert_data_4.line = 43;
+ __gen_e_acsl_assert_data_4.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_3,& __gen_e_acsl_assert_data_4);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
+ __gen_e_acsl_at_3 = *(p + __gen_e_acsl_at);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
"*(p + \\at(*q,L1))",0,
- *(p + __gen_e_acsl_at_3));
+ *(p + __gen_e_acsl_at));
__e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,"p",(void *)p);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
- "__gen_e_acsl_at_3",0,__gen_e_acsl_at_3);
+ "__gen_e_acsl_at",0,__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(p + __gen_e_acsl_at_3),
+ __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(p + __gen_e_acsl_at),
sizeof(int),(void *)p,
(void *)(& p));
__gen_e_acsl_assert_data_6.blocking = 1;
__gen_e_acsl_assert_data_6.kind = "RTE";
- __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(p + __gen_e_acsl_at_3)";
+ __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(p + __gen_e_acsl_at)";
__gen_e_acsl_assert_data_6.file = "at.i";
__gen_e_acsl_assert_data_6.fct = "g";
- __gen_e_acsl_assert_data_6.line = 31;
+ __gen_e_acsl_assert_data_6.line = 41;
__gen_e_acsl_assert_data_6.name = "mem_access";
__e_acsl_assert(__gen_e_acsl_valid_read_4,& __gen_e_acsl_assert_data_6);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
- __gen_e_acsl_assert_data_4.blocking = 1;
- __gen_e_acsl_assert_data_4.kind = "Assertion";
- __gen_e_acsl_assert_data_4.pred_txt = "\\at(*(p + \\at(*q,L1)),Here) == 2";
- __gen_e_acsl_assert_data_4.file = "at.i";
- __gen_e_acsl_assert_data_4.fct = "g";
- __gen_e_acsl_assert_data_4.line = 31;
- __e_acsl_assert(*(p + __gen_e_acsl_at_3) == 2,
- & __gen_e_acsl_assert_data_4);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
+ __gen_e_acsl_assert_data_5.blocking = 1;
+ __gen_e_acsl_assert_data_5.kind = "Assertion";
+ __gen_e_acsl_assert_data_5.pred_txt = "\\at(*(p + \\at(*q,L1)),Here) == 2";
+ __gen_e_acsl_assert_data_5.file = "at.i";
+ __gen_e_acsl_assert_data_5.fct = "g";
+ __gen_e_acsl_assert_data_5.line = 41;
+ __e_acsl_assert(*(p + __gen_e_acsl_at) == 2,& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
}
/*@ assert \at(*(p + \at(*q,L1)),Here) == 2; */ ;
+ {
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
+ "\\at(*(p + \\at(*q,L1)),L3)",0,
+ __gen_e_acsl_at_3);
+ __gen_e_acsl_assert_data_7.blocking = 1;
+ __gen_e_acsl_assert_data_7.kind = "Assertion";
+ __gen_e_acsl_assert_data_7.pred_txt = "\\at(*(p + \\at(*q,L1)),L3) == 2";
+ __gen_e_acsl_assert_data_7.file = "at.i";
+ __gen_e_acsl_assert_data_7.fct = "g";
+ __gen_e_acsl_assert_data_7.line = 43;
+ __e_acsl_assert(__gen_e_acsl_at_3 == 2,& __gen_e_acsl_assert_data_7);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
+ }
+ /*@ assert \at(*(p + \at(*q,L1)),L3) == 2; */ ;
__e_acsl_delete_block((void *)(& q));
__e_acsl_delete_block((void *)(& p));
return;
@@ -249,9 +315,53 @@ int h(int x)
return x;
}
+void i(void)
+{
+ long __gen_e_acsl_at_2;
+ long __gen_e_acsl_at;
+ int a = 0;
+ {
+ __gen_e_acsl_at = (long)a;
+ /*@ ensures \old(a) + 1 == \at(a,Post); */
+ a ++;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
+ __e_acsl_assert_register_long(& __gen_e_acsl_assert_data,"\\old(a)",0,
+ __gen_e_acsl_at);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"a",0,a);
+ __gen_e_acsl_assert_data.blocking = 1;
+ __gen_e_acsl_assert_data.kind = "Postcondition";
+ __gen_e_acsl_assert_data.pred_txt = "\\old(a) + 1 == \\at(a,Post)";
+ __gen_e_acsl_assert_data.file = "at.i";
+ __gen_e_acsl_assert_data.fct = "i";
+ __gen_e_acsl_assert_data.line = 59;
+ __e_acsl_assert(__gen_e_acsl_at + 1L == (long)a,
+ & __gen_e_acsl_assert_data);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
+ }
+ {
+ __gen_e_acsl_at_2 = (long)a;
+ /*@ ensures \old(a) + 1 == \at(a,Post); */
+ a ++;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_long(& __gen_e_acsl_assert_data_2,"\\old(a)",0,
+ __gen_e_acsl_at_2);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"a",0,a);
+ __gen_e_acsl_assert_data_2.blocking = 1;
+ __gen_e_acsl_assert_data_2.kind = "Postcondition";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\old(a) + 1 == \\at(a,Post)";
+ __gen_e_acsl_assert_data_2.file = "at.i";
+ __gen_e_acsl_assert_data_2.fct = "i";
+ __gen_e_acsl_assert_data_2.line = 62;
+ __e_acsl_assert(__gen_e_acsl_at_2 + 1L == (long)a,
+ & __gen_e_acsl_assert_data_2);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
+ }
+ return;
+}
+
int main(void)
{
- long __gen_e_acsl_at_3;
long __gen_e_acsl_at_2;
int __gen_e_acsl_at;
int __retres;
@@ -264,24 +374,20 @@ int main(void)
x = __gen_e_acsl_h(0);
L:
{
- __gen_e_acsl_at_3 = (long)x;
- __gen_e_acsl_at_2 = x + 1L;
__gen_e_acsl_at = x;
- {
- __e_acsl_assert_data_t __gen_e_acsl_assert_data =
- {.values = (void *)0};
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"x",0,x);
- __gen_e_acsl_assert_data.blocking = 1;
- __gen_e_acsl_assert_data.kind = "Assertion";
- __gen_e_acsl_assert_data.pred_txt = "x == 0";
- __gen_e_acsl_assert_data.file = "at.i";
- __gen_e_acsl_assert_data.fct = "main";
- __gen_e_acsl_assert_data.line = 48;
- __e_acsl_assert(x == 0,& __gen_e_acsl_assert_data);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
- }
- /*@ assert x == 0; */ ;
+ __gen_e_acsl_at_2 = x + 1L;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"x",0,x);
+ __gen_e_acsl_assert_data.blocking = 1;
+ __gen_e_acsl_assert_data.kind = "Assertion";
+ __gen_e_acsl_assert_data.pred_txt = "x == 0";
+ __gen_e_acsl_assert_data.file = "at.i";
+ __gen_e_acsl_assert_data.fct = "main";
+ __gen_e_acsl_assert_data.line = 71;
+ __e_acsl_assert(x == 0,& __gen_e_acsl_assert_data);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
+ /*@ assert x == 0; */ ;
__e_acsl_full_init((void *)(& x));
x = 1;
__e_acsl_full_init((void *)(& x));
@@ -297,7 +403,7 @@ int main(void)
__gen_e_acsl_assert_data_2.pred_txt = "\\at(x,L) == 0";
__gen_e_acsl_assert_data_2.file = "at.i";
__gen_e_acsl_assert_data_2.fct = "main";
- __gen_e_acsl_assert_data_2.line = 54;
+ __gen_e_acsl_assert_data_2.line = 77;
__e_acsl_assert(__gen_e_acsl_at == 0,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
@@ -312,7 +418,7 @@ int main(void)
__gen_e_acsl_assert_data_3.pred_txt = "\\at(x + 1,L) == 1";
__gen_e_acsl_assert_data_3.file = "at.i";
__gen_e_acsl_assert_data_3.fct = "main";
- __gen_e_acsl_assert_data_3.line = 55;
+ __gen_e_acsl_assert_data_3.line = 78;
__e_acsl_assert(__gen_e_acsl_at_2 == 1L,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
}
@@ -320,20 +426,21 @@ int main(void)
{
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
- __e_acsl_assert_register_long(& __gen_e_acsl_assert_data_4,"\\at(x,L)",0,
- __gen_e_acsl_at_3);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"\\at(x,L)",0,
+ __gen_e_acsl_at);
__gen_e_acsl_assert_data_4.blocking = 1;
__gen_e_acsl_assert_data_4.kind = "Assertion";
__gen_e_acsl_assert_data_4.pred_txt = "\\at(x,L) + 1 == 1";
__gen_e_acsl_assert_data_4.file = "at.i";
__gen_e_acsl_assert_data_4.fct = "main";
- __gen_e_acsl_assert_data_4.line = 56;
- __e_acsl_assert(__gen_e_acsl_at_3 + 1L == 1L,
+ __gen_e_acsl_assert_data_4.line = 79;
+ __e_acsl_assert((long)__gen_e_acsl_at + 1L == 1L,
& __gen_e_acsl_assert_data_4);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
}
/*@ assert \at(x,L) + 1 == 1; */ ;
g(t,& x);
+ i();
__retres = 0;
__e_acsl_delete_block((void *)(t));
__e_acsl_delete_block((void *)(& x));
@@ -361,7 +468,7 @@ int __gen_e_acsl_h(int x)
__gen_e_acsl_assert_data.pred_txt = "\\result == \\old(x)";
__gen_e_acsl_assert_data.file = "at.i";
__gen_e_acsl_assert_data.fct = "h";
- __gen_e_acsl_assert_data.line = 38;
+ __gen_e_acsl_assert_data.line = 48;
__e_acsl_assert(__retres == __gen_e_acsl_at,& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
__e_acsl_delete_block((void *)(& x));
@@ -370,24 +477,75 @@ int __gen_e_acsl_h(int x)
}
}
-/*@ ensures \at(A,Post) == 3; */
+/*@ requires \at(A,Here) == 0;
+ requires \at(A,Pre) == 0;
+ ensures \at(A,Pre) == \old(A) == 0;
+ ensures \at(A,Post) == 4;
+ */
void __gen_e_acsl_f(void)
{
+ int __gen_e_acsl_at_2;
int __gen_e_acsl_at;
- f();
{
__gen_e_acsl_at = A;
+ __gen_e_acsl_at_2 = A;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"\\at(A,Post)",0,
- __gen_e_acsl_at);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"A",0,A);
__gen_e_acsl_assert_data.blocking = 1;
- __gen_e_acsl_assert_data.kind = "Postcondition";
- __gen_e_acsl_assert_data.pred_txt = "\\at(A,Post) == 3";
+ __gen_e_acsl_assert_data.kind = "Precondition";
+ __gen_e_acsl_assert_data.pred_txt = "\\at(A,Here) == 0";
__gen_e_acsl_assert_data.file = "at.i";
__gen_e_acsl_assert_data.fct = "f";
- __gen_e_acsl_assert_data.line = 7;
- __e_acsl_assert(__gen_e_acsl_at == 3,& __gen_e_acsl_assert_data);
+ __gen_e_acsl_assert_data.line = 8;
+ __e_acsl_assert(A == 0,& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"\\at(A,Pre)",
+ 0,__gen_e_acsl_at_2);
+ __gen_e_acsl_assert_data_2.blocking = 1;
+ __gen_e_acsl_assert_data_2.kind = "Precondition";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\at(A,Pre) == 0";
+ __gen_e_acsl_assert_data_2.file = "at.i";
+ __gen_e_acsl_assert_data_2.fct = "f";
+ __gen_e_acsl_assert_data_2.line = 9;
+ __e_acsl_assert(__gen_e_acsl_at_2 == 0,& __gen_e_acsl_assert_data_2);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
+ }
+ f();
+ {
+ int __gen_e_acsl_and;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"\\at(A,Pre)",
+ 0,__gen_e_acsl_at_2);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"\\old(A)",0,
+ __gen_e_acsl_at);
+ if (__gen_e_acsl_at_2 == __gen_e_acsl_at) {
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"\\old(A)",0,
+ __gen_e_acsl_at);
+ __gen_e_acsl_and = __gen_e_acsl_at == 0;
+ }
+ else __gen_e_acsl_and = 0;
+ __gen_e_acsl_assert_data_3.blocking = 1;
+ __gen_e_acsl_assert_data_3.kind = "Postcondition";
+ __gen_e_acsl_assert_data_3.pred_txt = "\\at(A,Pre) == \\old(A) == 0";
+ __gen_e_acsl_assert_data_3.file = "at.i";
+ __gen_e_acsl_assert_data_3.fct = "f";
+ __gen_e_acsl_assert_data_3.line = 10;
+ __e_acsl_assert(__gen_e_acsl_and,& __gen_e_acsl_assert_data_3);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"A",0,A);
+ __gen_e_acsl_assert_data_4.blocking = 1;
+ __gen_e_acsl_assert_data_4.kind = "Postcondition";
+ __gen_e_acsl_assert_data_4.pred_txt = "\\at(A,Post) == 4";
+ __gen_e_acsl_assert_data_4.file = "at.i";
+ __gen_e_acsl_assert_data_4.fct = "f";
+ __gen_e_acsl_assert_data_4.line = 11;
+ __e_acsl_assert(A == 4,& __gen_e_acsl_assert_data_4);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
return;
}
}
diff --git a/src/plugins/e-acsl/tests/arith/oracle/gen_at_on-purely-logic-variables.c b/src/plugins/e-acsl/tests/arith/oracle/gen_at_on-purely-logic-variables.c
index 9398cc676d2148b415c3b2fd7bf634e7274f861e..cae72156516869acc9f2964bf479d16baafaa71a 100644
--- a/src/plugins/e-acsl/tests/arith/oracle/gen_at_on-purely-logic-variables.c
+++ b/src/plugins/e-acsl/tests/arith/oracle/gen_at_on-purely-logic-variables.c
@@ -30,26 +30,24 @@ void g(void)
m = 8;
Q:
{
- {
- int __gen_e_acsl_w_2;
- __gen_e_acsl_w_2 = 3;
- while (1) {
- if (__gen_e_acsl_w_2 < 6) ; else break;
- *(__gen_e_acsl_at + (__gen_e_acsl_w_2 - 3)) = m + (long)__gen_e_acsl_w_2 == 12L;
- __gen_e_acsl_w_2 ++;
- }
+ int __gen_e_acsl_w;
+ __gen_e_acsl_w = 3;
+ while (1) {
+ if (__gen_e_acsl_w < 6) ; else break;
+ *(__gen_e_acsl_at + (__gen_e_acsl_w - 3)) = m + (long)__gen_e_acsl_w == 12L;
+ __gen_e_acsl_w ++;
}
- ;
}
+ ;
m = 10;
{
int __gen_e_acsl_exists;
- int __gen_e_acsl_w;
+ int __gen_e_acsl_w_2;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__gen_e_acsl_exists = 0;
- __gen_e_acsl_w = 3;
+ __gen_e_acsl_w_2 = 3;
while (1) {
- if (__gen_e_acsl_w < 6) ; else break;
+ if (__gen_e_acsl_w_2 < 6) ; else break;
{
int __gen_e_acsl_valid_read;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
@@ -58,30 +56,30 @@ void g(void)
"__gen_e_acsl_at",
(void *)__gen_e_acsl_at);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
- "__gen_e_acsl_w",0,__gen_e_acsl_w);
+ "__gen_e_acsl_w_2",0,__gen_e_acsl_w_2);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
"sizeof(int)",0,sizeof(int));
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(__gen_e_acsl_at + (int)(
- __gen_e_acsl_w - 3L)),
+ __gen_e_acsl_w_2 - 3L)),
sizeof(int),
(void *)__gen_e_acsl_at,
(void *)(& __gen_e_acsl_at));
__gen_e_acsl_assert_data_2.blocking = 1;
__gen_e_acsl_assert_data_2.kind = "RTE";
- __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(__gen_e_acsl_at + (int)(__gen_e_acsl_w - 3))";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(__gen_e_acsl_at + (int)(__gen_e_acsl_w_2 - 3))";
__gen_e_acsl_assert_data_2.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_2.fct = "g";
__gen_e_acsl_assert_data_2.line = 16;
__gen_e_acsl_assert_data_2.name = "mem_access";
__e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
- if (! *(__gen_e_acsl_at + (__gen_e_acsl_w - 3))) ;
+ if (! *(__gen_e_acsl_at + (__gen_e_acsl_w_2 - 3))) ;
else {
__gen_e_acsl_exists = 1;
goto e_acsl_end_loop1;
}
}
- __gen_e_acsl_w ++;
+ __gen_e_acsl_w_2 ++;
}
e_acsl_end_loop1: ;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
@@ -103,138 +101,134 @@ void g(void)
int main(void)
{
+ long *__gen_e_acsl_at_8;
int *__gen_e_acsl_at_7;
- int *__gen_e_acsl_at_6;
- long *__gen_e_acsl_at_5;
- long *__gen_e_acsl_at_4;
+ long *__gen_e_acsl_at_6;
+ int *__gen_e_acsl_at_5;
int *__gen_e_acsl_at_3;
- int *__gen_e_acsl_at_2;
+ long *__gen_e_acsl_at_2;
int *__gen_e_acsl_at;
int __retres;
int n;
__e_acsl_memory_init((int *)0,(char ***)0,(size_t)8);
+ __gen_e_acsl_at_8 = (long *)malloc((size_t)64);
__gen_e_acsl_at_7 = (int *)malloc((size_t)12000);
- __gen_e_acsl_at_6 = (int *)malloc((size_t)1536);
- __gen_e_acsl_at_5 = (long *)malloc((size_t)64);
- __gen_e_acsl_at_4 = (long *)malloc((size_t)8);
- __gen_e_acsl_at_3 = (int *)malloc((size_t)528);
- __gen_e_acsl_at_2 = (int *)malloc((size_t)12);
+ __gen_e_acsl_at_6 = (long *)malloc((size_t)3072);
+ __gen_e_acsl_at_5 = (int *)malloc((size_t)528);
+ __gen_e_acsl_at_3 = (int *)malloc((size_t)12);
+ __gen_e_acsl_at_2 = (long *)malloc((size_t)8);
__gen_e_acsl_at = (int *)malloc((size_t)4);
__e_acsl_store_block((void *)(& n),(size_t)4);
__e_acsl_full_init((void *)(& n));
n = 7;
L:
{
- {
- int __gen_e_acsl_i_4;
- __gen_e_acsl_i_4 = 3;
- *(__gen_e_acsl_at_4 + 0) = n + (long)__gen_e_acsl_i_4;
- }
- {
- int __gen_e_acsl_j_2;
- __gen_e_acsl_j_2 = 2;
- while (1) {
- if (__gen_e_acsl_j_2 < 5) ; else break;
- *(__gen_e_acsl_at_2 + (__gen_e_acsl_j_2 - 2)) = n + (long)__gen_e_acsl_j_2 == 11L;
- __gen_e_acsl_j_2 ++;
- }
- }
- {
- int __gen_e_acsl_i_2;
- __gen_e_acsl_i_2 = 3;
- *(__gen_e_acsl_at + 0) = n + (long)__gen_e_acsl_i_2 == 10L;
+ int __gen_e_acsl_i;
+ __gen_e_acsl_i = 3;
+ *(__gen_e_acsl_at + 0) = n + (long)__gen_e_acsl_i == 10L;
+ }
+ {
+ int __gen_e_acsl_i_2;
+ __gen_e_acsl_i_2 = 3;
+ *(__gen_e_acsl_at_2 + 0) = n + (long)__gen_e_acsl_i_2;
+ }
+ {
+ int __gen_e_acsl_j;
+ __gen_e_acsl_j = 2;
+ while (1) {
+ if (__gen_e_acsl_j < 5) ; else break;
+ *(__gen_e_acsl_at_3 + (__gen_e_acsl_j - 2)) = n + (long)__gen_e_acsl_j == 11L;
+ __gen_e_acsl_j ++;
}
- ;
}
+ ;
__e_acsl_full_init((void *)(& n));
n = 9;
K:
{
- {
- int __gen_e_acsl_u_6;
- int __gen_e_acsl_v_6;
- int __gen_e_acsl_w_2;
- __gen_e_acsl_u_6 = 10;
+ int __gen_e_acsl_k;
+ int __gen_e_acsl_u;
+ int __gen_e_acsl_v;
+ __gen_e_acsl_k = -7;
+ __gen_e_acsl_u = 9;
+ while (1) {
+ if (__gen_e_acsl_u < 21) ; else break;
+ __gen_e_acsl_v = -5 + 1;
while (1) {
- if (__gen_e_acsl_u_6 < 20) ; else break;
- __gen_e_acsl_v_6 = -10 + 1;
- while (1) {
- {
- int __gen_e_acsl_u_8;
- __gen_e_acsl_u_8 = -2;
- if (__gen_e_acsl_v_6 <= -5 + __gen_e_acsl_u_8) ; else break;
- }
- __gen_e_acsl_w_2 = 100 + 1;
- while (1) {
- if (__gen_e_acsl_w_2 <= 200) ; else break;
- {
- int __gen_e_acsl_u_7;
- __gen_e_acsl_u_7 = 42;
- *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_6 - 10) * 300 + (
- (__gen_e_acsl_v_6 - -9) * 100 + (
- __gen_e_acsl_w_2 - 101)))) = (((
- n - (long)__gen_e_acsl_u_6) + __gen_e_acsl_u_7) + __gen_e_acsl_v_6) + __gen_e_acsl_w_2 > 0L;
- }
- __gen_e_acsl_w_2 ++;
- }
- __gen_e_acsl_v_6 ++;
+ if (__gen_e_acsl_v <= 6) ; else break;
+ {
+ long __gen_e_acsl_if;
+ if (__gen_e_acsl_u > 0) __gen_e_acsl_if = n + (long)__gen_e_acsl_k;
+ else __gen_e_acsl_if = __gen_e_acsl_u + __gen_e_acsl_v;
+ *(__gen_e_acsl_at_5 + ((__gen_e_acsl_u - 9) * 11 + (__gen_e_acsl_v - -4))) =
+ __gen_e_acsl_if > 0L;
}
- __gen_e_acsl_u_6 ++;
+ __gen_e_acsl_v ++;
}
+ __gen_e_acsl_u ++;
}
- {
- int __gen_e_acsl_u_4;
- int __gen_e_acsl_v_4;
- __gen_e_acsl_u_4 = 9;
+ }
+ {
+ int __gen_e_acsl_u_2;
+ int __gen_e_acsl_v_2;
+ __gen_e_acsl_u_2 = 9;
+ while (1) {
+ if (__gen_e_acsl_u_2 < 21) ; else break;
+ __gen_e_acsl_v_2 = -5 + 1;
while (1) {
- if (__gen_e_acsl_u_4 < 21) ; else break;
- __gen_e_acsl_v_4 = -5 + 1;
- while (1) {
- {
- int __gen_e_acsl_if_2;
- if (__gen_e_acsl_u_4 < 15) __gen_e_acsl_if_2 = __gen_e_acsl_u_4 + 6;
- else __gen_e_acsl_if_2 = 3;
- if (__gen_e_acsl_v_4 <= __gen_e_acsl_if_2) ; else break;
- }
- *(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_4 - 9) * 32 + (__gen_e_acsl_v_4 - -4))) =
- (n + (long)__gen_e_acsl_u_4) + __gen_e_acsl_v_4 > 0L;
- __gen_e_acsl_v_4 ++;
+ {
+ int __gen_e_acsl_if_2;
+ if (__gen_e_acsl_u_2 < 15) __gen_e_acsl_if_2 = __gen_e_acsl_u_2 + 6;
+ else __gen_e_acsl_if_2 = 3;
+ if (__gen_e_acsl_v_2 <= __gen_e_acsl_if_2) ; else break;
}
- __gen_e_acsl_u_4 ++;
+ *(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_2 - 9) * 32 + (__gen_e_acsl_v_2 - -4))) =
+ (n + (long)__gen_e_acsl_u_2) + __gen_e_acsl_v_2;
+ __gen_e_acsl_v_2 ++;
}
+ __gen_e_acsl_u_2 ++;
}
- {
- int __gen_e_acsl_k_2;
- int __gen_e_acsl_u_2;
- int __gen_e_acsl_v_2;
- __gen_e_acsl_k_2 = -7;
- __gen_e_acsl_u_2 = 9;
+ }
+ {
+ int __gen_e_acsl_u_3;
+ int __gen_e_acsl_v_3;
+ int __gen_e_acsl_w;
+ __gen_e_acsl_u_3 = 10;
+ while (1) {
+ if (__gen_e_acsl_u_3 < 20) ; else break;
+ __gen_e_acsl_v_3 = -10 + 1;
while (1) {
- if (__gen_e_acsl_u_2 < 21) ; else break;
- __gen_e_acsl_v_2 = -5 + 1;
+ {
+ int __gen_e_acsl_u_5;
+ __gen_e_acsl_u_5 = -2;
+ if (__gen_e_acsl_v_3 <= -5 + __gen_e_acsl_u_5) ; else break;
+ }
+ __gen_e_acsl_w = 100 + 1;
while (1) {
- if (__gen_e_acsl_v_2 <= 6) ; else break;
+ if (__gen_e_acsl_w <= 200) ; else break;
{
- long __gen_e_acsl_if;
- if (__gen_e_acsl_u_2 > 0) __gen_e_acsl_if = n + (long)__gen_e_acsl_k_2;
- else __gen_e_acsl_if = __gen_e_acsl_u_2 + __gen_e_acsl_v_2;
- *(__gen_e_acsl_at_3 + ((__gen_e_acsl_u_2 - 9) * 11 + (__gen_e_acsl_v_2 - -4))) =
- __gen_e_acsl_if > 0L;
+ int __gen_e_acsl_u_4;
+ __gen_e_acsl_u_4 = 42;
+ *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_3 - 10) * 300 + ((
+ __gen_e_acsl_v_3 - -9) * 100 + (
+ __gen_e_acsl_w - 101)))) =
+ (((n - (long)__gen_e_acsl_u_3) + __gen_e_acsl_u_4) + __gen_e_acsl_v_3) + __gen_e_acsl_w > 0L;
}
- __gen_e_acsl_v_2 ++;
+ __gen_e_acsl_w ++;
}
- __gen_e_acsl_u_2 ++;
+ __gen_e_acsl_v_3 ++;
}
+ __gen_e_acsl_u_3 ++;
}
- ;
}
+ ;
__e_acsl_full_init((void *)(& n));
n = 666;
{
- int __gen_e_acsl_i;
+ int __gen_e_acsl_i_3;
int __gen_e_acsl_valid_read;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
- __gen_e_acsl_i = 3;
+ __gen_e_acsl_i_3 = 3;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"\\at(n + i == 10,L)",0,
*(__gen_e_acsl_at + 0));
@@ -269,32 +263,32 @@ int main(void)
/*@ assert \let i = 3; \at(n + i == 10,L); */ ;
{
int __gen_e_acsl_exists;
- int __gen_e_acsl_j;
+ int __gen_e_acsl_j_2;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
__gen_e_acsl_exists = 0;
- __gen_e_acsl_j = 2;
+ __gen_e_acsl_j_2 = 2;
while (1) {
- if (__gen_e_acsl_j < 5) ; else break;
+ if (__gen_e_acsl_j_2 < 5) ; else break;
{
int __gen_e_acsl_valid_read_2;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,
- "__gen_e_acsl_at_2",
- (void *)__gen_e_acsl_at_2);
+ "__gen_e_acsl_at_3",
+ (void *)__gen_e_acsl_at_3);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
- "__gen_e_acsl_j",0,__gen_e_acsl_j);
+ "__gen_e_acsl_j_2",0,__gen_e_acsl_j_2);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + (int)(
- __gen_e_acsl_j - 2L)),
+ __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_3 + (int)(
+ __gen_e_acsl_j_2 - 2L)),
sizeof(int),
- (void *)__gen_e_acsl_at_2,
- (void *)(& __gen_e_acsl_at_2));
+ (void *)__gen_e_acsl_at_3,
+ (void *)(& __gen_e_acsl_at_3));
__gen_e_acsl_assert_data_4.blocking = 1;
__gen_e_acsl_assert_data_4.kind = "RTE";
- __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(__gen_e_acsl_at_2 + (int)(__gen_e_acsl_j - 2))";
+ __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(__gen_e_acsl_at_3 + (int)(__gen_e_acsl_j_2 - 2))";
__gen_e_acsl_assert_data_4.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_4.fct = "main";
__gen_e_acsl_assert_data_4.line = 29;
@@ -302,13 +296,13 @@ int main(void)
__e_acsl_assert(__gen_e_acsl_valid_read_2,
& __gen_e_acsl_assert_data_4);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
- if (! *(__gen_e_acsl_at_2 + (__gen_e_acsl_j - 2))) ;
+ if (! *(__gen_e_acsl_at_3 + (__gen_e_acsl_j_2 - 2))) ;
else {
__gen_e_acsl_exists = 1;
goto e_acsl_end_loop2;
}
}
- __gen_e_acsl_j ++;
+ __gen_e_acsl_j_2 ++;
}
e_acsl_end_loop2: ;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
@@ -325,48 +319,50 @@ int main(void)
}
/*@ assert \exists integer j; 2 <= j < 5 && \at(n + j == 11,L); */ ;
{
- int __gen_e_acsl_k;
+ int __gen_e_acsl_k_2;
int __gen_e_acsl_exists_2;
- int __gen_e_acsl_u;
+ int __gen_e_acsl_u_6;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
{.values = (void *)0};
- __gen_e_acsl_k = -7;
+ __gen_e_acsl_k_2 = -7;
__gen_e_acsl_exists_2 = 0;
- __gen_e_acsl_u = 9;
+ __gen_e_acsl_u_6 = 9;
while (1) {
- if (__gen_e_acsl_u < 21) ; else break;
+ if (__gen_e_acsl_u_6 < 21) ; else break;
{
int __gen_e_acsl_forall;
- int __gen_e_acsl_v;
+ int __gen_e_acsl_v_4;
__gen_e_acsl_forall = 1;
- __gen_e_acsl_v = -5 + 1;
+ __gen_e_acsl_v_4 = -5 + 1;
while (1) {
- if (__gen_e_acsl_v <= 6) ; else break;
+ if (__gen_e_acsl_v_4 <= 6) ; else break;
{
int __gen_e_acsl_valid_read_3;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,
- "__gen_e_acsl_at_3",
- (void *)__gen_e_acsl_at_3);
+ "__gen_e_acsl_at_5",
+ (void *)__gen_e_acsl_at_5);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
- "__gen_e_acsl_u",0,__gen_e_acsl_u);
+ "__gen_e_acsl_u_6",0,
+ __gen_e_acsl_u_6);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
- "__gen_e_acsl_v",0,__gen_e_acsl_v);
+ "__gen_e_acsl_v_4",0,
+ __gen_e_acsl_v_4);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
"sizeof(int)",0,sizeof(int));
__gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(
- __gen_e_acsl_at_3 + (int)(
+ __gen_e_acsl_at_5 + (int)(
(long)((int)(
(long)((int)(
- __gen_e_acsl_u - 9L)) * 11L)) + (int)(
- __gen_e_acsl_v - -4L))),
+ __gen_e_acsl_u_6 - 9L)) * 11L)) + (int)(
+ __gen_e_acsl_v_4 - -4L))),
sizeof(int),
- (void *)__gen_e_acsl_at_3,
- (void *)(& __gen_e_acsl_at_3));
+ (void *)__gen_e_acsl_at_5,
+ (void *)(& __gen_e_acsl_at_5));
__gen_e_acsl_assert_data_6.blocking = 1;
__gen_e_acsl_assert_data_6.kind = "RTE";
- __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at_3 +\n (int)((int)((int)(__gen_e_acsl_u - 9) * 11) +\n (int)(__gen_e_acsl_v - -4)))";
+ __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at_5 +\n (int)((int)((int)(__gen_e_acsl_u_6 - 9) * 11) +\n (int)(__gen_e_acsl_v_4 - -4)))";
__gen_e_acsl_assert_data_6.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_6.fct = "main";
__gen_e_acsl_assert_data_6.line = 34;
@@ -374,14 +370,14 @@ int main(void)
__e_acsl_assert(__gen_e_acsl_valid_read_3,
& __gen_e_acsl_assert_data_6);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
- if (*(__gen_e_acsl_at_3 + ((__gen_e_acsl_u - 9) * 11 + (__gen_e_acsl_v - -4))))
- ;
+ if (*(__gen_e_acsl_at_5 + ((__gen_e_acsl_u_6 - 9) * 11 + (
+ __gen_e_acsl_v_4 - -4)))) ;
else {
__gen_e_acsl_forall = 0;
goto e_acsl_end_loop3;
}
}
- __gen_e_acsl_v ++;
+ __gen_e_acsl_v_4 ++;
}
e_acsl_end_loop3: ;
if (! __gen_e_acsl_forall) ;
@@ -390,7 +386,7 @@ int main(void)
goto e_acsl_end_loop4;
}
}
- __gen_e_acsl_u ++;
+ __gen_e_acsl_u_6 ++;
}
e_acsl_end_loop4: ;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
@@ -413,27 +409,27 @@ int main(void)
*/
;
{
- int __gen_e_acsl_i_3;
+ int __gen_e_acsl_i_4;
int __gen_e_acsl_valid_read_4;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
- __gen_e_acsl_i_3 = 3;
+ __gen_e_acsl_i_4 = 3;
__e_acsl_assert_register_long(& __gen_e_acsl_assert_data_7,
- "\\at(n + i,L)",0,*(__gen_e_acsl_at_4 + 0));
+ "\\at(n + i,L)",0,*(__gen_e_acsl_at_2 + 0));
__e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,
- "__gen_e_acsl_at_4",
- (void *)__gen_e_acsl_at_4);
+ "__gen_e_acsl_at_2",
+ (void *)__gen_e_acsl_at_2);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_8,
"sizeof(long)",0,sizeof(long));
- __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_4 + 0),
+ __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + 0),
sizeof(long),
- (void *)__gen_e_acsl_at_4,
- (void *)(& __gen_e_acsl_at_4));
+ (void *)__gen_e_acsl_at_2,
+ (void *)(& __gen_e_acsl_at_2));
__gen_e_acsl_assert_data_8.blocking = 1;
__gen_e_acsl_assert_data_8.kind = "RTE";
- __gen_e_acsl_assert_data_8.pred_txt = "\\valid_read(__gen_e_acsl_at_4 + 0)";
+ __gen_e_acsl_assert_data_8.pred_txt = "\\valid_read(__gen_e_acsl_at_2 + 0)";
__gen_e_acsl_assert_data_8.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_8.fct = "main";
__gen_e_acsl_assert_data_8.line = 38;
@@ -446,7 +442,7 @@ int main(void)
__gen_e_acsl_assert_data_7.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_7.fct = "main";
__gen_e_acsl_assert_data_7.line = 38;
- __e_acsl_assert(*(__gen_e_acsl_at_4 + 0) == 10L,
+ __e_acsl_assert(*(__gen_e_acsl_at_2 + 0) == 10L,
& __gen_e_acsl_assert_data_7);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
}
@@ -454,46 +450,44 @@ int main(void)
unsigned int m = (unsigned int)3;
G:
{
- {
- int __gen_e_acsl_k_4;
- __gen_e_acsl_k_4 = -9 + 1;
- while (1) {
- if (__gen_e_acsl_k_4 < 0) ; else break;
- *(__gen_e_acsl_at_5 + (__gen_e_acsl_k_4 - -8)) = m + (long)__gen_e_acsl_k_4;
- __gen_e_acsl_k_4 ++;
- }
+ int __gen_e_acsl_k_3;
+ __gen_e_acsl_k_3 = -9 + 1;
+ while (1) {
+ if (__gen_e_acsl_k_3 < 0) ; else break;
+ *(__gen_e_acsl_at_8 + (__gen_e_acsl_k_3 - -8)) = m + (long)__gen_e_acsl_k_3;
+ __gen_e_acsl_k_3 ++;
}
- ;
}
+ ;
m = (unsigned int)(-3);
{
int __gen_e_acsl_exists_3;
- int __gen_e_acsl_k_3;
+ int __gen_e_acsl_k_4;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
{.values = (void *)0};
__gen_e_acsl_exists_3 = 0;
- __gen_e_acsl_k_3 = -9 + 1;
+ __gen_e_acsl_k_4 = -9 + 1;
while (1) {
- if (__gen_e_acsl_k_3 < 0) ; else break;
+ if (__gen_e_acsl_k_4 < 0) ; else break;
{
int __gen_e_acsl_valid_read_5;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_10 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_10,
- "__gen_e_acsl_at_5",
- (void *)__gen_e_acsl_at_5);
+ "__gen_e_acsl_at_8",
+ (void *)__gen_e_acsl_at_8);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_10,
- "__gen_e_acsl_k_3",0,__gen_e_acsl_k_3);
+ "__gen_e_acsl_k_4",0,__gen_e_acsl_k_4);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
"sizeof(long)",0,sizeof(long));
- __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_5 + (int)(
- __gen_e_acsl_k_3 - -8L)),
+ __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_8 + (int)(
+ __gen_e_acsl_k_4 - -8L)),
sizeof(long),
- (void *)__gen_e_acsl_at_5,
- (void *)(& __gen_e_acsl_at_5));
+ (void *)__gen_e_acsl_at_8,
+ (void *)(& __gen_e_acsl_at_8));
__gen_e_acsl_assert_data_10.blocking = 1;
__gen_e_acsl_assert_data_10.kind = "RTE";
- __gen_e_acsl_assert_data_10.pred_txt = "\\valid_read(__gen_e_acsl_at_5 + (int)(__gen_e_acsl_k_3 - -8))";
+ __gen_e_acsl_assert_data_10.pred_txt = "\\valid_read(__gen_e_acsl_at_8 + (int)(__gen_e_acsl_k_4 - -8))";
__gen_e_acsl_assert_data_10.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_10.fct = "main";
__gen_e_acsl_assert_data_10.line = 42;
@@ -501,14 +495,14 @@ int main(void)
__e_acsl_assert(__gen_e_acsl_valid_read_5,
& __gen_e_acsl_assert_data_10);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
- if (! (*(__gen_e_acsl_at_5 + (__gen_e_acsl_k_3 - -8)) == 0L))
+ if (! (*(__gen_e_acsl_at_8 + (__gen_e_acsl_k_4 - -8)) == 0L))
;
else {
__gen_e_acsl_exists_3 = 1;
goto e_acsl_end_loop5;
}
}
- __gen_e_acsl_k_3 ++;
+ __gen_e_acsl_k_4 ++;
}
e_acsl_end_loop5: ;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
@@ -526,24 +520,24 @@ int main(void)
/*@ assert \exists integer k; -9 < k < 0 && \at(m + k,G) == 0; */ ;
{
int __gen_e_acsl_exists_4;
- int __gen_e_acsl_u_3;
+ int __gen_e_acsl_u_7;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_11 =
{.values = (void *)0};
__gen_e_acsl_exists_4 = 0;
- __gen_e_acsl_u_3 = 9;
+ __gen_e_acsl_u_7 = 9;
while (1) {
- if (__gen_e_acsl_u_3 < 21) ; else break;
+ if (__gen_e_acsl_u_7 < 21) ; else break;
{
int __gen_e_acsl_forall_2;
- int __gen_e_acsl_v_3;
+ int __gen_e_acsl_v_5;
__gen_e_acsl_forall_2 = 1;
- __gen_e_acsl_v_3 = -5 + 1;
+ __gen_e_acsl_v_5 = -5 + 1;
while (1) {
{
int __gen_e_acsl_if_3;
- if (__gen_e_acsl_u_3 < 15) __gen_e_acsl_if_3 = __gen_e_acsl_u_3 + 6;
+ if (__gen_e_acsl_u_7 < 15) __gen_e_acsl_if_3 = __gen_e_acsl_u_7 + 6;
else __gen_e_acsl_if_3 = 3;
- if (__gen_e_acsl_v_3 <= __gen_e_acsl_if_3) ; else break;
+ if (__gen_e_acsl_v_5 <= __gen_e_acsl_if_3) ; else break;
}
{
int __gen_e_acsl_valid_read_6;
@@ -553,25 +547,25 @@ int main(void)
"__gen_e_acsl_at_6",
(void *)__gen_e_acsl_at_6);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
- "__gen_e_acsl_u_3",0,
- __gen_e_acsl_u_3);
+ "__gen_e_acsl_u_7",0,
+ __gen_e_acsl_u_7);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_12,
- "__gen_e_acsl_v_3",0,
- __gen_e_acsl_v_3);
+ "__gen_e_acsl_v_5",0,
+ __gen_e_acsl_v_5);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_12,
- "sizeof(int)",0,sizeof(int));
+ "sizeof(long)",0,sizeof(long));
__gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(
__gen_e_acsl_at_6 + (int)(
(long)((int)(
(long)((int)(
- __gen_e_acsl_u_3 - 9L)) * 32L)) + (int)(
- __gen_e_acsl_v_3 - -4L))),
- sizeof(int),
+ __gen_e_acsl_u_7 - 9L)) * 32L)) + (int)(
+ __gen_e_acsl_v_5 - -4L))),
+ sizeof(long),
(void *)__gen_e_acsl_at_6,
(void *)(& __gen_e_acsl_at_6));
__gen_e_acsl_assert_data_12.blocking = 1;
__gen_e_acsl_assert_data_12.kind = "RTE";
- __gen_e_acsl_assert_data_12.pred_txt = "\\valid_read(__gen_e_acsl_at_6 +\n (int)((int)((int)(__gen_e_acsl_u_3 - 9) * 32) +\n (int)(__gen_e_acsl_v_3 - -4)))";
+ __gen_e_acsl_assert_data_12.pred_txt = "\\valid_read(__gen_e_acsl_at_6 +\n (int)((int)((int)(__gen_e_acsl_u_7 - 9) * 32) +\n (int)(__gen_e_acsl_v_5 - -4)))";
__gen_e_acsl_assert_data_12.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_12.fct = "main";
__gen_e_acsl_assert_data_12.line = 46;
@@ -582,17 +576,18 @@ int main(void)
/*@ assert
Eva: initialization:
\initialized(__gen_e_acsl_at_6 +
- (int)((int)((int)(__gen_e_acsl_u_3 - 9) * 32)
- + (int)(__gen_e_acsl_v_3 - -4)));
+ (int)((int)((int)(__gen_e_acsl_u_7 - 9) * 32)
+ + (int)(__gen_e_acsl_v_5 - -4)));
*/
- if (*(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_3 - 9) * 32 + (
- __gen_e_acsl_v_3 - -4)))) ;
+ if (*(__gen_e_acsl_at_6 + ((__gen_e_acsl_u_7 - 9) * 32 + (
+ __gen_e_acsl_v_5 - -4))) > 0L)
+ ;
else {
__gen_e_acsl_forall_2 = 0;
goto e_acsl_end_loop6;
}
}
- __gen_e_acsl_v_3 ++;
+ __gen_e_acsl_v_5 ++;
}
e_acsl_end_loop6: ;
if (! __gen_e_acsl_forall_2) ;
@@ -601,15 +596,15 @@ int main(void)
goto e_acsl_end_loop7;
}
}
- __gen_e_acsl_u_3 ++;
+ __gen_e_acsl_u_7 ++;
}
e_acsl_end_loop7: ;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_11,
- "\\exists integer u;\n 9 <= u < 21 &&\n (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v > 0,K))",
+ "\\exists integer u;\n 9 <= u < 21 &&\n (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v,K) > 0)",
0,__gen_e_acsl_exists_4);
__gen_e_acsl_assert_data_11.blocking = 1;
__gen_e_acsl_assert_data_11.kind = "Assertion";
- __gen_e_acsl_assert_data_11.pred_txt = "\\exists integer u;\n 9 <= u < 21 &&\n (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v > 0,K))";
+ __gen_e_acsl_assert_data_11.pred_txt = "\\exists integer u;\n 9 <= u < 21 &&\n (\\forall integer v; -5 < v <= (u < 15? u + 6: 3) ==> \\at((n + u) + v,K) > 0)";
__gen_e_acsl_assert_data_11.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_11.fct = "main";
__gen_e_acsl_assert_data_11.line = 44;
@@ -621,7 +616,7 @@ int main(void)
\exists integer u;
9 <= u < 21 &&
(\forall integer v;
- -5 < v <= (u < 15? u + 6: 3) ==> \at((n + u) + v > 0,K));
+ -5 < v <= (u < 15? u + 6: 3) ==> \at((n + u) + v,K) > 0);
*/
;
int t[5] = {9, 12, 12, 12, -4};
@@ -631,31 +626,31 @@ int main(void)
g();
{
int __gen_e_acsl_exists_5;
- int __gen_e_acsl_u_5;
+ int __gen_e_acsl_u_8;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_13 =
{.values = (void *)0};
__gen_e_acsl_exists_5 = 0;
- __gen_e_acsl_u_5 = 10;
+ __gen_e_acsl_u_8 = 10;
while (1) {
- if (__gen_e_acsl_u_5 < 20) ; else break;
+ if (__gen_e_acsl_u_8 < 20) ; else break;
{
int __gen_e_acsl_exists_6;
- int __gen_e_acsl_v_5;
+ int __gen_e_acsl_v_6;
__gen_e_acsl_exists_6 = 0;
- __gen_e_acsl_v_5 = -10 + 1;
+ __gen_e_acsl_v_6 = -10 + 1;
while (1) {
{
int __gen_e_acsl_u_9;
__gen_e_acsl_u_9 = -2;
- if (__gen_e_acsl_v_5 <= -5 + __gen_e_acsl_u_9) ; else break;
+ if (__gen_e_acsl_v_6 <= -5 + __gen_e_acsl_u_9) ; else break;
}
{
int __gen_e_acsl_exists_7;
- int __gen_e_acsl_w;
+ int __gen_e_acsl_w_2;
__gen_e_acsl_exists_7 = 0;
- __gen_e_acsl_w = 100 + 1;
+ __gen_e_acsl_w_2 = 100 + 1;
while (1) {
- if (__gen_e_acsl_w <= 200) ; else break;
+ if (__gen_e_acsl_w_2 <= 200) ; else break;
{
int __gen_e_acsl_valid_read_7;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_14 =
@@ -664,31 +659,31 @@ int main(void)
"__gen_e_acsl_at_7",
(void *)__gen_e_acsl_at_7);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
- "__gen_e_acsl_u_5",0,
- __gen_e_acsl_u_5);
+ "__gen_e_acsl_u_8",0,
+ __gen_e_acsl_u_8);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
- "__gen_e_acsl_v_5",0,
- __gen_e_acsl_v_5);
+ "__gen_e_acsl_v_6",0,
+ __gen_e_acsl_v_6);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,
- "__gen_e_acsl_w",0,
- __gen_e_acsl_w);
+ "__gen_e_acsl_w_2",0,
+ __gen_e_acsl_w_2);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_14,
"sizeof(int)",0,sizeof(int));
__gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)(
__gen_e_acsl_at_7 + (int)(
(long)((int)(
(long)((int)(
- __gen_e_acsl_u_5 - 10L)) * 300L)) + (int)(
+ __gen_e_acsl_u_8 - 10L)) * 300L)) + (int)(
(long)((int)(
(long)((int)(
- __gen_e_acsl_v_5 - -9L)) * 100L)) + (int)(
- __gen_e_acsl_w - 101L)))),
+ __gen_e_acsl_v_6 - -9L)) * 100L)) + (int)(
+ __gen_e_acsl_w_2 - 101L)))),
sizeof(int),
(void *)__gen_e_acsl_at_7,
(void *)(& __gen_e_acsl_at_7));
__gen_e_acsl_assert_data_14.blocking = 1;
__gen_e_acsl_assert_data_14.kind = "RTE";
- __gen_e_acsl_assert_data_14.pred_txt = "\\valid_read(__gen_e_acsl_at_7 +\n (int)((int)((int)(__gen_e_acsl_u_5 - 10) * 300) +\n (int)((int)((int)(__gen_e_acsl_v_5 - -9) * 100) +\n (int)(__gen_e_acsl_w - 101))))";
+ __gen_e_acsl_assert_data_14.pred_txt = "\\valid_read(__gen_e_acsl_at_7 +\n (int)((int)((int)(__gen_e_acsl_u_8 - 10) * 300) +\n (int)((int)((int)(__gen_e_acsl_v_6 - -9) * 100) +\n (int)(__gen_e_acsl_w_2 - 101))))";
__gen_e_acsl_assert_data_14.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_14.fct = "main";
__gen_e_acsl_assert_data_14.line = 59;
@@ -696,16 +691,16 @@ int main(void)
__e_acsl_assert(__gen_e_acsl_valid_read_7,
& __gen_e_acsl_assert_data_14);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
- if (! *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_5 - 10) * 300 + (
- (__gen_e_acsl_v_5 - -9) * 100 + (
- __gen_e_acsl_w - 101)))))
+ if (! *(__gen_e_acsl_at_7 + ((__gen_e_acsl_u_8 - 10) * 300 + (
+ (__gen_e_acsl_v_6 - -9) * 100 + (
+ __gen_e_acsl_w_2 - 101)))))
;
else {
__gen_e_acsl_exists_7 = 1;
goto e_acsl_end_loop8;
}
}
- __gen_e_acsl_w ++;
+ __gen_e_acsl_w_2 ++;
}
e_acsl_end_loop8: ;
if (! __gen_e_acsl_exists_7) ;
@@ -714,7 +709,7 @@ int main(void)
goto e_acsl_end_loop9;
}
}
- __gen_e_acsl_v_5 ++;
+ __gen_e_acsl_v_6 ++;
}
e_acsl_end_loop9: ;
if (! __gen_e_acsl_exists_6) ;
@@ -723,7 +718,7 @@ int main(void)
goto e_acsl_end_loop10;
}
}
- __gen_e_acsl_u_5 ++;
+ __gen_e_acsl_u_8 ++;
}
e_acsl_end_loop10: ;
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,
@@ -759,10 +754,10 @@ int main(void)
free((void *)__gen_e_acsl_at);
free((void *)__gen_e_acsl_at_2);
free((void *)__gen_e_acsl_at_3);
- free((void *)__gen_e_acsl_at_4);
free((void *)__gen_e_acsl_at_5);
free((void *)__gen_e_acsl_at_6);
free((void *)__gen_e_acsl_at_7);
+ free((void *)__gen_e_acsl_at_8);
__e_acsl_memory_clean();
return __retres;
}
@@ -778,101 +773,100 @@ void __gen_e_acsl_f(int *t)
int *__gen_e_acsl_at_3;
int *__gen_e_acsl_at_2;
int *__gen_e_acsl_at;
- __gen_e_acsl_at_4 = (int *)malloc((size_t)4);
- __gen_e_acsl_at_3 = (int *)malloc((size_t)4);
- __gen_e_acsl_at_2 = (int *)malloc((size_t)8);
- __gen_e_acsl_at = (int *)malloc((size_t)8);
+ __gen_e_acsl_at_4 = (int *)malloc((size_t)8);
+ __gen_e_acsl_at_3 = (int *)malloc((size_t)8);
+ __gen_e_acsl_at_2 = (int *)malloc((size_t)4);
+ __gen_e_acsl_at = (int *)malloc((size_t)4);
__e_acsl_store_block((void *)(& t),(size_t)8);
{
- int __gen_e_acsl_m_3;
- __gen_e_acsl_m_3 = 4;
+ int __gen_e_acsl_m;
+ __gen_e_acsl_m = 4;
{
- int __gen_e_acsl_valid_read_7;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
+ int __gen_e_acsl_valid_read;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_9,"t",
- (void *)t);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_9,
- "__gen_e_acsl_m_3",0,__gen_e_acsl_m_3);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_9,
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"t",(void *)t);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
+ "__gen_e_acsl_m",0,__gen_e_acsl_m);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)(t + (int)(
- __gen_e_acsl_m_3 - 4L)),
- sizeof(int),(void *)t,
- (void *)(& t));
- __gen_e_acsl_assert_data_9.blocking = 1;
- __gen_e_acsl_assert_data_9.kind = "RTE";
- __gen_e_acsl_assert_data_9.pred_txt = "\\valid_read(t + (int)(__gen_e_acsl_m_3 - 4))";
- __gen_e_acsl_assert_data_9.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_9.fct = "f";
- __gen_e_acsl_assert_data_9.line = 8;
- __gen_e_acsl_assert_data_9.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_7,& __gen_e_acsl_assert_data_9);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
- *(__gen_e_acsl_at_4 + 0) = *(t + (__gen_e_acsl_m_3 - 4));
+ __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(t + __gen_e_acsl_m),
+ sizeof(int),(void *)t,
+ (void *)(& t));
+ __gen_e_acsl_assert_data.blocking = 1;
+ __gen_e_acsl_assert_data.kind = "RTE";
+ __gen_e_acsl_assert_data.pred_txt = "\\valid_read(t + __gen_e_acsl_m)";
+ __gen_e_acsl_assert_data.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data.fct = "f";
+ __gen_e_acsl_assert_data.line = 8;
+ __gen_e_acsl_assert_data.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
+ *(__gen_e_acsl_at + 0) = *(t + __gen_e_acsl_m) == -4;
}
}
{
int __gen_e_acsl_m_2;
__gen_e_acsl_m_2 = 4;
{
- int __gen_e_acsl_valid_read_5;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
+ int __gen_e_acsl_valid_read_2;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,"t",
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"t",
(void *)t);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
"__gen_e_acsl_m_2",0,__gen_e_acsl_m_2);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(t + __gen_e_acsl_m_2),
+ __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(t + (int)(
+ __gen_e_acsl_m_2 - 4L)),
sizeof(int),(void *)t,
(void *)(& t));
- __gen_e_acsl_assert_data_7.blocking = 1;
- __gen_e_acsl_assert_data_7.kind = "RTE";
- __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(t + __gen_e_acsl_m_2)";
- __gen_e_acsl_assert_data_7.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_7.fct = "f";
- __gen_e_acsl_assert_data_7.line = 8;
- __gen_e_acsl_assert_data_7.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_5,& __gen_e_acsl_assert_data_7);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
- *(__gen_e_acsl_at_3 + 0) = *(t + __gen_e_acsl_m_2) == -4;
+ __gen_e_acsl_assert_data_2.blocking = 1;
+ __gen_e_acsl_assert_data_2.kind = "RTE";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(t + (int)(__gen_e_acsl_m_2 - 4))";
+ __gen_e_acsl_assert_data_2.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_2.fct = "f";
+ __gen_e_acsl_assert_data_2.line = 8;
+ __gen_e_acsl_assert_data_2.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_2);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
+ *(__gen_e_acsl_at_2 + 0) = *(t + (__gen_e_acsl_m_2 - 4));
}
}
{
- int __gen_e_acsl_n_3;
- __gen_e_acsl_n_3 = 1 + 1;
+ int __gen_e_acsl_n;
+ __gen_e_acsl_n = 1 + 1;
while (1) {
- if (__gen_e_acsl_n_3 <= 3) ; else break;
+ if (__gen_e_acsl_n <= 3) ; else break;
{
int __gen_e_acsl_valid_read_3;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"t",
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"t",
(void *)t);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
- "__gen_e_acsl_n_3",0,__gen_e_acsl_n_3);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
+ "__gen_e_acsl_n",0,__gen_e_acsl_n);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
__gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(t + (int)(
- __gen_e_acsl_n_3 - 1L)),
+ __gen_e_acsl_n - 1L)),
sizeof(int),
(void *)t,
(void *)(& t));
- __gen_e_acsl_assert_data_4.blocking = 1;
- __gen_e_acsl_assert_data_4.kind = "RTE";
- __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(t + (int)(__gen_e_acsl_n_3 - 1))";
- __gen_e_acsl_assert_data_4.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_4.fct = "f";
- __gen_e_acsl_assert_data_4.line = 7;
- __gen_e_acsl_assert_data_4.name = "mem_access";
+ __gen_e_acsl_assert_data_3.blocking = 1;
+ __gen_e_acsl_assert_data_3.kind = "RTE";
+ __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(t + (int)(__gen_e_acsl_n - 1))";
+ __gen_e_acsl_assert_data_3.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_3.fct = "f";
+ __gen_e_acsl_assert_data_3.line = 7;
+ __gen_e_acsl_assert_data_3.name = "mem_access";
__e_acsl_assert(__gen_e_acsl_valid_read_3,
- & __gen_e_acsl_assert_data_4);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
- *(__gen_e_acsl_at_2 + (__gen_e_acsl_n_3 - 2)) = *(t + (__gen_e_acsl_n_3 - 1)) > 5;
+ & __gen_e_acsl_assert_data_3);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
+ *(__gen_e_acsl_at_3 + (__gen_e_acsl_n - 2)) = *(t + (__gen_e_acsl_n - 1)) > 5;
}
- __gen_e_acsl_n_3 ++;
+ __gen_e_acsl_n ++;
}
}
{
@@ -881,28 +875,30 @@ void __gen_e_acsl_f(int *t)
while (1) {
if (__gen_e_acsl_n_2 <= 3) ; else break;
{
- int __gen_e_acsl_valid_read;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
+ int __gen_e_acsl_valid_read_4;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"t",
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"t",
(void *)t);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,
"__gen_e_acsl_n_2",0,__gen_e_acsl_n_2);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(t + __gen_e_acsl_n_2),
- sizeof(int),(void *)t,
- (void *)(& t));
- __gen_e_acsl_assert_data_2.blocking = 1;
- __gen_e_acsl_assert_data_2.kind = "RTE";
- __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(t + __gen_e_acsl_n_2)";
- __gen_e_acsl_assert_data_2.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_2.fct = "f";
- __gen_e_acsl_assert_data_2.line = 7;
- __gen_e_acsl_assert_data_2.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_2);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
- *(__gen_e_acsl_at + (__gen_e_acsl_n_2 - 2)) = *(t + __gen_e_acsl_n_2) == 12;
+ __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(t + __gen_e_acsl_n_2),
+ sizeof(int),
+ (void *)t,
+ (void *)(& t));
+ __gen_e_acsl_assert_data_4.blocking = 1;
+ __gen_e_acsl_assert_data_4.kind = "RTE";
+ __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(t + __gen_e_acsl_n_2)";
+ __gen_e_acsl_assert_data_4.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_4.fct = "f";
+ __gen_e_acsl_assert_data_4.line = 7;
+ __gen_e_acsl_assert_data_4.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_4,
+ & __gen_e_acsl_assert_data_4);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
+ *(__gen_e_acsl_at_4 + (__gen_e_acsl_n_2 - 2)) = *(t + __gen_e_acsl_n_2) == 12;
}
__gen_e_acsl_n_2 ++;
}
@@ -910,69 +906,70 @@ void __gen_e_acsl_f(int *t)
f(t);
{
int __gen_e_acsl_forall;
- int __gen_e_acsl_n;
- int __gen_e_acsl_m;
- int __gen_e_acsl_valid_read_6;
+ int __gen_e_acsl_n_3;
+ int __gen_e_acsl_m_3;
+ int __gen_e_acsl_valid_read_7;
int __gen_e_acsl_and_2;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
+ {.values = (void *)0};
__gen_e_acsl_forall = 1;
- __gen_e_acsl_n = 1 + 1;
+ __gen_e_acsl_n_3 = 1 + 1;
while (1) {
- if (__gen_e_acsl_n <= 3) ; else break;
+ if (__gen_e_acsl_n_3 <= 3) ; else break;
{
- int __gen_e_acsl_valid_read_2;
+ int __gen_e_acsl_valid_read_5;
int __gen_e_acsl_and;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "__gen_e_acsl_at",
- (void *)__gen_e_acsl_at);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
- "__gen_e_acsl_n",0,__gen_e_acsl_n);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,
+ "__gen_e_acsl_at_4",
+ (void *)__gen_e_acsl_at_4);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
+ "__gen_e_acsl_n_3",0,__gen_e_acsl_n_3);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(__gen_e_acsl_at + (int)(
- __gen_e_acsl_n - 2L)),
+ __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_4 + (int)(
+ __gen_e_acsl_n_3 - 2L)),
sizeof(int),
- (void *)__gen_e_acsl_at,
- (void *)(& __gen_e_acsl_at));
- __gen_e_acsl_assert_data_3.blocking = 1;
- __gen_e_acsl_assert_data_3.kind = "RTE";
- __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(__gen_e_acsl_at + (int)(__gen_e_acsl_n - 2))";
- __gen_e_acsl_assert_data_3.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_3.fct = "f";
- __gen_e_acsl_assert_data_3.line = 7;
- __gen_e_acsl_assert_data_3.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_2,
- & __gen_e_acsl_assert_data_3);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
- if (*(__gen_e_acsl_at + (__gen_e_acsl_n - 2))) {
- int __gen_e_acsl_valid_read_4;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
+ (void *)__gen_e_acsl_at_4,
+ (void *)(& __gen_e_acsl_at_4));
+ __gen_e_acsl_assert_data_6.blocking = 1;
+ __gen_e_acsl_assert_data_6.kind = "RTE";
+ __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at_4 + (int)(__gen_e_acsl_n_3 - 2))";
+ __gen_e_acsl_assert_data_6.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_6.fct = "f";
+ __gen_e_acsl_assert_data_6.line = 7;
+ __gen_e_acsl_assert_data_6.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_5,
+ & __gen_e_acsl_assert_data_6);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
+ if (*(__gen_e_acsl_at_4 + (__gen_e_acsl_n_3 - 2))) {
+ int __gen_e_acsl_valid_read_6;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,
- "__gen_e_acsl_at_2",
- (void *)__gen_e_acsl_at_2);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
- "__gen_e_acsl_n",0,__gen_e_acsl_n);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,
+ "__gen_e_acsl_at_3",
+ (void *)__gen_e_acsl_at_3);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
+ "__gen_e_acsl_n_3",0,__gen_e_acsl_n_3);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + (int)(
- __gen_e_acsl_n - 2L)),
+ __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_3 + (int)(
+ __gen_e_acsl_n_3 - 2L)),
sizeof(int),
- (void *)__gen_e_acsl_at_2,
- (void *)(& __gen_e_acsl_at_2));
- __gen_e_acsl_assert_data_5.blocking = 1;
- __gen_e_acsl_assert_data_5.kind = "RTE";
- __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(__gen_e_acsl_at_2 + (int)(__gen_e_acsl_n - 2))";
- __gen_e_acsl_assert_data_5.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_5.fct = "f";
- __gen_e_acsl_assert_data_5.line = 7;
- __gen_e_acsl_assert_data_5.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_4,
- & __gen_e_acsl_assert_data_5);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
- __gen_e_acsl_and = *(__gen_e_acsl_at_2 + (__gen_e_acsl_n - 2));
+ (void *)__gen_e_acsl_at_3,
+ (void *)(& __gen_e_acsl_at_3));
+ __gen_e_acsl_assert_data_7.blocking = 1;
+ __gen_e_acsl_assert_data_7.kind = "RTE";
+ __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(__gen_e_acsl_at_3 + (int)(__gen_e_acsl_n_3 - 2))";
+ __gen_e_acsl_assert_data_7.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_7.fct = "f";
+ __gen_e_acsl_assert_data_7.line = 7;
+ __gen_e_acsl_assert_data_7.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_6,
+ & __gen_e_acsl_assert_data_7);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
+ __gen_e_acsl_and = *(__gen_e_acsl_at_3 + (__gen_e_acsl_n_3 - 2));
}
else __gen_e_acsl_and = 0;
if (__gen_e_acsl_and) ;
@@ -981,65 +978,64 @@ void __gen_e_acsl_f(int *t)
goto e_acsl_end_loop11;
}
}
- __gen_e_acsl_n ++;
+ __gen_e_acsl_n_3 ++;
}
e_acsl_end_loop11: ;
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,
"\\forall integer n;\n 1 < n <= 3 ==> \\old(*(t + n) == 12) && \\old(*(t + (n - 1)) > 5)",
0,__gen_e_acsl_forall);
- __gen_e_acsl_assert_data.blocking = 1;
- __gen_e_acsl_assert_data.kind = "Postcondition";
- __gen_e_acsl_assert_data.pred_txt = "\\forall integer n;\n 1 < n <= 3 ==> \\old(*(t + n) == 12) && \\old(*(t + (n - 1)) > 5)";
- __gen_e_acsl_assert_data.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data.fct = "f";
- __gen_e_acsl_assert_data.line = 6;
- __e_acsl_assert(__gen_e_acsl_forall,& __gen_e_acsl_assert_data);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
+ __gen_e_acsl_assert_data_5.blocking = 1;
+ __gen_e_acsl_assert_data_5.kind = "Postcondition";
+ __gen_e_acsl_assert_data_5.pred_txt = "\\forall integer n;\n 1 < n <= 3 ==> \\old(*(t + n) == 12) && \\old(*(t + (n - 1)) > 5)";
+ __gen_e_acsl_assert_data_5.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_5.fct = "f";
+ __gen_e_acsl_assert_data_5.line = 6;
+ __e_acsl_assert(__gen_e_acsl_forall,& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
{.values = (void *)0};
- __gen_e_acsl_m = 4;
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
+ __gen_e_acsl_m_3 = 4;
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
"\\old(*(t + m) == -4)",0,
- *(__gen_e_acsl_at_3 + 0));
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_8 =
+ *(__gen_e_acsl_at + 0));
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_9 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,
- "__gen_e_acsl_at_3",
- (void *)__gen_e_acsl_at_3);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_8,
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_9,
+ "__gen_e_acsl_at",(void *)__gen_e_acsl_at);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_9,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_3 + 0),
+ __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)(__gen_e_acsl_at + 0),
sizeof(int),
- (void *)__gen_e_acsl_at_3,
- (void *)(& __gen_e_acsl_at_3));
- __gen_e_acsl_assert_data_8.blocking = 1;
- __gen_e_acsl_assert_data_8.kind = "RTE";
- __gen_e_acsl_assert_data_8.pred_txt = "\\valid_read(__gen_e_acsl_at_3 + 0)";
- __gen_e_acsl_assert_data_8.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_8.fct = "f";
- __gen_e_acsl_assert_data_8.line = 8;
- __gen_e_acsl_assert_data_8.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_6,& __gen_e_acsl_assert_data_8);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
- if (*(__gen_e_acsl_at_3 + 0)) {
+ (void *)__gen_e_acsl_at,
+ (void *)(& __gen_e_acsl_at));
+ __gen_e_acsl_assert_data_9.blocking = 1;
+ __gen_e_acsl_assert_data_9.kind = "RTE";
+ __gen_e_acsl_assert_data_9.pred_txt = "\\valid_read(__gen_e_acsl_at + 0)";
+ __gen_e_acsl_assert_data_9.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_9.fct = "f";
+ __gen_e_acsl_assert_data_9.line = 8;
+ __gen_e_acsl_assert_data_9.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_7,& __gen_e_acsl_assert_data_9);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_9);
+ if (*(__gen_e_acsl_at + 0)) {
int __gen_e_acsl_valid_read_8;
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_8,
"\\old(*(t + (m - 4)))",0,
- *(__gen_e_acsl_at_4 + 0));
+ *(__gen_e_acsl_at_2 + 0));
__e_acsl_assert_data_t __gen_e_acsl_assert_data_10 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_10,
- "__gen_e_acsl_at_4",
- (void *)__gen_e_acsl_at_4);
+ "__gen_e_acsl_at_2",
+ (void *)__gen_e_acsl_at_2);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_10,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_4 + 0),
+ __gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)(__gen_e_acsl_at_2 + 0),
sizeof(int),
- (void *)__gen_e_acsl_at_4,
- (void *)(& __gen_e_acsl_at_4));
+ (void *)__gen_e_acsl_at_2,
+ (void *)(& __gen_e_acsl_at_2));
__gen_e_acsl_assert_data_10.blocking = 1;
__gen_e_acsl_assert_data_10.kind = "RTE";
- __gen_e_acsl_assert_data_10.pred_txt = "\\valid_read(__gen_e_acsl_at_4 + 0)";
+ __gen_e_acsl_assert_data_10.pred_txt = "\\valid_read(__gen_e_acsl_at_2 + 0)";
__gen_e_acsl_assert_data_10.file = "at_on-purely-logic-variables.c";
__gen_e_acsl_assert_data_10.fct = "f";
__gen_e_acsl_assert_data_10.line = 8;
@@ -1047,17 +1043,17 @@ void __gen_e_acsl_f(int *t)
__e_acsl_assert(__gen_e_acsl_valid_read_8,
& __gen_e_acsl_assert_data_10);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
- __gen_e_acsl_and_2 = *(__gen_e_acsl_at_4 + 0) == 9;
+ __gen_e_acsl_and_2 = *(__gen_e_acsl_at_2 + 0) == 9;
}
else __gen_e_acsl_and_2 = 0;
- __gen_e_acsl_assert_data_6.blocking = 1;
- __gen_e_acsl_assert_data_6.kind = "Postcondition";
- __gen_e_acsl_assert_data_6.pred_txt = "\\let m = 4; \\old(*(t + m) == -4) && \\old(*(t + (m - 4))) == 9";
- __gen_e_acsl_assert_data_6.file = "at_on-purely-logic-variables.c";
- __gen_e_acsl_assert_data_6.fct = "f";
- __gen_e_acsl_assert_data_6.line = 8;
- __e_acsl_assert(__gen_e_acsl_and_2,& __gen_e_acsl_assert_data_6);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
+ __gen_e_acsl_assert_data_8.blocking = 1;
+ __gen_e_acsl_assert_data_8.kind = "Postcondition";
+ __gen_e_acsl_assert_data_8.pred_txt = "\\let m = 4; \\old(*(t + m) == -4) && \\old(*(t + (m - 4))) == 9";
+ __gen_e_acsl_assert_data_8.file = "at_on-purely-logic-variables.c";
+ __gen_e_acsl_assert_data_8.fct = "f";
+ __gen_e_acsl_assert_data_8.line = 8;
+ __e_acsl_assert(__gen_e_acsl_and_2,& __gen_e_acsl_assert_data_8);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
__e_acsl_delete_block((void *)(& t));
free((void *)__gen_e_acsl_at);
free((void *)__gen_e_acsl_at_2);
diff --git a/src/plugins/e-acsl/tests/arith/oracle/gen_rationals.c b/src/plugins/e-acsl/tests/arith/oracle/gen_rationals.c
index 189169fa1e0f2750dae762e7b894217bf8d20c39..43188869d2bf8a7e6e5d346fb82881ec4d3da6c7 100644
--- a/src/plugins/e-acsl/tests/arith/oracle/gen_rationals.c
+++ b/src/plugins/e-acsl/tests/arith/oracle/gen_rationals.c
@@ -359,13 +359,13 @@ double __gen_e_acsl_avg(double a, double b)
double __gen_e_acsl_at_2;
__e_acsl_mpq_t __gen_e_acsl_at;
double __retres;
- __gen_e_acsl_at_2 = b;
{
__e_acsl_mpq_t __gen_e_acsl_a;
__gmpq_init(__gen_e_acsl_a);
__gmpq_set_d(__gen_e_acsl_a,a);
__gmpq_init(__gen_e_acsl_at);
__gmpq_set(__gen_e_acsl_at,(__e_acsl_mpq_struct const *)(__gen_e_acsl_a));
+ __gen_e_acsl_at_2 = b;
__gmpq_clear(__gen_e_acsl_a);
}
__retres = avg(a,b);
diff --git a/src/plugins/e-acsl/tests/bts/oracle/bts1326.res.oracle b/src/plugins/e-acsl/tests/bts/oracle/bts1326.res.oracle
index d5361e3ccbbb4ef402631986d176a91a4be87235..a543c032c6949039fe14b58bc4bee8bc2f83d561 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/bts1326.res.oracle
+++ b/src/plugins/e-acsl/tests/bts/oracle/bts1326.res.oracle
@@ -18,6 +18,6 @@
[eva:alarm] bts1326.i:8: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] :0: Warning:
+[eva:alarm] bts1326.i:8: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
diff --git a/src/plugins/e-acsl/tests/bts/oracle/gen_bts1307.c b/src/plugins/e-acsl/tests/bts/oracle/gen_bts1307.c
index 4683310c7c5aa6cb601f118d1a34e10cecb0c3e4..d88f9586db8b11110e08dd704a21edac2a41f861 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/gen_bts1307.c
+++ b/src/plugins/e-acsl/tests/bts/oracle/gen_bts1307.c
@@ -95,13 +95,10 @@ int main(void)
*/
void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
{
- float *__gen_e_acsl_at_6;
- float *__gen_e_acsl_at_5;
- float *__gen_e_acsl_at_4;
+ __e_acsl_contract_t *__gen_e_acsl_contract;
float *__gen_e_acsl_at_3;
float *__gen_e_acsl_at_2;
float *__gen_e_acsl_at;
- __e_acsl_contract_t *__gen_e_acsl_contract;
{
int __gen_e_acsl_valid;
int __gen_e_acsl_valid_2;
@@ -109,6 +106,9 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
__e_acsl_store_block((void *)(& Mtmin_out),(size_t)8);
__e_acsl_store_block((void *)(& Mwmin),(size_t)8);
__e_acsl_store_block((void *)(& Mtmin_in),(size_t)8);
+ __gen_e_acsl_at = Mtmin_in;
+ __gen_e_acsl_at_2 = Mwmin;
+ __gen_e_acsl_at_3 = Mtmin_out;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)1);
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"Mtmin_in",
@@ -167,12 +167,6 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,1);
}
- __gen_e_acsl_at_6 = Mwmin;
- __gen_e_acsl_at_5 = Mtmin_in;
- __gen_e_acsl_at_4 = Mwmin;
- __gen_e_acsl_at_3 = Mtmin_in;
- __gen_e_acsl_at_2 = Mtmin_in;
- __gen_e_acsl_at = Mtmin_out;
bar(Mtmin_in,Mwmin,Mtmin_out);
{
int __gen_e_acsl_assumes_value;
@@ -186,23 +180,22 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mtmin_out)",*__gen_e_acsl_at);
+ "*\\old(Mtmin_out)",*__gen_e_acsl_at_3);
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mtmin_in)",*__gen_e_acsl_at_2);
+ "*\\old(Mtmin_in)",*__gen_e_acsl_at);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,
- "__gen_e_acsl_at_2",
- (void *)__gen_e_acsl_at_2);
+ "__gen_e_acsl_at",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
"sizeof(float)",0,sizeof(float));
- __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)__gen_e_acsl_at,
sizeof(float),
- (void *)__gen_e_acsl_at_2,
- (void *)(& __gen_e_acsl_at_2));
+ (void *)__gen_e_acsl_at,
+ (void *)(& __gen_e_acsl_at));
__gen_e_acsl_assert_data_5.blocking = 1;
__gen_e_acsl_assert_data_5.kind = "RTE";
- __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(__gen_e_acsl_at_2)";
+ __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(__gen_e_acsl_at)";
__gen_e_acsl_assert_data_5.file = "bts1307.i";
__gen_e_acsl_assert_data_5.fct = "bar";
__gen_e_acsl_assert_data_5.line = 26;
@@ -212,42 +205,43 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
__e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,
- "__gen_e_acsl_at",(void *)__gen_e_acsl_at);
+ "__gen_e_acsl_at_3",
+ (void *)__gen_e_acsl_at_3);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
"sizeof(float)",0,sizeof(float));
- __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)__gen_e_acsl_at,
+ __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)__gen_e_acsl_at_3,
sizeof(float),
- (void *)__gen_e_acsl_at,
- (void *)(& __gen_e_acsl_at));
+ (void *)__gen_e_acsl_at_3,
+ (void *)(& __gen_e_acsl_at_3));
__gen_e_acsl_assert_data_6.blocking = 1;
__gen_e_acsl_assert_data_6.kind = "RTE";
- __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at)";
+ __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(__gen_e_acsl_at_3)";
__gen_e_acsl_assert_data_6.file = "bts1307.i";
__gen_e_acsl_assert_data_6.fct = "bar";
__gen_e_acsl_assert_data_6.line = 26;
__gen_e_acsl_assert_data_6.name = "mem_access";
__e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_6);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
- if (*__gen_e_acsl_at == *__gen_e_acsl_at_2) {
+ if (*__gen_e_acsl_at_3 == *__gen_e_acsl_at) {
__e_acsl_mpq_t __gen_e_acsl_;
__e_acsl_mpq_t __gen_e_acsl__2;
__e_acsl_mpq_t __gen_e_acsl_mul;
__e_acsl_mpq_t __gen_e_acsl__3;
int __gen_e_acsl_lt;
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mtmin_in)",*__gen_e_acsl_at_3);
+ "*\\old(Mtmin_in)",*__gen_e_acsl_at);
__gmpq_init(__gen_e_acsl_);
__gmpq_set_str(__gen_e_acsl_,"085/100",10);
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mwmin)",*__gen_e_acsl_at_4);
+ "*\\old(Mwmin)",*__gen_e_acsl_at_2);
__gmpq_init(__gen_e_acsl__2);
- __gmpq_set_d(__gen_e_acsl__2,(double)*__gen_e_acsl_at_4);
+ __gmpq_set_d(__gen_e_acsl__2,(double)*__gen_e_acsl_at_2);
__gmpq_init(__gen_e_acsl_mul);
__gmpq_mul(__gen_e_acsl_mul,
(__e_acsl_mpq_struct const *)(__gen_e_acsl_),
(__e_acsl_mpq_struct const *)(__gen_e_acsl__2));
__gmpq_init(__gen_e_acsl__3);
- __gmpq_set_d(__gen_e_acsl__3,(double)*__gen_e_acsl_at_3);
+ __gmpq_set_d(__gen_e_acsl__3,(double)*__gen_e_acsl_at);
__gen_e_acsl_lt = __gmpq_cmp((__e_acsl_mpq_struct const *)(__gen_e_acsl__3),
(__e_acsl_mpq_struct const *)(__gen_e_acsl_mul));
__gen_e_acsl_and = __gen_e_acsl_lt < 0;
@@ -260,21 +254,21 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
if (__gen_e_acsl_and) {
int __gen_e_acsl_valid_read_3;
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mtmin_in)",*__gen_e_acsl_at_5);
+ "*\\old(Mtmin_in)",*__gen_e_acsl_at);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,
- "__gen_e_acsl_at_5",
- (void *)__gen_e_acsl_at_5);
+ "__gen_e_acsl_at",
+ (void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
"sizeof(float)",0,sizeof(float));
- __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)__gen_e_acsl_at_5,
+ __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)__gen_e_acsl_at,
sizeof(float),
- (void *)__gen_e_acsl_at_5,
- (void *)(& __gen_e_acsl_at_5));
+ (void *)__gen_e_acsl_at,
+ (void *)(& __gen_e_acsl_at));
__gen_e_acsl_assert_data_7.blocking = 1;
__gen_e_acsl_assert_data_7.kind = "RTE";
- __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(__gen_e_acsl_at_5)";
+ __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(__gen_e_acsl_at)";
__gen_e_acsl_assert_data_7.file = "bts1307.i";
__gen_e_acsl_assert_data_7.fct = "bar";
__gen_e_acsl_assert_data_7.line = 26;
@@ -282,7 +276,7 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
__e_acsl_assert(__gen_e_acsl_valid_read_3,
& __gen_e_acsl_assert_data_7);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
- __gen_e_acsl_if = (double)*__gen_e_acsl_at_5 != 0.;
+ __gen_e_acsl_if = (double)*__gen_e_acsl_at != 0.;
}
else {
__e_acsl_mpq_t __gen_e_acsl__4;
@@ -293,9 +287,9 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
__gmpq_init(__gen_e_acsl__4);
__gmpq_set_str(__gen_e_acsl__4,"085/100",10);
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mwmin)",*__gen_e_acsl_at_6);
+ "*\\old(Mwmin)",*__gen_e_acsl_at_2);
__gmpq_init(__gen_e_acsl__5);
- __gmpq_set_d(__gen_e_acsl__5,(double)*__gen_e_acsl_at_6);
+ __gmpq_set_d(__gen_e_acsl__5,(double)*__gen_e_acsl_at_2);
__gmpq_init(__gen_e_acsl_mul_2);
__gmpq_mul(__gen_e_acsl_mul_2,
(__e_acsl_mpq_struct const *)(__gen_e_acsl__4),
@@ -340,10 +334,10 @@ void __gen_e_acsl_bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out)
*/
void __gen_e_acsl_foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out)
{
+ __e_acsl_contract_t *__gen_e_acsl_contract;
float *__gen_e_acsl_at_3;
float *__gen_e_acsl_at_2;
float *__gen_e_acsl_at;
- __e_acsl_contract_t *__gen_e_acsl_contract;
{
int __gen_e_acsl_valid;
int __gen_e_acsl_valid_2;
@@ -351,6 +345,9 @@ void __gen_e_acsl_foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out)
__e_acsl_store_block((void *)(& Mtmax_out),(size_t)8);
__e_acsl_store_block((void *)(& Mwmax),(size_t)8);
__e_acsl_store_block((void *)(& Mtmax_in),(size_t)8);
+ __gen_e_acsl_at = Mtmax_in;
+ __gen_e_acsl_at_2 = Mwmax;
+ __gen_e_acsl_at_3 = Mtmax_out;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)1);
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"Mtmax_in",
@@ -409,9 +406,6 @@ void __gen_e_acsl_foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,1);
}
- __gen_e_acsl_at_3 = Mwmax;
- __gen_e_acsl_at_2 = Mtmax_in;
- __gen_e_acsl_at = Mtmax_out;
foo(Mtmax_in,Mwmax,Mtmax_out);
{
int __gen_e_acsl_assumes_value;
@@ -434,9 +428,9 @@ void __gen_e_acsl_foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out)
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mtmax_out)",*__gen_e_acsl_at);
+ "*\\old(Mtmax_out)",*__gen_e_acsl_at_3);
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mtmax_in)",*__gen_e_acsl_at_2);
+ "*\\old(Mtmax_in)",*__gen_e_acsl_at);
__gmpq_init(__gen_e_acsl_);
__gmpq_set_str(__gen_e_acsl_,"5",10);
__gmpq_init(__gen_e_acsl__2);
@@ -448,9 +442,9 @@ void __gen_e_acsl_foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out)
(__e_acsl_mpq_struct const *)(__gen_e_acsl__2),
(__e_acsl_mpq_struct const *)(__gen_e_acsl__3));
__e_acsl_assert_register_float(& __gen_e_acsl_assert_data_4,
- "*\\old(Mwmax)",*__gen_e_acsl_at_3);
+ "*\\old(Mwmax)",*__gen_e_acsl_at_2);
__gmpq_init(__gen_e_acsl__4);
- __gmpq_set_d(__gen_e_acsl__4,(double)*__gen_e_acsl_at_3);
+ __gmpq_set_d(__gen_e_acsl__4,(double)*__gen_e_acsl_at_2);
__gmpq_init(__gen_e_acsl_mul);
__gmpq_mul(__gen_e_acsl_mul,
(__e_acsl_mpq_struct const *)(__gen_e_acsl_div),
@@ -466,13 +460,13 @@ void __gen_e_acsl_foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out)
(__e_acsl_mpq_struct const *)(__gen_e_acsl_),
(__e_acsl_mpq_struct const *)(__gen_e_acsl_mul_2));
__gmpq_init(__gen_e_acsl__6);
- __gmpq_set_d(__gen_e_acsl__6,(double)*__gen_e_acsl_at_2);
+ __gmpq_set_d(__gen_e_acsl__6,(double)*__gen_e_acsl_at);
__gmpq_init(__gen_e_acsl_add);
__gmpq_add(__gen_e_acsl_add,
(__e_acsl_mpq_struct const *)(__gen_e_acsl__6),
(__e_acsl_mpq_struct const *)(__gen_e_acsl_sub));
__gmpq_init(__gen_e_acsl__7);
- __gmpq_set_d(__gen_e_acsl__7,(double)*__gen_e_acsl_at);
+ __gmpq_set_d(__gen_e_acsl__7,(double)*__gen_e_acsl_at_3);
__gen_e_acsl_ne = __gmpq_cmp((__e_acsl_mpq_struct const *)(__gen_e_acsl__7),
(__e_acsl_mpq_struct const *)(__gen_e_acsl_add));
__gen_e_acsl_assert_data_4.blocking = 1;
diff --git a/src/plugins/e-acsl/tests/bts/oracle/gen_bts1326.c b/src/plugins/e-acsl/tests/bts/oracle/gen_bts1326.c
index e48c777bf33ec8b67b026477260fdad73930a82d..0e7391910046bb16db211d8452a20138dcd04a7c 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/gen_bts1326.c
+++ b/src/plugins/e-acsl/tests/bts/oracle/gen_bts1326.c
@@ -57,20 +57,12 @@ int main(void)
void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
int *AverageAccel)
{
- ArrayInt *__gen_e_acsl_at_6;
- ArrayInt *__gen_e_acsl_at_5;
- ArrayInt *__gen_e_acsl_at_4;
- ArrayInt *__gen_e_acsl_at_3;
- ArrayInt *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
+ int *__gen_e_acsl_at_2;
+ ArrayInt *__gen_e_acsl_at;
__e_acsl_store_block((void *)(& AverageAccel),(size_t)8);
__e_acsl_store_block((void *)(& Accel),(size_t)8);
- __gen_e_acsl_at_6 = Accel;
- __gen_e_acsl_at_5 = Accel;
- __gen_e_acsl_at_4 = Accel;
- __gen_e_acsl_at_3 = Accel;
- __gen_e_acsl_at_2 = Accel;
- __gen_e_acsl_at = AverageAccel;
+ __gen_e_acsl_at = Accel;
+ __gen_e_acsl_at_2 = AverageAccel;
atp_NORMAL_computeAverageAccel(Accel,AverageAccel);
{
int __gen_e_acsl_valid_read;
@@ -81,36 +73,36 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
int __gen_e_acsl_valid_read_6;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
- "*\\old(AverageAccel)",0,*__gen_e_acsl_at);
+ "*\\old(AverageAccel)",0,*__gen_e_acsl_at_2);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"(*\\old(Accel))[4]",0,
- (*__gen_e_acsl_at_2)[4]);
+ (*__gen_e_acsl_at)[4]);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"(*\\old(Accel))[3]",0,
- (*__gen_e_acsl_at_3)[3]);
+ (*__gen_e_acsl_at)[3]);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"(*\\old(Accel))[2]",0,
- (*__gen_e_acsl_at_4)[2]);
+ (*__gen_e_acsl_at)[2]);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"(*\\old(Accel))[1]",0,
- (*__gen_e_acsl_at_5)[1]);
+ (*__gen_e_acsl_at)[1]);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"(*\\old(Accel))[0]",0,
- (*__gen_e_acsl_at_6)[0]);
+ (*__gen_e_acsl_at)[0]);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,
- "(int *)*__gen_e_acsl_at_6",
- (void *)(*__gen_e_acsl_at_6));
+ "(int *)*__gen_e_acsl_at",
+ (void *)(*__gen_e_acsl_at));
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(*__gen_e_acsl_at_6),
+ __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(*__gen_e_acsl_at),
sizeof(int),
- (void *)(*__gen_e_acsl_at_6),
+ (void *)(*__gen_e_acsl_at),
(void *)0);
__gen_e_acsl_assert_data_2.blocking = 1;
__gen_e_acsl_assert_data_2.kind = "RTE";
- __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read((int *)*__gen_e_acsl_at_6)";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read((int *)*__gen_e_acsl_at)";
__gen_e_acsl_assert_data_2.file = "bts1326.i";
__gen_e_acsl_assert_data_2.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data_2.line = 8;
@@ -120,17 +112,17 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "&(*__gen_e_acsl_at_5)[1]",
- (void *)(& (*__gen_e_acsl_at_5)[1]));
+ "&(*__gen_e_acsl_at)[1]",
+ (void *)(& (*__gen_e_acsl_at)[1]));
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_5)[1]),
+ __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at)[1]),
sizeof(int),
- (void *)(*__gen_e_acsl_at_5),
+ (void *)(*__gen_e_acsl_at),
(void *)0);
__gen_e_acsl_assert_data_3.blocking = 1;
__gen_e_acsl_assert_data_3.kind = "RTE";
- __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(&(*__gen_e_acsl_at_5)[1])";
+ __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(&(*__gen_e_acsl_at)[1])";
__gen_e_acsl_assert_data_3.file = "bts1326.i";
__gen_e_acsl_assert_data_3.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data_3.line = 8;
@@ -140,17 +132,17 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,
- "&(*__gen_e_acsl_at_4)[2]",
- (void *)(& (*__gen_e_acsl_at_4)[2]));
+ "&(*__gen_e_acsl_at)[2]",
+ (void *)(& (*__gen_e_acsl_at)[2]));
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_4)[2]),
+ __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at)[2]),
sizeof(int),
- (void *)(*__gen_e_acsl_at_4),
+ (void *)(*__gen_e_acsl_at),
(void *)0);
__gen_e_acsl_assert_data_4.blocking = 1;
__gen_e_acsl_assert_data_4.kind = "RTE";
- __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(&(*__gen_e_acsl_at_4)[2])";
+ __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(&(*__gen_e_acsl_at)[2])";
__gen_e_acsl_assert_data_4.file = "bts1326.i";
__gen_e_acsl_assert_data_4.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data_4.line = 8;
@@ -160,17 +152,17 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,
- "&(*__gen_e_acsl_at_3)[3]",
- (void *)(& (*__gen_e_acsl_at_3)[3]));
+ "&(*__gen_e_acsl_at)[3]",
+ (void *)(& (*__gen_e_acsl_at)[3]));
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_3)[3]),
+ __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at)[3]),
sizeof(int),
- (void *)(*__gen_e_acsl_at_3),
+ (void *)(*__gen_e_acsl_at),
(void *)0);
__gen_e_acsl_assert_data_5.blocking = 1;
__gen_e_acsl_assert_data_5.kind = "RTE";
- __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(&(*__gen_e_acsl_at_3)[3])";
+ __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(&(*__gen_e_acsl_at)[3])";
__gen_e_acsl_assert_data_5.file = "bts1326.i";
__gen_e_acsl_assert_data_5.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data_5.line = 8;
@@ -180,17 +172,17 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,
- "&(*__gen_e_acsl_at_2)[4]",
- (void *)(& (*__gen_e_acsl_at_2)[4]));
+ "&(*__gen_e_acsl_at)[4]",
+ (void *)(& (*__gen_e_acsl_at)[4]));
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_6,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_2)[4]),
+ __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at)[4]),
sizeof(int),
- (void *)(*__gen_e_acsl_at_2),
+ (void *)(*__gen_e_acsl_at),
(void *)0);
__gen_e_acsl_assert_data_6.blocking = 1;
__gen_e_acsl_assert_data_6.kind = "RTE";
- __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(&(*__gen_e_acsl_at_2)[4])";
+ __gen_e_acsl_assert_data_6.pred_txt = "\\valid_read(&(*__gen_e_acsl_at)[4])";
__gen_e_acsl_assert_data_6.file = "bts1326.i";
__gen_e_acsl_assert_data_6.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data_6.line = 8;
@@ -200,16 +192,17 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,
- "__gen_e_acsl_at",(void *)__gen_e_acsl_at);
+ "__gen_e_acsl_at_2",
+ (void *)__gen_e_acsl_at_2);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_7,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)__gen_e_acsl_at,
+ __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)__gen_e_acsl_at_2,
sizeof(int),
- (void *)__gen_e_acsl_at,
- (void *)(& __gen_e_acsl_at));
+ (void *)__gen_e_acsl_at_2,
+ (void *)(& __gen_e_acsl_at_2));
__gen_e_acsl_assert_data_7.blocking = 1;
__gen_e_acsl_assert_data_7.kind = "RTE";
- __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(__gen_e_acsl_at)";
+ __gen_e_acsl_assert_data_7.pred_txt = "\\valid_read(__gen_e_acsl_at_2)";
__gen_e_acsl_assert_data_7.file = "bts1326.i";
__gen_e_acsl_assert_data_7.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data_7.line = 8;
@@ -222,7 +215,7 @@ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel,
__gen_e_acsl_assert_data.file = "bts1326.i";
__gen_e_acsl_assert_data.fct = "atp_NORMAL_computeAverageAccel";
__gen_e_acsl_assert_data.line = 8;
- __e_acsl_assert(*__gen_e_acsl_at == (int)((((((*__gen_e_acsl_at_2)[4] + (long)(*__gen_e_acsl_at_3)[3]) + (*__gen_e_acsl_at_4)[2]) + (*__gen_e_acsl_at_5)[1]) + (*__gen_e_acsl_at_6)[0]) / 5L),
+ __e_acsl_assert(*__gen_e_acsl_at_2 == (int)((((((*__gen_e_acsl_at)[4] + (long)(*__gen_e_acsl_at)[3]) + (*__gen_e_acsl_at)[2]) + (*__gen_e_acsl_at)[1]) + (*__gen_e_acsl_at)[0]) / 5L),
& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
__e_acsl_delete_block((void *)(& AverageAccel));
diff --git a/src/plugins/e-acsl/tests/bts/oracle/gen_bts1390.c b/src/plugins/e-acsl/tests/bts/oracle/gen_bts1390.c
index 18254b245ea74905f0a1daf93f8bc1869b91ae03..1626dbd4ea419ee09b6a1d48eedcacd2f584b7df 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/gen_bts1390.c
+++ b/src/plugins/e-acsl/tests/bts/oracle/gen_bts1390.c
@@ -70,9 +70,9 @@ void *memchr(void const *buf, int c, size_t n)
*/
void *__gen_e_acsl_memchr(void const *buf, int c, size_t n)
{
+ __e_acsl_contract_t *__gen_e_acsl_contract;
int __gen_e_acsl_at_2;
void const *__gen_e_acsl_at;
- __e_acsl_contract_t *__gen_e_acsl_contract;
void *__retres;
__e_acsl_store_block((void *)(& __retres),(size_t)8);
{
@@ -81,6 +81,8 @@ void *__gen_e_acsl_memchr(void const *buf, int c, size_t n)
int __gen_e_acsl_forall;
unsigned int __gen_e_acsl_k;
__e_acsl_store_block((void *)(& buf),(size_t)8);
+ __gen_e_acsl_at = buf;
+ __gen_e_acsl_at_2 = c;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__gen_e_acsl_exists = 0;
__gen_e_acsl_i = 0U;
@@ -162,8 +164,6 @@ void *__gen_e_acsl_memchr(void const *buf, int c, size_t n)
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)1,
__gen_e_acsl_forall);
}
- __gen_e_acsl_at_2 = c;
- __gen_e_acsl_at = buf;
__retres = memchr(buf,c,n);
{
int __gen_e_acsl_assumes_value;
diff --git a/src/plugins/e-acsl/tests/bts/oracle/gen_bts2252.c b/src/plugins/e-acsl/tests/bts/oracle/gen_bts2252.c
index 3b16a3b2a4bfd4764b7766b41ff34b7858988009..fbedbcc8e9c436959dea0e2e4eb241ed4452f867 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/gen_bts2252.c
+++ b/src/plugins/e-acsl/tests/bts/oracle/gen_bts2252.c
@@ -53,14 +53,14 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
size_t n)
{
- __e_acsl_mpz_t __gen_e_acsl_at_3;
- char *__gen_e_acsl_at_2;
- char *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ __e_acsl_mpz_t __gen_e_acsl_at_2;
+ char *__gen_e_acsl_at;
char *__retres;
{
- unsigned long __gen_e_acsl_size;
__e_acsl_mpz_t __gen_e_acsl_n;
+ unsigned long __gen_e_acsl_size;
+ __e_acsl_mpz_t __gen_e_acsl_n_2;
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl_sub;
__e_acsl_mpz_t __gen_e_acsl__2;
@@ -86,6 +86,10 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
int __gen_e_acsl_separated;
__e_acsl_store_block((void *)(& src),(size_t)8);
__e_acsl_store_block((void *)(& dest),(size_t)8);
+ __gen_e_acsl_at = dest;
+ __gmpz_init_set_ui(__gen_e_acsl_n,n);
+ __gmpz_init_set(__gen_e_acsl_at_2,
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_n));
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
@@ -96,11 +100,11 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"sizeof(char)",
0,1);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,"n",0,n);
- __gmpz_init_set_ui(__gen_e_acsl_n,n);
+ __gmpz_init_set_ui(__gen_e_acsl_n_2,n);
__gmpz_init_set_si(__gen_e_acsl_,1L);
__gmpz_init(__gen_e_acsl_sub);
__gmpz_sub(__gen_e_acsl_sub,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_n),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_n_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_));
__gmpz_init_set_si(__gen_e_acsl__2,0L);
__gmpz_init(__gen_e_acsl_sub_2);
@@ -253,21 +257,13 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__e_acsl_assert(__gen_e_acsl_separated,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__gmpz_clear(__gen_e_acsl_n);
+ __gmpz_clear(__gen_e_acsl_n_2);
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl_sub);
__gmpz_clear(__gen_e_acsl__2);
__gmpz_clear(__gen_e_acsl_sub_2);
__gmpz_clear(__gen_e_acsl_add);
}
- {
- __e_acsl_mpz_t __gen_e_acsl_n_2;
- __gmpz_init_set_ui(__gen_e_acsl_n_2,n);
- __gmpz_init_set(__gen_e_acsl_at_3,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_n_2));
- __gmpz_clear(__gen_e_acsl_n_2);
- }
- __gen_e_acsl_at_2 = dest;
- __gen_e_acsl_at = dest;
__retres = strncpy(dest,src,n);
__e_acsl_initialize((void *)dest,n);
{
@@ -298,17 +294,17 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,"\\old(dest)",
- (void *)__gen_e_acsl_at_2);
+ (void *)__gen_e_acsl_at);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"sizeof(char)",
0,1);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"sizeof(char)",
0,1);
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_7,"\\old(n)",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
__gmpz_init_set_si(__gen_e_acsl__8,1L);
__gmpz_init(__gen_e_acsl_sub_3);
__gmpz_sub(__gen_e_acsl_sub_3,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__8));
__gmpz_init_set_si(__gen_e_acsl__9,0L);
__gmpz_init(__gen_e_acsl_sub_4);
@@ -329,7 +325,7 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__gen_e_acsl_size_6);
__gen_e_acsl_if_6 = __gen_e_acsl_size_6;
}
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)(__gen_e_acsl_at_2 +
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)(__gen_e_acsl_at +
1 * 0),
__gen_e_acsl_if_6);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
@@ -352,7 +348,7 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__gmpz_clear(__gen_e_acsl__9);
__gmpz_clear(__gen_e_acsl_sub_4);
__gmpz_clear(__gen_e_acsl_add_2);
- __gmpz_clear(__gen_e_acsl_at_3);
+ __gmpz_clear(__gen_e_acsl_at_2);
return __retres;
}
}
diff --git a/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-139.c b/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-139.c
index a6466bb5a4cd839f0ff014b89c0080609e9786e8..7bccd9add2462a018e73403d29cc190b08992e8a 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-139.c
+++ b/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-139.c
@@ -40,31 +40,30 @@ void __gen_e_acsl_f(struct X *item)
{
struct X __gen_e_acsl_at_2;
struct X *__gen_e_acsl_at;
- __e_acsl_store_block((void *)(& item),(size_t)8);
{
int __gen_e_acsl_valid_read;
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
- {.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"item",
+ __e_acsl_store_block((void *)(& item),(size_t)8);
+ __gen_e_acsl_at = item;
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"item",
(void *)item);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,
"sizeof(struct X)",0,sizeof(struct X));
__gen_e_acsl_valid_read = __e_acsl_valid_read((void *)item,
sizeof(struct X),
(void *)item,
(void *)(& item));
- __gen_e_acsl_assert_data_2.blocking = 1;
- __gen_e_acsl_assert_data_2.kind = "RTE";
- __gen_e_acsl_assert_data_2.pred_txt = "\\valid_read(item)";
- __gen_e_acsl_assert_data_2.file = "issue-eacsl-139.c";
- __gen_e_acsl_assert_data_2.fct = "f";
- __gen_e_acsl_assert_data_2.line = 9;
- __gen_e_acsl_assert_data_2.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_2);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
+ __gen_e_acsl_assert_data.blocking = 1;
+ __gen_e_acsl_assert_data.kind = "RTE";
+ __gen_e_acsl_assert_data.pred_txt = "\\valid_read(item)";
+ __gen_e_acsl_assert_data.file = "issue-eacsl-139.c";
+ __gen_e_acsl_assert_data.fct = "f";
+ __gen_e_acsl_assert_data.line = 9;
+ __gen_e_acsl_assert_data.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data);
__gen_e_acsl_at_2 = *item;
}
- __gen_e_acsl_at = item;
f(item);
__e_acsl_delete_block((void *)(& item));
return;
diff --git a/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-40.c b/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-40.c
index 3e8074f9776e02e075d00ab8e2519445cb3f1f3b..aecdee5351dadcd56fe95c8c4748633747def547 100644
--- a/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-40.c
+++ b/src/plugins/e-acsl/tests/bts/oracle/gen_issue-eacsl-40.c
@@ -55,15 +55,16 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
FILE * restrict stream)
{
- __e_acsl_mpz_t __gen_e_acsl_at_3;
- void *__gen_e_acsl_at_2;
- size_t __gen_e_acsl_at;
+ size_t __gen_e_acsl_at_3;
+ __e_acsl_mpz_t __gen_e_acsl_at_2;
+ void *__gen_e_acsl_at;
size_t __retres;
{
__e_acsl_mpz_t __gen_e_acsl_size;
+ __e_acsl_mpz_t __gen_e_acsl_size_2;
__e_acsl_mpz_t __gen_e_acsl_sizeof;
__e_acsl_mpz_t __gen_e_acsl_nmemb;
- __e_acsl_mpz_t __gen_e_acsl_size_2;
+ __e_acsl_mpz_t __gen_e_acsl_size_3;
__e_acsl_mpz_t __gen_e_acsl_mul;
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl_sub;
@@ -75,11 +76,16 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_mpz_t __gen_e_acsl_if;
__e_acsl_mpz_t __gen_e_acsl__4;
int __gen_e_acsl_le_2;
- unsigned long __gen_e_acsl_size_3;
+ unsigned long __gen_e_acsl_size_4;
int __gen_e_acsl_valid;
int __gen_e_acsl_valid_2;
__e_acsl_store_block((void *)(& stream),(size_t)8);
__e_acsl_store_block((void *)(& ptr),(size_t)8);
+ __gen_e_acsl_at = ptr;
+ __gmpz_init_set_ui(__gen_e_acsl_size,size);
+ __gmpz_init_set(__gen_e_acsl_at_2,
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ __gen_e_acsl_at_3 = nmemb;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"ptr",ptr);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(char)",0,
@@ -91,11 +97,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
nmemb);
__gmpz_init_set_ui(__gen_e_acsl_nmemb,nmemb);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,"size",0,size);
- __gmpz_init_set_ui(__gen_e_acsl_size_2,size);
+ __gmpz_init_set_ui(__gen_e_acsl_size_3,size);
__gmpz_init(__gen_e_acsl_mul);
__gmpz_mul(__gen_e_acsl_mul,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_nmemb),
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_3));
__gmpz_init_set_si(__gen_e_acsl_,1L);
__gmpz_init(__gen_e_acsl_sub);
__gmpz_sub(__gen_e_acsl_sub,
@@ -114,11 +120,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_mul(__gen_e_acsl_mul_2,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
- __gmpz_init_set(__gen_e_acsl_size,
+ __gmpz_init_set(__gen_e_acsl_size_2,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_2));
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
- __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
+ __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
if (__gen_e_acsl_le <= 0) {
__e_acsl_mpz_t __gen_e_acsl__3;
@@ -129,9 +135,9 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
}
else {
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
__gmpz_init_set(__gen_e_acsl_if,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
}
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
@@ -153,9 +159,9 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gen_e_acsl_assert_data_2.name = "offset_lesser_or_eq_than_SIZE_MAX";
__e_acsl_assert(__gen_e_acsl_le_2 <= 0,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
- __gen_e_acsl_size_3 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
+ __gen_e_acsl_size_4 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
__gen_e_acsl_valid = __e_acsl_valid((void *)((char *)ptr + 1 * 0),
- __gen_e_acsl_size_3,ptr,
+ __gen_e_acsl_size_4,ptr,
(void *)(& ptr));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"valid_ptr_block: \\valid((char *)ptr + (0 .. nmemb * size - 1))",
@@ -189,9 +195,10 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert(__gen_e_acsl_valid_2,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__gmpz_clear(__gen_e_acsl_size);
+ __gmpz_clear(__gen_e_acsl_size_2);
__gmpz_clear(__gen_e_acsl_sizeof);
__gmpz_clear(__gen_e_acsl_nmemb);
- __gmpz_clear(__gen_e_acsl_size_2);
+ __gmpz_clear(__gen_e_acsl_size_3);
__gmpz_clear(__gen_e_acsl_mul);
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl_sub);
@@ -202,23 +209,14 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_clear(__gen_e_acsl_if);
__gmpz_clear(__gen_e_acsl__4);
}
- {
- __e_acsl_mpz_t __gen_e_acsl_size_7;
- __gmpz_init_set_ui(__gen_e_acsl_size_7,size);
- __gmpz_init_set(__gen_e_acsl_at_3,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
- __gmpz_clear(__gen_e_acsl_size_7);
- }
- __gen_e_acsl_at_2 = ptr;
- __gen_e_acsl_at = nmemb;
__retres = fread(ptr,size,nmemb,stream);
{
__e_acsl_mpz_t __gen_e_acsl___retres;
- __e_acsl_mpz_t __gen_e_acsl_size_4;
+ __e_acsl_mpz_t __gen_e_acsl_size_5;
__e_acsl_mpz_t __gen_e_acsl_mul_3;
__e_acsl_mpz_t __gen_e_acsl__5;
int __gen_e_acsl_le_3;
- unsigned long __gen_e_acsl_size_5;
+ unsigned long __gen_e_acsl_size_6;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,"__retres",0,
@@ -226,11 +224,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_init_set_ui(__gen_e_acsl___retres,__retres);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,"size",0,
size);
- __gmpz_init_set_ui(__gen_e_acsl_size_4,size);
+ __gmpz_init_set_ui(__gen_e_acsl_size_5,size);
__gmpz_init(__gen_e_acsl_mul_3);
__gmpz_mul(__gen_e_acsl_mul_3,
(__e_acsl_mpz_struct const *)(__gen_e_acsl___retres),
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_4));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
__gmpz_init_set_ui(__gen_e_acsl__5,18446744073709551615UL);
__gen_e_acsl_le_3 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_3),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__5));
@@ -243,15 +241,15 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gen_e_acsl_assert_data_4.name = "size_lesser_or_eq_than_SIZE_MAX";
__e_acsl_assert(__gen_e_acsl_le_3 <= 0,& __gen_e_acsl_assert_data_4);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
- __gen_e_acsl_size_5 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_3));
- __e_acsl_initialize(ptr,__gen_e_acsl_size_5);
+ __gen_e_acsl_size_6 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_3));
+ __e_acsl_initialize(ptr,__gen_e_acsl_size_6);
__gmpz_clear(__gen_e_acsl___retres);
- __gmpz_clear(__gen_e_acsl_size_4);
+ __gmpz_clear(__gen_e_acsl_size_5);
__gmpz_clear(__gen_e_acsl_mul_3);
__gmpz_clear(__gen_e_acsl__5);
}
{
- __e_acsl_mpz_t __gen_e_acsl_size_6;
+ __e_acsl_mpz_t __gen_e_acsl_size_7;
__e_acsl_mpz_t __gen_e_acsl_sizeof_2;
__e_acsl_mpz_t __gen_e_acsl_result;
__e_acsl_mpz_t __gen_e_acsl_mul_4;
@@ -272,7 +270,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,"\\result",0,
__retres);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
- "\\old(nmemb)",0,__gen_e_acsl_at);
+ "\\old(nmemb)",0,__gen_e_acsl_at_3);
__gen_e_acsl_assert_data_5.blocking = 1;
__gen_e_acsl_assert_data_5.kind = "Postcondition";
__gen_e_acsl_assert_data_5.pred_txt = "\\result <= \\old(nmemb)";
@@ -280,12 +278,13 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gen_e_acsl_assert_data_5.fct = "fread";
__gen_e_acsl_assert_data_5.line = 356;
__gen_e_acsl_assert_data_5.name = "size_read";
- __e_acsl_assert(__retres <= __gen_e_acsl_at,& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert(__retres <= __gen_e_acsl_at_3,
+ & __gen_e_acsl_assert_data_5);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,"\\old(ptr)",
- __gen_e_acsl_at_2);
+ __gen_e_acsl_at);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"sizeof(char)",
0,1);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"sizeof(char)",
@@ -296,11 +295,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_init_set_ui(__gen_e_acsl_result,__retres);
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_6,"\\old(size)",
0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
__gmpz_init(__gen_e_acsl_mul_4);
__gmpz_mul(__gen_e_acsl_mul_4,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_result),
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
__gmpz_init_set_si(__gen_e_acsl__6,1L);
__gmpz_init(__gen_e_acsl_sub_3);
__gmpz_sub(__gen_e_acsl_sub_3,
@@ -319,11 +318,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_mul(__gen_e_acsl_mul_5,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_add_2));
- __gmpz_init_set(__gen_e_acsl_size_6,
+ __gmpz_init_set(__gen_e_acsl_size_7,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_5));
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_6,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6));
- __gen_e_acsl_le_4 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
+ __gen_e_acsl_le_4 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__7));
if (__gen_e_acsl_le_4 <= 0) {
__e_acsl_mpz_t __gen_e_acsl__8;
@@ -334,9 +333,9 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
}
else {
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_6,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
__gmpz_init_set(__gen_e_acsl_if_2,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
}
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
@@ -359,7 +358,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert(__gen_e_acsl_le_5 <= 0,& __gen_e_acsl_assert_data_7);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
__gen_e_acsl_size_8 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if_2));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)((char *)__gen_e_acsl_at_2 +
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)((char *)__gen_e_acsl_at +
1 * 0),
__gen_e_acsl_size_8);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
@@ -376,7 +375,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
__e_acsl_delete_block((void *)(& stream));
__e_acsl_delete_block((void *)(& ptr));
- __gmpz_clear(__gen_e_acsl_size_6);
+ __gmpz_clear(__gen_e_acsl_size_7);
__gmpz_clear(__gen_e_acsl_sizeof_2);
__gmpz_clear(__gen_e_acsl_result);
__gmpz_clear(__gen_e_acsl_mul_4);
@@ -388,7 +387,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_clear(__gen_e_acsl_mul_5);
__gmpz_clear(__gen_e_acsl_if_2);
__gmpz_clear(__gen_e_acsl__9);
- __gmpz_clear(__gen_e_acsl_at_3);
+ __gmpz_clear(__gen_e_acsl_at_2);
return __retres;
}
}
diff --git a/src/plugins/e-acsl/tests/builtin/oracle/gen_strcat.c b/src/plugins/e-acsl/tests/builtin/oracle/gen_strcat.c
index 7423ad772d31fe769874a2b1c3100c41309c3e8a..4949156576b6bc32719122b4133ae404541d27fc 100644
--- a/src/plugins/e-acsl/tests/builtin/oracle/gen_strcat.c
+++ b/src/plugins/e-acsl/tests/builtin/oracle/gen_strcat.c
@@ -700,13 +700,13 @@ pid_t __gen_e_acsl_fork(void)
*/
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
- int *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int *__gen_e_acsl_at;
pid_t __retres;
{
int __gen_e_acsl_assumes_value;
__e_acsl_store_block((void *)(& stat_loc),(size_t)8);
+ __gen_e_acsl_at = stat_loc;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
stat_loc == (int *)0);
@@ -738,8 +738,6 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
}
- __gen_e_acsl_at_2 = stat_loc;
- __gen_e_acsl_at = stat_loc;
__retres = waitpid(pid,stat_loc,options);
{
int __gen_e_acsl_or;
@@ -778,11 +776,10 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
else {
int __gen_e_acsl_initialized;
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "\\old(stat_loc)",
- (void *)__gen_e_acsl_at_2);
+ "\\old(stat_loc)",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
sizeof(int));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\initialized(\\old(stat_loc))",0,
diff --git a/src/plugins/e-acsl/tests/builtin/oracle/gen_strcmp.c b/src/plugins/e-acsl/tests/builtin/oracle/gen_strcmp.c
index 347be95252fe859c04523ce6b8dc37b9b9d57a5d..835b7da03d0d6d67bd22e2c4d15ab1271bf3ace5 100644
--- a/src/plugins/e-acsl/tests/builtin/oracle/gen_strcmp.c
+++ b/src/plugins/e-acsl/tests/builtin/oracle/gen_strcmp.c
@@ -241,13 +241,13 @@ pid_t __gen_e_acsl_fork(void)
*/
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
- int *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int *__gen_e_acsl_at;
pid_t __retres;
{
int __gen_e_acsl_assumes_value;
__e_acsl_store_block((void *)(& stat_loc),(size_t)8);
+ __gen_e_acsl_at = stat_loc;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
stat_loc == (int *)0);
@@ -279,8 +279,6 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
}
- __gen_e_acsl_at_2 = stat_loc;
- __gen_e_acsl_at = stat_loc;
__retres = waitpid(pid,stat_loc,options);
{
int __gen_e_acsl_or;
@@ -319,11 +317,10 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
else {
int __gen_e_acsl_initialized;
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "\\old(stat_loc)",
- (void *)__gen_e_acsl_at_2);
+ "\\old(stat_loc)",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
sizeof(int));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\initialized(\\old(stat_loc))",0,
diff --git a/src/plugins/e-acsl/tests/builtin/oracle/gen_strcpy.c b/src/plugins/e-acsl/tests/builtin/oracle/gen_strcpy.c
index 893f81a67edabdfab1dd017663cbb56506f5b5db..4328926452d166452f267138baf6d299c327b6d7 100644
--- a/src/plugins/e-acsl/tests/builtin/oracle/gen_strcpy.c
+++ b/src/plugins/e-acsl/tests/builtin/oracle/gen_strcpy.c
@@ -675,13 +675,13 @@ pid_t __gen_e_acsl_fork(void)
*/
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
- int *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int *__gen_e_acsl_at;
pid_t __retres;
{
int __gen_e_acsl_assumes_value;
__e_acsl_store_block((void *)(& stat_loc),(size_t)8);
+ __gen_e_acsl_at = stat_loc;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
stat_loc == (int *)0);
@@ -713,8 +713,6 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
}
- __gen_e_acsl_at_2 = stat_loc;
- __gen_e_acsl_at = stat_loc;
__retres = waitpid(pid,stat_loc,options);
{
int __gen_e_acsl_or;
@@ -753,11 +751,10 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
else {
int __gen_e_acsl_initialized;
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "\\old(stat_loc)",
- (void *)__gen_e_acsl_at_2);
+ "\\old(stat_loc)",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
sizeof(int));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\initialized(\\old(stat_loc))",0,
diff --git a/src/plugins/e-acsl/tests/builtin/oracle/gen_strlen.c b/src/plugins/e-acsl/tests/builtin/oracle/gen_strlen.c
index 4de9c149b4f9efd18cd257d98779f06afcc729d8..824fb3503a591edf467f21b2832705dc5583a931 100644
--- a/src/plugins/e-acsl/tests/builtin/oracle/gen_strlen.c
+++ b/src/plugins/e-acsl/tests/builtin/oracle/gen_strlen.c
@@ -215,13 +215,13 @@ pid_t __gen_e_acsl_fork(void)
*/
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
- int *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int *__gen_e_acsl_at;
pid_t __retres;
{
int __gen_e_acsl_assumes_value;
__e_acsl_store_block((void *)(& stat_loc),(size_t)8);
+ __gen_e_acsl_at = stat_loc;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
stat_loc == (int *)0);
@@ -253,8 +253,6 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
}
- __gen_e_acsl_at_2 = stat_loc;
- __gen_e_acsl_at = stat_loc;
__retres = waitpid(pid,stat_loc,options);
{
int __gen_e_acsl_or;
@@ -293,11 +291,10 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
else {
int __gen_e_acsl_initialized;
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "\\old(stat_loc)",
- (void *)__gen_e_acsl_at_2);
+ "\\old(stat_loc)",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
sizeof(int));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\initialized(\\old(stat_loc))",0,
diff --git a/src/plugins/e-acsl/tests/concurrency/oracle/gen_parallel_threads.c b/src/plugins/e-acsl/tests/concurrency/oracle/gen_parallel_threads.c
index 76ac158551f5a3b2cc9eb53a5e30b94dbd22ecf4..65e0a1d60438b62081897d070f4285491869a3cf 100644
--- a/src/plugins/e-acsl/tests/concurrency/oracle/gen_parallel_threads.c
+++ b/src/plugins/e-acsl/tests/concurrency/oracle/gen_parallel_threads.c
@@ -957,6 +957,7 @@ int __gen_e_acsl_pthread_mutex_init(pthread_mutex_t * restrict mutex,
int __gen_e_acsl_or;
__e_acsl_store_block((void *)(& attrs),(size_t)8);
__e_acsl_store_block((void *)(& mutex),(size_t)8);
+ __gen_e_acsl_at = mutex;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"mutex",
(void *)mutex);
@@ -1008,7 +1009,6 @@ int __gen_e_acsl_pthread_mutex_init(pthread_mutex_t * restrict mutex,
__e_acsl_assert(__gen_e_acsl_or,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
- __gen_e_acsl_at = mutex;
__retres = pthread_mutex_init(mutex,attrs);
{
int __gen_e_acsl_and;
@@ -1424,6 +1424,7 @@ int __gen_e_acsl_pthread_cond_init(pthread_cond_t * restrict cond,
int __gen_e_acsl_or;
__e_acsl_store_block((void *)(& attr),(size_t)8);
__e_acsl_store_block((void *)(& cond),(size_t)8);
+ __gen_e_acsl_at = cond;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"cond",
(void *)cond);
@@ -1474,7 +1475,6 @@ int __gen_e_acsl_pthread_cond_init(pthread_cond_t * restrict cond,
__e_acsl_assert(__gen_e_acsl_or,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
- __gen_e_acsl_at = cond;
__retres = pthread_cond_init(cond,attr);
{
int __gen_e_acsl_initialized;
diff --git a/src/plugins/e-acsl/tests/concurrency/oracle/gen_threads_debug.c b/src/plugins/e-acsl/tests/concurrency/oracle/gen_threads_debug.c
index 4b07a6a1478adaa2271cee811f1d544ef83202a4..bad13c318e4c95ae8fec4d83fa2ee7c0f10ebb03 100644
--- a/src/plugins/e-acsl/tests/concurrency/oracle/gen_threads_debug.c
+++ b/src/plugins/e-acsl/tests/concurrency/oracle/gen_threads_debug.c
@@ -639,6 +639,7 @@ int __gen_e_acsl_pthread_mutex_init(pthread_mutex_t * restrict mutex,
int __gen_e_acsl_or;
__e_acsl_store_block((void *)(& attrs),(size_t)8);
__e_acsl_store_block((void *)(& mutex),(size_t)8);
+ __gen_e_acsl_at = mutex;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"mutex",
(void *)mutex);
@@ -690,7 +691,6 @@ int __gen_e_acsl_pthread_mutex_init(pthread_mutex_t * restrict mutex,
__e_acsl_assert(__gen_e_acsl_or,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
- __gen_e_acsl_at = mutex;
__retres = pthread_mutex_init(mutex,attrs);
{
int __gen_e_acsl_and;
@@ -1106,6 +1106,7 @@ int __gen_e_acsl_pthread_cond_init(pthread_cond_t * restrict cond,
int __gen_e_acsl_or;
__e_acsl_store_block((void *)(& attr),(size_t)8);
__e_acsl_store_block((void *)(& cond),(size_t)8);
+ __gen_e_acsl_at = cond;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"cond",
(void *)cond);
@@ -1156,7 +1157,6 @@ int __gen_e_acsl_pthread_cond_init(pthread_cond_t * restrict cond,
__e_acsl_assert(__gen_e_acsl_or,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
- __gen_e_acsl_at = cond;
__retres = pthread_cond_init(cond,attr);
{
int __gen_e_acsl_initialized;
diff --git a/src/plugins/e-acsl/tests/constructs/oracle/gen_function_contract.c b/src/plugins/e-acsl/tests/constructs/oracle/gen_function_contract.c
index 1cf003981e3405f102571e9fdc71d96845960180..501806c4f435ef09594846b2a8a7e66d2bf84847 100644
--- a/src/plugins/e-acsl/tests/constructs/oracle/gen_function_contract.c
+++ b/src/plugins/e-acsl/tests/constructs/oracle/gen_function_contract.c
@@ -228,15 +228,12 @@ int main(void)
*/
void __gen_e_acsl_o(void)
{
- int __gen_e_acsl_at_5;
- int __gen_e_acsl_at_4;
- int __gen_e_acsl_at_3;
- int __gen_e_acsl_at_2;
- int __gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int __gen_e_acsl_at;
{
int __gen_e_acsl_assumes_value;
int __gen_e_acsl_active_bhvrs;
+ __gen_e_acsl_at = Y;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)4);
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"X",0,X);
@@ -406,11 +403,6 @@ void __gen_e_acsl_o(void)
& __gen_e_acsl_assert_data_10);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_10);
}
- __gen_e_acsl_at_5 = Y;
- __gen_e_acsl_at_4 = Y;
- __gen_e_acsl_at_3 = Y;
- __gen_e_acsl_at_2 = Y;
- __gen_e_acsl_at = Y;
o();
{
int __gen_e_acsl_assumes_value_2;
@@ -434,7 +426,7 @@ void __gen_e_acsl_o(void)
{.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,"X",0,X);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_13,"\\old(Y)",
- 0,__gen_e_acsl_at_2);
+ 0,__gen_e_acsl_at);
__gen_e_acsl_assert_data_13.blocking = 1;
__gen_e_acsl_assert_data_13.kind = "Postcondition";
__gen_e_acsl_assert_data_13.pred_txt = "X == \\old(Y)";
@@ -442,7 +434,7 @@ void __gen_e_acsl_o(void)
__gen_e_acsl_assert_data_13.fct = "o";
__gen_e_acsl_assert_data_13.line = 99;
__gen_e_acsl_assert_data_13.name = "neg";
- __e_acsl_assert(X == __gen_e_acsl_at_2,& __gen_e_acsl_assert_data_13);
+ __e_acsl_assert(X == __gen_e_acsl_at,& __gen_e_acsl_assert_data_13);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_13);
}
__gen_e_acsl_assumes_value_2 = __e_acsl_contract_get_behavior_assumes
@@ -452,7 +444,7 @@ void __gen_e_acsl_o(void)
{.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,"X",0,X);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_14,"\\old(Y)",
- 0,__gen_e_acsl_at_3);
+ 0,__gen_e_acsl_at);
__gen_e_acsl_assert_data_14.blocking = 1;
__gen_e_acsl_assert_data_14.kind = "Postcondition";
__gen_e_acsl_assert_data_14.pred_txt = "X == \\old(Y)";
@@ -460,7 +452,7 @@ void __gen_e_acsl_o(void)
__gen_e_acsl_assert_data_14.fct = "o";
__gen_e_acsl_assert_data_14.line = 104;
__gen_e_acsl_assert_data_14.name = "pos";
- __e_acsl_assert(X == __gen_e_acsl_at_3,& __gen_e_acsl_assert_data_14);
+ __e_acsl_assert(X == __gen_e_acsl_at,& __gen_e_acsl_assert_data_14);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_14);
}
__gen_e_acsl_assumes_value_2 = __e_acsl_contract_get_behavior_assumes
@@ -470,7 +462,7 @@ void __gen_e_acsl_o(void)
{.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,"X",0,X);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_15,"\\old(Y)",
- 0,__gen_e_acsl_at_4);
+ 0,__gen_e_acsl_at);
__gen_e_acsl_assert_data_15.blocking = 1;
__gen_e_acsl_assert_data_15.kind = "Postcondition";
__gen_e_acsl_assert_data_15.pred_txt = "X == \\old(Y)";
@@ -478,7 +470,7 @@ void __gen_e_acsl_o(void)
__gen_e_acsl_assert_data_15.fct = "o";
__gen_e_acsl_assert_data_15.line = 109;
__gen_e_acsl_assert_data_15.name = "odd";
- __e_acsl_assert(X == __gen_e_acsl_at_4,& __gen_e_acsl_assert_data_15);
+ __e_acsl_assert(X == __gen_e_acsl_at,& __gen_e_acsl_assert_data_15);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_15);
}
__gen_e_acsl_assumes_value_2 = __e_acsl_contract_get_behavior_assumes
@@ -488,7 +480,7 @@ void __gen_e_acsl_o(void)
{.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,"X",0,X);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_16,"\\old(Y)",
- 0,__gen_e_acsl_at_5);
+ 0,__gen_e_acsl_at);
__gen_e_acsl_assert_data_16.blocking = 1;
__gen_e_acsl_assert_data_16.kind = "Postcondition";
__gen_e_acsl_assert_data_16.pred_txt = "X == \\old(Y)";
@@ -496,7 +488,7 @@ void __gen_e_acsl_o(void)
__gen_e_acsl_assert_data_16.fct = "o";
__gen_e_acsl_assert_data_16.line = 114;
__gen_e_acsl_assert_data_16.name = "even";
- __e_acsl_assert(X == __gen_e_acsl_at_5,& __gen_e_acsl_assert_data_16);
+ __e_acsl_assert(X == __gen_e_acsl_at,& __gen_e_acsl_assert_data_16);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_16);
}
__e_acsl_contract_clean(__gen_e_acsl_contract);
@@ -598,10 +590,11 @@ void __gen_e_acsl_n(void)
*/
void __gen_e_acsl_m(void)
{
- long __gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ long __gen_e_acsl_at;
{
int __gen_e_acsl_and;
+ __gen_e_acsl_at = (long)X;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
X == 7);
@@ -609,7 +602,6 @@ void __gen_e_acsl_m(void)
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)1,
__gen_e_acsl_and);
}
- __gen_e_acsl_at = (long)X;
m();
{
int __gen_e_acsl_assumes_value;
diff --git a/src/plugins/e-acsl/tests/constructs/oracle/gen_result.c b/src/plugins/e-acsl/tests/constructs/oracle/gen_result.c
index b90c677cd6740b1f66f7d8d1ae345b67489ca9dc..c99db3bf2f45ab4efa11c47155678b6581fe419a 100644
--- a/src/plugins/e-acsl/tests/constructs/oracle/gen_result.c
+++ b/src/plugins/e-acsl/tests/constructs/oracle/gen_result.c
@@ -112,10 +112,8 @@ int __gen_e_acsl_g(int x)
/*@ ensures \result == (int)(\old(x) - \old(x)); */
int __gen_e_acsl_f(int x)
{
- int __gen_e_acsl_at_2;
long __gen_e_acsl_at;
int __retres;
- __gen_e_acsl_at_2 = x;
__gen_e_acsl_at = (long)x;
__retres = f(x);
{
@@ -124,15 +122,15 @@ int __gen_e_acsl_f(int x)
__retres);
__e_acsl_assert_register_long(& __gen_e_acsl_assert_data,"\\old(x)",0,
__gen_e_acsl_at);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"\\old(x)",0,
- __gen_e_acsl_at_2);
+ __e_acsl_assert_register_long(& __gen_e_acsl_assert_data,"\\old(x)",0,
+ __gen_e_acsl_at);
__gen_e_acsl_assert_data.blocking = 1;
__gen_e_acsl_assert_data.kind = "Postcondition";
__gen_e_acsl_assert_data.pred_txt = "\\result == (int)(\\old(x) - \\old(x))";
__gen_e_acsl_assert_data.file = "result.i";
__gen_e_acsl_assert_data.fct = "f";
__gen_e_acsl_assert_data.line = 5;
- __e_acsl_assert(__retres == (int)(__gen_e_acsl_at - __gen_e_acsl_at_2),
+ __e_acsl_assert(__retres == (int)(__gen_e_acsl_at - __gen_e_acsl_at),
& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
return __retres;
diff --git a/src/plugins/e-acsl/tests/constructs/oracle/gen_rte.c b/src/plugins/e-acsl/tests/constructs/oracle/gen_rte.c
index d541359143b02d5e336ac2d54af2faa7864a2451..20f953076433b4058d4249f0cbbe345bd0ddd782 100644
--- a/src/plugins/e-acsl/tests/constructs/oracle/gen_rte.c
+++ b/src/plugins/e-acsl/tests/constructs/oracle/gen_rte.c
@@ -56,11 +56,13 @@ int main(void)
void __gen_e_acsl_test(int a, int b, int c, int d, int e, int f, int g,
int h, int i, int j, int k, int l)
{
+ __e_acsl_contract_t *__gen_e_acsl_contract;
int __gen_e_acsl_at_2;
int __gen_e_acsl_at;
- __e_acsl_contract_t *__gen_e_acsl_contract;
{
int __gen_e_acsl_assumes_value;
+ __gen_e_acsl_at = b;
+ __gen_e_acsl_at_2 = e;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)1);
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"a",0,a);
@@ -324,8 +326,6 @@ void __gen_e_acsl_test(int a, int b, int c, int d, int e, int f, int g,
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
}
}
- __gen_e_acsl_at_2 = e;
- __gen_e_acsl_at = b;
test(a,b,c,d,e,f,g,h,i,j,k,l);
{
int __gen_e_acsl_assumes_value_2;
diff --git a/src/plugins/e-acsl/tests/constructs/oracle/result.res.oracle b/src/plugins/e-acsl/tests/constructs/oracle/result.res.oracle
index c154bf096dd6e181a09a9350cf0c8e3b0ed7ab83..8b89a531d8c6f7499c7c29b67f3416e881c3809a 100644
--- a/src/plugins/e-acsl/tests/constructs/oracle/result.res.oracle
+++ b/src/plugins/e-acsl/tests/constructs/oracle/result.res.oracle
@@ -4,8 +4,8 @@
function __e_acsl_assert_register_long: precondition data->values == \null ||
\valid(data->values) got status unknown.
[eva:alarm] result.i:5: Warning:
- function __e_acsl_assert_register_int: precondition data->values == \null ||
- \valid(data->values) got status unknown.
+ function __e_acsl_assert_register_long: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
[eva:alarm] result.i:13: Warning:
function __e_acsl_assert_register_int: precondition data->values == \null ||
\valid(data->values) got status unknown.
diff --git a/src/plugins/e-acsl/tests/constructs/oracle_dev/printed_data.e-acsl.err.log b/src/plugins/e-acsl/tests/constructs/oracle_dev/printed_data.e-acsl.err.log
index 6ae207c797812ba73f9eb18cb2d8153d839a3d57..66e7a3231b68451f7e4400fbf1c8cf1be3b91ba4 100644
--- a/src/plugins/e-acsl/tests/constructs/oracle_dev/printed_data.e-acsl.err.log
+++ b/src/plugins/e-acsl/tests/constructs/oracle_dev/printed_data.e-acsl.err.log
@@ -2,98 +2,98 @@ EVERY ASSERTION SHOULD PRINT ITS DATA IN EXECUTION LOG
printed_data.c: In function 'main'
printed_data.c:69: Assertion valid:
\let x = int_bool; \true.
- With values:
+ With values at failure point:
- int_bool: 1
printed_data.c: In function 'main'
printed_data.c:71: Assertion valid:
\let x = int_char; \true.
- With values:
+ With values at failure point:
- int_char: 127
printed_data.c: In function 'main'
printed_data.c:73: Assertion valid:
\let x = int_schar; \true.
- With values:
+ With values at failure point:
- int_schar: 127
printed_data.c: In function 'main'
printed_data.c:75: Assertion valid:
\let x = int_uchar; \true.
- With values:
+ With values at failure point:
- int_uchar: 255
printed_data.c: In function 'main'
printed_data.c:77: Assertion valid:
\let x = int_int; \true.
- With values:
+ With values at failure point:
- int_int: 2147483647
printed_data.c: In function 'main'
printed_data.c:79: Assertion valid:
\let x = int_uint; \true.
- With values:
+ With values at failure point:
- int_uint: 4294967295
printed_data.c: In function 'main'
printed_data.c:81: Assertion valid:
\let x = int_short; \true.
- With values:
+ With values at failure point:
- int_short: 32767
printed_data.c: In function 'main'
printed_data.c:83: Assertion valid:
\let x = int_ushort; \true.
- With values:
+ With values at failure point:
- int_ushort: 65535
printed_data.c: In function 'main'
printed_data.c:85: Assertion valid:
\let x = int_long; \true.
- With values:
+ With values at failure point:
- int_long: 9223372036854775807
printed_data.c: In function 'main'
printed_data.c:87: Assertion valid:
\let x = int_ulong; \true.
- With values:
+ With values at failure point:
- int_ulong: 18446744073709551615
printed_data.c: In function 'main'
printed_data.c:89: Assertion valid:
\let x = int_llong; \true.
- With values:
+ With values at failure point:
- int_llong: 9223372036854775807
printed_data.c: In function 'main'
printed_data.c:91: Assertion valid:
\let x = int_ullong; \true.
- With values:
+ With values at failure point:
- int_ullong: 18446744073709551615
printed_data.c: In function 'main'
printed_data.c:93: Assertion valid:
\let int_mpz = (0x7fffffffffffffffLL * 2ULL + 1ULL) + 1;
int_mpz != 0x7fffffffffffffffLL * 2ULL + 1ULL.
- With values:
+ With values at failure point:
- int_mpz: 18446744073709551616
printed_data.c: In function 'main'
printed_data.c:98: Assertion valid:
\let x = real_float; \true.
- With values:
+ With values at failure point:
- real_float: 3.402823e+38
printed_data.c: In function 'main'
printed_data.c:100: Assertion valid:
\let x = real_double; \true.
- With values:
+ With values at failure point:
- real_double: 1.797693e+308
printed_data.c: In function 'main'
printed_data.c:102: Assertion valid:
\let x = real_ldouble; \true.
- With values:
+ With values at failure point:
- real_ldouble: 1.189731e+4932
printed_data.c: In function 'main'
printed_data.c:104: Assertion valid:
\let real_mpq = 0.1; real_mpq != 1.
- With values:
+ With values at failure point:
- real_mpq: 1/10
printed_data.c: In function 'main'
printed_data.c:109: Assertion valid:
ptr != (void *)0.
- With values:
+ With values at failure point:
- ptr: 0x000000
printed_data.c: In function 'main'
printed_data.c:113: Assertion valid:
array1 != array2.
- With values:
+ With values at failure point:
- array2: <array>
- address: 0x000000
- array1: <array>
@@ -101,83 +101,83 @@ printed_data.c:113: Assertion valid:
printed_data.c: In function 'main'
printed_data.c:118: Assertion valid:
&f != &g.
- With values:
+ With values at failure point:
- &g: 0x000000
- &f: 0x000000
printed_data.c: In function 'main'
printed_data.c:123: Assertion valid:
\let x = struct1; \true.
- With values:
+ With values at failure point:
- struct1: <struct>
printed_data.c: In function 'main'
printed_data.c:128: Assertion valid:
\let x = union1; \true.
- With values:
+ With values at failure point:
- union1: <union>
printed_data.c: In function 'main'
printed_data.c:133: Assertion valid:
\let x = enum_bool; \true.
- With values:
+ With values at failure point:
- enum_bool: <enum> 1
printed_data.c: In function 'main'
printed_data.c:135: Assertion valid:
\let x = enum_char; \true.
- With values:
+ With values at failure point:
- enum_char: <enum> 127
printed_data.c: In function 'main'
printed_data.c:137: Assertion valid:
\let x = enum_schar; \true.
- With values:
+ With values at failure point:
- enum_schar: <enum> 127
printed_data.c: In function 'main'
printed_data.c:139: Assertion valid:
\let x = enum_uchar; \true.
- With values:
+ With values at failure point:
- enum_uchar: <enum> 255
printed_data.c: In function 'main'
printed_data.c:141: Assertion valid:
\let x = enum_int; \true.
- With values:
+ With values at failure point:
- enum_int: <enum> 2147483647
printed_data.c: In function 'main'
printed_data.c:143: Assertion valid:
\let x = enum_uint; \true.
- With values:
+ With values at failure point:
- enum_uint: <enum> 4294967295
printed_data.c: In function 'main'
printed_data.c:145: Assertion valid:
\let x = enum_short; \true.
- With values:
+ With values at failure point:
- enum_short: <enum> 32767
printed_data.c: In function 'main'
printed_data.c:147: Assertion valid:
\let x = enum_ushort; \true.
- With values:
+ With values at failure point:
- enum_ushort: <enum> 65535
printed_data.c: In function 'main'
printed_data.c:149: Assertion valid:
\let x = enum_long; \true.
- With values:
+ With values at failure point:
- enum_long: <enum> 9223372036854775807
printed_data.c: In function 'main'
printed_data.c:151: Assertion valid:
\let x = enum_ulong; \true.
- With values:
+ With values at failure point:
- enum_ulong: <enum> 18446744073709551615
printed_data.c: In function 'main'
printed_data.c:153: Assertion valid:
\let x = enum_llong; \true.
- With values:
+ With values at failure point:
- enum_llong: <enum> 9223372036854775807
printed_data.c: In function 'main'
printed_data.c:155: Assertion valid:
\let x = enum_ullong; \true.
- With values:
+ With values at failure point:
- enum_ullong: <enum> 18446744073709551615
printed_data.c: In function 'main'
printed_data.c:161: Assertion valid:
\let c = a + b; a != b && c == a + b.
- With values:
+ With values at failure point:
- c: 5
- b: 3
- a: 2
diff --git a/src/plugins/e-acsl/tests/format/oracle/gen_fprintf.c b/src/plugins/e-acsl/tests/format/oracle/gen_fprintf.c
index 6f72b40c111a225647a22a74e7662b92ffc9e4d5..f9fa434c6110f921a62e4d548ada67b48be2ffb0 100644
--- a/src/plugins/e-acsl/tests/format/oracle/gen_fprintf.c
+++ b/src/plugins/e-acsl/tests/format/oracle/gen_fprintf.c
@@ -154,13 +154,13 @@ pid_t __gen_e_acsl_fork(void)
*/
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
- int *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int *__gen_e_acsl_at;
pid_t __retres;
{
int __gen_e_acsl_assumes_value;
__e_acsl_store_block((void *)(& stat_loc),(size_t)8);
+ __gen_e_acsl_at = stat_loc;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
stat_loc == (int *)0);
@@ -192,8 +192,6 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
}
- __gen_e_acsl_at_2 = stat_loc;
- __gen_e_acsl_at = stat_loc;
__retres = waitpid(pid,stat_loc,options);
{
int __gen_e_acsl_or;
@@ -232,11 +230,10 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
else {
int __gen_e_acsl_initialized;
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "\\old(stat_loc)",
- (void *)__gen_e_acsl_at_2);
+ "\\old(stat_loc)",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
sizeof(int));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\initialized(\\old(stat_loc))",0,
diff --git a/src/plugins/e-acsl/tests/format/oracle/gen_printf.c b/src/plugins/e-acsl/tests/format/oracle/gen_printf.c
index ca8765b8f2703ec3458a2925a0d5fed15bbcd41c..3cc0a9f218434ee686c775f66611fcde9a72ee1c 100644
--- a/src/plugins/e-acsl/tests/format/oracle/gen_printf.c
+++ b/src/plugins/e-acsl/tests/format/oracle/gen_printf.c
@@ -735,13 +735,13 @@ void test_specifier_application(char const *allowed, char const *fmt,
*/
char *__gen_e_acsl_strcpy(char * restrict dest, char const * restrict src)
{
- char *__gen_e_acsl_at;
unsigned long __gen_e_acsl_strcpy_src_size;
+ char *__gen_e_acsl_at;
char *__retres;
__e_acsl_store_block((void *)(& src),(size_t)8);
__e_acsl_store_block((void *)(& dest),(size_t)8);
- __gen_e_acsl_strcpy_src_size = __e_acsl_builtin_strlen(src);
__gen_e_acsl_at = dest;
+ __gen_e_acsl_strcpy_src_size = __e_acsl_builtin_strlen(src);
__retres = strcpy(dest,src);
{
__e_acsl_mpz_t __gen_e_acsl___gen_e_acsl_strcpy_src_size;
@@ -830,19 +830,16 @@ char *__gen_e_acsl_strcpy(char * restrict dest, char const * restrict src)
*/
char *__gen_e_acsl_strchr(char const *s, int c)
{
- char const *__gen_e_acsl_at_4;
- char const *__gen_e_acsl_at_2;
- int __gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int __gen_e_acsl_at_2;
+ char const *__gen_e_acsl_at;
char *__retres;
__e_acsl_store_block((void *)(& __retres),(size_t)8);
__e_acsl_store_block((void *)(& s),(size_t)8);
+ __gen_e_acsl_at = s;
+ __gen_e_acsl_at_2 = c;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)3);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)2,1);
- __gen_e_acsl_at_4 = s;
- __gen_e_acsl_at_3 = s;
- __gen_e_acsl_at_2 = s;
- __gen_e_acsl_at = c;
__retres = strchr(s,c);
{
int __gen_e_acsl_assumes_value;
@@ -858,7 +855,7 @@ char *__gen_e_acsl_strchr(char const *s, int c)
__e_acsl_assert_register_char(& __gen_e_acsl_assert_data_2,"*\\result",
0,*__retres);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"\\old(c)",0,
- __gen_e_acsl_at);
+ __gen_e_acsl_at_2);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"&__retres",
@@ -895,7 +892,7 @@ char *__gen_e_acsl_strchr(char const *s, int c)
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,
"\\base_addr(\\result)",
__gen_e_acsl_base_addr);
- __gen_e_acsl_base_addr_2 = __e_acsl_base_addr((void *)__gen_e_acsl_at_2);
+ __gen_e_acsl_base_addr_2 = __e_acsl_base_addr((void *)__gen_e_acsl_at);
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,
"\\base_addr(\\old(s))",
__gen_e_acsl_base_addr_2);
@@ -916,7 +913,7 @@ char *__gen_e_acsl_strchr(char const *s, int c)
__gen_e_acsl_assert_data_2.fct = "strchr";
__gen_e_acsl_assert_data_2.line = 177;
__gen_e_acsl_assert_data_2.name = "found/result_char";
- __e_acsl_assert((int)*__retres == (int)((char)__gen_e_acsl_at),
+ __e_acsl_assert((int)*__retres == (int)((char)__gen_e_acsl_at_2),
& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
@@ -953,7 +950,7 @@ char *__gen_e_acsl_strchr(char const *s, int c)
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_9,
"\\base_addr(\\result)",
__gen_e_acsl_base_addr_3);
- __gen_e_acsl_base_addr_4 = __e_acsl_base_addr((void *)__gen_e_acsl_at_4);
+ __gen_e_acsl_base_addr_4 = __e_acsl_base_addr((void *)__gen_e_acsl_at);
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_9,
"\\base_addr(\\old(s))",
__gen_e_acsl_base_addr_4);
@@ -1050,13 +1047,13 @@ pid_t __gen_e_acsl_fork(void)
*/
pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
{
- int *__gen_e_acsl_at_2;
- int *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ int *__gen_e_acsl_at;
pid_t __retres;
{
int __gen_e_acsl_assumes_value;
__e_acsl_store_block((void *)(& stat_loc),(size_t)8);
+ __gen_e_acsl_at = stat_loc;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
stat_loc == (int *)0);
@@ -1088,8 +1085,6 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
}
}
- __gen_e_acsl_at_2 = stat_loc;
- __gen_e_acsl_at = stat_loc;
__retres = waitpid(pid,stat_loc,options);
{
int __gen_e_acsl_or;
@@ -1128,11 +1123,10 @@ pid_t __gen_e_acsl_waitpid(pid_t pid, int *stat_loc, int options)
else {
int __gen_e_acsl_initialized;
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,
- "\\old(stat_loc)",
- (void *)__gen_e_acsl_at_2);
+ "\\old(stat_loc)",(void *)__gen_e_acsl_at);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at_2,
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)__gen_e_acsl_at,
sizeof(int));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,
"\\initialized(\\old(stat_loc))",0,
diff --git a/src/plugins/e-acsl/tests/libc/oracle/gen_file.c b/src/plugins/e-acsl/tests/libc/oracle/gen_file.c
index 06f88c63176372a599aefcc0d772d00e1ebd6a57..f4e8c5310d990d1a47034b19a3fd5758e5a50a3b 100644
--- a/src/plugins/e-acsl/tests/libc/oracle/gen_file.c
+++ b/src/plugins/e-acsl/tests/libc/oracle/gen_file.c
@@ -55,15 +55,16 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
FILE * restrict stream)
{
- __e_acsl_mpz_t __gen_e_acsl_at_3;
- void *__gen_e_acsl_at_2;
- size_t __gen_e_acsl_at;
+ size_t __gen_e_acsl_at_3;
+ __e_acsl_mpz_t __gen_e_acsl_at_2;
+ void *__gen_e_acsl_at;
size_t __retres;
{
__e_acsl_mpz_t __gen_e_acsl_size;
+ __e_acsl_mpz_t __gen_e_acsl_size_2;
__e_acsl_mpz_t __gen_e_acsl_sizeof;
__e_acsl_mpz_t __gen_e_acsl_nmemb;
- __e_acsl_mpz_t __gen_e_acsl_size_2;
+ __e_acsl_mpz_t __gen_e_acsl_size_3;
__e_acsl_mpz_t __gen_e_acsl_mul;
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl_sub;
@@ -75,11 +76,16 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_mpz_t __gen_e_acsl_if;
__e_acsl_mpz_t __gen_e_acsl__4;
int __gen_e_acsl_le_2;
- unsigned long __gen_e_acsl_size_3;
+ unsigned long __gen_e_acsl_size_4;
int __gen_e_acsl_valid;
int __gen_e_acsl_valid_2;
__e_acsl_store_block((void *)(& stream),(size_t)8);
__e_acsl_store_block((void *)(& ptr),(size_t)8);
+ __gen_e_acsl_at = ptr;
+ __gmpz_init_set_ui(__gen_e_acsl_size,size);
+ __gmpz_init_set(__gen_e_acsl_at_2,
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ __gen_e_acsl_at_3 = nmemb;
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"ptr",ptr);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,"sizeof(char)",0,
@@ -91,11 +97,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
nmemb);
__gmpz_init_set_ui(__gen_e_acsl_nmemb,nmemb);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,"size",0,size);
- __gmpz_init_set_ui(__gen_e_acsl_size_2,size);
+ __gmpz_init_set_ui(__gen_e_acsl_size_3,size);
__gmpz_init(__gen_e_acsl_mul);
__gmpz_mul(__gen_e_acsl_mul,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_nmemb),
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_3));
__gmpz_init_set_si(__gen_e_acsl_,1L);
__gmpz_init(__gen_e_acsl_sub);
__gmpz_sub(__gen_e_acsl_sub,
@@ -114,11 +120,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_mul(__gen_e_acsl_mul_2,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
- __gmpz_init_set(__gen_e_acsl_size,
+ __gmpz_init_set(__gen_e_acsl_size_2,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_2));
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
- __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
+ __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
if (__gen_e_acsl_le <= 0) {
__e_acsl_mpz_t __gen_e_acsl__3;
@@ -129,9 +135,9 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
}
else {
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
__gmpz_init_set(__gen_e_acsl_if,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
}
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
@@ -153,9 +159,9 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gen_e_acsl_assert_data_2.name = "offset_lesser_or_eq_than_SIZE_MAX";
__e_acsl_assert(__gen_e_acsl_le_2 <= 0,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
- __gen_e_acsl_size_3 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
+ __gen_e_acsl_size_4 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
__gen_e_acsl_valid = __e_acsl_valid((void *)((char *)ptr + 1 * 0),
- __gen_e_acsl_size_3,ptr,
+ __gen_e_acsl_size_4,ptr,
(void *)(& ptr));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"valid_ptr_block: \\valid((char *)ptr + (0 .. nmemb * size - 1))",
@@ -189,9 +195,10 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert(__gen_e_acsl_valid_2,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__gmpz_clear(__gen_e_acsl_size);
+ __gmpz_clear(__gen_e_acsl_size_2);
__gmpz_clear(__gen_e_acsl_sizeof);
__gmpz_clear(__gen_e_acsl_nmemb);
- __gmpz_clear(__gen_e_acsl_size_2);
+ __gmpz_clear(__gen_e_acsl_size_3);
__gmpz_clear(__gen_e_acsl_mul);
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl_sub);
@@ -202,23 +209,14 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_clear(__gen_e_acsl_if);
__gmpz_clear(__gen_e_acsl__4);
}
- {
- __e_acsl_mpz_t __gen_e_acsl_size_7;
- __gmpz_init_set_ui(__gen_e_acsl_size_7,size);
- __gmpz_init_set(__gen_e_acsl_at_3,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
- __gmpz_clear(__gen_e_acsl_size_7);
- }
- __gen_e_acsl_at_2 = ptr;
- __gen_e_acsl_at = nmemb;
__retres = fread(ptr,size,nmemb,stream);
{
__e_acsl_mpz_t __gen_e_acsl___retres;
- __e_acsl_mpz_t __gen_e_acsl_size_4;
+ __e_acsl_mpz_t __gen_e_acsl_size_5;
__e_acsl_mpz_t __gen_e_acsl_mul_3;
__e_acsl_mpz_t __gen_e_acsl__5;
int __gen_e_acsl_le_3;
- unsigned long __gen_e_acsl_size_5;
+ unsigned long __gen_e_acsl_size_6;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,"__retres",0,
@@ -226,11 +224,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_init_set_ui(__gen_e_acsl___retres,__retres);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,"size",0,
size);
- __gmpz_init_set_ui(__gen_e_acsl_size_4,size);
+ __gmpz_init_set_ui(__gen_e_acsl_size_5,size);
__gmpz_init(__gen_e_acsl_mul_3);
__gmpz_mul(__gen_e_acsl_mul_3,
(__e_acsl_mpz_struct const *)(__gen_e_acsl___retres),
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_4));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
__gmpz_init_set_ui(__gen_e_acsl__5,18446744073709551615UL);
__gen_e_acsl_le_3 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_3),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__5));
@@ -243,15 +241,15 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gen_e_acsl_assert_data_4.name = "size_lesser_or_eq_than_SIZE_MAX";
__e_acsl_assert(__gen_e_acsl_le_3 <= 0,& __gen_e_acsl_assert_data_4);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
- __gen_e_acsl_size_5 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_3));
- __e_acsl_initialize(ptr,__gen_e_acsl_size_5);
+ __gen_e_acsl_size_6 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_3));
+ __e_acsl_initialize(ptr,__gen_e_acsl_size_6);
__gmpz_clear(__gen_e_acsl___retres);
- __gmpz_clear(__gen_e_acsl_size_4);
+ __gmpz_clear(__gen_e_acsl_size_5);
__gmpz_clear(__gen_e_acsl_mul_3);
__gmpz_clear(__gen_e_acsl__5);
}
{
- __e_acsl_mpz_t __gen_e_acsl_size_6;
+ __e_acsl_mpz_t __gen_e_acsl_size_7;
__e_acsl_mpz_t __gen_e_acsl_sizeof_2;
__e_acsl_mpz_t __gen_e_acsl_result;
__e_acsl_mpz_t __gen_e_acsl_mul_4;
@@ -272,7 +270,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,"\\result",0,
__retres);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
- "\\old(nmemb)",0,__gen_e_acsl_at);
+ "\\old(nmemb)",0,__gen_e_acsl_at_3);
__gen_e_acsl_assert_data_5.blocking = 1;
__gen_e_acsl_assert_data_5.kind = "Postcondition";
__gen_e_acsl_assert_data_5.pred_txt = "\\result <= \\old(nmemb)";
@@ -280,12 +278,13 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gen_e_acsl_assert_data_5.fct = "fread";
__gen_e_acsl_assert_data_5.line = 356;
__gen_e_acsl_assert_data_5.name = "size_read";
- __e_acsl_assert(__retres <= __gen_e_acsl_at,& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert(__retres <= __gen_e_acsl_at_3,
+ & __gen_e_acsl_assert_data_5);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_6 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_6,"\\old(ptr)",
- __gen_e_acsl_at_2);
+ __gen_e_acsl_at);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"sizeof(char)",
0,1);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,"sizeof(char)",
@@ -296,11 +295,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_init_set_ui(__gen_e_acsl_result,__retres);
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_6,"\\old(size)",
0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
__gmpz_init(__gen_e_acsl_mul_4);
__gmpz_mul(__gen_e_acsl_mul_4,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_result),
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
__gmpz_init_set_si(__gen_e_acsl__6,1L);
__gmpz_init(__gen_e_acsl_sub_3);
__gmpz_sub(__gen_e_acsl_sub_3,
@@ -319,11 +318,11 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_mul(__gen_e_acsl_mul_5,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_add_2));
- __gmpz_init_set(__gen_e_acsl_size_6,
+ __gmpz_init_set(__gen_e_acsl_size_7,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_5));
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_6,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6));
- __gen_e_acsl_le_4 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
+ __gen_e_acsl_le_4 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__7));
if (__gen_e_acsl_le_4 <= 0) {
__e_acsl_mpz_t __gen_e_acsl__8;
@@ -334,9 +333,9 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
}
else {
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_6,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
__gmpz_init_set(__gen_e_acsl_if_2,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_6));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_7));
}
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
@@ -359,7 +358,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert(__gen_e_acsl_le_5 <= 0,& __gen_e_acsl_assert_data_7);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_7);
__gen_e_acsl_size_8 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if_2));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)((char *)__gen_e_acsl_at_2 +
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)((char *)__gen_e_acsl_at +
1 * 0),
__gen_e_acsl_size_8);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_6,
@@ -376,7 +375,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_6);
__e_acsl_delete_block((void *)(& stream));
__e_acsl_delete_block((void *)(& ptr));
- __gmpz_clear(__gen_e_acsl_size_6);
+ __gmpz_clear(__gen_e_acsl_size_7);
__gmpz_clear(__gen_e_acsl_sizeof_2);
__gmpz_clear(__gen_e_acsl_result);
__gmpz_clear(__gen_e_acsl_mul_4);
@@ -388,7 +387,7 @@ size_t __gen_e_acsl_fread(void * restrict ptr, size_t size, size_t nmemb,
__gmpz_clear(__gen_e_acsl_mul_5);
__gmpz_clear(__gen_e_acsl_if_2);
__gmpz_clear(__gen_e_acsl__9);
- __gmpz_clear(__gen_e_acsl_at_3);
+ __gmpz_clear(__gen_e_acsl_at_2);
return __retres;
}
}
diff --git a/src/plugins/e-acsl/tests/libc/oracle/gen_mem.c b/src/plugins/e-acsl/tests/libc/oracle/gen_mem.c
index 503f06d93716cae46b39b2d05307255839b19039..5d9daf5e2e76e143f2c8324aba63392160a3723c 100644
--- a/src/plugins/e-acsl/tests/libc/oracle/gen_mem.c
+++ b/src/plugins/e-acsl/tests/libc/oracle/gen_mem.c
@@ -518,6 +518,7 @@ void *__gen_e_acsl_memcpy(void * restrict dest, void const * restrict src,
int __gen_e_acsl_separated;
__e_acsl_store_block((void *)(& src),(size_t)8);
__e_acsl_store_block((void *)(& dest),(size_t)8);
+ __gen_e_acsl_at = dest;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
@@ -656,7 +657,6 @@ void *__gen_e_acsl_memcpy(void * restrict dest, void const * restrict src,
__gmpz_clear(__gen_e_acsl_sub_2);
__gmpz_clear(__gen_e_acsl_add);
}
- __gen_e_acsl_at = dest;
__retres = memcpy(dest,src,n);
__e_acsl_initialize(dest,n);
{
diff --git a/src/plugins/e-acsl/tests/libc/oracle/gen_str.c b/src/plugins/e-acsl/tests/libc/oracle/gen_str.c
index 3b7660e1a3ebbb5388edb7a40c3b91b86d786ae9..a920841927e7a495fe70d277d47f50922257f2c0 100644
--- a/src/plugins/e-acsl/tests/libc/oracle/gen_str.c
+++ b/src/plugins/e-acsl/tests/libc/oracle/gen_str.c
@@ -149,17 +149,17 @@ char *__gen_e_acsl_strncat(char * restrict dest, char const * restrict src,
char *__gen_e_acsl_strncat(char * restrict dest, char const * restrict src,
size_t n)
{
- char *__gen_e_acsl_at;
unsigned long __gen_e_acsl_strcat_dest_size;
unsigned long __gen_e_acsl_strcat_src_size;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ char *__gen_e_acsl_at;
char *__retres;
__e_acsl_store_block((void *)(& dest),(size_t)8);
+ __gen_e_acsl_at = dest;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__gen_e_acsl_strcat_src_size = __e_acsl_builtin_strlen(src);
if (n < __gen_e_acsl_strcat_src_size) __gen_e_acsl_strcat_src_size = n;
__gen_e_acsl_strcat_dest_size = __e_acsl_builtin_strlen((char const *)dest);
- __gen_e_acsl_at = dest;
__retres = strncat(dest,src,n);
{
__e_acsl_mpz_t __gen_e_acsl___gen_e_acsl_strcat_src_size;
@@ -256,15 +256,14 @@ char *__gen_e_acsl_strncat(char * restrict dest, char const * restrict src,
*/
char *__gen_e_acsl_strcat(char * restrict dest, char const * restrict src)
{
- char *__gen_e_acsl_at_2;
unsigned long __gen_e_acsl_strcat_dest_size;
unsigned long __gen_e_acsl_strcat_src_size;
+ char *__gen_e_acsl_at;
char *__retres;
__e_acsl_store_block((void *)(& dest),(size_t)8);
+ __gen_e_acsl_at = dest;
__gen_e_acsl_strcat_src_size = __e_acsl_builtin_strlen(src);
__gen_e_acsl_strcat_dest_size = __e_acsl_builtin_strlen((char const *)dest);
- __gen_e_acsl_at_2 = dest;
- __gen_e_acsl_at = dest;
__retres = strcat(dest,src);
{
__e_acsl_mpz_t __gen_e_acsl___gen_e_acsl_strcat_src_size;
@@ -323,7 +322,7 @@ char *__gen_e_acsl_strcat(char * restrict dest, char const * restrict src)
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,"\\result",
(void *)__retres);
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_8,"\\old(dest)",
- (void *)__gen_e_acsl_at_2);
+ (void *)__gen_e_acsl_at);
__gen_e_acsl_assert_data_8.blocking = 1;
__gen_e_acsl_assert_data_8.kind = "Postcondition";
__gen_e_acsl_assert_data_8.pred_txt = "\\result == \\old(dest)";
@@ -331,8 +330,7 @@ char *__gen_e_acsl_strcat(char * restrict dest, char const * restrict src)
__gen_e_acsl_assert_data_8.fct = "strcat";
__gen_e_acsl_assert_data_8.line = 434;
__gen_e_acsl_assert_data_8.name = "result_ptr";
- __e_acsl_assert(__retres == __gen_e_acsl_at_2,
- & __gen_e_acsl_assert_data_8);
+ __e_acsl_assert(__retres == __gen_e_acsl_at,& __gen_e_acsl_assert_data_8);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_8);
__e_acsl_delete_block((void *)(& dest));
return __retres;
@@ -360,14 +358,14 @@ char *__gen_e_acsl_strcat(char * restrict dest, char const * restrict src)
char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
size_t n)
{
- __e_acsl_mpz_t __gen_e_acsl_at_3;
- char *__gen_e_acsl_at_2;
- char *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ __e_acsl_mpz_t __gen_e_acsl_at_2;
+ char *__gen_e_acsl_at;
char *__retres;
{
- unsigned long __gen_e_acsl_size;
__e_acsl_mpz_t __gen_e_acsl_n;
+ unsigned long __gen_e_acsl_size;
+ __e_acsl_mpz_t __gen_e_acsl_n_2;
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl_sub;
__e_acsl_mpz_t __gen_e_acsl__2;
@@ -393,6 +391,10 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
int __gen_e_acsl_separated;
__e_acsl_store_block((void *)(& src),(size_t)8);
__e_acsl_store_block((void *)(& dest),(size_t)8);
+ __gen_e_acsl_at = dest;
+ __gmpz_init_set_ui(__gen_e_acsl_n,n);
+ __gmpz_init_set(__gen_e_acsl_at_2,
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_n));
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
@@ -403,11 +405,11 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"sizeof(char)",
0,1);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,"n",0,n);
- __gmpz_init_set_ui(__gen_e_acsl_n,n);
+ __gmpz_init_set_ui(__gen_e_acsl_n_2,n);
__gmpz_init_set_si(__gen_e_acsl_,1L);
__gmpz_init(__gen_e_acsl_sub);
__gmpz_sub(__gen_e_acsl_sub,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_n),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_n_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_));
__gmpz_init_set_si(__gen_e_acsl__2,0L);
__gmpz_init(__gen_e_acsl_sub_2);
@@ -560,21 +562,13 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__e_acsl_assert(__gen_e_acsl_separated,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__gmpz_clear(__gen_e_acsl_n);
+ __gmpz_clear(__gen_e_acsl_n_2);
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl_sub);
__gmpz_clear(__gen_e_acsl__2);
__gmpz_clear(__gen_e_acsl_sub_2);
__gmpz_clear(__gen_e_acsl_add);
}
- {
- __e_acsl_mpz_t __gen_e_acsl_n_2;
- __gmpz_init_set_ui(__gen_e_acsl_n_2,n);
- __gmpz_init_set(__gen_e_acsl_at_3,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_n_2));
- __gmpz_clear(__gen_e_acsl_n_2);
- }
- __gen_e_acsl_at_2 = dest;
- __gen_e_acsl_at = dest;
__retres = strncpy(dest,src,n);
__e_acsl_initialize((void *)dest,n);
{
@@ -605,17 +599,17 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__e_acsl_assert_data_t __gen_e_acsl_assert_data_7 =
{.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_7,"\\old(dest)",
- (void *)__gen_e_acsl_at_2);
+ (void *)__gen_e_acsl_at);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"sizeof(char)",
0,1);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,"sizeof(char)",
0,1);
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_7,"\\old(n)",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2));
__gmpz_init_set_si(__gen_e_acsl__8,1L);
__gmpz_init(__gen_e_acsl_sub_3);
__gmpz_sub(__gen_e_acsl_sub_3,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_3),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_at_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__8));
__gmpz_init_set_si(__gen_e_acsl__9,0L);
__gmpz_init(__gen_e_acsl_sub_4);
@@ -636,7 +630,7 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__gen_e_acsl_size_6);
__gen_e_acsl_if_6 = __gen_e_acsl_size_6;
}
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)(__gen_e_acsl_at_2 +
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)(__gen_e_acsl_at +
1 * 0),
__gen_e_acsl_if_6);
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data_7,
@@ -659,7 +653,7 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
__gmpz_clear(__gen_e_acsl__9);
__gmpz_clear(__gen_e_acsl_sub_4);
__gmpz_clear(__gen_e_acsl_add_2);
- __gmpz_clear(__gen_e_acsl_at_3);
+ __gmpz_clear(__gen_e_acsl_at_2);
return __retres;
}
}
@@ -678,13 +672,13 @@ char *__gen_e_acsl_strncpy(char * restrict dest, char const * restrict src,
*/
char *__gen_e_acsl_strcpy(char * restrict dest, char const * restrict src)
{
- char *__gen_e_acsl_at;
unsigned long __gen_e_acsl_strcpy_src_size;
+ char *__gen_e_acsl_at;
char *__retres;
__e_acsl_store_block((void *)(& src),(size_t)8);
__e_acsl_store_block((void *)(& dest),(size_t)8);
- __gen_e_acsl_strcpy_src_size = __e_acsl_builtin_strlen(src);
__gen_e_acsl_at = dest;
+ __gen_e_acsl_strcpy_src_size = __e_acsl_builtin_strlen(src);
__retres = strcpy(dest,src);
{
__e_acsl_mpz_t __gen_e_acsl___gen_e_acsl_strcpy_src_size;
diff --git a/src/plugins/e-acsl/tests/memory/oracle/gen_ranges_in_builtins.c b/src/plugins/e-acsl/tests/memory/oracle/gen_ranges_in_builtins.c
index e8c4b325fcc879c6d3eded17655065d74bee84e2..51a87c4aa3be194352b758708cc91416a6e7d18a 100644
--- a/src/plugins/e-acsl/tests/memory/oracle/gen_ranges_in_builtins.c
+++ b/src/plugins/e-acsl/tests/memory/oracle/gen_ranges_in_builtins.c
@@ -835,8 +835,9 @@ void __gen_e_acsl_g(long *ptr, size_t size)
long *__gen_e_acsl_at;
{
__e_acsl_mpz_t __gen_e_acsl_size;
- __e_acsl_mpz_t __gen_e_acsl_sizeof;
__e_acsl_mpz_t __gen_e_acsl_size_2;
+ __e_acsl_mpz_t __gen_e_acsl_sizeof;
+ __e_acsl_mpz_t __gen_e_acsl_size_3;
__e_acsl_mpz_t __gen_e_acsl_;
__e_acsl_mpz_t __gen_e_acsl_sub;
__e_acsl_mpz_t __gen_e_acsl__2;
@@ -847,9 +848,13 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__e_acsl_mpz_t __gen_e_acsl_if;
__e_acsl_mpz_t __gen_e_acsl__4;
int __gen_e_acsl_le_2;
- unsigned long __gen_e_acsl_size_3;
+ unsigned long __gen_e_acsl_size_4;
int __gen_e_acsl_valid;
__e_acsl_store_block((void *)(& ptr),(size_t)8);
+ __gen_e_acsl_at = ptr;
+ __gmpz_init_set_ui(__gen_e_acsl_size,size);
+ __gmpz_init_set(__gen_e_acsl_at_2,
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"ptr",
(void *)ptr);
@@ -859,11 +864,11 @@ void __gen_e_acsl_g(long *ptr, size_t size)
8);
__gmpz_init_set_si(__gen_e_acsl_sizeof,8L);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,"size",0,size);
- __gmpz_init_set_ui(__gen_e_acsl_size_2,size);
+ __gmpz_init_set_ui(__gen_e_acsl_size_3,size);
__gmpz_init_set_si(__gen_e_acsl_,1L);
__gmpz_init(__gen_e_acsl_sub);
__gmpz_sub(__gen_e_acsl_sub,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_3),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_));
__gmpz_init_set_si(__gen_e_acsl__2,0L);
__gmpz_init(__gen_e_acsl_sub_2);
@@ -878,11 +883,11 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__gmpz_mul(__gen_e_acsl_mul,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_add));
- __gmpz_init_set(__gen_e_acsl_size,
+ __gmpz_init_set(__gen_e_acsl_size_2,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_mul));
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
- __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
+ __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__2));
if (__gen_e_acsl_le <= 0) {
__e_acsl_mpz_t __gen_e_acsl__3;
@@ -893,9 +898,9 @@ void __gen_e_acsl_g(long *ptr, size_t size)
}
else {
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
__gmpz_init_set(__gen_e_acsl_if,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_2));
}
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
@@ -917,9 +922,9 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__gen_e_acsl_assert_data_2.name = "offset_lesser_or_eq_than_SIZE_MAX";
__e_acsl_assert(__gen_e_acsl_le_2 <= 0,& __gen_e_acsl_assert_data_2);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
- __gen_e_acsl_size_3 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
+ __gen_e_acsl_size_4 = __gmpz_get_ui((__e_acsl_mpz_struct const *)(__gen_e_acsl_if));
__gen_e_acsl_valid = __e_acsl_valid((void *)((char *)ptr + 8 * 0),
- __gen_e_acsl_size_3,(void *)ptr,
+ __gen_e_acsl_size_4,(void *)ptr,
(void *)(& ptr));
__e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
"\\valid(ptr + (0 .. size - 1))",0,
@@ -933,8 +938,9 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__e_acsl_assert(__gen_e_acsl_valid,& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
__gmpz_clear(__gen_e_acsl_size);
- __gmpz_clear(__gen_e_acsl_sizeof);
__gmpz_clear(__gen_e_acsl_size_2);
+ __gmpz_clear(__gen_e_acsl_sizeof);
+ __gmpz_clear(__gen_e_acsl_size_3);
__gmpz_clear(__gen_e_acsl_);
__gmpz_clear(__gen_e_acsl_sub);
__gmpz_clear(__gen_e_acsl__2);
@@ -944,17 +950,9 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__gmpz_clear(__gen_e_acsl_if);
__gmpz_clear(__gen_e_acsl__4);
}
- {
- __e_acsl_mpz_t __gen_e_acsl_size_5;
- __gmpz_init_set_ui(__gen_e_acsl_size_5,size);
- __gmpz_init_set(__gen_e_acsl_at_2,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
- __gmpz_clear(__gen_e_acsl_size_5);
- }
- __gen_e_acsl_at = ptr;
g(ptr,size);
{
- __e_acsl_mpz_t __gen_e_acsl_size_4;
+ __e_acsl_mpz_t __gen_e_acsl_size_5;
__e_acsl_mpz_t __gen_e_acsl_sizeof_2;
__e_acsl_mpz_t __gen_e_acsl__5;
__e_acsl_mpz_t __gen_e_acsl_add_2;
@@ -998,11 +996,11 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__gmpz_mul(__gen_e_acsl_mul_2,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_sizeof_2),
(__e_acsl_mpz_struct const *)(__gen_e_acsl_add_3));
- __gmpz_init_set(__gen_e_acsl_size_4,
+ __gmpz_init_set(__gen_e_acsl_size_5,
(__e_acsl_mpz_struct const *)(__gen_e_acsl_mul_2));
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_3,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_4));
- __gen_e_acsl_le_3 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_4),
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
+ __gen_e_acsl_le_3 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5),
(__e_acsl_mpz_struct const *)(__gen_e_acsl__6));
if (__gen_e_acsl_le_3 <= 0) {
__e_acsl_mpz_t __gen_e_acsl__7;
@@ -1013,9 +1011,9 @@ void __gen_e_acsl_g(long *ptr, size_t size)
}
else {
__e_acsl_assert_register_mpz(& __gen_e_acsl_assert_data_3,"size",0,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_4));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
__gmpz_init_set(__gen_e_acsl_if_2,
- (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_4));
+ (__e_acsl_mpz_struct const *)(__gen_e_acsl_size_5));
}
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
{.values = (void *)0};
@@ -1055,7 +1053,7 @@ void __gen_e_acsl_g(long *ptr, size_t size)
__e_acsl_assert(! __gen_e_acsl_valid_2,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
__e_acsl_delete_block((void *)(& ptr));
- __gmpz_clear(__gen_e_acsl_size_4);
+ __gmpz_clear(__gen_e_acsl_size_5);
__gmpz_clear(__gen_e_acsl_sizeof_2);
__gmpz_clear(__gen_e_acsl__5);
__gmpz_clear(__gen_e_acsl_add_2);
diff --git a/src/plugins/e-acsl/tests/memory/oracle/gen_valid_in_contract.c b/src/plugins/e-acsl/tests/memory/oracle/gen_valid_in_contract.c
index 087ef8783af5880fa77f4caf88562952160d686c..af84a51e13bced58dbfedafa5657fa3ad9c16c42 100644
--- a/src/plugins/e-acsl/tests/memory/oracle/gen_valid_in_contract.c
+++ b/src/plugins/e-acsl/tests/memory/oracle/gen_valid_in_contract.c
@@ -66,15 +66,15 @@ int main(void)
*/
struct list *__gen_e_acsl_f(struct list *l)
{
- struct list *__gen_e_acsl_at_2;
- struct list *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ struct list *__gen_e_acsl_at;
struct list *__retres;
__e_acsl_store_block((void *)(& __retres),(size_t)8);
{
int __gen_e_acsl_valid;
int __gen_e_acsl_or;
__e_acsl_store_block((void *)(& l),(size_t)8);
+ __gen_e_acsl_at = l;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
l == (struct list *)0);
@@ -121,8 +121,6 @@ struct list *__gen_e_acsl_f(struct list *l)
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)1,
__gen_e_acsl_or);
}
- __gen_e_acsl_at_2 = l;
- __gen_e_acsl_at = l;
__retres = f(l);
{
int __gen_e_acsl_assumes_value;
@@ -154,7 +152,7 @@ struct list *__gen_e_acsl_f(struct list *l)
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"\\result",
(void *)__retres);
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"\\old(l)",
- (void *)__gen_e_acsl_at_2);
+ (void *)__gen_e_acsl_at);
__gen_e_acsl_assert_data_3.blocking = 1;
__gen_e_acsl_assert_data_3.kind = "Postcondition";
__gen_e_acsl_assert_data_3.pred_txt = "\\result == \\old(l)";
@@ -162,7 +160,7 @@ struct list *__gen_e_acsl_f(struct list *l)
__gen_e_acsl_assert_data_3.fct = "f";
__gen_e_acsl_assert_data_3.line = 18;
__gen_e_acsl_assert_data_3.name = "B2";
- __e_acsl_assert(__retres == __gen_e_acsl_at_2,
+ __e_acsl_assert(__retres == __gen_e_acsl_at,
& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
}
diff --git a/src/plugins/e-acsl/tests/memory/oracle/gen_vdso.c b/src/plugins/e-acsl/tests/memory/oracle/gen_vdso.c
index 54be1732403f281be5d49021696b420322544072..a41ca5d9a3cc3340c93dc7197414b8f54315ba35 100644
--- a/src/plugins/e-acsl/tests/memory/oracle/gen_vdso.c
+++ b/src/plugins/e-acsl/tests/memory/oracle/gen_vdso.c
@@ -52,14 +52,15 @@ time_t __gen_e_acsl_time(time_t *timer);
*/
time_t __gen_e_acsl_time(time_t *timer)
{
- time_t *__gen_e_acsl_at;
__e_acsl_contract_t *__gen_e_acsl_contract;
+ time_t *__gen_e_acsl_at;
time_t __retres;
__e_acsl_store_block((void *)(& __retres),(size_t)8);
{
int __gen_e_acsl_assumes_value;
int __gen_e_acsl_active_bhvrs;
__e_acsl_store_block((void *)(& timer),(size_t)8);
+ __gen_e_acsl_at = timer;
__gen_e_acsl_contract = __e_acsl_contract_init((size_t)2);
__e_acsl_contract_set_behavior_assumes(__gen_e_acsl_contract,(size_t)0,
timer == (time_t *)0);
@@ -122,7 +123,6 @@ time_t __gen_e_acsl_time(time_t *timer)
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
}
}
- __gen_e_acsl_at = timer;
__retres = time(timer);
{
int __gen_e_acsl_assumes_value_2;
diff --git a/src/plugins/e-acsl/tests/special/oracle/e-acsl-functions.res.oracle b/src/plugins/e-acsl/tests/special/oracle/e-acsl-functions.res.oracle
index f4b8d2b5d868a7b3105d7959e16fec999a8a5ad1..80c12c0821d94d39d64514ea2a9074e5a86e779c 100644
--- a/src/plugins/e-acsl/tests/special/oracle/e-acsl-functions.res.oracle
+++ b/src/plugins/e-acsl/tests/special/oracle/e-acsl-functions.res.oracle
@@ -1,5 +1,8 @@
[e-acsl] beginning translation.
[e-acsl] translation done in project "e-acsl".
+[eva:alarm] e-acsl-functions.c:11: Warning:
+ function __e_acsl_assert_register_ulong: precondition data->values == \null ||
+ \valid(data->values) got status unknown.
[eva:alarm] e-acsl-functions.c:9: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
@@ -9,9 +12,6 @@
[eva:alarm] e-acsl-functions.c:10: Warning:
function __e_acsl_assert_register_ulong: precondition data->values == \null ||
\valid(data->values) got status unknown.
-[eva:alarm] e-acsl-functions.c:11: Warning:
- function __e_acsl_assert_register_ulong: precondition data->values == \null ||
- \valid(data->values) got status unknown.
[eva:alarm] e-acsl-functions.c:13: Warning:
function __e_acsl_assert_register_int: precondition data->values == \null ||
\valid(data->values) got status unknown.
diff --git a/src/plugins/e-acsl/tests/special/oracle/gen_e-acsl-functions.c b/src/plugins/e-acsl/tests/special/oracle/gen_e-acsl-functions.c
index 1eda3264b1fe3bb63c5d9840eb9515541ac963b7..fae8de9073015154e66d4a745e8aef0e23f0387b 100644
--- a/src/plugins/e-acsl/tests/special/oracle/gen_e-acsl-functions.c
+++ b/src/plugins/e-acsl/tests/special/oracle/gen_e-acsl-functions.c
@@ -104,89 +104,87 @@ int __gen_e_acsl_f(int *p)
int __gen_e_acsl_at;
int __retres;
{
- int __gen_e_acsl_initialized;
int __gen_e_acsl_valid_read;
+ int __gen_e_acsl_initialized;
+ int __gen_e_acsl_valid_read_2;
__e_acsl_store_block((void *)(& p),(size_t)8);
__e_acsl_assert_data_t __gen_e_acsl_assert_data = {.values = (void *)0};
__e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data,"p",(void *)p);
__e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data,"sizeof(int)",
0,sizeof(int));
- __gen_e_acsl_initialized = __e_acsl_initialized((void *)p,sizeof(int));
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data,
- "\\initialized(p)",0,
- __gen_e_acsl_initialized);
+ __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)p,sizeof(int),
+ (void *)p,(void *)(& p));
__gen_e_acsl_assert_data.blocking = 1;
- __gen_e_acsl_assert_data.kind = "Precondition";
- __gen_e_acsl_assert_data.pred_txt = "\\initialized(p)";
+ __gen_e_acsl_assert_data.kind = "RTE";
+ __gen_e_acsl_assert_data.pred_txt = "\\valid_read(p)";
__gen_e_acsl_assert_data.file = "e-acsl-functions.c";
__gen_e_acsl_assert_data.fct = "f";
- __gen_e_acsl_assert_data.line = 9;
- __e_acsl_assert(__gen_e_acsl_initialized,& __gen_e_acsl_assert_data);
+ __gen_e_acsl_assert_data.line = 11;
+ __gen_e_acsl_assert_data.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data);
+ __gen_e_acsl_at = *p;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_2 =
{.values = (void *)0};
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,"*p",0,*p);
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_2,"p",(void *)p);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_2,
+ "sizeof(int)",0,sizeof(int));
+ __gen_e_acsl_initialized = __e_acsl_initialized((void *)p,sizeof(int));
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_2,
+ "\\initialized(p)",0,
+ __gen_e_acsl_initialized);
+ __gen_e_acsl_assert_data_2.blocking = 1;
+ __gen_e_acsl_assert_data_2.kind = "Precondition";
+ __gen_e_acsl_assert_data_2.pred_txt = "\\initialized(p)";
+ __gen_e_acsl_assert_data_2.file = "e-acsl-functions.c";
+ __gen_e_acsl_assert_data_2.fct = "f";
+ __gen_e_acsl_assert_data_2.line = 9;
+ __e_acsl_assert(__gen_e_acsl_initialized,& __gen_e_acsl_assert_data_2);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
__e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_3,"p",(void *)p);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_3,
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_3,"*p",0,*p);
+ __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
+ {.values = (void *)0};
+ __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_4,"p",(void *)p);
+ __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_4,
"sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)p,sizeof(int),
- (void *)p,(void *)(& p));
+ __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)p,sizeof(int),
+ (void *)p,(void *)(& p));
+ __gen_e_acsl_assert_data_4.blocking = 1;
+ __gen_e_acsl_assert_data_4.kind = "RTE";
+ __gen_e_acsl_assert_data_4.pred_txt = "\\valid_read(p)";
+ __gen_e_acsl_assert_data_4.file = "e-acsl-functions.c";
+ __gen_e_acsl_assert_data_4.fct = "f";
+ __gen_e_acsl_assert_data_4.line = 10;
+ __gen_e_acsl_assert_data_4.name = "mem_access";
+ __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_4);
+ __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
__gen_e_acsl_assert_data_3.blocking = 1;
- __gen_e_acsl_assert_data_3.kind = "RTE";
- __gen_e_acsl_assert_data_3.pred_txt = "\\valid_read(p)";
+ __gen_e_acsl_assert_data_3.kind = "Precondition";
+ __gen_e_acsl_assert_data_3.pred_txt = "*p == 0";
__gen_e_acsl_assert_data_3.file = "e-acsl-functions.c";
__gen_e_acsl_assert_data_3.fct = "f";
__gen_e_acsl_assert_data_3.line = 10;
- __gen_e_acsl_assert_data_3.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read,& __gen_e_acsl_assert_data_3);
+ __e_acsl_assert(*p == 0,& __gen_e_acsl_assert_data_3);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_3);
- __gen_e_acsl_assert_data_2.blocking = 1;
- __gen_e_acsl_assert_data_2.kind = "Precondition";
- __gen_e_acsl_assert_data_2.pred_txt = "*p == 0";
- __gen_e_acsl_assert_data_2.file = "e-acsl-functions.c";
- __gen_e_acsl_assert_data_2.fct = "f";
- __gen_e_acsl_assert_data_2.line = 10;
- __e_acsl_assert(*p == 0,& __gen_e_acsl_assert_data_2);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_2);
}
+ __retres = f(p);
{
- int __gen_e_acsl_valid_read_2;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_5 =
{.values = (void *)0};
- __e_acsl_assert_register_ptr(& __gen_e_acsl_assert_data_5,"p",(void *)p);
- __e_acsl_assert_register_ulong(& __gen_e_acsl_assert_data_5,
- "sizeof(int)",0,sizeof(int));
- __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)p,sizeof(int),
- (void *)p,(void *)(& p));
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"\\result",0,
+ __retres);
+ __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_5,"\\old(*p)",0,
+ __gen_e_acsl_at);
__gen_e_acsl_assert_data_5.blocking = 1;
- __gen_e_acsl_assert_data_5.kind = "RTE";
- __gen_e_acsl_assert_data_5.pred_txt = "\\valid_read(p)";
+ __gen_e_acsl_assert_data_5.kind = "Postcondition";
+ __gen_e_acsl_assert_data_5.pred_txt = "\\result == \\old(*p)";
__gen_e_acsl_assert_data_5.file = "e-acsl-functions.c";
__gen_e_acsl_assert_data_5.fct = "f";
__gen_e_acsl_assert_data_5.line = 11;
- __gen_e_acsl_assert_data_5.name = "mem_access";
- __e_acsl_assert(__gen_e_acsl_valid_read_2,& __gen_e_acsl_assert_data_5);
+ __e_acsl_assert(__retres == __gen_e_acsl_at,& __gen_e_acsl_assert_data_5);
__e_acsl_assert_clean(& __gen_e_acsl_assert_data_5);
- __gen_e_acsl_at = *p;
- }
- __retres = f(p);
- {
- __e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
- {.values = (void *)0};
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"\\result",0,
- __retres);
- __e_acsl_assert_register_int(& __gen_e_acsl_assert_data_4,"\\old(*p)",0,
- __gen_e_acsl_at);
- __gen_e_acsl_assert_data_4.blocking = 1;
- __gen_e_acsl_assert_data_4.kind = "Postcondition";
- __gen_e_acsl_assert_data_4.pred_txt = "\\result == \\old(*p)";
- __gen_e_acsl_assert_data_4.file = "e-acsl-functions.c";
- __gen_e_acsl_assert_data_4.fct = "f";
- __gen_e_acsl_assert_data_4.line = 11;
- __e_acsl_assert(__retres == __gen_e_acsl_at,& __gen_e_acsl_assert_data_4);
- __e_acsl_assert_clean(& __gen_e_acsl_assert_data_4);
__e_acsl_delete_block((void *)(& p));
return __retres;
}
diff --git a/src/plugins/e-acsl/tests/special/oracle_dev/e-acsl-external-print-value.e-acsl.err.log b/src/plugins/e-acsl/tests/special/oracle_dev/e-acsl-external-print-value.e-acsl.err.log
index 3d675389171b08485dc090f06aa577328c2b2cc2..907aef209f7b7ad84611e61258a73f453f69faec 100644
--- a/src/plugins/e-acsl/tests/special/oracle_dev/e-acsl-external-print-value.e-acsl.err.log
+++ b/src/plugins/e-acsl/tests/special/oracle_dev/e-acsl-external-print-value.e-acsl.err.log
@@ -2,5 +2,5 @@ e-acsl-external-print-value.c: In function 'main'
e-acsl-external-print-value.c:7: Error: Assertion failed:
The failing predicate is:
\let x = value; \false.
- With values:
+ With values at failure point:
- custom print for value
diff --git a/src/plugins/e-acsl/tests/temporal/oracle/gen_t_memcpy.c b/src/plugins/e-acsl/tests/temporal/oracle/gen_t_memcpy.c
index 9b0a94e0efa8152db7d793b74336d09789904632..9d5021eb070b12afaed8be77738575b0bb47f472 100644
--- a/src/plugins/e-acsl/tests/temporal/oracle/gen_t_memcpy.c
+++ b/src/plugins/e-acsl/tests/temporal/oracle/gen_t_memcpy.c
@@ -738,11 +738,11 @@ void *__gen_e_acsl_memset(void *s, int c, size_t n)
void *__retres;
__e_acsl_store_block((void *)(& s),(size_t)8);
__e_acsl_temporal_pull_parameter((void *)(& s),0U,8UL);
+ __gen_e_acsl_at = s;
__e_acsl_temporal_reset_parameters();
__e_acsl_temporal_reset_return();
__e_acsl_temporal_save_nreferent_parameter((void *)(& s),0U);
__e_acsl_temporal_memset(s,c,n);
- __gen_e_acsl_at = s;
__retres = memset(s,c,n);
__e_acsl_initialize(s,n);
{
@@ -812,6 +812,7 @@ void *__gen_e_acsl_memcpy(void * restrict dest, void const * restrict src,
__e_acsl_store_block((void *)(& dest),(size_t)8);
__e_acsl_temporal_pull_parameter((void *)(& dest),0U,8UL);
__e_acsl_temporal_pull_parameter((void *)(& src),1U,8UL);
+ __gen_e_acsl_at = dest;
__e_acsl_assert_data_t __gen_e_acsl_assert_data_3 =
{.values = (void *)0};
__e_acsl_assert_data_t __gen_e_acsl_assert_data_4 =
@@ -955,7 +956,6 @@ void *__gen_e_acsl_memcpy(void * restrict dest, void const * restrict src,
__gmpz_clear(__gen_e_acsl_sub_2);
__gmpz_clear(__gen_e_acsl_add);
}
- __gen_e_acsl_at = dest;
__retres = memcpy(dest,src,n);
__e_acsl_initialize(dest,n);
{
diff --git a/src/plugins/markdown-report/tests/md/oracle/cwe126.0.md b/src/plugins/markdown-report/tests/md/oracle/cwe126.0.md
index bec42c33dbae166cc1c8012d038ecbacb61c977c..7cf06c232a619ad0ae15cd66cea3a3f08c8f3763 100644
--- a/src/plugins/markdown-report/tests/md/oracle/cwe126.0.md
+++ b/src/plugins/markdown-report/tests/md/oracle/cwe126.0.md
@@ -60,10 +60,10 @@ Table: Warning reported by Frama-C
| Location | Description |
|:---------|:------------|
-| cwe126.c:28 | `out of bounds read. assert \valid_read(data + i);` (emitted by `eva`) |
+| cwe126.c:29 | `out of bounds read. assert \valid_read(data + i);` (emitted by `eva`) |
-## Warning 0 (cwe126.c:28) {#warn-0}
+## Warning 0 (cwe126.c:29) {#warn-0}
Message:
@@ -87,10 +87,10 @@ Table: Alarm emitted by the analysis
| No | Kind | Emitter | Function | Location |
|:---:|:----:|:-------:|:---------|:---------|
-| [0](#alarm-0) | `mem_access` | `Eva` | `CWE126_Buffer_Overread__malloc_char_loop_64b_badSink` | cwe126.c:28 |
+| [0](#alarm-0) | `mem_access` | `Eva` | `CWE126_Buffer_Overread__malloc_char_loop_64b_badSink` | cwe126.c:29 |
-## Alarm 0 at cwe126.c:28 {#Alarm-0}
+## Alarm 0 at cwe126.c:29 {#Alarm-0}
The following ACSL assertion must hold to avoid invalid pointer dereferencing
(undefined behavior).
diff --git a/src/plugins/markdown-report/tests/md/oracle/cwe126.res.oracle b/src/plugins/markdown-report/tests/md/oracle/cwe126.res.oracle
index 50108574f1711d4c7645fac9762815c185b5edfc..2bf983554f62d4a90cb998a5d513591d124d9345 100644
--- a/src/plugins/markdown-report/tests/md/oracle/cwe126.res.oracle
+++ b/src/plugins/markdown-report/tests/md/oracle/cwe126.res.oracle
@@ -4,15 +4,15 @@
[eva] Initial state computed
[eva:initial-state] Values of globals at initialization
-[eva] cwe126.c:76: allocating variable __malloc_goodG2B_l76
+[eva] cwe126.c:77: allocating variable __malloc_goodG2B_l77
[eva] using specification for function exit
[eva] FRAMAC_SHARE/libc/string.h:134:
cannot evaluate ACSL term, unsupported ACSL construct: logic function memset
-[eva] cwe126.c:62: starting to merge loop iterations
-[eva] cwe126.c:40:
- allocating variable __malloc_CWE126_Buffer_Overread__malloc_char_loop_64_bad_l40
-[eva] cwe126.c:26: starting to merge loop iterations
-[eva:alarm] cwe126.c:28: Warning:
+[eva] cwe126.c:63: starting to merge loop iterations
+[eva] cwe126.c:41:
+ allocating variable __malloc_CWE126_Buffer_Overread__malloc_char_loop_64_bad_l41
+[eva] cwe126.c:27: starting to merge loop iterations
+[eva:alarm] cwe126.c:29: Warning:
out of bounds read. assert \valid_read(data + i);
[eva] done for function main
[eva] ====== VALUES COMPUTED ======
diff --git a/tests/libc/check_full_libc.sh b/tests/libc/check_full_libc.sh
index bce6a2f6159cad9a016c4032538ab74852c32dce..f325a41b0bd16259dfbb9b2930662d437c4b9193 100755
--- a/tests/libc/check_full_libc.sh
+++ b/tests/libc/check_full_libc.sh
@@ -4,14 +4,12 @@
errors=0
-if [ "$#" -ge 1 ] && [ -d "$1" ]; then
- cd "$1"
-else
- cd share/libc
-fi
+test_dir=$(pwd)
+share_libc="$1"
+cd "$share_libc"
for A in *.h */*.h; do
- if ! grep -q $A ../../tests/libc/fc_libc.c
+ if ! grep -q $A "$test_dir/fc_libc.c"
then
echo "missing include in tests/libc/fc_libc.c: $A"
errors=$((errors+1))
@@ -24,7 +22,7 @@ for A in *.h */*.h; do
done
for A in *.c */*.c; do
- if ! grep -q $A __fc_runtime.c ../../tests/libc/fc_libc.c
+ if ! grep -q $A __fc_runtime.c "$test_dir/fc_libc.c"
then
echo "missing include in share/libc/__fc_runtime.c or tests/libc/fc_libc.c: $A"
errors=$((errors+1))
diff --git a/tests/libc/check_parsing_individual_headers.ml b/tests/libc/check_parsing_individual_headers.ml
index 29066eb45e43d60b1375d4df389d319f1be5124d..cd7d83b4448114a0ec7bd50c1026266bf7fec008 100644
--- a/tests/libc/check_parsing_individual_headers.ml
+++ b/tests/libc/check_parsing_individual_headers.ml
@@ -7,16 +7,17 @@ let header_re = Str.regexp ".*\\.h$"
let is_header f = Str.string_match header_re f 0
(* Files which are *not* supposed to be parsed *)
-let blacklist () =
- let libc = (Filename.concat (Sys.getenv "FRAMAC_SHARE") "libc") in
+let blacklist libc_dir =
List.map (fun f ->
- Datatype.Filepath.of_string (Filename.concat libc f))
+ Datatype.Filepath.concat libc_dir f)
["tgmath.h"; "complex.h"; "__fc_machdep_linux_shared.h"]
(* only goes down one level, which is enough for the libc *)
-let collect_headers libc_dir =
+let collect_headers () =
+ let libc_dir = Kernel.Share.get_dir ~mode:`Must_exist "libc" in
+ let libc_dir_files = Array.to_list (Sys.readdir (libc_dir :> string)) in
let contents =
- List.map (Filename.concat libc_dir) (Array.to_list (Sys.readdir libc_dir))
+ List.map (Filename.concat (libc_dir :> string)) libc_dir_files
in
let subdirs = List.filter Sys.is_directory contents in
let base_headers = List.filter is_header contents in
@@ -29,7 +30,7 @@ let collect_headers libc_dir =
) base_headers subdirs
in
let all_headers = List.sort Extlib.compare_ignore_case all_headers in
- let to_skip = blacklist () in
+ let to_skip = blacklist libc_dir in
List.iter (fun header ->
let header_path = Datatype.Filepath.of_string header in
if List.mem header_path to_skip then
@@ -42,4 +43,4 @@ let collect_headers libc_dir =
) all_headers
let () =
- Db.Main.apply (collect_headers (Filename.concat (Sys.getenv "FRAMAC_SHARE") "libc"))
+ Db.Main.extend collect_headers
diff --git a/tests/libc/oracle/fc_libc.2.res.oracle b/tests/libc/oracle/fc_libc.2.res.oracle
index 4bd6354e3b0aafdba95b18b0a671fd8de7c8aebb..dc3e1747f8b51da5427112734c10885ea157d00a 100644
--- a/tests/libc/oracle/fc_libc.2.res.oracle
+++ b/tests/libc/oracle/fc_libc.2.res.oracle
@@ -1,3 +1,4 @@
+[kernel] Parsing fc_libc.c (with preprocessing)
[kernel] Parsing FRAMAC_SHARE/libc/__fc_alloc_axiomatic.h (with preprocessing)
[kernel] Parsing FRAMAC_SHARE/libc/__fc_builtin.h (with preprocessing)
[kernel] Parsing FRAMAC_SHARE/libc/__fc_define_blkcnt_t.h (with preprocessing)
@@ -154,4 +155,3 @@ skipping FRAMAC_SHARE/libc/tgmath.h
[kernel] Parsing FRAMAC_SHARE/libc/wchar.h (with preprocessing)
[kernel] Parsing FRAMAC_SHARE/libc/wctype.h (with preprocessing)
[kernel] Parsing FRAMAC_SHARE/libc/wordexp.h (with preprocessing)
-[kernel] Parsing fc_libc.c (with preprocessing)