diff --git a/src/plugins/e-acsl/share/e-acsl/e_acsl.h b/src/plugins/e-acsl/share/e-acsl/e_acsl.h
index 73003fc05401414c1d5fd33db14ef5a6361bf47f..249e65692e356519b1c7f3032eab640b29b634e8 100644
--- a/src/plugins/e-acsl/share/e-acsl/e_acsl.h
+++ b/src/plugins/e-acsl/share/e-acsl/e_acsl.h
@@ -89,11 +89,11 @@
/*** Generated code API {{{ ***/
/************************************************************************/
-#include "observation_model/e_acsl_observation_model.h"
#include "instrumentation_model/e_acsl_contract.h"
#include "instrumentation_model/e_acsl_temporal.h"
#include "numerical_model/e_acsl_floating_point.h"
#include "numerical_model/e_acsl_gmp_api.h"
+#include "observation_model/e_acsl_observation_model.h"
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/e_acsl_rtl.c b/src/plugins/e-acsl/share/e-acsl/e_acsl_rtl.c
index 4317ace0b93bc35b60ff88efe31380acb44035b1..a8ea00d2dcefad194a621fdada02adc85d1c0df9 100644
--- a/src/plugins/e-acsl/share/e-acsl/e_acsl_rtl.c
+++ b/src/plugins/e-acsl/share/e-acsl/e_acsl_rtl.c
@@ -22,7 +22,7 @@
/* Get default definitions and macros e.g., PATH_MAX */
#ifndef _DEFAULT_SOURCE
-# define _DEFAULT_SOURCE 1
+# define _DEFAULT_SOURCE 1
#endif
/* On Windows, setup minimum version to Windows 8 (or Server 2012) to be able to
@@ -30,7 +30,7 @@
Check directly for windows instead of using E_ACSL_OS_IS_WINDOWS so that it
can be done without including anything. */
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32)
-# define _WIN32_WINNT 0x0602
+# define _WIN32_WINNT 0x0602
#endif
// Internals
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 e0d8412b1730aed33e1e71071ffa6e7208121b08..f5903c27cebde17678869f611dc67b077a86ea81 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,22 +37,23 @@ int eacsl_runtime_sound_verdict = 1;
#ifndef E_ACSL_EXTERNAL_ASSERT
/*! \brief Default implementation of E-ACSL runtime assertions */
void eacsl_runtime_assert(int predicate, int blocking, const char *kind,
- const char *fct, const char *pred_txt, const char * file, int line) {
+ const char *fct, const char *pred_txt,
+ const char *file, int line) {
if (eacsl_runtime_sound_verdict) {
- if (! predicate) {
+ if (!predicate) {
STDERR("%s: In function '%s'\n"
"%s:%d: Error: %s failed:\n"
"\tThe failing predicate is:\n"
"\t%s.\n",
file, fct, file, line, kind, pred_txt);
if (blocking) {
-#ifndef E_ACSL_NO_ASSERT_FAIL /* Do fail on assertions */
-#ifdef E_ACSL_FAIL_EXITCODE /* Fail by exit with a given code */
+# ifndef E_ACSL_NO_ASSERT_FAIL /* Do fail on assertions */
+# ifdef E_ACSL_FAIL_EXITCODE /* Fail by exit with a given code */
exit(E_ACSL_FAIL_EXITCODE);
-#else
+# else
raise_abort(file, line); /* Raise abort signal */
-#endif
-#endif
+# endif
+# endif
}
}
} else
@@ -60,6 +61,6 @@ void eacsl_runtime_assert(int predicate, int blocking, const char *kind,
"%s:%d: Warning: no sound verdict for %s (guess: %s).\n"
"\tthe considered predicate is:\n"
"\t%s\n",
- file, fct, file, line, kind, predicate ? "ok": "FAIL", pred_txt);
+ file, fct, file, line, kind, predicate ? "ok" : "FAIL", pred_txt);
}
#endif
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.h b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.h
index 3703a649266fd80b5a906150fb9ac2ab245c58eb..5a7dec8c2e9af58f59269a73abcc152cbddad4c3 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.h
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_assert.h
@@ -57,7 +57,8 @@ extern int __attribute__((FC_BUILTIN)) eacsl_runtime_sound_verdict;
@ complete behaviors;
@ disjoint behaviors; */
void eacsl_runtime_assert(int pred, int blocking, const char *kind,
- const char *fct, const char *pred_txt, const char * file, int line)
- __attribute__((FC_BUILTIN));
+ const char *fct, const char *pred_txt,
+ const char *file, int line)
+ __attribute__((FC_BUILTIN));
#endif // E_ACSL_ASSERT_H
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.c b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.c
index 4a373c803dc81736e8d7fd25cc3dcdcd2d542904..14c827d425f2b8afa03ebf6202e0d6d83be15c2e 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.c
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.c
@@ -35,124 +35,124 @@
/*! \brief Return the index of the `char` where the bit number
`global_bit_index` is located. */
static inline size_t find_char_index(size_t global_bit_index) {
- return global_bit_index / CHAR_BIT;
+ return global_bit_index / CHAR_BIT;
}
/*! \brief Return the index of the bit in the `char` given by
\ref find_char_index for the bit number `global_bit_index`. */
static inline size_t find_bit_index(size_t global_bit_index) {
- return global_bit_index % CHAR_BIT;
+ return global_bit_index % CHAR_BIT;
}
/*! \brief Return the number of `char` to allocate to store `bit_count` bits. */
static inline size_t find_char_count(size_t bit_count) {
- size_t char_count = bit_count / CHAR_BIT;
- if (bit_count % CHAR_BIT > 0) {
- ++char_count;
- }
- return char_count;
+ size_t char_count = bit_count / CHAR_BIT;
+ if (bit_count % CHAR_BIT > 0) {
+ ++char_count;
+ }
+ return char_count;
}
/*! \brief Normalize the boolean parameter `value` to 0 or 1 */
static inline int normalize_to_boolean(int value) {
- return value ? 1 : 0;
+ return value ? 1 : 0;
}
/* Documented in e_acsl.h */
struct contract_t {
- /*! \brief Number of cells in the char array used to store the results of
+ /*! \brief Number of cells in the char array used to store the results of
* the assumes clauses.
*/
- size_t char_count;
+ size_t char_count;
- /*! \brief Char array to store the results of the assumes clauses. One bit
+ /*! \brief Char array to store the results of the assumes clauses. One bit
* per behavior.
*
* The functions \ref find_char_index() and \ref find_bit_index() can be
* used to find the location of the bit for a specific behavior. */
- char * assumes;
+ char *assumes;
};
/* Documented in e_acsl.h */
-contract_t * contract_init(size_t size) {
- // Allocate memory for the structure
- contract_t * c = malloc(sizeof(contract_t));
- DVASSERT(c != NULL,
- "Unable to allocate %d bytes of memory for contract_t",
- sizeof(contract_t));
-
- // Compute the number of char needed to store `size` behaviors, assuming
- // that one behavior is stored in one bit.
- c->char_count = find_char_count(size);
-
- // Allocate an array of char of the computed count
- if (c->char_count > 0) {
- c->assumes = calloc(c->char_count, sizeof(char));
- DVASSERT(c->assumes != NULL,
- "Unable to allocate %d cells of %d bytes of memory for contract_t::assumes",
- c->char_count, sizeof(char));
- } else {
- c->assumes = NULL;
- }
-
- return c;
+contract_t *contract_init(size_t size) {
+ // Allocate memory for the structure
+ contract_t *c = malloc(sizeof(contract_t));
+ DVASSERT(c != NULL, "Unable to allocate %d bytes of memory for contract_t",
+ sizeof(contract_t));
+
+ // Compute the number of char needed to store `size` behaviors, assuming
+ // that one behavior is stored in one bit.
+ c->char_count = find_char_count(size);
+
+ // Allocate an array of char of the computed count
+ if (c->char_count > 0) {
+ c->assumes = calloc(c->char_count, sizeof(char));
+ DVASSERT(c->assumes != NULL,
+ "Unable to allocate %d cells of %d bytes of memory for "
+ "contract_t::assumes",
+ c->char_count, sizeof(char));
+ } else {
+ c->assumes = NULL;
+ }
+
+ return c;
}
/* Documented in e_acsl.h */
-void contract_clean(contract_t * c) {
- // Free array of char
- free(c->assumes);
- // Free structure
- free(c);
+void contract_clean(contract_t *c) {
+ // Free array of char
+ free(c->assumes);
+ // Free structure
+ free(c);
}
/* Documented in e_acsl.h */
-void contract_set_behavior_assumes(contract_t * c, size_t i, int assumes) {
- size_t char_idx = find_char_index(i);
- DVASSERT(char_idx < c->char_count,
- "Out of bound char index %d (char_count: %d)",
- char_idx, c->char_count);
- size_t bit_idx = find_bit_index(i);
- assumes = normalize_to_boolean(assumes);
- c->assumes[char_idx] |= (assumes<<bit_idx);
+void contract_set_behavior_assumes(contract_t *c, size_t i, int assumes) {
+ size_t char_idx = find_char_index(i);
+ DVASSERT(char_idx < c->char_count,
+ "Out of bound char index %d (char_count: %d)", char_idx,
+ c->char_count);
+ size_t bit_idx = find_bit_index(i);
+ assumes = normalize_to_boolean(assumes);
+ c->assumes[char_idx] |= (assumes << bit_idx);
}
/* Documented in e_acsl.h */
-int contract_get_behavior_assumes(const contract_t * c, size_t i) {
- size_t char_idx = find_char_index(i);
- DVASSERT(char_idx < c->char_count,
- "Out of bound char index %d (char_count: %d)",
- char_idx, c->char_count);
- size_t bit_idx = find_bit_index(i);
- int result = c->assumes[char_idx] & (1<<bit_idx);
- return normalize_to_boolean(result);
+int contract_get_behavior_assumes(const contract_t *c, size_t i) {
+ size_t char_idx = find_char_index(i);
+ DVASSERT(char_idx < c->char_count,
+ "Out of bound char index %d (char_count: %d)", char_idx,
+ c->char_count);
+ size_t bit_idx = find_bit_index(i);
+ int result = c->assumes[char_idx] & (1 << bit_idx);
+ return normalize_to_boolean(result);
}
/* Documented in e_acsl.h */
-int contract_partial_count_behaviors(const contract_t * c, size_t count, ...) {
- va_list args;
- va_start(args, count);
+int contract_partial_count_behaviors(const contract_t *c, size_t count, ...) {
+ va_list args;
+ va_start(args, count);
- int result = 0;
- for (size_t i = 0 ; i < 2 && i < count ; ++i) {
- result += contract_get_behavior_assumes(c, va_arg(args, int));
- }
+ int result = 0;
+ for (size_t i = 0; i < 2 && i < count; ++i) {
+ result += contract_get_behavior_assumes(c, va_arg(args, int));
+ }
- va_end(args);
- return result;
+ va_end(args);
+ return result;
}
/* Documented in e_acsl.h */
-int contract_partial_count_all_behaviors(const contract_t * c) {
- int result = 0;
- for (int i = 0 ; i < c->char_count && result < 2 ; ++i) {
- // Counting bits set with Kernighan's algorithm, but stopping at two
- // bits set.
- // cf. <https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan>
- unsigned char assumes_cell = c->assumes[i];
- for (; assumes_cell && result < 2 ; ++result) {
- assumes_cell &= assumes_cell - 1;
- }
+int contract_partial_count_all_behaviors(const contract_t *c) {
+ int result = 0;
+ for (int i = 0; i < c->char_count && result < 2; ++i) {
+ // Counting bits set with Kernighan's algorithm, but stopping at two
+ // bits set.
+ // cf. <https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan>
+ unsigned char assumes_cell = c->assumes[i];
+ for (; assumes_cell && result < 2; ++result) {
+ assumes_cell &= assumes_cell - 1;
}
- return result;
+ }
+ return result;
}
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.h b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.h
index 2ec0e0efc23cb88fd8943c7e6d2b2cdedc7d50a4..98fa261bf28779ec3281cb2665512daacf830a9c 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.h
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_contract.h
@@ -33,18 +33,22 @@
#include "../internals/e_acsl_alias.h"
#ifdef __FC_STDLIB
-#include <__fc_alloc_axiomatic.h>
+# include <__fc_alloc_axiomatic.h>
#else
/*@ ghost extern int __fc_heap_status; */
#endif
-#define contract_t export_alias(contract_t)
-#define contract_init export_alias(contract_init)
-#define contract_clean export_alias(contract_clean)
-#define contract_set_behavior_assumes export_alias(contract_set_behavior_assumes)
-#define contract_get_behavior_assumes export_alias(contract_get_behavior_assumes)
-#define contract_partial_count_behaviors export_alias(contract_partial_count_behaviors)
-#define contract_partial_count_all_behaviors export_alias(contract_partial_count_all_behaviors)
+#define contract_t export_alias(contract_t)
+#define contract_init export_alias(contract_init)
+#define contract_clean export_alias(contract_clean)
+#define contract_set_behavior_assumes \
+ export_alias(contract_set_behavior_assumes)
+#define contract_get_behavior_assumes \
+ export_alias(contract_get_behavior_assumes)
+#define contract_partial_count_behaviors \
+ export_alias(contract_partial_count_behaviors)
+#define contract_partial_count_all_behaviors \
+ export_alias(contract_partial_count_all_behaviors)
/*! \brief Structure to hold pieces of information about function and statement
* contracts at runtime. */
@@ -58,7 +62,7 @@ typedef struct contract_t __attribute__((__FC_BUILTIN__)) contract_t;
*/
/*@ assigns \result \from indirect:__fc_heap_status, indirect:size;
@ admit ensures \valid(\result); */
-contract_t * contract_init(size_t size) __attribute__((FC_BUILTIN));
+contract_t *contract_init(size_t size) __attribute__((FC_BUILTIN));
/*! \brief Cleanup the structure `c` previously allocated by
* \ref contract_init.
@@ -67,7 +71,7 @@ contract_t * contract_init(size_t size) __attribute__((FC_BUILTIN));
*/
/*@ requires \valid(c);
@ assigns \nothing; */
-void contract_clean(contract_t * c) __attribute__((FC_BUILTIN));
+void contract_clean(contract_t *c) __attribute__((FC_BUILTIN));
/*! \brief Set the result of the assumes clauses for the behavior `i` in the
* structure.
@@ -79,8 +83,8 @@ void contract_clean(contract_t * c) __attribute__((FC_BUILTIN));
*/
/*@ requires \valid(c);
@ assigns *c \from indirect:c, indirect:i, assumes; */
-void contract_set_behavior_assumes(contract_t * c, size_t i, int assumes)
- __attribute__((FC_BUILTIN));
+void contract_set_behavior_assumes(contract_t *c, size_t i, int assumes)
+ __attribute__((FC_BUILTIN));
/*! \brief Retrieve the result of the assumes clauses for the behavior `i` from
* the structure.
@@ -94,8 +98,8 @@ void contract_set_behavior_assumes(contract_t * c, size_t i, int assumes)
/*@ requires \valid_read(c);
@ assigns \result \from indirect:c, indirect:i;
@ ensures \result == 0 || \result == 1; */
-int contract_get_behavior_assumes(const contract_t * c, size_t i)
- __attribute__((FC_BUILTIN));
+int contract_get_behavior_assumes(const contract_t *c, size_t i)
+ __attribute__((FC_BUILTIN));
/*! \brief Count the number of active behaviors among the `count` given
* behaviors.
@@ -108,8 +112,8 @@ int contract_get_behavior_assumes(const contract_t * c, size_t i)
* \return 0 if no behaviors are active, 1 if exactly one behavior is active,
* and 2 if more than one behavior is active.
*/
-int contract_partial_count_behaviors(const contract_t * c, size_t count, ...)
- __attribute__((FC_BUILTIN));
+int contract_partial_count_behaviors(const contract_t *c, size_t count, ...)
+ __attribute__((FC_BUILTIN));
/*! \brief Count the number of active behaviors among all the behaviors of the
* contract.
@@ -118,7 +122,7 @@ int contract_partial_count_behaviors(const contract_t * c, size_t count, ...)
* \return 0 if no behaviors are active, 1 if exactly one behavior is active,
* and 2 if more than one behavior is active.
*/
-int contract_partial_count_all_behaviors(const contract_t * c)
- __attribute__((FC_BUILTIN));
+int contract_partial_count_all_behaviors(const contract_t *c)
+ __attribute__((FC_BUILTIN));
#endif
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.c b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.c
index 37c0d97959f8ba8c997ec0305dc231ba9c045cef..12fdd8f1d76e474d1995570f79b99ca17228ea56 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.c
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.c
@@ -22,14 +22,14 @@
#ifdef E_ACSL_TEMPORAL
-#include <stddef.h>
+# include <stddef.h>
-#include "../internals/e_acsl_private_assert.h"
-#include "../observation_model/internals/e_acsl_omodel_debug.h"
-#include "../observation_model/internals/e_acsl_timestamp_retrieval.h"
-#include "e_acsl_temporal_timestamp.h"
+# include "../internals/e_acsl_private_assert.h"
+# include "../observation_model/internals/e_acsl_omodel_debug.h"
+# include "../observation_model/internals/e_acsl_timestamp_retrieval.h"
+# include "e_acsl_temporal_timestamp.h"
-#include "e_acsl_temporal.h"
+# include "e_acsl_temporal.h"
/* Temporal store {{{ */
void eacsl_temporal_store_nblock(void *lhs, void *rhs) {
@@ -45,7 +45,7 @@ void eacsl_temporal_store_nreferent(void *lhs, void *rhs) {
void eacsl_temporal_memcpy(void *dest, void *src, size_t size) {
/* Memcpy is only relevant for pointers here, so if there is a
* copy under a pointer's size then there no point in copying memory*/
- if (size >= sizeof(void*)) {
+ if (size >= sizeof(void *)) {
DVALIDATE_ALLOCATED(src, size, src);
DVALIDATE_WRITEABLE(dest, size, dest);
void *dest_shadow = (void *)temporal_referent_shadow(dest);
@@ -79,18 +79,18 @@ void eacsl_temporal_save_copy_parameter(void *ptr, unsigned int param) {
void eacsl_temporal_pull_parameter(void *ptr, unsigned int param, size_t size) {
struct temporal_parameter *tpar = ¶meter_referents[param];
- switch(tpar->temporal_flow) {
- case TBlockN:
- store_temporal_referent(ptr, origin_timestamp(tpar->ptr));
- break;
- case TReferentN:
- store_temporal_referent(ptr, referent_timestamp(tpar->ptr));
- break;
- case TCopy:
- eacsl_temporal_memcpy(ptr, tpar->ptr, size);
- break;
- default:
- private_assert(0, "Unreachable", NULL);
+ switch (tpar->temporal_flow) {
+ case TBlockN:
+ store_temporal_referent(ptr, origin_timestamp(tpar->ptr));
+ break;
+ case TReferentN:
+ store_temporal_referent(ptr, referent_timestamp(tpar->ptr));
+ break;
+ case TCopy:
+ eacsl_temporal_memcpy(ptr, tpar->ptr, size);
+ break;
+ default:
+ private_assert(0, "Unreachable", NULL);
}
}
@@ -101,7 +101,7 @@ void eacsl_temporal_reset_parameters() {
/* Return values {{{ */
void eacsl_temporal_save_return(void *ptr) {
- return_referent = (ptr, sizeof(void*)) ? referent_timestamp(ptr) : 0;
+ return_referent = (ptr, sizeof(void *)) ? referent_timestamp(ptr) : 0;
}
void eacsl_temporal_pull_return(void *ptr) {
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.h b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.h
index b7fc3940d502797fd47cbde0cb3f788b0bd0a445..19db388feb228e736a3901387c6df4947f6ca31e 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.h
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal.h
@@ -54,13 +54,13 @@
* store it as a referent number of a pointer given by `ptr_addr`. */
/*@ assigns \nothing; */
void eacsl_temporal_store_nblock(void *lhs, void *rhs)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief Same as `eacsl_temporal_store_nblock` but take a referent
* number of `block_addr` instead */
/*@ assigns \nothing; */
void eacsl_temporal_store_nreferent(void *lhs, void *rhs)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* }}} */
@@ -70,13 +70,13 @@ void eacsl_temporal_store_nreferent(void *lhs, void *rhs)
* [dest, dest + size]. Counterpart of the memcpy function */
/*@ assigns \nothing; */
void eacsl_temporal_memcpy(void *dest, void *src, size_t size)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief Set temporal shadow data from [src, src + size] to 0.
* Counterpart of memset the function */
/*@ assigns \nothing; */
void eacsl_temporal_memset(void *dest, int c, size_t size)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* }}} */
/* Function parameters {{{ */
@@ -85,30 +85,29 @@ void eacsl_temporal_memset(void *dest, int c, size_t size)
* in the global parameter array. */
/*@ assigns \nothing; */
void eacsl_temporal_save_nblock_parameter(void *ptr, unsigned int param)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief store struct { .ptr = ptr, .temporal_flow = TReferentN }
* in the global parameter array. */
/*@ assigns \nothing; */
void eacsl_temporal_save_nreferent_parameter(void *ptr, unsigned int param)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief store struct { .ptr = ptr, .temporal_flow = TCopy } in the global
* parameter array. */
/*@ assigns \nothing; */
void eacsl_temporal_save_copy_parameter(void *ptr, unsigned int param)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief Assign a referent number of `ptr` based on the record in the global
* parameter array at index `param`. */
/*@ assigns \nothing; */
void eacsl_temporal_pull_parameter(void *ptr, unsigned int param, size_t size)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief Nullify global parameter array */
/*@ assigns \nothing; */
-void eacsl_temporal_reset_parameters()
- __attribute__((FC_BUILTIN));
+void eacsl_temporal_reset_parameters() __attribute__((FC_BUILTIN));
/* }}} */
/* Return values {{{ */
@@ -116,20 +115,17 @@ void eacsl_temporal_reset_parameters()
/*! \brief Save temporal referent number of `ptr` in a placeholder variable
* tracking the referent number of a function's return. */
/*@ assigns \nothing; */
-void eacsl_temporal_save_return(void *ptr)
- __attribute__((FC_BUILTIN));
+void eacsl_temporal_save_return(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Take a temporal referent stored in the placeholder tracking return
* values as a temporal referent number of `ptr`. */
/*@ assigns \nothing; */
-void eacsl_temporal_pull_return(void *ptr)
- __attribute__((FC_BUILTIN));
+void eacsl_temporal_pull_return(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Nullify a placeholder variable tracking the referent number of a
* function's return. */
/*@ assigns \nothing; */
-void eacsl_temporal_reset_return()
- __attribute__((FC_BUILTIN));
+void eacsl_temporal_reset_return() __attribute__((FC_BUILTIN));
/* }}} */
/* Temporal valid {{{ */
diff --git a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal_timestamp.h b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal_timestamp.h
index 95efda841b4b3bf058698a4a4868a5135e92a192..754973dd26cb0c67a8e2f41897327c4a22d567ed 100644
--- a/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal_timestamp.h
+++ b/src/plugins/e-acsl/share/e-acsl/instrumentation_model/e_acsl_temporal_timestamp.h
@@ -30,8 +30,8 @@
#ifdef E_ACSL_TEMPORAL /*{{{*/
-#include "../internals/e_acsl_rtl_string.h"
-#include <stdint.h>
+# include "../internals/e_acsl_rtl_string.h"
+# include <stdint.h>
/*! Temporal time stamp generator variable
* Time stamp is generated by incrementing `temporal_timestamp` variable.
@@ -43,23 +43,19 @@
* `>1` - heap or stack blocks allocated during a program's execution */
static uint32_t temporal_timestamp = 2;
-#define INVALID_TEMPORAL_TIMESTAMP 0
-#define GLOBAL_TEMPORAL_TIMESTAMP 1
-#define NEW_TEMPORAL_TIMESTAMP() (++temporal_timestamp)
+# define INVALID_TEMPORAL_TIMESTAMP 0
+# define GLOBAL_TEMPORAL_TIMESTAMP 1
+# define NEW_TEMPORAL_TIMESTAMP() (++temporal_timestamp)
/*! Maximal number of parameters a function can accept
* [ C99, 5.2.4.1 Translation Limits ] */
-#define MAX_PARAMETERS 127
+# define MAX_PARAMETERS 127
struct temporal_parameter {
void *ptr;
/* Number all members such that there is no `0` which potentially
corresponds to an invalid number */
- enum {
- TBlockN = 10,
- TReferentN = 20,
- TCopy = 30
- } temporal_flow;
+ enum { TBlockN = 10, TReferentN = 20, TCopy = 30 } temporal_flow;
};
typedef struct temporal_parameter temporal_parameter;
@@ -72,8 +68,8 @@ typedef struct temporal_parameter temporal_parameter;
static temporal_parameter parameter_referents[MAX_PARAMETERS];
static uint32_t return_referent;
-#define reset_parameter_referents() \
- memset(parameter_referents, 0, sizeof(parameter_referents))
+# define reset_parameter_referents() \
+ memset(parameter_referents, 0, sizeof(parameter_referents))
#endif /*}}} E_ACSL_TEMPORAL */
#endif /*}}} E_ACSL_TEMPORAL_TIMESTAMP */
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_alias.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_alias.h
index f73d7a1eec6e15ee57075128c1da50649b969a7f..7d06fc912e400d8cee8d2155e40c4824e4057c5a 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_alias.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_alias.h
@@ -29,11 +29,11 @@
#define E_ACSL_ALIAS_H
/* Concatenation of 2 tokens */
-# define preconcat(x,y) x ## y
-# define concat(x,y) preconcat(x,y)
+#define preconcat(x, y) x##y
+#define concat(x, y) preconcat(x, y)
/** Prefix of public functions */
-# define export_prefix __e_acsl_
+#define export_prefix __e_acsl_
/** Add public prefix to an identifier */
-# define export_alias(_n) concat(export_prefix, _n)
+#define export_alias(_n) concat(export_prefix, _n)
#endif
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_bits.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_bits.h
index b1e16bbff65c9530c22001228838abb89cc3eb3f..62c29c47afa0758cb0ae61d73133df89eec34ed3 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_bits.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_bits.h
@@ -38,8 +38,8 @@
#ifndef E_ACSL_BITS_H
#define E_ACSL_BITS_H
-#include <stdint.h>
#include <stddef.h>
+#include <stdint.h>
/* Bit-level manipulations {{{ */
@@ -54,7 +54,7 @@
* int x = 0; // x => 0000 0000 ...
* bitset(0, x) // x => 1000 0000 ...
* bitset(7, x) // x => 1000 0001 ... */
-#define setbit(_bit,_number) (_number |= 1 << _bit)
+#define setbit(_bit, _number) (_number |= 1 << _bit)
/** Same as bitset but the `_bit` bit is cleared (i.e., set of zero) */
#define clearbit(_bit, _number) (_number &= ~(1 << _bit))
@@ -73,7 +73,7 @@
#define togglebit(_bit, _number) (_number ^= 1 << _bit)
/** Set a given bit to a specified value (e.g., 0 or 1). */
-#define changebit(_bit, _val, _number) \
+#define changebit(_bit, _val, _number) \
(_number ^= (-_val ^ _number) & (1 << _bit))
/** Set up to 64 bits from left to right to ones.
@@ -81,14 +81,14 @@
* int x = 0; // x => 00000000 00000000 ...
* setbits64(11, x) // => 11111111 11100000 ...
* setbits64(64, x) // => behaviour undefined */
-#define setbits64(_bits, _number) (_number |= ~(ONE << _bits))
+#define setbits64(_bits, _number) (_number |= ~(ONE << _bits))
/** Set up to 64 bits from left to right to ones skiping `_skip` leftmost bits
* Example:
* int x = 0; // x => 00000000 00000000 ...
* setbits64(11, x, 2) // => 00111111 11111000 ...
* setbits64(64, x, 2) // => behaviour undefined */
-#define setbits64_skip(_bits, _number, _skip) \
+#define setbits64_skip(_bits, _number, _skip) \
(_number |= ~(ONE << _bits) << _skip)
/** Evaluate to 1 if up to 64 bits from left to right in `_number` are set:
@@ -98,8 +98,8 @@
* checkbits64(5, x) // => 1
* checkbits64(6, x) // => 0
* checkbits64(64, x) // => behaviour undefined */
-#define checkbits64(_bits, _number) \
- ((_number & ~(ONE << _bits)) == (~(ONE << _bits)))
+#define checkbits64(_bits, _number) \
+ ((_number & ~(ONE << _bits)) == (~(ONE << _bits)))
/** Same as checkbits64 but with skipping `_skip` leftmost bits
* Example:
@@ -109,7 +109,7 @@
* checkbits64_skip(5, x, 2) // => 0
* checkbits64_skip(3, x, 1) // => 0
* checkbits64_skip(64, x, 0) // => behaviour undefined */
-#define checkbits64_skip(_bits, _number, _skip) \
+#define checkbits64_skip(_bits, _number, _skip) \
((_number & ~(ONE << _bits) << _skip) == (~(ONE << _bits) << _skip))
/** Same as `setbits64' but clear the bits (set to zeroes). */
@@ -119,7 +119,7 @@
* Example:
* long x = 0; // x => ... 00000000 00000000 00000000 00000000
* setbits64_right(10, x) // x => ... 00000000 00000000 00000011 11111111 */
-#define setbits64_right(_bits, _number) (_number |= ~(ONE >> _bits))
+#define setbits64_right(_bits, _number) (_number |= ~(ONE >> _bits))
/** Same as setbits64_right but clears bits (sets to zeroes) */
#define clearbits64_right(_bits, _number) (_number &= ONE >> _bits)
@@ -131,30 +131,30 @@
* setbits(&a, 11); // => 11111111 11100000 00000000 00000000 */
static inline void setbits(size_t size, void *ptr) {
size_t i;
- int64_t *lp = (int64_t*)ptr;
- for (i = 0; i < size/64; i++)
- *(lp+i) |= ONE;
- setbits64(size%64, *(lp+i));
+ int64_t *lp = (int64_t *)ptr;
+ for (i = 0; i < size / 64; i++)
+ *(lp + i) |= ONE;
+ setbits64(size % 64, *(lp + i));
}
/** Same as `setbits' but clear the bits (set to zeroes). */
static inline void clearbits(size_t size, void *ptr) {
size_t i;
- int64_t *lp = (int64_t*)ptr;
- for (i = 0; i < size/64; i++)
- *(lp+i) &= ZERO;
- clearbits64(size%64, *(lp+i));
+ int64_t *lp = (int64_t *)ptr;
+ for (i = 0; i < size / 64; i++)
+ *(lp + i) &= ZERO;
+ clearbits64(size % 64, *(lp + i));
}
/** Same as `setbits' but clear the bits (set to zeroes). */
static inline int checkbits(size_t size, void *ptr) {
size_t i;
- int64_t *lp = (int64_t*)ptr;
- for (i = 0; i < size/64; i++) {
- if (*(lp+i) != ONE)
+ int64_t *lp = (int64_t *)ptr;
+ for (i = 0; i < size / 64; i++) {
+ if (*(lp + i) != ONE)
return 0;
}
- return checkbits64(size%64, *(lp+i));
+ return checkbits64(size % 64, *(lp + i));
}
/** Same as `setbits' but set the bits from right to left
@@ -164,19 +164,19 @@ static inline int checkbits(size_t size, void *ptr) {
* setbits_right(&a, 11); // => 00000000 00000000 00000111 11111111 */
static inline void setbits_right(size_t size, void *ptr) {
size_t i = 0;
- int64_t *lp = (int64_t*)ptr - 1;
- for (i = 0; i < size/64; i++)
- *(lp-i) |= ONE;
- setbits64_right(size%64, *(lp-i));
+ int64_t *lp = (int64_t *)ptr - 1;
+ for (i = 0; i < size / 64; i++)
+ *(lp - i) |= ONE;
+ setbits64_right(size % 64, *(lp - i));
}
/** Same as `setbits_right' but clear the bits (set to zeroes). */
static inline void clearbits_right(size_t size, void *ptr) {
size_t i = 0;
- int64_t *lp = (int64_t*)ptr - 1;
- for (i = 0; i < size/64; i++)
- *(lp-i) &= ZERO;
- clearbits64_right(size%64, *(lp-i));
+ int64_t *lp = (int64_t *)ptr - 1;
+ for (i = 0; i < size / 64; i++)
+ *(lp - i) &= ZERO;
+ clearbits64_right(size % 64, *(lp - i));
}
#endif // E_ACSL_BITS_H
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_config.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_config.h
index 7ab971cc8b2ea03672415c85629ed54d3c755b94..51be6c9227f9f9b92156218188752941bd32ab0f 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_config.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_config.h
@@ -34,9 +34,9 @@
// OS detection
// - Assign values to specific OSes
-#define E_ACSL_OS_LINUX_VALUE 1
+#define E_ACSL_OS_LINUX_VALUE 1
#define E_ACSL_OS_WINDOWS_VALUE 2
-#define E_ACSL_OS_OTHER_VALUE 999
+#define E_ACSL_OS_OTHER_VALUE 999
// - Declare defines to test for a specific OS
/*!
* \brief True if the target OS is linux, false otherwise
@@ -53,14 +53,14 @@
// - Check current OS
#ifdef __linux__
// Linux compilation
-# define E_ACSL_OS E_ACSL_OS_LINUX_VALUE
+# define E_ACSL_OS E_ACSL_OS_LINUX_VALUE
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32)
// Windows compilation
-# define E_ACSL_OS E_ACSL_OS_WINDOWS_VALUE
+# define E_ACSL_OS E_ACSL_OS_WINDOWS_VALUE
#else
// Other
-# define E_ACSL_OS E_ACSL_OS_OTHER_VALUE
-# error "Unsupported OS for E-ACSL RTL"
+# define E_ACSL_OS E_ACSL_OS_OTHER_VALUE
+# error "Unsupported OS for E-ACSL RTL"
#endif
#endif // E_ACSL_CONFIG_H
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.c
index 0056305c84da1217fe05c768fb1d54b86d48c60c..61e1ebb6b89b9c3a0d9b23371eb90d42723be0db 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.c
@@ -20,8 +20,8 @@
/* */
/**************************************************************************/
-#include <sys/stat.h>
#include <fcntl.h>
+#include <sys/stat.h>
#include "../observation_model/internals/e_acsl_omodel_debug.h"
#include "e_acsl_config.h"
@@ -46,13 +46,14 @@ void initialize_report_file(int *argc, char ***argv) {
if (!strcmp(dlog_name, "-") || !strcmp(dlog_name, "1")) {
dlog_fd = 2;
} else {
-#if E_ACSL_OS_IS_LINUX
- dlog_fd = open(dlog_name, O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK
- | O_NOCTTY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-#elif E_ACSL_OS_IS_WINDOWS
- dlog_fd = _open(dlog_name, _O_WRONLY | _O_CREAT | _O_TRUNC,
- _S_IREAD | _S_IWRITE);
-#endif
+# if E_ACSL_OS_IS_LINUX
+ dlog_fd =
+ open(dlog_name, O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK | O_NOCTTY,
+ S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+# elif E_ACSL_OS_IS_WINDOWS
+ dlog_fd =
+ _open(dlog_name, _O_WRONLY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE);
+# endif
}
if (dlog_fd == -1)
private_abort("Cannot open file descriptor for %s\n", dlog_name);
@@ -62,39 +63,41 @@ void initialize_report_file(int *argc, char ***argv) {
// }}}
#ifdef E_ACSL_WEAK_VALIDITY
-# define E_ACSL_VALIDITY_DESC "weak"
+# define E_ACSL_VALIDITY_DESC "weak"
#else
-# define E_ACSL_VALIDITY_DESC "strong"
+# define E_ACSL_VALIDITY_DESC "strong"
#endif
#ifdef E_ACSL_NO_ASSERT_FAIL
-# define E_ACSL_ASSERT_NO_FAIL_DESC "pass through"
+# define E_ACSL_ASSERT_NO_FAIL_DESC "pass through"
#else
-# define E_ACSL_ASSERT_NO_FAIL_DESC "abort"
+# define E_ACSL_ASSERT_NO_FAIL_DESC "abort"
#endif
#ifdef E_ACSL_TEMPORAL
-#define E_ACSL_TEMPORAL_DESC "enabled"
+# define E_ACSL_TEMPORAL_DESC "enabled"
#else
-# define E_ACSL_TEMPORAL_DESC "disabled"
+# define E_ACSL_TEMPORAL_DESC "disabled"
#endif // E_ACSL_TEMPORAL
#ifndef E_ACSL_VALIDATE_FORMAT_STRINGS
-# define E_ACSL_FORMAT_VALIDITY_DESC "disabled"
+# define E_ACSL_FORMAT_VALIDITY_DESC "disabled"
#else
-# define E_ACSL_FORMAT_VALIDITY_DESC "enabled"
+# define E_ACSL_FORMAT_VALIDITY_DESC "enabled"
#endif // E_ACSL_VALIDATE_FORMAT_STRINGS
void describe_run() {
#if defined(E_ACSL_VERBOSE)
- rtl_printf("/* ========================================================= */\n");
- rtl_printf(" * E-ACSL instrumented run\n" );
+ rtl_printf(
+ "/* ========================================================= */\n");
+ rtl_printf(" * E-ACSL instrumented run\n");
rtl_printf(" * Execution mode: %s\n", E_ACSL_DEBUG_DESC);
describe_observation_model();
rtl_printf(" * Assertions mode: %s\n", E_ACSL_ASSERT_NO_FAIL_DESC);
rtl_printf(" * Validity notion: %s\n", E_ACSL_VALIDITY_DESC);
rtl_printf(" * Temporal checks: %s\n", E_ACSL_TEMPORAL_DESC);
rtl_printf(" * Format Checks: %s\n", E_ACSL_FORMAT_VALIDITY_DESC);
- rtl_printf("/* ========================================================= */\n");
+ rtl_printf(
+ "/* ========================================================= */\n");
#endif
}
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.h
index ed317ec0639705633cf861989f10f9f0c905930b..82c85d10bc79d07e4ca2b157dee97a3da3176a1f 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_debug.h
@@ -43,35 +43,35 @@
* Enabled in the presence of the E_ACSL_DEBUG macro */
#ifdef E_ACSL_DEBUG
-#define E_ACSL_DEBUG_DESC "debug"
+# define E_ACSL_DEBUG_DESC "debug"
-#include "e_acsl_private_assert.h"
-#include "e_acsl_rtl_io.h"
+# include "e_acsl_private_assert.h"
+# include "e_acsl_rtl_io.h"
-#include <stdio.h>
+# include <stdio.h>
/* Default location of the E_ACSL log file */
-#ifndef E_ACSL_DEBUG_LOG
-# define E_ACSL_DEBUG_LOG -
-#endif
+# ifndef E_ACSL_DEBUG_LOG
+# define E_ACSL_DEBUG_LOG -
+# endif
/*! \brief File descriptor associated with the debug log file */
int dlog_fd;
/*! \brief Output a message to a log file */
-#define DLOG(...) rtl_dprintf(dlog_fd, __VA_ARGS__)
+# define DLOG(...) rtl_dprintf(dlog_fd, __VA_ARGS__)
-#ifdef E_ACSL_DEBUG_VERBOSE
-# define DVLOG(...) rtl_dprintf(dlog_fd, __VA_ARGS__)
-#else
-# define DVLOG(...)
-#endif
+# ifdef E_ACSL_DEBUG_VERBOSE
+# define DVLOG(...) rtl_dprintf(dlog_fd, __VA_ARGS__)
+# else
+# define DVLOG(...)
+# endif
/*! \brief Debug-time assertion based on assert (see e_acsl_assert.h) */
-#define DASSERT(_e) private_assert(_e,TOSTRING(_e),NULL)
+# define DASSERT(_e) private_assert(_e, TOSTRING(_e), NULL)
/*! \brief Debug-time assertion based on vassert (see e_acsl_assert.h) */
-#define DVASSERT(_expr, _fmt, ...) private_assert(_expr, _fmt, __VA_ARGS__)
+# define DVASSERT(_expr, _fmt, ...) private_assert(_expr, _fmt, __VA_ARGS__)
/*! \brief Initialize debug report file:
* - open file descriptor
@@ -79,11 +79,14 @@ int dlog_fd;
void initialize_report_file(int *argc, char ***argv);
int debug_stop_number;
-#define DSTOP { \
- DLOG(" << ***** " "Debug Stop %d in '%s' at %s:%d" " ***** >> ", \
- ++debug_stop_number, __func__, __FILE__, __LINE__); \
- getchar(); \
-}
+# define DSTOP \
+ { \
+ DLOG(" << ***** " \
+ "Debug Stop %d in '%s' at %s:%d" \
+ " ***** >> ", \
+ ++debug_stop_number, __func__, __FILE__, __LINE__); \
+ getchar(); \
+ }
#else
# define E_ACSL_DEBUG_DESC "production"
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.c
index 5855ea8586e1196792382316441be3f6062fcff9..0b05f7f2db4bef0d370798a0948e6036d7985375 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.c
@@ -23,11 +23,11 @@
#include "e_acsl_malloc.h"
struct memory_spaces mem_spaces = {
- .rtl_mspace = NULL,
- .heap_mspace = NULL,
- .heap_start = 0,
- .heap_end = 0,
- .heap_mspace_least = 0,
+ .rtl_mspace = NULL,
+ .heap_mspace = NULL,
+ .heap_start = 0,
+ .heap_end = 0,
+ .heap_mspace_least = 0,
};
/* \brief Create two memory spaces, one for RTL and the other for application
@@ -38,11 +38,13 @@ void eacsl_make_memory_spaces(size_t rtl_size, size_t heap_size) {
mem_spaces.heap_mspace = eacsl_create_mspace(heap_size, 0);
/* Do not use `eacsl_mspace_least_addr` here, as it returns the address of the
mspace header. */
- mem_spaces.heap_start = (uintptr_t)eacsl_mspace_malloc(mem_spaces.heap_mspace,1);
+ mem_spaces.heap_start =
+ (uintptr_t)eacsl_mspace_malloc(mem_spaces.heap_mspace, 1);
mem_spaces.heap_end = mem_spaces.heap_start + heap_size;
/* Save initial least address of heap memspace. This address is used later
to check whether memspace has been moved. */
- mem_spaces.heap_mspace_least = (uintptr_t)eacsl_mspace_least_addr(mem_spaces.heap_mspace);
+ mem_spaces.heap_mspace_least =
+ (uintptr_t)eacsl_mspace_least_addr(mem_spaces.heap_mspace);
}
void eacsl_destroy_memory_spaces() {
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.h
index 3cee07934278aa8a0aefb87b0aedf091184f90d6..b284f709be856f4c602dce45e1298aef1856ecbf 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_malloc.h
@@ -35,18 +35,18 @@
#ifndef E_ACSL_MALLOC_H
#define E_ACSL_MALLOC_H
-#include <stdint.h>
#include <stddef.h>
+#include <stdint.h>
#include "e_acsl_alias.h"
/* Block size units in bytes */
-#define KB (1024) //!< Bytes in a kilobyte
-#define MB (1024*KB) //!< Bytes in a megabyte
-#define GB (1024*MB) //!< Bytes in a gigabyte
-#define KB_SZ(_s) (_s/KB) //!< Convert bytes to kilobytes
-#define MB_SZ(_s) (_s/MB) //!< Convert bytes to megabytes
-#define GB_SZ(_s) (_s/GB) //!< Convert bytes to gigabytes
+#define KB (1024) //!< Bytes in a kilobyte
+#define MB (1024 * KB) //!< Bytes in a megabyte
+#define GB (1024 * MB) //!< Bytes in a gigabyte
+#define KB_SZ(_s) (_s / KB) //!< Convert bytes to kilobytes
+#define MB_SZ(_s) (_s / MB) //!< Convert bytes to megabytes
+#define GB_SZ(_s) (_s / GB) //!< Convert bytes to gigabytes
/************************************************************************/
/*** Mspace initialization {{{ ***/
@@ -66,7 +66,6 @@ void eacsl_destroy_memory_spaces();
/* }}} */
-
/************************************************************************/
/*** Mspace allocators (from dlmalloc) {{{ ***/
/************************************************************************/
@@ -81,26 +80,26 @@ void eacsl_destroy_memory_spaces();
#define eacsl_mspace_posix_memalign export_alias(mspace_posix_memalign)
#define eacsl_mspace_aligned_alloc export_alias(mspace_aligned_alloc)
-typedef void* mspace;
+typedef void *mspace;
struct memory_spaces {
- mspace rtl_mspace; /* `private` (RTL) mspace */
- mspace heap_mspace; /* `public` (application) mspace */
- uintptr_t heap_start; /* least address in application mspace */
- uintptr_t heap_end; /* greatest address in application mspace */
+ mspace rtl_mspace; /* `private` (RTL) mspace */
+ mspace heap_mspace; /* `public` (application) mspace */
+ uintptr_t heap_start; /* least address in application mspace */
+ uintptr_t heap_end; /* greatest address in application mspace */
uintptr_t heap_mspace_least; /* Initial least address in heap mspace */
};
extern struct memory_spaces mem_spaces;
extern mspace eacsl_create_mspace(size_t, int);
extern size_t eacsl_destroy_mspace(mspace);
-extern void* eacsl_mspace_malloc(mspace, size_t);
-extern void eacsl_mspace_free(mspace, void*);
-extern void* eacsl_mspace_calloc(mspace msp, size_t, size_t);
-extern void* eacsl_mspace_realloc(mspace msp, void*, size_t);
-extern void* eacsl_mspace_aligned_alloc(mspace, size_t, size_t);
-extern int eacsl_mspace_posix_memalign(mspace, void **, size_t, size_t);
-extern void* eacsl_mspace_least_addr(mspace);
+extern void *eacsl_mspace_malloc(mspace, size_t);
+extern void eacsl_mspace_free(mspace, void *);
+extern void *eacsl_mspace_calloc(mspace msp, size_t, size_t);
+extern void *eacsl_mspace_realloc(mspace msp, void *, size_t);
+extern void *eacsl_mspace_aligned_alloc(mspace, size_t, size_t);
+extern int eacsl_mspace_posix_memalign(mspace, void **, size_t, size_t);
+extern void *eacsl_mspace_least_addr(mspace);
/* }}} */
@@ -111,12 +110,17 @@ extern void* eacsl_mspace_least_addr(mspace);
/* Used within RTL to override standard allocation */
/* Shortcuts for public allocation functions */
-#define public_malloc(...) eacsl_mspace_malloc(mem_spaces.heap_mspace, __VA_ARGS__)
-#define public_realloc(...) eacsl_mspace_realloc(mem_spaces.heap_mspace, __VA_ARGS__)
-#define public_calloc(...) eacsl_mspace_calloc(mem_spaces.heap_mspace, __VA_ARGS__)
-#define public_free(...) eacsl_mspace_free(mem_spaces.heap_mspace, __VA_ARGS__)
-#define public_aligned_alloc(...) eacsl_mspace_aligned_alloc(mem_spaces.heap_mspace, __VA_ARGS__)
-#define public_posix_memalign(...) eacsl_mspace_posix_memalign(mem_spaces.heap_mspace, __VA_ARGS__)
+#define public_malloc(...) \
+ eacsl_mspace_malloc(mem_spaces.heap_mspace, __VA_ARGS__)
+#define public_realloc(...) \
+ eacsl_mspace_realloc(mem_spaces.heap_mspace, __VA_ARGS__)
+#define public_calloc(...) \
+ eacsl_mspace_calloc(mem_spaces.heap_mspace, __VA_ARGS__)
+#define public_free(...) eacsl_mspace_free(mem_spaces.heap_mspace, __VA_ARGS__)
+#define public_aligned_alloc(...) \
+ eacsl_mspace_aligned_alloc(mem_spaces.heap_mspace, __VA_ARGS__)
+#define public_posix_memalign(...) \
+ eacsl_mspace_posix_memalign(mem_spaces.heap_mspace, __VA_ARGS__)
/* }}} */
@@ -124,10 +128,13 @@ extern void* eacsl_mspace_least_addr(mspace);
/*** Private allocators usable within RTL and GMP {{{ ***/
/************************************************************************/
-#define private_malloc(...) eacsl_mspace_malloc(mem_spaces.rtl_mspace, __VA_ARGS__)
-#define private_calloc(...) eacsl_mspace_calloc(mem_spaces.rtl_mspace, __VA_ARGS__)
-#define private_realloc(...) eacsl_mspace_realloc(mem_spaces.rtl_mspace, __VA_ARGS__)
-#define private_free(...) eacsl_mspace_free(mem_spaces.rtl_mspace, __VA_ARGS__)
+#define private_malloc(...) \
+ eacsl_mspace_malloc(mem_spaces.rtl_mspace, __VA_ARGS__)
+#define private_calloc(...) \
+ eacsl_mspace_calloc(mem_spaces.rtl_mspace, __VA_ARGS__)
+#define private_realloc(...) \
+ eacsl_mspace_realloc(mem_spaces.rtl_mspace, __VA_ARGS__)
+#define private_free(...) eacsl_mspace_free(mem_spaces.rtl_mspace, __VA_ARGS__)
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.c
index b5133be6fdc26828abba82fa819ce520af351ac9..7346da9ce45a0f9189e0b04c7d8cccf2b8759b73 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.c
@@ -31,49 +31,49 @@
#include "e_acsl_private_assert.h"
-#define prepend_file_line(file, line, fmt) \
- do { \
- char * afmt = "%s:%d: %s\n"; \
- char buf[strlen(fmt) + strlen(afmt) + PATH_MAX + 11]; \
- rtl_sprintf(buf, afmt, file, line, fmt); \
- fmt = buf; \
+#define prepend_file_line(file, line, fmt) \
+ do { \
+ char *afmt = "%s:%d: %s\n"; \
+ char buf[strlen(fmt) + strlen(afmt) + PATH_MAX + 11]; \
+ rtl_sprintf(buf, afmt, file, line, fmt); \
+ fmt = buf; \
} while (0)
void raise_abort(const char *file, int line) {
#ifdef E_ACSL_DEBUG
-#ifndef E_ACSL_NO_TRACE
+# ifndef E_ACSL_NO_TRACE
trace();
-#endif
+# endif
#endif
raise(SIGABRT);
}
-void private_abort_fail(const char * file, int line, char *fmt, ...) {
+void private_abort_fail(const char *file, int line, char *fmt, ...) {
va_list va;
#if E_ACSL_OS_IS_LINUX
sigset_t defer_abrt;
sigemptyset(&defer_abrt);
- sigaddset(&defer_abrt,SIGABRT);
- sigprocmask(SIG_BLOCK,&defer_abrt,NULL);
+ sigaddset(&defer_abrt, SIGABRT);
+ sigprocmask(SIG_BLOCK, &defer_abrt, NULL);
#endif // E_ACSL_OS_IS_LINUX
- va_start(va,fmt);
+ va_start(va, fmt);
rtl_veprintf(fmt, va);
va_end(va);
#if E_ACSL_OS_IS_LINUX
- sigprocmask(SIG_UNBLOCK,&defer_abrt,NULL);
+ sigprocmask(SIG_UNBLOCK, &defer_abrt, NULL);
#endif // E_ACSL_OS_IS_LINUX
raise_abort(file, line);
}
-void private_assert_fail(int expr, const char *file, int line, char *fmt, ...) {
+void private_assert_fail(int expr, const char *file, int line, char *fmt, ...) {
if (!expr) {
- char * afmt = "%s:%d: %s";
+ char *afmt = "%s:%d: %s";
char buf[strlen(fmt) + strlen(afmt) + PATH_MAX + 11];
rtl_sprintf(buf, afmt, file, line, fmt);
fmt = buf;
va_list va;
- va_start(va,fmt);
+ va_start(va, fmt);
rtl_veprintf(fmt, va);
va_end(va);
raise_abort(file, line);
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.h
index 53a6cccec425912253e05a5c1d6513adc3a364af..68f682d8ceb5bc34d58d1388f4d0217cafb2a29d 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_private_assert.h
@@ -29,29 +29,30 @@
#define E_ACSL_PRIVATE_ASSERT
/*! \brief Assert with printf-like error message support */
-#define private_assert(expr, fmt_and_args...) \
+#define private_assert(expr, fmt_and_args...) \
private_assert_fail(expr, __FILE__, __LINE__, fmt_and_args)
/*! \brief Output a message to error stream using printf-like format string
* and abort the execution.
*
* This is a wrapper for \p eprintf combined with \p abort */
-#define private_abort(fmt_and_args...) \
+#define private_abort(fmt_and_args...) \
private_abort_fail(__FILE__, __LINE__, fmt_and_args)
-
-void private_assert_fail(int expr, const char *file, int line, char *fmt, ...);
-void private_abort_fail(const char * file, int line, char *fmt, ...);
-void raise_abort(const char * file, int line);
+void private_assert_fail(int expr, const char *file, int line, char *fmt, ...);
+void private_abort_fail(const char *file, int line, char *fmt, ...);
+void raise_abort(const char *file, int line);
/* Instances of assertions shared accross different memory models */
/*! \brief Abort the execution if the size of the pointer computed during
* instrumentation (\p _ptr_sz) does not match the size of the pointer used
* by a compiler (\p void*) */
-#define arch_assert(_ptr_sz) \
- private_assert(_ptr_sz == sizeof(void*), \
- "Mismatch of instrumentation- and compile-time pointer sizes: " \
- "%lu vs %lu\n", _ptr_sz, sizeof(void*))
+#define arch_assert(_ptr_sz) \
+ private_assert( \
+ _ptr_sz == sizeof(void *), \
+ "Mismatch of instrumentation- and compile-time pointer sizes: " \
+ "%lu vs %lu\n", \
+ _ptr_sz, sizeof(void *))
#endif // E_ACSL_PRIVATE_ASSERT
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.c
index d92292563afa8c55cba815d9d4be074c71cb70af..8b6d2d4e9d6497ea63154f2069c94402e87956b4 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.c
@@ -47,314 +47,322 @@
#include "e_acsl_rtl_io.h"
-typedef void (*putcf) (void*,char);
+typedef void (*putcf)(void *, char);
/* Unsigned long integers to string conversion (%u) */
-static void uli2a(unsigned long int num, unsigned int base, int uc,char * bf) {
- int n=0;
- unsigned long int d=1;
- while (num/d >= base)
- d*=base;
- while (d!=0) {
+static void uli2a(unsigned long int num, unsigned int base, int uc, char *bf) {
+ int n = 0;
+ unsigned long int d = 1;
+ while (num / d >= base)
+ d *= base;
+ while (d != 0) {
int dgt = num / d;
- num%=d;
- d/=base;
- if (n || dgt>0|| d==0) {
- *bf++ = dgt+(dgt<10 ? '0' : (uc ? 'A' : 'a')-10);
+ num %= d;
+ d /= base;
+ if (n || dgt > 0 || d == 0) {
+ *bf++ = dgt + (dgt < 10 ? '0' : (uc ? 'A' : 'a') - 10);
++n;
}
}
- *bf=0;
+ *bf = 0;
}
/* Unsigned pointer-wide integers to memory address conversion (%a) */
-static void addr2a(uintptr_t addr, char * bf) {
+static void addr2a(uintptr_t addr, char *bf) {
*bf++ = '0';
*bf++ = 'x';
unsigned int digits = 1;
- int n=0;
- unsigned long int d=1;
- while (addr/d >= 10) {
- d*=10;
+ int n = 0;
+ unsigned long int d = 1;
+ while (addr / d >= 10) {
+ d *= 10;
digits++;
}
unsigned int ctr = 0;
- while (d!=0) {
+ while (d != 0) {
ctr++;
int dgt = addr / d;
- addr%=d;
- d/=10;
- if (n || dgt>0|| d==0) {
- *bf++ = dgt+(dgt<10 ? '0' : 'a' - 10);
+ addr %= d;
+ d /= 10;
+ if (n || dgt > 0 || d == 0) {
+ *bf++ = dgt + (dgt < 10 ? '0' : 'a' - 10);
++n;
}
- if (--digits%5 == 0 && d != 0)
- *bf++ = '-';
+ if (--digits % 5 == 0 && d != 0)
+ *bf++ = '-';
}
- *bf=0;
+ *bf = 0;
}
/* Pointer to string conversion (%p) */
static void ptr2a(void *p, char *bf) {
- *bf++ = '0';
- *bf++ = 'x';
- uli2a((intptr_t)p,16,0,bf);
+ *bf++ = '0';
+ *bf++ = 'x';
+ uli2a((intptr_t)p, 16, 0, bf);
}
/* Signed long integer to string conversion (%ld) */
-static void li2a (long num, char * bf) {
- if (num<0) {
- num=-num;
+static void li2a(long num, char *bf) {
+ if (num < 0) {
+ num = -num;
*bf++ = '-';
}
- uli2a(num,10,0,bf);
+ uli2a(num, 10, 0, bf);
}
/* Signed integer to string conversion (%d) */
-static void ui2a(unsigned int num, unsigned int base, int uc,char * bf) {
- int n=0;
- unsigned int d=1;
- while (num/d >= base)
- d*=base;
- while (d!=0) {
+static void ui2a(unsigned int num, unsigned int base, int uc, char *bf) {
+ int n = 0;
+ unsigned int d = 1;
+ while (num / d >= base)
+ d *= base;
+ while (d != 0) {
int dgt = num / d;
- num%= d;
- d/=base;
- if (n || dgt>0 || d==0) {
- *bf++ = dgt+(dgt<10 ? '0' : (uc ? 'A' : 'a')-10);
+ num %= d;
+ d /= base;
+ if (n || dgt > 0 || d == 0) {
+ *bf++ = dgt + (dgt < 10 ? '0' : (uc ? 'A' : 'a') - 10);
++n;
}
}
- *bf=0;
+ *bf = 0;
}
/* Integer bit-fields to string conversion (%b, %B) */
static void bits2a(long int v, int size, char *bf, int l2r) {
int i;
if (l2r) {
- for(i = 0; i < size; i++) {
+ for (i = 0; i < size; i++) {
*bf++ = '0' + ((v >> i) & 1);
- if (i && i+1 < size && (i+1)%8 == 0)
- *bf++ = ' ';
+ if (i && i + 1 < size && (i + 1) % 8 == 0)
+ *bf++ = ' ';
}
} else {
- for(i = size - 1; i >= 0; i--) {
+ for (i = size - 1; i >= 0; i--) {
*bf++ = '0' + ((v >> i) & 1);
- if (i && i+1 < size && i%4 == 0)
- *bf++ = ' ';
+ if (i && i + 1 < size && i % 4 == 0)
+ *bf++ = ' ';
}
}
- *bf=0;
+ *bf = 0;
}
/* Pointer bit-fields to string conversion (%v, %V) */
static void pbits2a(void *p, int size, char *bf, int l2r) {
- char *v = (char*)p;
+ char *v = (char *)p;
int i;
if (l2r) {
- for(i = 0; i < size; i++) {
- *bf++ = '0' + ((v[i/8] >> i%8) & 1);
- if (i && i+1 < size && (i+1)%4 == 0)
- *bf++ = ' ';
+ for (i = 0; i < size; i++) {
+ *bf++ = '0' + ((v[i / 8] >> i % 8) & 1);
+ if (i && i + 1 < size && (i + 1) % 4 == 0)
+ *bf++ = ' ';
}
} else {
- for(i = size - 1; i >= 0; i--) {
- *bf++ = '0' + ((v[i/8] >> i%8) & 1);
- if (i && i+1 < size && i%4 == 0)
- *bf++ = ' ';
+ for (i = size - 1; i >= 0; i--) {
+ *bf++ = '0' + ((v[i / 8] >> i % 8) & 1);
+ if (i && i + 1 < size && i % 4 == 0)
+ *bf++ = ' ';
}
}
- *bf=0;
+ *bf = 0;
}
/* Signed integer to string (%d) */
-static void i2a (int num, char * bf) {
- if (num<0) {
- num=-num;
+static void i2a(int num, char *bf) {
+ if (num < 0) {
+ num = -num;
*bf++ = '-';
}
- ui2a(num,10,0,bf);
+ ui2a(num, 10, 0, bf);
}
/* Char to int conversion */
static int a2d(char ch) {
- if (ch>='0' && ch<='9')
- return ch-'0';
- else if (ch>='a' && ch<='f')
- return ch-'a'+10;
- else if (ch>='A' && ch<='F')
- return ch-'A'+10;
- else return -1;
+ if (ch >= '0' && ch <= '9')
+ return ch - '0';
+ else if (ch >= 'a' && ch <= 'f')
+ return ch - 'a' + 10;
+ else if (ch >= 'A' && ch <= 'F')
+ return ch - 'A' + 10;
+ else
+ return -1;
}
-static char a2i(char ch, char** src, int base, int* nump) {
- char* p= *src;
- int num=0;
+static char a2i(char ch, char **src, int base, int *nump) {
+ char *p = *src;
+ int num = 0;
int digit;
- while ((digit=a2d(ch))>=0) {
- if (digit>base) break;
- num=num*base+digit;
- ch=*p++;
+ while ((digit = a2d(ch)) >= 0) {
+ if (digit > base)
+ break;
+ num = num * base + digit;
+ ch = *p++;
}
- *src=p;
- *nump=num;
+ *src = p;
+ *nump = num;
return ch;
}
-static void putchw(void* putp, putcf putf, int n, char z, char* bf) {
- char fc=z? '0' : ' ';
+static void putchw(void *putp, putcf putf, int n, char z, char *bf) {
+ char fc = z ? '0' : ' ';
char ch;
- char* p=bf;
+ char *p = bf;
while (*p++ && n > 0)
n--;
while (n-- > 0)
- putf(putp,fc);
- while ((ch= *bf++))
- putf(putp,ch);
+ putf(putp, fc);
+ while ((ch = *bf++))
+ putf(putp, ch);
}
-static void putcp(void* p,char c) {
- *(*((char**)p))++ = c;
+static void putcp(void *p, char c) {
+ *(*((char **)p))++ = c;
}
-static void _format(void* putp, putcf putf, char *fmt, va_list va) {
+static void _format(void *putp, putcf putf, char *fmt, va_list va) {
char bf[256];
char ch;
- while ((ch=*(fmt++))) {
- if (ch!='%') // if not '%' print character as is
- putf(putp,ch);
+ while ((ch = *(fmt++))) {
+ if (ch != '%') // if not '%' print character as is
+ putf(putp, ch);
else { // otherwise do the print based on the format following '%'
- char lz=0;
- char lng=0; // long (i.e., 'l' specifier)
- int w=0;
- ch=*(fmt++);
- if (ch=='0') { // '0' specifier - padding with zeroes
- ch=*(fmt++);
- lz=1;
+ char lz = 0;
+ char lng = 0; // long (i.e., 'l' specifier)
+ int w = 0;
+ ch = *(fmt++);
+ if (ch == '0') { // '0' specifier - padding with zeroes
+ ch = *(fmt++);
+ lz = 1;
}
- if (ch>='0' && ch<='9') {
- ch=a2i(ch,&fmt,10,&w);
+ if (ch >= '0' && ch <= '9') {
+ ch = a2i(ch, &fmt, 10, &w);
}
- if (ch=='l') {
- ch=*(fmt++);
- lng=1;
+ if (ch == 'l') {
+ ch = *(fmt++);
+ lng = 1;
}
switch (ch) {
- case 0:
- break;
- case 'u': {
- if (lng)
- uli2a(va_arg(va, unsigned long int),10,0,bf);
- else
- ui2a(va_arg(va, unsigned int),10,0,bf);
- putchw(putp,putf,w,lz,bf);
- break;
- }
- case 'd': {
- if (lng)
- li2a(va_arg(va, unsigned long int),bf);
- else
- i2a(va_arg(va, int),bf);
- putchw(putp,putf,w,lz,bf);
- break;
- }
- case 'p':
- ptr2a(va_arg(va, void*), bf);
- putchw(putp,putf,w,lz,bf);
- break;
- case 'a':
- addr2a(va_arg(va, uintptr_t), bf);
- putchw(putp,putf,w,lz,bf);
- break;
- case 'b':
- bits2a(va_arg(va, long), w > 64 ? 64 : w ? w : 8, bf, 1);
- putchw(putp,putf,0,0,bf);
- break;
- case 'B':
- bits2a(va_arg(va, long), w > 64 ? 64 : w ? w : 8, bf, 0);
- putchw(putp,putf,0,0,bf);
- break;
- case 'v':
- pbits2a(va_arg(va, void*), w ? w : 8, bf, 1);
- putchw(putp,putf,0,0,bf);
- break;
- case 'V':
- pbits2a(va_arg(va, void*), w ? w : 8, bf, 0);
- putchw(putp,putf,0,0,bf);
- break;
- case 'x':
- case 'X':
- if (lng)
- uli2a(va_arg(va, unsigned long int),16,(ch=='X'),bf);
- else
- ui2a(va_arg(va, unsigned int),16,(ch=='X'),bf);
- putchw(putp,putf,w,lz,bf);
- break;
- case 'f' : {
- double num = va_arg(va, double);
- int ord = (int)num;
- i2a(ord,bf);
- putchw(putp,putf,w,lz,bf);
- putf(putp,'.');
- num = num - ord;
- num *= 1000;
- ord = (int)num;
- i2a(ord,bf);
- putchw(putp,putf,w,lz,bf);
- break;
- }
- case 'c' :
- putf(putp,(char)(va_arg(va, int)));
- break;
- case 's' :
- putchw(putp,putf,w,0,va_arg(va, char*));
- break;
- case '%' :
- putf(putp,ch);
- default:
- break;
+ case 0:
+ break;
+ case 'u': {
+ if (lng)
+ uli2a(va_arg(va, unsigned long int), 10, 0, bf);
+ else
+ ui2a(va_arg(va, unsigned int), 10, 0, bf);
+ putchw(putp, putf, w, lz, bf);
+ break;
+ }
+ case 'd': {
+ if (lng)
+ li2a(va_arg(va, unsigned long int), bf);
+ else
+ i2a(va_arg(va, int), bf);
+ putchw(putp, putf, w, lz, bf);
+ break;
+ }
+ case 'p':
+ ptr2a(va_arg(va, void *), bf);
+ putchw(putp, putf, w, lz, bf);
+ break;
+ case 'a':
+ addr2a(va_arg(va, uintptr_t), bf);
+ putchw(putp, putf, w, lz, bf);
+ break;
+ case 'b':
+ bits2a(va_arg(va, long), w > 64 ? 64 : w ? w : 8, bf, 1);
+ putchw(putp, putf, 0, 0, bf);
+ break;
+ case 'B':
+ bits2a(va_arg(va, long), w > 64 ? 64 : w ? w : 8, bf, 0);
+ putchw(putp, putf, 0, 0, bf);
+ break;
+ case 'v':
+ pbits2a(va_arg(va, void *), w ? w : 8, bf, 1);
+ putchw(putp, putf, 0, 0, bf);
+ break;
+ case 'V':
+ pbits2a(va_arg(va, void *), w ? w : 8, bf, 0);
+ putchw(putp, putf, 0, 0, bf);
+ break;
+ case 'x':
+ case 'X':
+ if (lng)
+ uli2a(va_arg(va, unsigned long int), 16, (ch == 'X'), bf);
+ else
+ ui2a(va_arg(va, unsigned int), 16, (ch == 'X'), bf);
+ putchw(putp, putf, w, lz, bf);
+ break;
+ case 'f': {
+ double num = va_arg(va, double);
+ int ord = (int)num;
+ i2a(ord, bf);
+ putchw(putp, putf, w, lz, bf);
+ putf(putp, '.');
+ num = num - ord;
+ num *= 1000;
+ ord = (int)num;
+ i2a(ord, bf);
+ putchw(putp, putf, w, lz, bf);
+ break;
+ }
+ case 'c':
+ putf(putp, (char)(va_arg(va, int)));
+ break;
+ case 's':
+ putchw(putp, putf, w, 0, va_arg(va, char *));
+ break;
+ case '%':
+ putf(putp, ch);
+ default:
+ break;
}
}
}
}
-static void _charc_stdout (void* p, char c) { write(STDOUT_FILENO,&c,1); }
-static void _charc_stderr (void* p, char c) { write(STDERR_FILENO,&c,1); }
-static void _charc_file (void* p, char c) { write((size_t)p,&c,1); }
+static void _charc_stdout(void *p, char c) {
+ write(STDOUT_FILENO, &c, 1);
+}
+static void _charc_stderr(void *p, char c) {
+ write(STDERR_FILENO, &c, 1);
+}
+static void _charc_file(void *p, char c) {
+ write((size_t)p, &c, 1);
+}
-static void _charc_literal (void* p, char c) {
- switch(c) {
- case '\r':
- write((size_t)p,"\\r",2);
- break;
- case '\f':
- write((size_t)p,"\\f",2);
- break;
- case '\b':
- write((size_t)p,"\\b",2);
- break;
- case '\a':
- write((size_t)p,"\\a",2);
- break;
- case '\n':
- write((size_t)p,"\\n",2);
- break;
- case '\t':
- write((size_t)p,"\\t",2);
- break;
- case '\0':
- write((size_t)p,"\\0",2);
- break;
- default:
- write((size_t)p,&c,1);
+static void _charc_literal(void *p, char c) {
+ switch (c) {
+ case '\r':
+ write((size_t)p, "\\r", 2);
+ break;
+ case '\f':
+ write((size_t)p, "\\f", 2);
+ break;
+ case '\b':
+ write((size_t)p, "\\b", 2);
+ break;
+ case '\a':
+ write((size_t)p, "\\a", 2);
+ break;
+ case '\n':
+ write((size_t)p, "\\n", 2);
+ break;
+ case '\t':
+ write((size_t)p, "\\t", 2);
+ break;
+ case '\0':
+ write((size_t)p, "\\0", 2);
+ break;
+ default:
+ write((size_t)p, &c, 1);
}
}
int rtl_printf(char *fmt, ...) {
va_list va;
- va_start(va,fmt);
+ va_start(va, fmt);
int result = rtl_vprintf(fmt, va);
va_end(va);
return result;
@@ -367,7 +375,7 @@ int rtl_vprintf(char *fmt, va_list vlist) {
int rtl_eprintf(char *fmt, ...) {
va_list va;
- va_start(va,fmt);
+ va_start(va, fmt);
int result = rtl_veprintf(fmt, va);
va_end(va);
return result;
@@ -380,7 +388,7 @@ int rtl_veprintf(char *fmt, va_list vlist) {
int rtl_dprintf(int fd, char *fmt, ...) {
va_list va;
- va_start(va,fmt);
+ va_start(va, fmt);
int result = rtl_vdprintf(fd, fmt, va);
va_end(va);
return result;
@@ -388,13 +396,13 @@ int rtl_dprintf(int fd, char *fmt, ...) {
int rtl_vdprintf(int fd, char *fmt, va_list vlist) {
intptr_t fd_long = fd;
- _format((void*)fd_long, _charc_file, fmt, vlist);
+ _format((void *)fd_long, _charc_file, fmt, vlist);
return 1;
}
-int rtl_sprintf(char* s, char *fmt, ...) {
+int rtl_sprintf(char *s, char *fmt, ...) {
va_list va;
- va_start(va,fmt);
+ va_start(va, fmt);
int result = rtl_vsprintf(s, fmt, va);
va_end(va);
return result;
@@ -402,6 +410,6 @@ int rtl_sprintf(char* s, char *fmt, ...) {
int rtl_vsprintf(char *s, char *fmt, va_list vlist) {
_format(&s, putcp, fmt, vlist);
- putcp(&s,0);
+ putcp(&s, 0);
return 1;
}
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.h
index d2eccbfdf96e7c72117960801e06f3c8f8973cea..e5b93e73ca1c9c49fa0412ccf0e6bc5c00f031a0 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_io.h
@@ -82,7 +82,7 @@ int rtl_printf(char *fmt, ...);
int rtl_vprintf(char *fmt, va_list vlist);
/* Same as printf but write to a string buffer */
-int rtl_sprintf(char* s, char *fmt, ...);
+int rtl_sprintf(char *s, char *fmt, ...);
int rtl_vsprintf(char *s, char *fmt, va_list vlist);
/* Same as printf but write to the error stream. */
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.c
index d908c0f23b8d9a22faa5e8c09fa11786318d5b7d..804d46d37869d6666fe168d985170dd6568a9e55 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.c
@@ -33,7 +33,7 @@ char *nstrdup(const char *s) {
if (s) {
size_t len = strlen(s) + 1;
void *n = private_malloc(len);
- return (n == NULL) ? NULL : (char*)memcpy(n, s, len);
+ return (n == NULL) ? NULL : (char *)memcpy(n, s, len);
}
return NULL;
}
@@ -67,11 +67,10 @@ int endswith(char *str, char *pat) {
}
#define ZERO_BLOCK_SIZE 1024
-static unsigned char zeroblock [ZERO_BLOCK_SIZE];
+static unsigned char zeroblock[ZERO_BLOCK_SIZE];
int zeroed_out(const void *p, size_t size) {
- size_t lim = size/ZERO_BLOCK_SIZE,
- rem = size%ZERO_BLOCK_SIZE;
+ size_t lim = size / ZERO_BLOCK_SIZE, rem = size % ZERO_BLOCK_SIZE;
unsigned char *pc = (unsigned char *)p;
size_t i;
@@ -85,7 +84,7 @@ int zeroed_out(const void *p, size_t size) {
int charcount(const char *s, char c) {
int count = 0;
- while ((s = strchr(s,c)) != NULL) {
+ while ((s = strchr(s, c)) != NULL) {
count++;
s++;
}
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.h
index 03c292c21b3a6294182ffc0d8dccc4e15d8d748f..c8fe34d2be939aa0bcdc235a1ffb5b70b0c0dc58 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_rtl_string.h
@@ -40,20 +40,20 @@
#define E_ACSL_RTL_STRING_H
#ifndef E_ACSL_NO_COMPILER_BUILTINS
-# define memset __builtin_memset
-# define memcmp __builtin_memcmp
-# define memcpy __builtin_memcpy
-# define memmove __builtin_memmove
-# define strncat __builtin_strncat
-# define strcat __builtin_strcat
-# define strlen __builtin_strlen
-# define strcmp __builtin_strcmp
-# define strncmp __builtin_strncmp
-# define strcpy __builtin_strcpy
-# define strncpy __builtin_strncpy
-# define strchr __builtin_strchr
+# define memset __builtin_memset
+# define memcmp __builtin_memcmp
+# define memcpy __builtin_memcpy
+# define memmove __builtin_memmove
+# define strncat __builtin_strncat
+# define strcat __builtin_strcat
+# define strlen __builtin_strlen
+# define strcmp __builtin_strcmp
+# define strncmp __builtin_strncmp
+# define strcpy __builtin_strcpy
+# define strncpy __builtin_strncpy
+# define strchr __builtin_strchr
#else
-# include <string.h>
+# include <string.h>
#endif
#include <stddef.h>
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.c
index 264b63ed5a2f1277dc01723d42054851b7cb6352..017405396f8048074864694277218277f9f311d8 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.c
@@ -30,16 +30,16 @@
// Only available on linux
#if E_ACSL_OS_IS_LINUX
-#include <errno.h>
-#include <stddef.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
+# include <errno.h>
+# include <stddef.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <unistd.h>
-#include "e_acsl_malloc.h"
-#include "e_acsl_rtl_string.h"
+# include "e_acsl_malloc.h"
+# include "e_acsl_rtl_string.h"
-#include "e_acsl_shexec.h"
+# include "e_acsl_shexec.h"
/* \brief Read characters from a buffer associated with a file descriptor into
* a C string
@@ -54,13 +54,13 @@
*
* \return NUL-terminated C string on success
* \return NULL on failure */
-static char* fd_read (int fd, short bufsize) {
+static char *fd_read(int fd, short bufsize) {
/* Read `buffer_size` chars at a time */
- short buffer_size = bufsize*sizeof(char);
+ short buffer_size = bufsize * sizeof(char);
/* Size of the fetched string */
int size = buffer_size;
/* Buffer where for read data */
- char *buffer = (char*)private_malloc(size);
+ char *buffer = (char *)private_malloc(size);
/* The number of read bytes */
short fetched = 0;
int rd = 0; /* Count of fetched characters */
@@ -70,7 +70,7 @@ static char* fd_read (int fd, short bufsize) {
while ((fetched = read(fd, buffer + size - buffer_size, buffer_size))) {
rd += fetched;
if (fetched != -1) {
- size += fetched*sizeof(char);
+ size += fetched * sizeof(char);
buffer = private_realloc(buffer, size + 1);
} else {
return NULL;
@@ -81,15 +81,15 @@ static char* fd_read (int fd, short bufsize) {
}
/* Execute a command in the shell and place results to data */
-static ipr_t* __shexec (ipr_t *data) {
+static ipr_t *__shexec(ipr_t *data) {
int outfd[2], errfd[2], infd[2];
int oldstdout, oldstderr, oldstdin;
- if (pipe(infd)) /* From where parent is going to read */
+ if (pipe(infd)) /* From where parent is going to read */
data->error = nstrdup("Can not create a pipe for STDIN");
- if (pipe(outfd)) /* From where parent is going to read */
+ if (pipe(outfd)) /* From where parent is going to read */
data->error = nstrdup("Can not create a pipe for STDOUT");
- if (pipe(errfd)) /* From where parent is going to read */
+ if (pipe(errfd)) /* From where parent is going to read */
data->error = nstrdup("Can not create a pipe for STDERR");
/* Immediately return if reading from one of the STD pipes failed */
@@ -97,7 +97,7 @@ static ipr_t* __shexec (ipr_t *data) {
return data;
/* Save stdin, stdout and stderr */
- oldstdin = dup(0);
+ oldstdin = dup(0);
oldstdout = dup(1);
oldstderr = dup(2);
@@ -107,21 +107,25 @@ static ipr_t* __shexec (ipr_t *data) {
close(2);
dup2(infd[0], 0); /* Make the read end of infd as STDIN */
- dup2(outfd[1],1); /* Make the write end of outfd as STDOUT */
- dup2(errfd[1],2); /* Make the write end of outfd as STDERR */
+ dup2(outfd[1], 1); /* Make the write end of outfd as STDOUT */
+ dup2(errfd[1], 2); /* Make the write end of outfd as STDERR */
pid_t pid = fork();
- if(!pid) {
+ if (!pid) {
/* Close the streams as they are not required for a child */
- close(infd[0]); close(outfd[0]); close(errfd[0]);
- close(infd[1]); close(outfd[1]); close(errfd[1]);
+ close(infd[0]);
+ close(outfd[0]);
+ close(errfd[0]);
+ close(infd[1]);
+ close(outfd[1]);
+ close(errfd[1]);
- execvp(data->argv[0],data->argv);
+ execvp(data->argv[0], data->argv);
if (errno) {
data->error = nstrdup("Failed to execute:\n ");
char **arg = data->argv - 1;
- while(*++arg)
+ while (*++arg)
data->error = sappend(*arg, data->error, " ");
}
} else {
@@ -129,15 +133,15 @@ static ipr_t* __shexec (ipr_t *data) {
close(1);
close(2);
dup2(oldstdin, 0);
- dup2(oldstdout,1);
- dup2(oldstderr,2);
+ dup2(oldstdout, 1);
+ dup2(oldstderr, 2);
close(outfd[1]);
close(errfd[1]);
close(infd[0]);
/* If data->stdin string is supplied, write that string to the child's
stdin first */
- if (data->stdins) /* Return NULL if write fails */
+ if (data->stdins) /* Return NULL if write fails */
if (write(infd[1], data->stdins, strlen(data->stdins)) == -1)
return NULL;
@@ -167,7 +171,7 @@ static ipr_t* __shexec (ipr_t *data) {
}
/* \brief Deallocate an `ipr_t` structure returned by `shexec` */
-static void free_ipr (ipr_t* ipr) {
+static void free_ipr(ipr_t *ipr) {
if (ipr) {
if (ipr->stdouts)
private_free(ipr->stdouts);
@@ -192,10 +196,10 @@ static void free_ipr (ipr_t* ipr) {
* \return - heap-allocated struct `ipr_t` which describes the output of the
* executed command. Deallocation of this struct must be performed via the
* `free_ipr` function. */
-ipr_t* shexec (char **data, const char *sin) {
+ipr_t *shexec(char **data, const char *sin) {
/* Allocate and initialise the `ipr_t` struct to store the results
* of the command execution */
- ipr_t *ipr = (ipr_t*)private_malloc(sizeof(ipr_t));
+ ipr_t *ipr = (ipr_t *)private_malloc(sizeof(ipr_t));
ipr->stderrs = NULL;
ipr->stdouts = NULL;
ipr->stdins = nstrdup(sin);
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.h b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.h
index f530dd28bc1961cf31c6b721e93416fb326307d1..04710c7389deff4cfa6677d047baa4cbe1122901 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.h
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_shexec.h
@@ -33,7 +33,7 @@
// Only available on linux
#if E_ACSL_OS_IS_LINUX
-#include <sys/types.h>
+# include <sys/types.h>
/*! \class ipr_t
* \brief Result struct for `shexec` function -- execute a command in the
@@ -46,16 +46,16 @@ typedef struct {
/** \brief resulting STDOUT stream as \p const \p char* */
char *stdouts;
/** \brief Exit status of a program */
- int exit_status;
+ int exit_status;
/** \brief ID of a child process this command has been executed in */
pid_t pid;
/** \brief Set to non-zero if child process is interrupted via a signal */
- int signaled;
+ int signaled;
/** \brief If \p signalled is set, \p signo is set to the number of signal
* that interrupted execution of a child process */
- int signo;
+ int signo;
/** \brief A command to execute. Needs to be NULL terminated */
- char **argv; /** \brief ARGV */
+ char **argv; /** \brief ARGV */
/** \brief Message if the command has failed to run */
char *error;
} ipr_t;
@@ -71,7 +71,7 @@ typedef struct {
* \return - heap-allocated struct `ipr_t` which describes the output of the
* executed command. Deallocation of this struct must be performed via the
* `free_ipr` function. */
-ipr_t* shexec (char **data, const char *sin);
+ipr_t *shexec(char **data, const char *sin);
#endif // E_ACSL_OS_IS_LINUX
diff --git a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_trace.c b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_trace.c
index 64336e758bd4f23af52d118a5a8854be7985bed3..2d0bff075be92ed60c3c7070c7bca7ab2f95701b 100644
--- a/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_trace.c
+++ b/src/plugins/e-acsl/share/e-acsl/internals/e_acsl_trace.c
@@ -37,7 +37,7 @@
#include "e_acsl_trace.h"
#if E_ACSL_OS_IS_LINUX
-extern void *__libc_stack_end;
+extern void *__libc_stack_end;
struct frame_layout {
void *next;
@@ -46,61 +46,63 @@ struct frame_layout {
/* The following implementation of malloc-free backtrace [native_backtrace]
is mostly taken from Glibc-2.22 (see file debug/backtrace.c) */
-static int native_backtrace (void **array, int size) {
+static int native_backtrace(void **array, int size) {
struct frame_layout *current;
- void *top_frame,
- *top_stack;
+ void *top_frame, *top_stack;
int cnt = 0;
top_frame = __builtin_frame_address(0);
/* Some notion of current stack. Need not be exactly the top of the stack,
just something somewhere in the current frame. */
- top_stack = ({ char __csf; &__csf; });
+ top_stack = ({
+ char __csf;
+ &__csf;
+ });
/* We skip the call to this function, it makes no sense to record it. */
- current = ((struct frame_layout *) top_frame);
+ current = ((struct frame_layout *)top_frame);
while (cnt < size) {
/* Assume that the stack grows downwards */
- if ((void *) current < top_stack || !((void *) current < __libc_stack_end))
+ if ((void *)current < top_stack || !((void *)current < __libc_stack_end))
/* This means the address is out of range. Note that for the
toplevel we see a frame pointer with value NULL which clearly is
out of range. */
break;
array[cnt++] = current->return_address;
- current = ((struct frame_layout *) (current->next));
+ current = ((struct frame_layout *)(current->next));
}
return cnt;
}
#endif
void trace() {
-# if E_ACSL_OS_IS_LINUX
+#if E_ACSL_OS_IS_LINUX
int size = 24;
- void **bb = private_malloc(sizeof(void*)*size);
+ void **bb = private_malloc(sizeof(void *) * size);
native_backtrace(bb, size);
- char executable [PATH_MAX];
+ char executable[PATH_MAX];
rtl_sprintf(executable, "/proc/%d/exe", getpid());
STDOUT("/** Backtrace **************************/\n");
int counter = 0;
while (*bb) {
- char *addr = (char*)private_malloc(21);
- rtl_sprintf(addr,"%p", *bb);
- char *ar[] = { "addr2line", "-f", "-p", "-C", "-s", "-e",
- executable, addr, NULL};
+ char *addr = (char *)private_malloc(21);
+ rtl_sprintf(addr, "%p", *bb);
+ char *ar[] = {"addr2line", "-f", "-p", "-C", "-s",
+ "-e", executable, addr, NULL};
ipr_t *ipr = shexec(ar, NULL);
char *prefix = (counter) ? " - " : "";
if (ipr) {
- char *outs = (char*)ipr->stdouts;
+ char *outs = (char *)ipr->stdouts;
if (outs) {
- outs[strlen(outs)-1] = '\0';
+ outs[strlen(outs) - 1] = '\0';
if (strlen(outs) && endswith(outs, "??:0") && endswith(outs, "??:?")) {
STDOUT("%s%s\n", prefix, outs);
}
} else {
- char *errs = (char*)ipr->stderrs;
+ char *errs = (char *)ipr->stderrs;
if (errs) {
STDOUT("%s\n", errs);
}
@@ -110,5 +112,5 @@ void trace() {
counter++;
}
STDOUT("/***************************************/\n");
-# endif /* E_ACSL_OS_IS_LINUX */
+#endif /* E_ACSL_OS_IS_LINUX */
}
diff --git a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.c b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.c
index 00bcfe88a7197f0a10c8bf982873331f92e353cd..76f45959cd35afbc2079342b4754ef7cad9c2e5d 100644
--- a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.c
+++ b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.c
@@ -22,26 +22,26 @@
#ifdef E_ACSL_VALIDATE_FORMAT_STRINGS
-#include <fcntl.h>
-#include <limits.h>
-#include <stdint.h>
-#include <wctype.h>
+# include <fcntl.h>
+# include <limits.h>
+# include <stdint.h>
+# include <wctype.h>
-#include "../internals/e_acsl_malloc.h"
-#include "../internals/e_acsl_private_assert.h"
-#include "../internals/e_acsl_rtl_io.h"
-#include "../internals/e_acsl_rtl_string.h"
-#include "../observation_model/e_acsl_observation_model.h"
-#include "e_acsl_string.h"
+# include "../internals/e_acsl_malloc.h"
+# include "../internals/e_acsl_private_assert.h"
+# include "../internals/e_acsl_rtl_io.h"
+# include "../internals/e_acsl_rtl_string.h"
+# include "../observation_model/e_acsl_observation_model.h"
+# include "e_acsl_string.h"
-#include "e_acsl_stdio.h"
+# include "e_acsl_stdio.h"
-#define FMT_ERROR "Format error: "
-#define INT_ERROR "Internal error: "
+# define FMT_ERROR "Format error: "
+# define INT_ERROR "Internal error: "
/* Check whether a value is unsigned or not.
Watch out for integer promotions. */
-#define UNSIGNED(n) (n >= 0 && ~n >= 0)
+# define UNSIGNED(n) (n >= 0 && ~n >= 0)
/* Abbreviated types {{{ */
@@ -91,27 +91,31 @@
/* Define abbreviated types as enum so they can be referred to as aliases */
typedef enum {
-#define typedef_abbreviated(type,val,alias) alias = type,
+# define typedef_abbreviated(type, val, alias) alias = type,
abbreviated_types
-#undef typedef_abbreviated
+# undef typedef_abbreviated
} abbrev_t;
/** \brief Return a C-string representation of a given abbreviated type */
-static const char* abbr2str(abbrev_t type) {
- switch(type) {
-#define typedef_abbreviated(type,val,alias) case type: return #val;
- abbreviated_types
-#undef typedef_abbreviated
+static const char *abbr2str(abbrev_t type) {
+ switch (type) {
+# define typedef_abbreviated(type, val, alias) \
+ case type: \
+ return #val;
+ abbreviated_types
+# undef typedef_abbreviated
}
return '\0';
}
/** \brief Return a byte-size of a given abbreviated type */
static int abbr2size(abbrev_t type) {
- switch(type) {
-#define typedef_abbreviated(type,val,alias) case type: return sizeof(val);
- abbreviated_types
-#undef typedef_abbreviated
+ switch (type) {
+# define typedef_abbreviated(type, val, alias) \
+ case type: \
+ return sizeof(val);
+ abbreviated_types
+# undef typedef_abbreviated
}
return 0;
}
@@ -130,7 +134,8 @@ static abbrev_t size2abbri(int size, int sign) {
return sign ? ILong : IULong;
else if (size == sizeof(long long int))
return sign ? ILongLong : IULongLong;
- private_abort(INT_ERROR "integral type corresponding to size %d unknown\n", size);
+ private_abort(INT_ERROR "integral type corresponding to size %d unknown\n",
+ size);
return '\0';
}
@@ -142,23 +147,29 @@ static abbrev_t size2abbrf(int size) {
return FDouble;
else if (size == sizeof(long double))
return FLongDouble;
- vabort
- (INT_ERROR "floating point type corresponding to size %d unknown\n", size);
+ vabort(INT_ERROR "floating point type corresponding to size %d unknown\n",
+ size);
return '\0';
}
/* Partial mapping of primitive abreviated type to a pointer of the same type,
e.g., 'd' (int) -> 's' (*) */
static char abbr2ptr(char c) {
- switch(c) {
- case IInt: return PInt;
- case IUInt: return PUInt;
- case ILong: return PLong;
- case IULong: return PULong;
- case ILongLong: return PLongLong;
- case IULongLong: return PULongLong;
- default:
- private_abort(INT_ERROR "Unexpected abbreviated type %c\n", c);
+ switch (c) {
+ case IInt:
+ return PInt;
+ case IUInt:
+ return PUInt;
+ case ILong:
+ return PLong;
+ case IULong:
+ return PULong;
+ case ILongLong:
+ return PLongLong;
+ case IULongLong:
+ return PULongLong;
+ default:
+ private_abort(INT_ERROR "Unexpected abbreviated type %c\n", c);
}
return '\0';
}
@@ -182,15 +193,15 @@ const char *period_chars = ".";
Do not use this map directly, use one of the below macros. */
char format_char_map[256];
-#define specifier_id 's'
-#define length_id 'l'
-#define flag_id 'f'
-#define period_id 'r'
+# define specifier_id 's'
+# define length_id 'l'
+# define flag_id 'f'
+# define period_id 'r'
-#define is_specifier_char(_c) (format_char_map[(int)_c] == specifier_id)
-#define is_flag_char(_c) (format_char_map[(int)_c] == flag_id)
-#define is_length_char(_c) (format_char_map[(int)_c] == length_id)
-#define is_period_char(_c) (format_char_map[(int)_c] == period_id)
+# define is_specifier_char(_c) (format_char_map[(int)_c] == specifier_id)
+# define is_flag_char(_c) (format_char_map[(int)_c] == flag_id)
+# define is_length_char(_c) (format_char_map[(int)_c] == length_id)
+# define is_period_char(_c) (format_char_map[(int)_c] == period_id)
static void set_format_char_map() {
int init_idx = (int)'\0';
@@ -198,13 +209,13 @@ static void set_format_char_map() {
if (format_char_map[init_idx] != init_char) {
memset(format_char_map, 0, 256);
int i;
- for(i = 0; i < strlen(specifier_chars); i++)
+ for (i = 0; i < strlen(specifier_chars); i++)
format_char_map[(int)specifier_chars[i]] = specifier_id;
- for(i = 0; i < strlen(length_chars); i++)
+ for (i = 0; i < strlen(length_chars); i++)
format_char_map[(int)length_chars[i]] = length_id;
- for(i = 0; i < strlen(flag_chars); i++)
+ for (i = 0; i < strlen(flag_chars); i++)
format_char_map[(int)flag_chars[i]] = flag_id;
- for(i = 0; i < strlen(period_chars); i++)
+ for (i = 0; i < strlen(period_chars); i++)
format_char_map[(int)period_chars[i]] = period_id;
format_char_map[init_idx] = init_char;
}
@@ -213,26 +224,26 @@ static void set_format_char_map() {
/* Argument specification {{{ */
typedef struct {
- char *format; /* Pointer to the complete format string */
- char directive [16]; /* Directive string */
+ char *format; /* Pointer to the complete format string */
+ char directive[16]; /* Directive string */
struct arg {
int index; /* Argument index this specification refers to */
_Bool expl; /* Set to 1 if the argument has been numbered via $ */
} arg;
- struct flags { /* Flags */
+ struct flags { /* Flags */
_Bool specified; /* set if any of the below flags are set */
- _Bool minus; /* - */
- _Bool plus; /* + */
- _Bool space; /* ' ' */
- _Bool hash; /* # */
- _Bool zero; /* 0 */
+ _Bool minus; /* - */
+ _Bool plus; /* + */
+ _Bool space; /* ' ' */
+ _Bool hash; /* # */
+ _Bool zero; /* 0 */
_Bool apostroph; /* ' */
} flags;
- int field_width; /* Field width, INT_MIN if not given, -1 if '*' */
- int precision; /* Format precision, INT_MIN if not given, -1 if '*' */
- struct length { /* Length Modifier */
- int bytes; /* Number of bytes inferred from length modifier */
- char mod; /* Modifier character (such as 'l' or 'h') */
+ int field_width; /* Field width, INT_MIN if not given, -1 if '*' */
+ int precision; /* Format precision, INT_MIN if not given, -1 if '*' */
+ struct length { /* Length Modifier */
+ int bytes; /* Number of bytes inferred from length modifier */
+ char mod; /* Modifier character (such as 'l' or 'h') */
_Bool extended; /* Set if modifier is repeated (e.g., 'll' or 'hh') */
} length;
char specifier; /* Format specifier character */
@@ -253,14 +264,16 @@ static void print_directive(format_directive *dir, char *rem) {
rtl_printf(" Bytes: %d \n", dir->length.bytes);
rtl_printf(" Extended: %d \n", dir->length.extended);
rtl_printf(" Flags: <");
-#define print_format_flag(_f,_s) if (dir->flags._f) rtl_printf(_s)
- print_format_flag(plus,"+");
+# define print_format_flag(_f, _s) \
+ if (dir->flags._f) \
+ rtl_printf(_s)
+ print_format_flag(plus, "+");
print_format_flag(minus, "-");
print_format_flag(space, " ");
- print_format_flag(hash,"#");
- print_format_flag(apostroph,"'");
- print_format_flag(zero,"0");
-#undef print_format_flag
+ print_format_flag(hash, "#");
+ print_format_flag(apostroph, "'");
+ print_format_flag(zero, "0");
+# undef print_format_flag
rtl_printf(">\n");
rtl_printf(" Remainder: \"%s\"\n", rem);
}
@@ -275,7 +288,7 @@ static void print_directive(format_directive *dir, char *rem) {
This function assumes that *(fmt-1) is '%' */
static char *fetch_format_argno(char *fmt, format_directive *dir,
- format_directive *prev, int ind) {
+ format_directive *prev, int ind) {
int argno = 0;
char *ret = fmt;
@@ -296,7 +309,7 @@ static char *fetch_format_argno(char *fmt, format_directive *dir,
dir->arg.index = argno - 1;
dir->arg.expl = 1;
ret++;
- /* ... do nothing otherwise but revert back to original format as some
+ /* ... do nothing otherwise but revert back to original format as some
characters may have been fetched */
} else {
dir->arg.index = ind;
@@ -306,9 +319,10 @@ static char *fetch_format_argno(char *fmt, format_directive *dir,
/* make sure that numbered and non-numbered directives are not mixed */
if (prev && prev->arg.expl != dir->arg.expl)
- private_abort(FMT_ERROR
- "\"%s\": numbered and non-numbered directives cannot be mixed\n",
- dir->format);
+ private_abort(
+ FMT_ERROR
+ "\"%s\": numbered and non-numbered directives cannot be mixed\n",
+ dir->format);
return ret;
}
@@ -317,37 +331,38 @@ static char *fetch_format_argno(char *fmt, format_directive *dir,
/* Fetch format flags {{{ */
/* Assumes that `fmt` is a format string returned by ::fetch_format_argno */
static char *fetch_format_flags(char *fmt, format_directive *dir) {
-#define set_format_flag(_f) \
- if (!dir->flags._f) \
- { dir->flags._f = 1; } \
- else \
- { private_abort(FMT_ERROR "flag %s has already been set\n", #_f); }
+# define set_format_flag(_f) \
+ if (!dir->flags._f) { \
+ dir->flags._f = 1; \
+ } else { \
+ private_abort(FMT_ERROR "flag %s has already been set\n", #_f); \
+ }
while (is_flag_char(*fmt)) {
dir->flags.specified = 1;
- switch(*fmt) {
- case '#':
- set_format_flag(hash);
- break;
- case '-':
- set_format_flag(minus);
- break;
- case '+':
- set_format_flag(plus);
- break;
- case ' ':
- set_format_flag(space);
- break;
- case '\'':
- set_format_flag(apostroph);
- break;
- case '0':
- set_format_flag(zero);
- break;
+ switch (*fmt) {
+ case '#':
+ set_format_flag(hash);
+ break;
+ case '-':
+ set_format_flag(minus);
+ break;
+ case '+':
+ set_format_flag(plus);
+ break;
+ case ' ':
+ set_format_flag(space);
+ break;
+ case '\'':
+ set_format_flag(apostroph);
+ break;
+ case '0':
+ set_format_flag(zero);
+ break;
}
fmt++;
}
-#undef set_format_flag
+# undef set_format_flag
return fmt;
}
/* }}} */
@@ -365,7 +380,8 @@ static char *fetch_format_field_width(char *fmt, format_directive *dir) {
if (isdigit(*fmt)) {
if (*fmt == '0') {
private_abort(FMT_ERROR
- "field width in format cannot start with zero (%s)\n", dir->format);
+ "field width in format cannot start with zero (%s)\n",
+ dir->format);
};
while (isdigit(*fmt)) {
len = len * 10 + (*fmt - '0');
@@ -407,43 +423,43 @@ static char *fetch_format_length(char *fmt, format_directive *dir) {
dir->length.mod = '\0';
dir->length.extended = 0;
- switch(*fmt) {
- case 'h': {
- if (*(fmt + 1) == 'h') {
- dir->length.bytes = sizeof(char);
- dir->length.extended = 1;
- fmt++;
- } else
- dir->length.bytes = sizeof(short);
- break;
- }
- case 'l': {
- if (*(fmt + 1) == 'l') {
- dir->length.bytes = sizeof(long long);
- dir->length.extended = 1;
- fmt++;
- } else
- dir->length.bytes = sizeof(long);
- break;
- }
- case 'j':
- dir->length.bytes = sizeof(intmax_t);
- break;
- case 'z':
- dir->length.bytes = sizeof(size_t);
- break;
- case 't':
- dir->length.bytes = sizeof(ptrdiff_t);
- break;
- case 'L':
- dir->length.bytes = sizeof(long double);
- break;
+ switch (*fmt) {
+ case 'h': {
+ if (*(fmt + 1) == 'h') {
+ dir->length.bytes = sizeof(char);
+ dir->length.extended = 1;
+ fmt++;
+ } else
+ dir->length.bytes = sizeof(short);
+ break;
+ }
+ case 'l': {
+ if (*(fmt + 1) == 'l') {
+ dir->length.bytes = sizeof(long long);
+ dir->length.extended = 1;
+ fmt++;
+ } else
+ dir->length.bytes = sizeof(long);
+ break;
+ }
+ case 'j':
+ dir->length.bytes = sizeof(intmax_t);
+ break;
+ case 'z':
+ dir->length.bytes = sizeof(size_t);
+ break;
+ case 't':
+ dir->length.bytes = sizeof(ptrdiff_t);
+ break;
+ case 'L':
+ dir->length.bytes = sizeof(long double);
+ break;
}
/* Make sure that the length modifier (if there is one) belongs
to a right character class */
private_assert(dir->length.mod == '\0' || is_length_char(dir->length.mod),
- INT_ERROR "Bad length modifier: '%c'\n", dir->length.mod);
+ INT_ERROR "Bad length modifier: '%c'\n", dir->length.mod);
if (dir->length.bytes) {
dir->length.mod = *fmt;
@@ -456,23 +472,26 @@ static char *fetch_format_length(char *fmt, format_directive *dir) {
/* Detect specifying length modifiers twice. This is purely for better error
reporting. Even if there is no this check, the one below detects it,
but with a different error message. */
- if ( dir->specifier )
-
- /* which has been fetched at the start matches the one we have arrived at */
- if (!is_specifier_char(dir->specifier)) {
- if (dir->specifier == '%')
- private_abort(FMT_ERROR "in directive '%s'."
- "the complete conversion specification for '%%' is '%%%%'\n",
- dir->format);
- else
- private_abort(FMT_ERROR "illegal format specifier '%c'\n", dir->specifier);
- }
+ if (dir->specifier)
+
+ /* which has been fetched at the start matches the one we have arrived at */
+ if (!is_specifier_char(dir->specifier)) {
+ if (dir->specifier == '%')
+ private_abort(
+ FMT_ERROR
+ "in directive '%s'."
+ "the complete conversion specification for '%%' is '%%%%'\n",
+ dir->format);
+ else
+ private_abort(FMT_ERROR "illegal format specifier '%c'\n",
+ dir->specifier);
+ }
return ++fmt;
} /* }}} */
/* Parse format string {{{ */
/* Parse format string into a NULL-terminated array of directives */
-static format_directive ** get_format_directives(char *fmt) {
+static format_directive **get_format_directives(char *fmt) {
/* Count the number of formatting directives in the format string
by counting '%' occurrences. Yes, it may give more specifications than
needed (e.g., "%%") but allocating space for a few extra pointers does not
@@ -480,8 +499,8 @@ static format_directive ** get_format_directives(char *fmt) {
string twice. */
int sz = charcount(fmt, '%') + 1;
- format_directive ** directives =
- private_malloc(sizeof(format_directive *) * sz);
+ format_directive **directives =
+ private_malloc(sizeof(format_directive *) * sz);
char *format_string = fmt;
/* Nullify all pointers to make sure there is no leftover rubbish */
@@ -506,7 +525,7 @@ static format_directive ** get_format_directives(char *fmt) {
format_directive *dir = private_calloc(1, sizeof(format_directive));
/* Parse format string */
dir->format = format_string;
- char *fmt_start = fmt - 1;
+ char *fmt_start = fmt - 1;
fmt = fetch_format_argno(fmt, dir, prev, i);
fmt = fetch_format_flags(fmt, dir);
fmt = fetch_format_field_width(fmt, dir);
@@ -519,7 +538,7 @@ static format_directive ** get_format_directives(char *fmt) {
ptrdiff_t max_len = sizeof(dir->directive) - 1;
int len = max_len > fmt_len ? fmt_len : max_len;
strncpy(dir->directive, fmt_start, len);
- dir->directive[len+1] = '\0';
+ dir->directive[len + 1] = '\0';
/* Save the directive */
directives[i++] = dir;
prev = dir;
@@ -529,7 +548,7 @@ static format_directive ** get_format_directives(char *fmt) {
return directives;
}
-static void release_directives(const char *fmt, format_directive ** dirs) {
+static void release_directives(const char *fmt, format_directive **dirs) {
int formats = charcount(fmt, '%') + 1;
int i;
for (i = 0; i < formats; i++)
@@ -540,10 +559,11 @@ static void release_directives(const char *fmt, format_directive ** dirs) {
/* Format string validation (well-formedness) {{{ */
static inline void validate_application(format_directive *dir, char *allowed,
- char* kind, char *desc) {
- private_assert(strchr(allowed, dir->specifier) != NULL, FMT_ERROR
- "wrong application of %s [%s] to format specifier [%c]\n",
- desc, kind, dir->specifier);
+ char *kind, char *desc) {
+ private_assert(strchr(allowed, dir->specifier) != NULL,
+ FMT_ERROR
+ "wrong application of %s [%s] to format specifier [%c]\n",
+ desc, kind, dir->specifier);
}
/** \brief Check that a given format specifier are used with right flags,
@@ -598,7 +618,7 @@ static void validate_applications(format_directive *dir) {
if (dir->length.mod != '\0') {
/* Make sure the length specifier is one of the allowed ones */
private_assert(is_length_char(dir->length.mod),
- FMT_ERROR "bad length specifier [%c]\n", dir->length.mod);
+ FMT_ERROR "bad length specifier [%c]\n", dir->length.mod);
/* Conver length modifier to a string */
char lm_kind[3];
@@ -609,24 +629,24 @@ static void validate_applications(format_directive *dir) {
lm_kind[i++] = '\0';
switch (dir->length.mod) {
- case 'l':
- if (!dir->length.extended) {
- validate_application(dir, "diouxXncsfFeEgGaA", lm_kind, desc);
- break;
- }
- /* No need to look whether 'h' is extended, both 'h' and 'hh' are only
- applicable to [diouxXn] */
- case 'h':
- case 'j':
- case 'z':
- case 't':
- validate_application(dir, "diouxXn", lm_kind, desc);
- break;
- case 'L':
- validate_application(dir, "aAeEfFgG", lm_kind, desc);
+ case 'l':
+ if (!dir->length.extended) {
+ validate_application(dir, "diouxXncsfFeEgGaA", lm_kind, desc);
break;
- default:
- private_abort(INT_ERROR "unexpected length modifier %c\n", lm_kind);
+ }
+ /* No need to look whether 'h' is extended, both 'h' and 'hh' are only
+ applicable to [diouxXn] */
+ case 'h':
+ case 'j':
+ case 'z':
+ case 't':
+ validate_application(dir, "diouxXn", lm_kind, desc);
+ break;
+ case 'L':
+ validate_application(dir, "aAeEfFgG", lm_kind, desc);
+ break;
+ default:
+ private_abort(INT_ERROR "unexpected length modifier %c\n", lm_kind);
}
}
}
@@ -640,46 +660,48 @@ static void validate_applications(format_directive *dir) {
computes an integer type that a format expects using length modifiers and
format specifiers. */
static abbrev_t infer_integral_abbr(format_directive *dir, int sgn) {
- switch(dir->length.mod) {
- case 'l': /* expects long long or long */
- return (dir->length.extended) ?
- (sgn ? ILongLong : IULongLong) : (sgn ? ILong : IULong);
- case 'h': /* short/char: promoted to int */
- return IInt;
- case 'j': /* intmax_t */
- return size2abbri(sizeof(intmax_t), sgn);
- case 'z': /* size_t */
- return size2abbri(sizeof(size_t), sgn);
- case 't': /* ptrdiff_t */
- return size2abbri(sizeof(ptrdiff_t), sgn);
- case '\0':
- return (sgn ? IInt : IUInt);
+ switch (dir->length.mod) {
+ case 'l': /* expects long long or long */
+ return (dir->length.extended) ? (sgn ? ILongLong : IULongLong)
+ : (sgn ? ILong : IULong);
+ case 'h': /* short/char: promoted to int */
+ return IInt;
+ case 'j': /* intmax_t */
+ return size2abbri(sizeof(intmax_t), sgn);
+ case 'z': /* size_t */
+ return size2abbri(sizeof(size_t), sgn);
+ case 't': /* ptrdiff_t */
+ return size2abbri(sizeof(ptrdiff_t), sgn);
+ case '\0':
+ return (sgn ? IInt : IUInt);
}
- private_abort(INT_ERROR "unexpected length modifier: '%c'\n", dir->length.mod);
+ private_abort(INT_ERROR "unexpected length modifier: '%c'\n",
+ dir->length.mod);
return '\0';
}
/** \brief Same as above but for 'n' conversion specifier. */
static abbrev_t infer_n_abbr(format_directive *dir) {
char c;
- switch(dir->length.mod) {
- case 'h':
- return dir->length.extended ? PChar : PShort;
- case 'l':
- return dir->length.extended ? PLongLong : PLong;
- case 'j': /* intmax_t: signed type */
- c = size2abbri(sizeof(intmax_t), 1);
- return abbr2ptr(c);
- case 'z': /* size_t: unsigned type */
- c = size2abbri(sizeof(size_t), 0);
- return abbr2ptr(c);
- case 't': /* ptrdiff_t: signed type */
- c = size2abbri(sizeof(ptrdiff_t), 1);
- return abbr2ptr(c);
- case '\0':
- return PInt;
- default:
- private_abort(INT_ERROR "unexpected length modifier '%c'\n", dir->length.mod);
+ switch (dir->length.mod) {
+ case 'h':
+ return dir->length.extended ? PChar : PShort;
+ case 'l':
+ return dir->length.extended ? PLongLong : PLong;
+ case 'j': /* intmax_t: signed type */
+ c = size2abbri(sizeof(intmax_t), 1);
+ return abbr2ptr(c);
+ case 'z': /* size_t: unsigned type */
+ c = size2abbri(sizeof(size_t), 0);
+ return abbr2ptr(c);
+ case 't': /* ptrdiff_t: signed type */
+ c = size2abbri(sizeof(ptrdiff_t), 1);
+ return abbr2ptr(c);
+ case '\0':
+ return PInt;
+ default:
+ private_abort(INT_ERROR "unexpected length modifier '%c'\n",
+ dir->length.mod);
}
return '\0';
}
@@ -691,16 +713,14 @@ static abbrev_t infer_n_abbr(format_directive *dir) {
This function expects that the index given via the format directive
`dir` is less than or equal to the length of `fmtdesc`, i.e., there is an
actual argument that corresponds to `dir`. */
-static void validate_format_type
- (abbrev_t expected_t, const char *fmtdesc,
- format_directive *dir, const char *func)
-{
+static void validate_format_type(abbrev_t expected_t, const char *fmtdesc,
+ format_directive *dir, const char *func) {
abbrev_t actual_t = fmtdesc[dir->arg.index];
if (actual_t != expected_t) {
private_abort("%s: directive %d ('%s') expects argument of type '%s'"
- " but the corresponding argument has type '%s'\n",
- func, dir->arg.index + 1, dir->directive,
- abbr2str(expected_t), abbr2str(actual_t));
+ " but the corresponding argument has type '%s'\n",
+ func, dir->arg.index + 1, dir->directive,
+ abbr2str(expected_t), abbr2str(actual_t));
}
}
@@ -712,28 +732,28 @@ static void validate_format_type
@param func - name of the function (e.g., printf)
@param wide - if set to a true value then the string should be treated as
a wide string (wchar_t*) */
-static long validate_format_string_argument
- (char *s, format_directive *dir, const char *func, int wide)
-{
+static long validate_format_string_argument(char *s, format_directive *dir,
+ const char *func, int wide) {
int limit = (dir->precision >= 0) ? dir->precision : -1;
- long size =
- (wide) ? valid_nwstring((wchar_t*)s, limit, 0) : valid_nstring(s, limit, 0);
- switch(size) {
- case -1:
- private_abort
- ("%s: attempt to access unallocated memory via directive %d ('%s')\n",
+ long size = (wide) ? valid_nwstring((wchar_t *)s, limit, 0)
+ : valid_nstring(s, limit, 0);
+ switch (size) {
+ case -1:
+ private_abort(
+ "%s: attempt to access unallocated memory via directive %d ('%s')\n",
func, dir->arg.index + 1, dir->directive);
- case -2:
- private_abort(INT_ERROR
+ case -2:
+ private_abort(
+ INT_ERROR
"%s: writeable check unexpectedly failed in directive %d ('%s')\n",
func, dir->arg.index + 1, dir->directive);
- case -3:
- private_abort("%s: attempt to access partially unallocated memory "
- "via directive %d ('%s')\n",
- func, dir->arg.index + 1, dir->directive);
- case -4:
- private_abort("%s: unterminated string in directive %d ('%s')\n",
- func, dir->arg.index + 1, dir->directive);
+ case -3:
+ private_abort("%s: attempt to access partially unallocated memory "
+ "via directive %d ('%s')\n",
+ func, dir->arg.index + 1, dir->directive);
+ case -4:
+ private_abort("%s: unterminated string in directive %d ('%s')\n", func,
+ dir->arg.index + 1, dir->directive);
}
return size;
}
@@ -741,11 +761,12 @@ static long validate_format_string_argument
/** \brief Check that a buffer of a given length overlaps with the memory space
of a formatting directive argument. */
static void validate_overlapping_buffer(char *buffer, size_t buf_sz, void *arg,
- size_t arg_sz, const char *func, format_directive *dir) {
+ size_t arg_sz, const char *func,
+ format_directive *dir) {
if (buffer) {
if (!disjoint_spaces((uintptr_t)buffer, buf_sz, (uintptr_t)arg, arg_sz))
- private_abort("%s: output buffer overlaps with argument %d (%s)\n",
- func, dir->arg.index + 1, dir->directive);
+ private_abort("%s: output buffer overlaps with argument %d (%s)\n", func,
+ dir->arg.index + 1, dir->directive);
}
}
@@ -761,25 +782,24 @@ static void validate_overlapping_buffer(char *buffer, size_t buf_sz, void *arg,
@param func - symbolic name of a formatting function used
@param buffer - buffer to write (in case of sprintf/snprintf, NULL otherwise)
@param buffer - buffer limit */
-static void validate_format
- (const char *fmtdesc, const char *fmt,
- va_list ap, const char *func, char *buffer, size_t buf_size)
-{
+static void validate_format(const char *fmtdesc, const char *fmt, va_list ap,
+ const char *func, char *buffer, size_t buf_size) {
/* Check that format string is valid first */
- if (valid_string((char*)fmt, 0) < 0)
- private_abort("%s: invalid format string (unallocated or unterminated)\n", func);
+ if (valid_string((char *)fmt, 0) < 0)
+ private_abort("%s: invalid format string (unallocated or unterminated)\n",
+ func);
/* Parse format string and generate format directives */
- format_directive ** dirs = get_format_directives((char*)fmt);
- format_directive ** dirs_c = dirs; /* extra alias for passing it to `free` */
+ format_directive **dirs = get_format_directives((char *)fmt);
+ format_directive **dirs_c = dirs; /* extra alias for passing it to `free` */
/* Track addresses of variadic arguments */
int arglen = strlen(fmtdesc); /* number of variadic arguments */
void *args[arglen];
int i;
for (int i = 0; i < arglen; i++)
- args[i] = va_arg(ap, void*);
+ args[i] = va_arg(ap, void *);
va_end(ap);
/* Validate each generated directive */
@@ -793,94 +813,100 @@ static void validate_format
argument except for literal directive `%%` */
if (argno >= arglen)
private_abort("%s: directive %d (%s) in format \"%s\" has no argument\n",
- func, dir->arg.index + 1, dir->directive, dir->format);
+ func, dir->arg.index + 1, dir->directive, dir->format);
/* Shortcut for `validate_format_type` function */
-#define validate_type(_t) validate_format_type(_t, fmtdesc, dir, func)
+# define validate_type(_t) validate_format_type(_t, fmtdesc, dir, func)
uintptr_t addr = (uintptr_t)args[argno]; /* Address of the argument */
char expected_t; /* Placeholder for the type expected by the directive */
- switch(dir->specifier) {
- case 'd': /* signed integer */
- case 'i':
- expected_t = infer_integral_abbr(dir, 1);
- validate_type(expected_t);
- break;
- case 'o': /* unsigned integer */
- case 'u':
- case 'x': case 'X':
- expected_t = infer_integral_abbr(dir, 0);
- validate_type(expected_t);
- break;
- case 'f': case 'F': /* double */
- case 'e': case 'E':
- case 'g': case 'G':
- case 'a': case 'A':
- /* All floating point modifiers (aAeEfFgG) expect doubles except for
+ switch (dir->specifier) {
+ case 'd': /* signed integer */
+ case 'i':
+ expected_t = infer_integral_abbr(dir, 1);
+ validate_type(expected_t);
+ break;
+ case 'o': /* unsigned integer */
+ case 'u':
+ case 'x':
+ case 'X':
+ expected_t = infer_integral_abbr(dir, 0);
+ validate_type(expected_t);
+ break;
+ case 'f':
+ case 'F': /* double */
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ case 'a':
+ case 'A':
+ /* All floating point modifiers (aAeEfFgG) expect doubles except for
the case when 'L' length modifier is given in which case it expects
long double. Any other length modifier leads to an undefined
behaviour. Checking that does not happen is done in
::validate_applications */
- expected_t = (dir->length.mod == 'L') ? FLongDouble : FDouble;
- validate_type(expected_t);
- break;
- case 'c': /* character */
- /* On all occasions 'c' expects an `int`. This is because `char` is
+ expected_t = (dir->length.mod == 'L') ? FLongDouble : FDouble;
+ validate_type(expected_t);
+ break;
+ case 'c': /* character */
+ /* On all occasions 'c' expects an `int`. This is because `char` is
always promoted. However, in case `l` length modifier is specified
(i.e., "%lc") then it expects an argument be of type `wint_t` and
can either be signed or unsigned. So let's compute it! */
- if (dir->length.mod == 'l') {
- wint_t wi = 1;
- int sign = UNSIGNED(wi);
- expected_t = size2abbri(sizeof(wint_t), !sign);
- } else
- expected_t = IInt;
- validate_type(expected_t);
- break;
- case 's': { /* character string */
- int wide = (dir->length.mod == 'l');
- if (wide) { /* same as with %lc, compute sign of wchar_t */
- wchar_t wi = 1;
- int sign = UNSIGNED(wi);
- expected_t = size2abbri(sizeof(wint_t), !sign);
- expected_t = abbr2ptr(expected_t);
- } else
- expected_t = PChar;
- validate_type(expected_t);
- /* Check that a string is valid */
- int asz = validate_format_string_argument((char*)addr, dir, func, wide);
- validate_overlapping_buffer
- (buffer, buf_size, (void*)addr, asz, func, dir);
- break;
- }
- case 'p':
- validate_type(PVoid);
- if (!allocated(addr, 1, addr))
- private_abort("%s: argument %d of directive %s not allocated\n", func,
- argno + 1, dir->directive);
- validate_overlapping_buffer
- (buffer, buf_size, (void*)addr, 1, func, dir);
- break;
- case 'n': {
- expected_t = infer_n_abbr(dir);
- validate_type(expected_t);
- /* 'n' modifier writes the number of bytes corresponding to characters
+ if (dir->length.mod == 'l') {
+ wint_t wi = 1;
+ int sign = UNSIGNED(wi);
+ expected_t = size2abbri(sizeof(wint_t), !sign);
+ } else
+ expected_t = IInt;
+ validate_type(expected_t);
+ break;
+ case 's': { /* character string */
+ int wide = (dir->length.mod == 'l');
+ if (wide) { /* same as with %lc, compute sign of wchar_t */
+ wchar_t wi = 1;
+ int sign = UNSIGNED(wi);
+ expected_t = size2abbri(sizeof(wint_t), !sign);
+ expected_t = abbr2ptr(expected_t);
+ } else
+ expected_t = PChar;
+ validate_type(expected_t);
+ /* Check that a string is valid */
+ int asz = validate_format_string_argument((char *)addr, dir, func, wide);
+ validate_overlapping_buffer(buffer, buf_size, (void *)addr, asz, func,
+ dir);
+ break;
+ }
+ case 'p':
+ validate_type(PVoid);
+ if (!allocated(addr, 1, addr))
+ private_abort("%s: argument %d of directive %s not allocated\n", func,
+ argno + 1, dir->directive);
+ validate_overlapping_buffer(buffer, buf_size, (void *)addr, 1, func, dir);
+ break;
+ case 'n': {
+ expected_t = infer_n_abbr(dir);
+ validate_type(expected_t);
+ /* 'n' modifier writes the number of bytes corresponding to characters
written by a function so far to a pointer of an integral type. Make
sure that the provided pointer corresponds to writeable memory. */
- int size = dir->length.bytes == 0 ? sizeof(int) : dir->length.bytes;
- if (!writeable(addr, size, addr))
- private_abort("%s: argument %d of directive %s not allocated or writeable\n",
+ int size = dir->length.bytes == 0 ? sizeof(int) : dir->length.bytes;
+ if (!writeable(addr, size, addr))
+ private_abort(
+ "%s: argument %d of directive %s not allocated or writeable\n",
func, argno, dir->directive);
- validate_overlapping_buffer
- (buffer, buf_size, (void*)addr, size, func, dir);
- break;
- }
- default:
- private_abort(INT_ERROR "Unexpected format specifier '%c'\n", dir->specifier);
+ validate_overlapping_buffer(buffer, buf_size, (void *)addr, size, func,
+ dir);
+ break;
+ }
+ default:
+ private_abort(INT_ERROR "Unexpected format specifier '%c'\n",
+ dir->specifier);
}
dirs++;
-#undef validate_type
+# undef validate_type
}
release_directives(fmt, dirs_c);
}
@@ -895,7 +921,8 @@ int eacsl_builtin_printf(const char *fmtdesc, const char *fmt, ...) {
return vprintf(fmt, ap);
}
-int eacsl_builtin_fprintf(const char *fmtdesc, FILE *stream, const char *fmt, ...) {
+int eacsl_builtin_fprintf(const char *fmtdesc, FILE *stream, const char *fmt,
+ ...) {
va_list ap;
va_start(ap, fmt);
/* First check that stream belongs to allocated space */
@@ -923,13 +950,15 @@ int eacsl_builtin_dprintf(const char *fmtdesc, int fd, const char *fmt, ...) {
va_start(ap, fmt);
/* Make sure that the designated file descriptor is open */
if (fcntl(fd, F_GETFD) == -1)
- private_abort("dprintf: attempt to write to a closed file descriptor %d\n", fd);
+ private_abort("dprintf: attempt to write to a closed file descriptor %d\n",
+ fd);
validate_format(fmtdesc, fmt, ap, "dprintf", NULL, 0);
va_start(ap, fmt);
return vdprintf(fd, fmt, ap);
}
-int eacsl_builtin_sprintf(const char *fmtdesc, char *buffer, const char *fmt, ...) {
+int eacsl_builtin_sprintf(const char *fmtdesc, char *buffer, const char *fmt,
+ ...) {
va_list ap;
/* Make sure that the buffer has sufficient space to store the result of the
function. Luckily this can be accomplished via `snprintf(buf, n, mfmt,...)`
@@ -940,8 +969,10 @@ int eacsl_builtin_sprintf(const char *fmtdesc, char *buffer, const char *fmt, ..
va_start(ap, fmt);
int len = vsnprintf(NULL, 0, fmt, ap);
if (!writeable((uintptr_t)buffer, len + 1, (uintptr_t)buffer))
- private_abort("sprintf: output buffer is unallocated or has insufficient length "
- "to store %d characters or not writeable\n", len + 1);
+ private_abort(
+ "sprintf: output buffer is unallocated or has insufficient length "
+ "to store %d characters or not writeable\n",
+ len + 1);
va_start(ap, fmt);
validate_format(fmtdesc, fmt, ap, "sprintf", buffer, len + 1);
va_start(ap, fmt);
@@ -953,15 +984,17 @@ int eacsl_builtin_sprintf(const char *fmtdesc, char *buffer, const char *fmt, ..
}
int eacsl_builtin_snprintf(const char *fmtdesc, char *buffer, size_t size,
- const char *fmt, ...) {
+ const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
validate_format(fmtdesc, fmt, ap, "snprintf", buffer, size);
/* Check that the input buffer is large enough. However, if there are zero
characters to write, it does not matter */
if (size > 0 && !writeable((uintptr_t)buffer, size, (uintptr_t)buffer))
- private_abort("sprintf: output buffer is unallocated or has insufficient length "
- "to store %d characters and \\0 terminator or not writeable\n", size);
+ private_abort(
+ "sprintf: output buffer is unallocated or has insufficient length "
+ "to store %d characters and \\0 terminator or not writeable\n",
+ size);
va_start(ap, fmt);
int res = vsnprintf(buffer, size, fmt, ap);
if (res >= 0 && size > 0) {
@@ -970,7 +1003,8 @@ int eacsl_builtin_snprintf(const char *fmtdesc, char *buffer, size_t size,
return res;
}
-int eacsl_builtin_syslog(const char *fmtdesc, int priority, const char *fmt, ...) {
+int eacsl_builtin_syslog(const char *fmtdesc, int priority, const char *fmt,
+ ...) {
va_list ap;
va_start(ap, fmt);
validate_format(fmtdesc, fmt, ap, "syslog", NULL, 0);
diff --git a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.h b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.h
index d64a0249f7d560e42dc4f8de23f8217c6afaa66d..db6f69c9c2708bae4138a65785ec5ed01a7b9cba 100644
--- a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.h
+++ b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_stdio.h
@@ -93,28 +93,27 @@
/** \brief `printf` with error checking. */
int eacsl_builtin_printf(const char *fmtdesc, const char *fmt, ...)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/** \brief `fprintf` with error checking. */
-int eacsl_builtin_fprintf(const char *fmtdesc, FILE *stream, const char *fmt, ...)
- __attribute__((FC_BUILTIN));
+int eacsl_builtin_fprintf(const char *fmtdesc, FILE *stream, const char *fmt,
+ ...) __attribute__((FC_BUILTIN));
/** \brief `dprintf` with error checking. */
int eacsl_builtin_dprintf(const char *fmtdesc, int fd, const char *fmt, ...)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/** \brief `sprintf` with error checking. */
-int eacsl_builtin_sprintf(const char *fmtdesc, char *buffer, const char *fmt, ...)
- __attribute__((FC_BUILTIN));
+int eacsl_builtin_sprintf(const char *fmtdesc, char *buffer, const char *fmt,
+ ...) __attribute__((FC_BUILTIN));
/** \brief `snprintf` with error checking. */
int eacsl_builtin_snprintf(const char *fmtdesc, char *buffer, size_t size,
- const char *fmt, ...)
- __attribute__((FC_BUILTIN));
+ const char *fmt, ...) __attribute__((FC_BUILTIN));
/** \brief `syslog` with error checking. */
-int eacsl_builtin_syslog(const char *fmtdesc, int priority, const char *fmt, ...)
- __attribute__((FC_BUILTIN));
+int eacsl_builtin_syslog(const char *fmtdesc, int priority, const char *fmt,
+ ...) __attribute__((FC_BUILTIN));
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.c b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.c
index 38a7711183787ca6baffeb3dbb5c25426c97541b..ae8c826dd5b315ac7b502ab4f4744659330684ce 100644
--- a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.c
+++ b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.c
@@ -46,7 +46,7 @@ long valid_nstring(char *s, long n, int wrtbl) {
return n;
if (n > size)
return -3; /* Insufficient length */
- return -4; /* Not NUL-terminated */
+ return -4; /* Not NUL-terminated */
}
return -1 /* Not allocated */;
}
@@ -59,7 +59,7 @@ long valid_nwstring(wchar_t *s, long n, int wrtbl) {
if (alc) {
if (wrtbl && readonly(s))
return -2; /* Not writeable */
- long size = (eacsl_block_length(s) - eacsl_offset(s))/sizeof(wchar_t);
+ long size = (eacsl_block_length(s) - eacsl_offset(s)) / sizeof(wchar_t);
long i;
for (i = 0; i < size; i++) {
if (s[i] == L'\0' || n == i)
@@ -69,73 +69,73 @@ long valid_nwstring(wchar_t *s, long n, int wrtbl) {
return n;
if (n > size)
return -3; /* Insufficient length */
- return -4; /* Not NUL-terminated */
+ return -4; /* Not NUL-terminated */
}
return -1 /* Not allocated */;
}
-static long validate_string
- (char *s, long n, int wrtbl, const char *fun, const char *desc)
-{
+static long validate_string(char *s, long n, int wrtbl, const char *fun,
+ const char *desc) {
long size = valid_nstring(s, n, wrtbl);
- switch(size) {
- case -1:
- private_abort("%s: %sstring unallocated\n", fun, desc);
- case -2:
- private_abort("%s: %sstring is not writable\n", fun, desc);
- case -3:
- private_abort("%s: %sstring has insufficient length\n", fun, desc);
- case -4:
- private_abort("%s: %sstring not NUL-terminated\n", fun, desc);
+ switch (size) {
+ case -1:
+ private_abort("%s: %sstring unallocated\n", fun, desc);
+ case -2:
+ private_abort("%s: %sstring is not writable\n", fun, desc);
+ case -3:
+ private_abort("%s: %sstring has insufficient length\n", fun, desc);
+ case -4:
+ private_abort("%s: %sstring not NUL-terminated\n", fun, desc);
}
/* at this point negative return values should have been handled */
private_assert(size >= 0, "unexpected return value of %d\n", size);
return size;
}
-static inline long validate_writeable_string
- (char *s, long n, const char *fun, const char *desc)
-{
+static inline long validate_writeable_string(char *s, long n, const char *fun,
+ const char *desc) {
return validate_string(s, n, 1, fun, desc);
}
-static inline long validate_allocated_string
- (char *s, long n, const char *fun, const char *desc)
-{
+static inline long validate_allocated_string(char *s, long n, const char *fun,
+ const char *desc) {
return validate_string(s, n, 0, fun, desc);
}
/* }}} */
/* *** Memory spaces {{{ */
-int disjoint_spaces(uintptr_t s1, size_t s1_sz, uintptr_t s2, size_t s2_sz)
-{
+int disjoint_spaces(uintptr_t s1, size_t s1_sz, uintptr_t s2, size_t s2_sz) {
return s1 + s1_sz <= s2 || s2 + s2_sz <= s1;
}
-static inline void validate_allocated_space
- (void *p, size_t sz, const char *func, const char *space)
-{
+static inline void validate_allocated_space(void *p, size_t sz,
+ const char *func,
+ const char *space) {
if (!allocated((uintptr_t)p, sz, (uintptr_t)p)) {
- private_abort("%s: unallocated (or insufficient) space in %s\n", func, space);
+ private_abort("%s: unallocated (or insufficient) space in %s\n", func,
+ space);
}
}
static inline void validate_writeable_space(void *p, size_t sz,
- const char *func, const char *space) {
+ const char *func,
+ const char *space) {
if (!writeable((uintptr_t)p, sz, (uintptr_t)p)) {
if (writeable((uintptr_t)p, 1, (uintptr_t)p)) {
private_abort("%s: insufficient space in %s, "
- "at least %lu bytes required\n", func, space, sz);
+ "at least %lu bytes required\n",
+ func, space, sz);
} else {
- private_abort("%s: %s space unallocated or cannot be written\n", func, space);
+ private_abort("%s: %s space unallocated or cannot be written\n", func,
+ space);
}
}
}
-static inline void validate_overlapping_spaces
- (uintptr_t s1, size_t s1_sz, uintptr_t s2, size_t s2_sz, const char *func)
-{
+static inline void validate_overlapping_spaces(uintptr_t s1, size_t s1_sz,
+ uintptr_t s2, size_t s2_sz,
+ const char *func) {
if (!disjoint_spaces(s1, s1_sz, s2, s2_sz))
private_abort("%s: overlapping memory areas\n", func);
}
@@ -147,82 +147,82 @@ static inline void validate_overlapping_spaces
/************************************************************************/
size_t eacsl_builtin_strlen(const char *s) {
- return validate_allocated_string((char*)s, -1, "strlen", "input ");
+ return validate_allocated_string((char *)s, -1, "strlen", "input ");
}
char *eacsl_builtin_strcpy(char *dest, const char *src) {
// `src` string should be a valid NUL-terminated C string
size_t size =
- validate_allocated_string((char*)src, -1, "strlen", "source string ");
+ validate_allocated_string((char *)src, -1, "strlen", "source string ");
/* `dest` should be writable and at least `size + 1` bytes long to
accommodate the NUL-terminator */
validate_writeable_space(dest, size + 1, "strlen", "destination string");
/* source and destination strings should not overlap */
- validate_overlapping_spaces
- ((uintptr_t)dest, size + 1, (uintptr_t)src, size + 1, "strcpy");
- char * res = strcpy(dest, src);
+ validate_overlapping_spaces((uintptr_t)dest, size + 1, (uintptr_t)src,
+ size + 1, "strcpy");
+ char *res = strcpy(dest, src);
eacsl_initialize(dest, size + 1);
return res;
}
char *eacsl_builtin_strncpy(char *dest, const char *src, size_t n) {
/* `src` should be a valid string up to `nth` character */
- validate_allocated_string((char*)src, n, "strncpy", "source string ");
+ validate_allocated_string((char *)src, n, "strncpy", "source string ");
/* `dest` should be allocated and writeable up to `nth` character */
validate_writeable_space(dest, n, "strncpy", "destination string ");
/* source and destination strings should not overlap */
validate_overlapping_spaces((uintptr_t)dest, n, (uintptr_t)src, n, "strncpy");
- char * res = strncpy(dest, src, n);
+ char *res = strncpy(dest, src, n);
eacsl_initialize(dest, n);
return res;
}
int eacsl_builtin_strcmp(const char *s1, const char *s2) {
/* both strings should be valid NUL-terminated strings */
- validate_allocated_string((char*)s1, -1, "strcmp", "string 1 ");
- validate_allocated_string((char*)s2, -1, "strcmp", "string 2 ");
+ validate_allocated_string((char *)s1, -1, "strcmp", "string 1 ");
+ validate_allocated_string((char *)s2, -1, "strcmp", "string 2 ");
return strcmp(s1, s2);
}
int eacsl_builtin_strncmp(const char *s1, const char *s2, size_t n) {
/* both strings should be valid up to nth character */
- validate_allocated_string((char*)s1, n, "strncmp", "string 1 ");
- validate_allocated_string((char*)s2, n, "strncmp", "string 2 ");
+ validate_allocated_string((char *)s1, n, "strncmp", "string 1 ");
+ validate_allocated_string((char *)s2, n, "strncmp", "string 2 ");
return strncmp(s1, s2, n);
}
char *eacsl_builtin_strcat(char *dest, const char *src) {
long src_sz =
- validate_allocated_string((char*)src, -1, "strcat", "source string ");
- long dest_sz =
- validate_writeable_string((char*)dest, -1, "strcat", "destination string ");
+ validate_allocated_string((char *)src, -1, "strcat", "source string ");
+ long dest_sz = validate_writeable_string((char *)dest, -1, "strcat",
+ "destination string ");
size_t avail_sz = eacsl_block_length(dest) - eacsl_offset(dest);
if (!(avail_sz >= src_sz + dest_sz + 1)) {
private_abort("strcat: insufficient space in destination string, "
- "available: %lu bytes, requires at least %lu bytes\n",
- avail_sz, src_sz + dest_sz + 1);
+ "available: %lu bytes, requires at least %lu bytes\n",
+ avail_sz, src_sz + dest_sz + 1);
}
- validate_overlapping_spaces
- ((uintptr_t)src, src_sz + 1, (uintptr_t)dest, dest_sz + 1, "strcat");
- char * res = strcat(dest, src);
+ validate_overlapping_spaces((uintptr_t)src, src_sz + 1, (uintptr_t)dest,
+ dest_sz + 1, "strcat");
+ char *res = strcat(dest, src);
eacsl_initialize(&dest[dest_sz], src_sz + 1);
return res;
}
char *eacsl_builtin_strncat(char *dest, const char *src, size_t n) {
long src_sz =
- validate_allocated_string((char*)src, n, "strncat", "source string ");
- long dest_sz =
- validate_writeable_string((char*)dest, -1, "strcat", "destination string ");
+ validate_allocated_string((char *)src, n, "strncat", "source string ");
+ long dest_sz = validate_writeable_string((char *)dest, -1, "strcat",
+ "destination string ");
size_t avail_sz = eacsl_block_length(dest) - eacsl_offset(dest);
if (!(avail_sz >= n + dest_sz + 1)) {
private_abort("strncat: insufficient space in destination string, "
- "available: %lu bytes, requires at least %lu bytes\n",
- avail_sz, n + dest_sz + 1);
+ "available: %lu bytes, requires at least %lu bytes\n",
+ avail_sz, n + dest_sz + 1);
}
- validate_overlapping_spaces
- ((uintptr_t)src, n, (uintptr_t)dest, dest_sz, "strcat");
- char * res = strncat(dest, src, n);
+ validate_overlapping_spaces((uintptr_t)src, n, (uintptr_t)dest, dest_sz,
+ "strcat");
+ char *res = strncat(dest, src, n);
eacsl_initialize(&dest[dest_sz], src_sz + 1);
return res;
}
@@ -233,35 +233,34 @@ char *eacsl_builtin_strncat(char *dest, const char *src, size_t n) {
/************************************************************************/
void *eacsl_builtin_memcpy(void *dest, const void *src, size_t n) {
- validate_allocated_space((void*)src, n, "memcpy", "source space ");
- validate_writeable_space((void*)dest, n, "memcpy", "destination space ");
+ validate_allocated_space((void *)src, n, "memcpy", "source space ");
+ validate_writeable_space((void *)dest, n, "memcpy", "destination space ");
validate_overlapping_spaces((uintptr_t)src, n, (uintptr_t)dest, n, "memcpy");
- void * res = memcpy(dest, src, n);
+ void *res = memcpy(dest, src, n);
eacsl_initialize(dest, n);
return res;
}
void *eacsl_builtin_memset(void *s, int c, size_t n) {
- validate_writeable_space((void*)s, n, "memset", "space ");
- void * res = memset(s, c, n);
+ validate_writeable_space((void *)s, n, "memset", "space ");
+ void *res = memset(s, c, n);
eacsl_initialize(s, n);
return res;
}
int eacsl_builtin_memcmp(const void *s1, const void *s2, size_t n) {
- validate_allocated_space((void*)s1, n, "memcmp", "space 1 ");
- validate_allocated_space((void*)s2, n, "memcmp", "space 1 ");
+ validate_allocated_space((void *)s1, n, "memcmp", "space 1 ");
+ validate_allocated_space((void *)s2, n, "memcmp", "space 1 ");
validate_overlapping_spaces((uintptr_t)s1, n, (uintptr_t)s2, n, "memcpy");
return memcmp(s1, s2, n);
}
void *eacsl_builtin_memmove(void *dest, const void *src, size_t n) {
- validate_allocated_space((void*)src, n, "memcmp", "source space ");
- validate_writeable_space((void*)dest, n, "memcmp", "destination space ");
- void * res = memmove(dest, src, n);
+ validate_allocated_space((void *)src, n, "memcmp", "source space ");
+ validate_writeable_space((void *)dest, n, "memcmp", "destination space ");
+ void *res = memmove(dest, src, n);
eacsl_initialize(dest, n);
return res;
}
/* }}} */
-
diff --git a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.h b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.h
index d50a66c847bc66fabca15f70bda7442c40ad828a..2914dd5678bb9fb8666033ea6a5e11680c3d07b0 100644
--- a/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.h
+++ b/src/plugins/e-acsl/share/e-acsl/libc_replacements/e_acsl_string.h
@@ -33,17 +33,17 @@
#include "../internals/e_acsl_alias.h"
-#define eacsl_builtin_strlen export_alias(builtin_strlen)
-#define eacsl_builtin_strcpy export_alias(builtin_strcpy)
-#define eacsl_builtin_strncpy export_alias(builtin_strncpy)
-#define eacsl_builtin_strcat export_alias(builtin_strcat)
-#define eacsl_builtin_strncat export_alias(builtin_strncat)
-#define eacsl_builtin_strcmp export_alias(builtin_strcmp)
-#define eacsl_builtin_strncmp export_alias(builtin_strncmp)
-#define eacsl_builtin_memcpy export_alias(builtin_memcpy)
-#define eacsl_builtin_memset export_alias(builtin_memset)
-#define eacsl_builtin_memcmp export_alias(builtin_memcmp)
-#define eacsl_builtin_memmove export_alias(builtin_memmove)
+#define eacsl_builtin_strlen export_alias(builtin_strlen)
+#define eacsl_builtin_strcpy export_alias(builtin_strcpy)
+#define eacsl_builtin_strncpy export_alias(builtin_strncpy)
+#define eacsl_builtin_strcat export_alias(builtin_strcat)
+#define eacsl_builtin_strncat export_alias(builtin_strncat)
+#define eacsl_builtin_strcmp export_alias(builtin_strcmp)
+#define eacsl_builtin_strncmp export_alias(builtin_strncmp)
+#define eacsl_builtin_memcpy export_alias(builtin_memcpy)
+#define eacsl_builtin_memset export_alias(builtin_memset)
+#define eacsl_builtin_memcmp export_alias(builtin_memcmp)
+#define eacsl_builtin_memmove export_alias(builtin_memmove)
/************************************************************************/
/*** Support functionality {{{ ***/
@@ -100,46 +100,45 @@ int disjoint_spaces(uintptr_t s1, size_t s1_sz, uintptr_t s2, size_t s2_sz);
/* drop-in replacement for `strlen` */
/*@ assigns \result \from s[0..]; */
-size_t eacsl_builtin_strlen(const char *s)
- __attribute__((FC_BUILTIN));
+size_t eacsl_builtin_strlen(const char *s) __attribute__((FC_BUILTIN));
/* drop-in replacement for `strcpy` */
/*@ assigns dest[0..] \from src[0..];
@ assigns \result \from dest;
@ ensures \result == dest; */
char *eacsl_builtin_strcpy(char *dest, const char *src)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `strncpy` */
/*@ assigns dest[0..n - 1] \from src[0..n-1];
@ assigns \result \from dest;
@ ensures \result == dest; */
char *eacsl_builtin_strncpy(char *dest, const char *src, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `strcmp` */
/*@ assigns \result \from s1[0..], s2[0..]; */
int eacsl_builtin_strcmp(const char *s1, const char *s2)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `strncmp` */
/*@ assigns \result \from s1[0..n-1], s2[0..n-1]; */
int eacsl_builtin_strncmp(const char *s1, const char *s2, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `strcat` */
/*@ assigns dest[..] \from src[0..];
@ assigns \result \from dest;
@ ensures \result == dest; */
char *eacsl_builtin_strcat(char *dest, const char *src)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `strncat` */
/*@ assigns dest[..] \from src[0..n];
@ assigns \result \from dest;
@ ensures \result == dest; */
char *eacsl_builtin_strncat(char *dest, const char *src, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* }}} */
/************************************************************************/
@@ -151,26 +150,26 @@ char *eacsl_builtin_strncat(char *dest, const char *src, size_t n)
@ assigns \result \from dest;
@ ensures \result == dest; */
void *eacsl_builtin_memcpy(void *dest, const void *src, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `memset` */
/*@ assigns ((char*)s)[0..n-1] \from c;
@ assigns \result \from s;
@ ensures \result == s; */
void *eacsl_builtin_memset(void *s, int c, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `memcmp` */
/*@ assigns \result \from ((char*)s1)[0..n-1], ((char*)s2)[0..n-1]; */
int eacsl_builtin_memcmp(const void *s1, const void *s2, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* drop-in replacement for `memmove` */
/*@ assigns ((char*)dest)[0..n-1] \from ((char*)src)[0..n-1];
@ assigns \result \from dest;
@ ensures \result == dest; */
void *eacsl_builtin_memmove(void *dest, const void *src, size_t n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.c b/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.c
index e357b4b942a2e3caecabdf42439aacd9c7ae3dd8..571e05ae64615c2dc429111a5c7d890334f921b8 100644
--- a/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.c
+++ b/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.c
@@ -30,14 +30,14 @@
// Initialization
double eacsl_math_HUGE_VAL = 0.0;
-float eacsl_math_HUGE_VALF = 0.0;
+float eacsl_math_HUGE_VALF = 0.0;
double eacsl_math_INFINITY = 0.0;
void init_infinity_values() {
/* Initialize E-ACSL infinity values */
- eacsl_math_HUGE_VAL = HUGE_VAL;
+ eacsl_math_HUGE_VAL = HUGE_VAL;
eacsl_math_HUGE_VALF = HUGE_VALF;
- eacsl_math_INFINITY = INFINITY;
+ eacsl_math_INFINITY = INFINITY;
/* Clear exceptions buffers */
feclearexcept(FE_ALL_EXCEPT);
}
@@ -49,7 +49,8 @@ void eacsl_floating_point_exception(const char *exp) {
if (fetestexcept(FE_DIVBYZERO))
resp = "Division by zero";
else if (fetestexcept(FE_INEXACT))
- resp = "Rounded result of an operation is not equal to the infinite precision result";
+ resp = "Rounded result of an operation is not equal to the infinite "
+ "precision result";
else if (fetestexcept(FE_INVALID))
resp = "Result of a floating-point operation is not well-defined";
else if (fetestexcept(FE_OVERFLOW))
@@ -58,7 +59,9 @@ void eacsl_floating_point_exception(const char *exp) {
resp = "Floating-point underflow";
}
if (resp) {
- rtl_printf("Execution of the statement `%s` leads to a floating point exception\n", exp);
+ rtl_printf(
+ "Execution of the statement `%s` leads to a floating point exception\n",
+ exp);
rtl_printf("Exception: %s\n", resp);
}
feclearexcept(FE_ALL_EXCEPT);
diff --git a/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.h b/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.h
index b9452a7fae4dbd0454e8ae0aaa94c79ebee70026..719ad13a5ff703dbbf05528c3af3584407eefb0b 100644
--- a/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.h
+++ b/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_floating_point.h
@@ -30,10 +30,10 @@
#include "../internals/e_acsl_alias.h"
-#define eacsl_math_HUGE_VAL export_alias(math_HUGE_VAL)
-#define eacsl_math_HUGE_VALF export_alias(math_HUGE_VALF)
-#define eacsl_math_INFINITY export_alias(math_INFINITY)
-#define eacsl_floating_point_exception export_alias(floating_point_exception)
+#define eacsl_math_HUGE_VAL export_alias(math_HUGE_VAL)
+#define eacsl_math_HUGE_VALF export_alias(math_HUGE_VALF)
+#define eacsl_math_INFINITY export_alias(math_INFINITY)
+#define eacsl_floating_point_exception export_alias(floating_point_exception)
/* Below variables hold infinity values for floating points defined in math.h.
Most of them are defined as macros that expand to built-in function calls.
@@ -50,14 +50,11 @@
*/
/** \brief Positive infinity for doubles: same as HUGE_VAL */
-extern double eacsl_math_HUGE_VAL
- __attribute__((FC_BUILTIN));
+extern double eacsl_math_HUGE_VAL __attribute__((FC_BUILTIN));
/** \brief Positive infinity for floats: same as HUGE_VALF */
-extern float eacsl_math_HUGE_VALF
- __attribute__((FC_BUILTIN));
+extern float eacsl_math_HUGE_VALF __attribute__((FC_BUILTIN));
/** \brief Representation of infinity value for doubles: same as INFINITY */
-extern double eacsl_math_INFINITY
- __attribute__((FC_BUILTIN));
+extern double eacsl_math_INFINITY __attribute__((FC_BUILTIN));
/* FIXME: An additional variable that should be added to this list is
long double math_HUGE_VALL;
@@ -68,6 +65,6 @@ extern double eacsl_math_INFINITY
void init_infinity_values();
void eacsl_floating_point_exception(const char *exp)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
#endif // E_ACSL_FLOATING_POINT_H
diff --git a/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_gmp_api.h b/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_gmp_api.h
index c76fcf49e29bb42aa4b1f2c48911dbde7b5471b8..eede828f6a9481e960d1612f2d0b9e5ac0b4f96a 100644
--- a/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_gmp_api.h
+++ b/src/plugins/e-acsl/share/e-acsl/numerical_model/e_acsl_gmp_api.h
@@ -33,8 +33,8 @@
#ifndef E_ACSL_GMP_API_H
#define E_ACSL_GMP_API_H
-#include <stddef.h>
#include "../internals/e_acsl_alias.h"
+#include <stddef.h>
#define eacsl_mpz_struct export_alias(mpz_struct)
#define eacsl_mpz_t export_alias(mpz_t)
@@ -49,7 +49,7 @@ struct eacsl_mpz_struct {
};
typedef struct eacsl_mpz_struct eacsl_mpz_struct;
-typedef eacsl_mpz_struct (__attribute__((__FC_BUILTIN__)) eacsl_mpz_t)[1];
+typedef eacsl_mpz_struct(__attribute__((__FC_BUILTIN__)) eacsl_mpz_t)[1];
struct eacsl_mpq_struct {
eacsl_mpz_struct _mp_num;
@@ -57,7 +57,7 @@ struct eacsl_mpq_struct {
};
typedef struct eacsl_mpq_struct eacsl_mpq_struct;
-typedef eacsl_mpq_struct (__attribute__((__FC_BUILTIN__)) eacsl_mpq_t)[1];
+typedef eacsl_mpq_struct(__attribute__((__FC_BUILTIN__)) eacsl_mpq_t)[1];
/**
* Counts of bits of a multi-precision number are represented in the C type
@@ -77,15 +77,13 @@ typedef unsigned long int eacsl_mp_bitcnt_t;
@ ensures \valid(z);
@ allocates z;
@ assigns *z \from __e_acsl_init; */
-extern void __gmpz_init(eacsl_mpz_t z)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_init(eacsl_mpz_t z) __attribute__((FC_BUILTIN));
/*@ requires ! \initialized(q);
@ ensures \valid(q);
@ allocates q;
@ assigns *q \from __e_acsl_init; */
-extern void __gmpq_init(eacsl_mpq_t q)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_init(eacsl_mpq_t q) __attribute__((FC_BUILTIN));
/*@ requires \valid_read(z_orig);
@ requires ! \initialized(z);
@@ -94,7 +92,7 @@ extern void __gmpq_init(eacsl_mpq_t q)
// @ ensures z->n == z_orig->n;
@ assigns *z \from *z_orig; */
extern void __gmpz_init_set(eacsl_mpz_t z, const eacsl_mpz_t z_orig)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires ! \initialized(z);
@ allocates z;
@@ -103,7 +101,7 @@ extern void __gmpz_init_set(eacsl_mpz_t z, const eacsl_mpz_t z_orig)
// @ ensures z->n == n;
@ assigns *z \from n; */
extern void __gmpz_init_set_ui(eacsl_mpz_t z, unsigned long int n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires ! \initialized(z);
@ allocates z;
@@ -112,7 +110,7 @@ extern void __gmpz_init_set_ui(eacsl_mpz_t z, unsigned long int n)
// @ ensures z->n == n;
@ assigns *z \from n; */
extern void __gmpz_init_set_si(eacsl_mpz_t z, signed long int n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires ! \initialized(z);
@ allocates z;
@@ -121,15 +119,15 @@ extern void __gmpz_init_set_si(eacsl_mpz_t z, signed long int n)
@ assigns *z \from str[0..],base;
@ assigns \result \from str[0..],base; */
extern int __gmpz_init_set_str(eacsl_mpz_t z, const char *str, int base)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires ! \initialized(z);
@ allocates z;
@ ensures \valid(z);
@ ensures \initialized(z);
@ assigns *z \from base; */
-extern void __gmpz_import (eacsl_mpz_t z, size_t, int, size_t, int, size_t, const void *base)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_import(eacsl_mpz_t z, size_t, int, size_t, int, size_t,
+ const void *base) __attribute__((FC_BUILTIN));
/***************/
/* Assignments */
@@ -140,34 +138,33 @@ extern void __gmpz_import (eacsl_mpz_t z, size_t, int, size_t, int, size_t, cons
// @ ensures z->n == z_orig->n;
@ assigns *z \from *z_orig; */
extern void __gmpz_set(eacsl_mpz_t z, const eacsl_mpz_t z_orig)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid_read(q_orig);
@ requires \valid(q);
@ assigns *q \from *q_orig; */
extern void __gmpq_set(eacsl_mpq_t q, const eacsl_mpq_t q_orig)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid(q);
@ assigns *q \from d; */
-extern void __gmpq_set_d(eacsl_mpq_t q, double d)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_set_d(eacsl_mpq_t q, double d) __attribute__((FC_BUILTIN));
/*@ requires \valid(q);
@ assigns *q \from n,d; */
-extern void __gmpq_set_ui(eacsl_mpq_t q, unsigned long int n, unsigned long int d)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_set_ui(eacsl_mpq_t q, unsigned long int n,
+ unsigned long int d) __attribute__((FC_BUILTIN));
/*@ requires \valid(q);
@ assigns *q \from n,d; */
extern void __gmpq_set_si(eacsl_mpq_t q, signed long int n, unsigned long int d)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid_read(z_orig);
@ requires \valid(q);
@ assigns *q \from *z_orig; */
extern void __gmpq_set_z(eacsl_mpq_t q, const eacsl_mpz_t z_orig)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ allocates q;
@ ensures \valid(q);
@@ -175,24 +172,24 @@ extern void __gmpq_set_z(eacsl_mpq_t q, const eacsl_mpz_t z_orig)
@ assigns *q \from str[0..],base;
@ assigns \result \from str[0..],base; */
extern int __gmpq_set_str(eacsl_mpq_t q, const char *str, int base)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid(z);
@ assigns *z \from n; */
extern void __gmpz_set_ui(eacsl_mpz_t z, unsigned long int n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid(z);
// @ ensures z->n == n;
@ assigns *z \from n; */
extern void __gmpz_set_si(eacsl_mpz_t z, signed long int n)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid_read(q_orig);
@ requires \valid(z);
@ assigns *z \from *q_orig; */
extern void __gmpz_set_q(eacsl_mpz_t z, const eacsl_mpq_t q_orig)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*************/
/* Finalizer */
@@ -201,14 +198,12 @@ extern void __gmpz_set_q(eacsl_mpz_t z, const eacsl_mpq_t q_orig)
/*@ requires \valid(x);
// @ frees x;
@ assigns *x \from *x; */
-extern void __gmpz_clear(eacsl_mpz_t x)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_clear(eacsl_mpz_t x) __attribute__((FC_BUILTIN));
/*@ requires \valid(x);
// @ frees x;
@ assigns *x \from *x; */
-extern void __gmpq_clear(eacsl_mpq_t x)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_clear(eacsl_mpq_t x) __attribute__((FC_BUILTIN));
/********************/
/* Logical operator */
@@ -218,13 +213,13 @@ extern void __gmpq_clear(eacsl_mpq_t x)
@ requires \valid_read(z2);
@ assigns \result \from *z1, *z2; */
extern int __gmpz_cmp(const eacsl_mpz_t z1, const eacsl_mpz_t z2)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid_read(q1);
@ requires \valid_read(q2);
@ assigns \result \from *q1, *q2; */
extern int __gmpq_cmp(const eacsl_mpq_t q1, const eacsl_mpq_t q2)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/************************/
/* Arithmetic operators */
@@ -234,82 +229,82 @@ extern int __gmpq_cmp(const eacsl_mpq_t q1, const eacsl_mpq_t q2)
@ requires \valid_read(z2);
@ assigns *z1 \from *z2; */
extern void __gmpz_neg(eacsl_mpz_t z1, const eacsl_mpz_t z2)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_add(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_add(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(q1);
@ requires \valid_read(q2);
@ requires \valid_read(q3);
@ assigns *q1 \from *q2, *q3; */
-extern void __gmpq_add(eacsl_mpq_t q1, const eacsl_mpq_t q2, const eacsl_mpq_t q3)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_add(eacsl_mpq_t q1, const eacsl_mpq_t q2,
+ const eacsl_mpq_t q3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_sub(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_sub(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(q1);
@ requires \valid_read(q2);
@ requires \valid_read(q3);
@ assigns *q1 \from *q2, *q3; */
-extern void __gmpq_sub(eacsl_mpq_t q1, const eacsl_mpq_t q2, const eacsl_mpq_t q3)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_sub(eacsl_mpq_t q1, const eacsl_mpq_t q2,
+ const eacsl_mpq_t q3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_mul(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_mul(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ assigns *z1 \from *z2, n; */
-extern void __gmpz_mul_2exp(eacsl_mpz_t z1, const eacsl_mpz_t z2, eacsl_mp_bitcnt_t n)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_mul_2exp(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ eacsl_mp_bitcnt_t n) __attribute__((FC_BUILTIN));
/*@ requires \valid(q1);
@ requires \valid_read(q2);
@ requires \valid_read(q3);
@ assigns *q1 \from *q2, *q3; */
-extern void __gmpq_mul(eacsl_mpq_t q1, const eacsl_mpq_t q2, const eacsl_mpq_t q3)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_mul(eacsl_mpq_t q1, const eacsl_mpq_t q2,
+ const eacsl_mpq_t q3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_tdiv_q(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_tdiv_q(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_tdiv_r(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_tdiv_r(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ assigns *z1 \from *z2, n; */
-extern void __gmpz_tdiv_q_2exp(eacsl_mpz_t z1, const eacsl_mpz_t z2, eacsl_mp_bitcnt_t n)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_tdiv_q_2exp(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ eacsl_mp_bitcnt_t n) __attribute__((FC_BUILTIN));
/*@ requires \valid(q1);
@ requires \valid_read(q2);
@ requires \valid_read(q3);
@ assigns *q1 \from *q2, *q3; */
-extern void __gmpq_div(eacsl_mpq_t q1, const eacsl_mpq_t q2, const eacsl_mpq_t q3)
- __attribute__((FC_BUILTIN));
+extern void __gmpq_div(eacsl_mpq_t q1, const eacsl_mpq_t q2,
+ const eacsl_mpq_t q3) __attribute__((FC_BUILTIN));
/*********************/
/* Bitwise operators */
@@ -319,29 +314,29 @@ extern void __gmpq_div(eacsl_mpq_t q1, const eacsl_mpq_t q2, const eacsl_mpq_t q
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_and(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_and(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_ior(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_ior(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ requires \valid_read(z3);
@ assigns *z1 \from *z2, *z3; */
-extern void __gmpz_xor(eacsl_mpz_t z1, const eacsl_mpz_t z2, const eacsl_mpz_t z3)
- __attribute__((FC_BUILTIN));
+extern void __gmpz_xor(eacsl_mpz_t z1, const eacsl_mpz_t z2,
+ const eacsl_mpz_t z3) __attribute__((FC_BUILTIN));
/*@ requires \valid(z1);
@ requires \valid_read(z2);
@ assigns *z1 \from *z2;
@ assigns \result \from *z1,*z2; */
extern int __gmpz_com(eacsl_mpz_t z1, const eacsl_mpz_t z2)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/************************/
/* Coercions to C types */
@@ -350,28 +345,24 @@ extern int __gmpz_com(eacsl_mpz_t z1, const eacsl_mpz_t z2)
/** Return non-zero iff the value of z fits in an unsigned long */
/*@ requires \valid_read(z);
@ assigns \result \from *z; */
-extern int __gmpz_fits_ulong_p(const eacsl_mpz_t z)
- __attribute__((FC_BUILTIN));
+extern int __gmpz_fits_ulong_p(const eacsl_mpz_t z) __attribute__((FC_BUILTIN));
/** Return non-zero iff the value of z fits in a signed long */
/*@ requires \valid_read(z);
@ assigns \result \from *z; */
-extern int __gmpz_fits_slong_p(const eacsl_mpz_t z)
- __attribute__((FC_BUILTIN));
+extern int __gmpz_fits_slong_p(const eacsl_mpz_t z) __attribute__((FC_BUILTIN));
/*@ requires \valid_read(z);
@ assigns \result \from *z; */
-extern long __gmpz_get_si(const eacsl_mpz_t z)
- __attribute__((FC_BUILTIN));
+extern long __gmpz_get_si(const eacsl_mpz_t z) __attribute__((FC_BUILTIN));
/*@ requires \valid_read(q);
@ assigns \result \from *q; */
-extern double __gmpq_get_d(const eacsl_mpq_t q)
- __attribute__((FC_BUILTIN));
+extern double __gmpq_get_d(const eacsl_mpq_t q) __attribute__((FC_BUILTIN));
/*@ requires \valid_read(z);
@ assigns \result \from *z; */
extern unsigned long __gmpz_get_ui(const eacsl_mpz_t z)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
#endif
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.c b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.c
index 70ebb814364d703c5ffbd20b927550d94b7c6c47..9bd6e36758aadc97cec9a39b753fdf9933957506 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.c
@@ -32,45 +32,48 @@
#include "e_acsl_bittree.h"
#if E_ACSL_OS_IS_LINUX
-#define WORDBITS __WORDSIZE
+# define WORDBITS __WORDSIZE
#elif E_ACSL_OS_IS_WINDOWS
// On windows, __WORDSIZE is not available
-# ifdef _WIN64
-# define WORDBITS 64
-# else
-# define WORDBITS 32
-# endif
+# ifdef _WIN64
+# define WORDBITS 64
+# else
+# define WORDBITS 32
+# endif
#else
-# error "Unsupported OS"
+# error "Unsupported OS"
#endif
static size_t mask(size_t, size_t);
#if WORDBITS == 16
-static const size_t Tmasks[] = {
-0x0,0x8000,0xc000,0xe000,0xf000,0xf800,0xfc00,0xfe00,0xff00,0xff80,0xffc0,
-0xffe0,0xfff0,0xfff8,0xfffc,0xfffe,0xffff};
+static const size_t Tmasks[] = {0x0, 0x8000, 0xc000, 0xe000, 0xf000, 0xf800,
+ 0xfc00, 0xfe00, 0xff00, 0xff80, 0xffc0, 0xffe0,
+ 0xfff0, 0xfff8, 0xfffc, 0xfffe, 0xffff};
-static const int Teq[] = {0,-1,3,-3,6,-5,7,-7,12,-9,11,-11,14,-13,15,16,-16};
-static const int Tneq[] = {0,0,1,-2,2,-4,5,-6,4,-8,9,-10,10,-12,13,-14,-15};
+static const int Teq[] = {0, -1, 3, -3, 6, -5, 7, -7, 12,
+ -9, 11, -11, 14, -13, 15, 16, -16};
+static const int Tneq[] = {0, 0, 1, -2, 2, -4, 5, -6, 4,
+ -8, 9, -10, 10, -12, 13, -14, -15};
#elif WORDBITS == 32
static const size_t Tmasks[] = {
-0x0,0x80000000,0xc0000000,0xe0000000,0xf0000000,0xf8000000,0xfc000000,
-0xfe000000,0xff000000,0xff800000,0xffc00000,0xffe00000,0xfff00000,0xfff80000,
-0xfffc0000,0xfffe0000,0xffff0000,0xffff8000,0xffffc000,0xffffe000,0xfffff000,
-0xfffff800,0xfffffc00,0xfffffe00,0xffffff00,0xffffff80,0xffffffc0,0xffffffe0,
-0xfffffff0,0xfffffff8,0xfffffffc,0xfffffffe,0xffffffff};
+ 0x0, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000,
+ 0xfc000000, 0xfe000000, 0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
+ 0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, 0xffff8000,
+ 0xffffc000, 0xffffe000, 0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
+ 0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 0xfffffff8,
+ 0xfffffffc, 0xfffffffe, 0xffffffff};
-static const int Teq[] =
- { 0,-1,3,-3,6,-5,7,-7,12,-9,11,-11,14,-13,15,-15,24,-17,19,-19,22,
- -21,23,-23,28,-25,27,-27,30,-29,31,32,-32 };
+static const int Teq[] = {0, -1, 3, -3, 6, -5, 7, -7, 12, -9, 11,
+ -11, 14, -13, 15, -15, 24, -17, 19, -19, 22, -21,
+ 23, -23, 28, -25, 27, -27, 30, -29, 31, 32, -32};
-static const int Tneq[] =
- { 0,0,1,-2,2,-4,5,-6,4,-8,9,-10,10,-12,13,-14,8,-16,17,-18,18,-20,21,-22,20,
- -24,25,-26,26,-28,29,-30,-31 };
+static const int Tneq[] = {0, 0, 1, -2, 2, -4, 5, -6, 4, -8, 9, -10,
+ 10, -12, 13, -14, 8, -16, 17, -18, 18, -20, 21, -22,
+ 20, -24, 25, -26, 26, -28, 29, -30, -31};
#else /* WORDBITS == 64 */
@@ -94,20 +97,24 @@ static const size_t Tmasks[] = {
0xfffffffffffffff8,0xfffffffffffffffc,0xfffffffffffffffe,0xffffffffffffffff};
// clang-format on
-static const int Teq[] =
- { 0,-1,3,-3,6,-5,7,-7,12,-9,11,-11,14,-13,15,-15,24,-17,19,-19,22,-21,23,-23,
- 28,-25,27,-27,30,-29,31,-31,48,-33,35,-35,38,-37,39,-39,44,-41,43,-43,46,
- -45,47,-47,56,-49,51,-51,54,-53,55,-55,60,-57,59,-59,62,-61,63,64,-64 };
+static const int Teq[] = {0, -1, 3, -3, 6, -5, 7, -7, 12, -9, 11,
+ -11, 14, -13, 15, -15, 24, -17, 19, -19, 22, -21,
+ 23, -23, 28, -25, 27, -27, 30, -29, 31, -31, 48,
+ -33, 35, -35, 38, -37, 39, -39, 44, -41, 43, -43,
+ 46, -45, 47, -47, 56, -49, 51, -51, 54, -53, 55,
+ -55, 60, -57, 59, -59, 62, -61, 63, 64, -64};
-static const int Tneq[] =
- { 0,0,1,-2,2,-4,5,-6,4,-8,9,-10,10,-12,13,-14,8,-16,17,-18,18,-20,21,-22,20,
- -24,25,-26,26,-28,29,-30,16,-32,33,-34,34,-36,37,-38,36,-40,41,-42,42,-44,
- 45,-46,40,-48,49,-50,50,-52,53,-54,52,-56,57,-58,58,-60,61,-62,-63 };
+static const int Tneq[] = {0, 0, 1, -2, 2, -4, 5, -6, 4, -8, 9, -10,
+ 10, -12, 13, -14, 8, -16, 17, -18, 18, -20, 21, -22,
+ 20, -24, 25, -26, 26, -28, 29, -30, 16, -32, 33, -34,
+ 34, -36, 37, -38, 36, -40, 41, -42, 42, -44, 45, -46,
+ 40, -48, 49, -50, 50, -52, 53, -54, 52, -56, 57, -58,
+ 58, -60, 61, -62, -63};
#endif
/*! \brief Root node of the bitree */
-static bt_node * bt_root = NULL;
+static bt_node *bt_root = NULL;
/* common prefix of two addresses */
/*@ assigns \nothing;
@@ -120,7 +127,7 @@ static bt_node * bt_root = NULL;
@*/
static size_t mask(size_t a, size_t b) {
size_t nxor = ~(a ^ b), ret;
- int i = WORDBITS/2; /* dichotomic search, starting in the middle */
+ int i = WORDBITS / 2; /* dichotomic search, starting in the middle */
/*cpt_mask++;*/
/* if the current mask matches we use transition from Teq, else from Tneq
@@ -129,7 +136,7 @@ static size_t mask(size_t a, size_t b) {
/*@ loop invariant -WORDBITS <= i <= WORDBITS;
@ loop assigns i;
@*/
- while(i > 0) {
+ while (i > 0) {
//@ assert 0 < i <= WORDBITS;
//@ assert \valid(Tmasks+i);
if (nxor >= Tmasks[i])
@@ -142,11 +149,10 @@ static size_t mask(size_t a, size_t b) {
//@ assert -WORDBITS <= i <= 0;
ret = Tmasks[-i];
- DASSERT ((a & ret) == (b & ret));
+ DASSERT((a & ret) == (b & ret));
return ret;
}
-
/* called from bt_remove */
/* the block we are looking for has to be in the tree */
/*@ requires \valid(ptr);
@@ -155,24 +161,24 @@ static size_t mask(size_t a, size_t b) {
@ ensures \valid(\result);
@ ensures \result->leaf == ptr;
@*/
-static bt_node * bt_get_leaf_from_block (bt_block * ptr) {
- bt_node * curr = bt_root;
+static bt_node *bt_get_leaf_from_block(bt_block *ptr) {
+ bt_node *curr = bt_root;
DASSERT(bt_root != NULL);
DASSERT(ptr != NULL);
/*@ loop assigns curr;
@*/
- while(!curr->is_leaf) {
+ while (!curr->is_leaf) {
// the prefix is consistent
DASSERT((curr->addr & curr->mask) == (ptr->ptr & curr->mask));
// two children
DASSERT(curr->left != NULL && curr->right != NULL);
// the prefix of one child is consistent
- if((curr->right->addr & curr->right->mask)
- == (ptr->ptr & curr->right->mask))
+ if ((curr->right->addr & curr->right->mask)
+ == (ptr->ptr & curr->right->mask))
curr = curr->right;
- else if((curr->left->addr & curr->left->mask)
- == (ptr->ptr & curr->left->mask))
+ else if ((curr->left->addr & curr->left->mask)
+ == (ptr->ptr & curr->left->mask))
curr = curr->left;
else
private_assert(0, "Unreachable", NULL);
@@ -182,20 +188,19 @@ static bt_node * bt_get_leaf_from_block (bt_block * ptr) {
return curr;
}
-
/* remove the block from the structure */
/* the block we are looking for has to be in the tree */
/*@ requires \valid(ptr);
@*/
-static void bt_remove (bt_block * ptr) {
- bt_node * leaf_to_delete = bt_get_leaf_from_block (ptr);
+static void bt_remove(bt_block *ptr) {
+ bt_node *leaf_to_delete = bt_get_leaf_from_block(ptr);
DASSERT(leaf_to_delete->leaf == ptr);
- if(leaf_to_delete->parent == NULL)
+ if (leaf_to_delete->parent == NULL)
// the leaf is the root
bt_root = NULL;
else {
- bt_node * sibling, * parent;
+ bt_node *sibling, *parent;
parent = leaf_to_delete->parent;
sibling = (leaf_to_delete == parent->left) ? parent->right : parent->left;
DASSERT(sibling != NULL);
@@ -206,24 +211,22 @@ static void bt_remove (bt_block * ptr) {
parent->left = sibling->left;
parent->right = sibling->right;
parent->leaf = sibling->leaf;
- if(!sibling->is_leaf) {
+ if (!sibling->is_leaf) {
sibling->left->parent = parent;
sibling->right->parent = parent;
}
private_free(sibling);
/* necessary ? -- begin */
- if(parent->parent != NULL) {
- parent->parent->mask = mask(parent->parent->left->addr
- & parent->parent->left->mask,
- parent->parent->right->addr
- & parent->parent->right->mask);
+ if (parent->parent != NULL) {
+ parent->parent->mask =
+ mask(parent->parent->left->addr & parent->parent->left->mask,
+ parent->parent->right->addr & parent->parent->right->mask);
}
/* necessary ? -- end */
}
private_free(leaf_to_delete);
}
-
/* called from bt_insert */
/* the returned node will be the sibling of the soon to be added node */
/*@ requires \valid(ptr);
@@ -231,21 +234,21 @@ static void bt_remove (bt_block * ptr) {
@ assigns \nothing;
@ ensures \valid(\result);
@*/
-static bt_node * bt_most_similar_node (bt_block * ptr) {
- bt_node * curr = bt_root;
+static bt_node *bt_most_similar_node(bt_block *ptr) {
+ bt_node *curr = bt_root;
size_t left_prefix, right_prefix;
DASSERT(ptr != NULL);
DASSERT(bt_root != NULL);
- while(1) {
- if(curr->is_leaf)
+ while (1) {
+ if (curr->is_leaf)
return curr;
DASSERT(curr->left != NULL && curr->right != NULL);
left_prefix = mask(curr->left->addr & curr->left->mask, ptr->ptr);
right_prefix = mask(curr->right->addr & curr->right->mask, ptr->ptr);
- if(left_prefix > right_prefix)
+ if (left_prefix > right_prefix)
curr = curr->left;
- else if(right_prefix > left_prefix)
+ else if (right_prefix > left_prefix)
curr = curr->right;
else
return curr;
@@ -255,8 +258,8 @@ static bt_node * bt_most_similar_node (bt_block * ptr) {
/* add a block in the structure */
/*@ requires \valid(ptr);
@*/
-static void bt_insert (bt_block * ptr) {
- bt_node * new_leaf;
+static void bt_insert(bt_block *ptr) {
+ bt_node *new_leaf;
DASSERT(ptr != NULL);
new_leaf = private_malloc(sizeof(bt_node));
@@ -269,10 +272,10 @@ static void bt_insert (bt_block * ptr) {
new_leaf->parent = NULL;
new_leaf->leaf = ptr;
- if(bt_root == NULL)
+ if (bt_root == NULL)
bt_root = new_leaf;
else {
- bt_node * sibling = bt_most_similar_node (ptr), * parent, * aux;
+ bt_node *sibling = bt_most_similar_node(ptr), *parent, *aux;
DASSERT(sibling != NULL);
parent = private_malloc(sizeof(bt_node));
@@ -281,7 +284,7 @@ static void bt_insert (bt_block * ptr) {
parent->addr = sibling->addr & new_leaf->addr;
/*parent->mask = mask(sibling->addr & sibling->mask, ptr->ptr);*/
parent->leaf = NULL;
- if(new_leaf->addr <= sibling->addr) {
+ if (new_leaf->addr <= sibling->addr) {
parent->left = new_leaf;
parent->right = sibling;
} else {
@@ -290,7 +293,7 @@ static void bt_insert (bt_block * ptr) {
}
new_leaf->parent = parent;
- if(sibling == bt_root) {
+ if (sibling == bt_root) {
parent->parent = NULL;
parent->mask = mask(sibling->addr & sibling->mask, ptr->ptr);
bt_root = parent;
@@ -304,16 +307,16 @@ static void bt_insert (bt_block * ptr) {
/* necessary ? -- begin */
aux = parent;
aux->mask = mask(aux->left->addr & aux->left->mask,
- aux->right->addr & aux->right->mask);
+ aux->right->addr & aux->right->mask);
/* necessary ? -- end */
}
sibling->parent = parent;
- if(!sibling->is_leaf)
+ if (!sibling->is_leaf)
sibling->mask = mask(sibling->left->addr & sibling->left->mask,
- sibling->right->addr & sibling->right->mask);
+ sibling->right->addr & sibling->right->mask);
DASSERT((parent->left == sibling && parent->right == new_leaf)
- || (parent->left == new_leaf && parent->right == sibling));
+ || (parent->left == new_leaf && parent->right == sibling));
}
}
@@ -323,32 +326,32 @@ static void bt_insert (bt_block * ptr) {
@ ensures \valid(\result);
@ ensures \result == \null || \result->ptr == (size_t)ptr;
@*/
-static bt_block * bt_lookup (void * ptr) {
- bt_node * tmp = bt_root;
+static bt_block *bt_lookup(void *ptr) {
+ bt_node *tmp = bt_root;
DASSERT(bt_root != NULL);
DASSERT(ptr != NULL);
/*@ loop assigns tmp;
@*/
- while(!tmp->is_leaf) {
+ while (!tmp->is_leaf) {
// if the ptr we are looking for does not share the prefix of tmp
- if((tmp->addr & tmp->mask) != ((size_t)ptr & tmp->mask))
+ if ((tmp->addr & tmp->mask) != ((size_t)ptr & tmp->mask))
return NULL;
// two children
DASSERT(tmp->left != NULL && tmp->right != NULL);
// the prefix of one child is consistent
- if((tmp->right->addr & tmp->right->mask)
- == ((size_t)ptr & tmp->right->mask))
+ if ((tmp->right->addr & tmp->right->mask)
+ == ((size_t)ptr & tmp->right->mask))
tmp = tmp->right;
- else if((tmp->left->addr & tmp->left->mask)
- == ((size_t)ptr & tmp->left->mask))
+ else if ((tmp->left->addr & tmp->left->mask)
+ == ((size_t)ptr & tmp->left->mask))
tmp = tmp->left;
else
return NULL;
}
- if(tmp->leaf->ptr != (size_t)ptr)
+ if (tmp->leaf->ptr != (size_t)ptr)
return NULL;
return tmp->leaf;
}
@@ -356,23 +359,23 @@ static bt_block * bt_lookup (void * ptr) {
/* return the block B containing ptr, such as :
begin addr of B <= ptr < (begin addr + size) of B
or NULL if such a block does not exist */
-static bt_block * bt_find (void * ptr) {
- bt_node * tmp = bt_root;
- if(bt_root == NULL || ptr == NULL)
+static bt_block *bt_find(void *ptr) {
+ bt_node *tmp = bt_root;
+ if (bt_root == NULL || ptr == NULL)
return NULL;
- bt_node * other_choice = NULL;
+ bt_node *other_choice = NULL;
- while(1) {
- if(tmp->is_leaf) {
+ while (1) {
+ if (tmp->is_leaf) {
/* tmp cannot contain ptr because its begin addr is higher */
- if(tmp->addr > (size_t)ptr)
+ if (tmp->addr > (size_t)ptr)
return NULL;
/* tmp->addr <= ptr, tmp may contain ptr
ptr is contained if tmp is large enough (begin addr + size) */
- else if((size_t)ptr < tmp->leaf->size + tmp->addr
- || (tmp->leaf->size == 0 && (size_t)ptr == tmp->leaf->ptr))
+ else if ((size_t)ptr < tmp->leaf->size + tmp->addr
+ || (tmp->leaf->size == 0 && (size_t)ptr == tmp->leaf->ptr))
return tmp->leaf;
/* tmp->addr <= ptr, but tmp->addr is not large enough */
else
@@ -382,16 +385,15 @@ static bt_block * bt_find (void * ptr) {
DASSERT(tmp->left != NULL && tmp->right != NULL);
/* the right child has the highest address, so we test it first */
- if(((size_t)tmp->right->addr & tmp->right->mask)
- <= ((size_t)ptr & tmp->right->mask)) {
+ if (((size_t)tmp->right->addr & tmp->right->mask)
+ <= ((size_t)ptr & tmp->right->mask)) {
other_choice = tmp->left;
tmp = tmp->right;
- }
- else if(((size_t)tmp->left->addr & tmp->left->mask)
- <= ((size_t)ptr & tmp->left->mask))
+ } else if (((size_t)tmp->left->addr & tmp->left->mask)
+ <= ((size_t)ptr & tmp->left->mask))
tmp = tmp->left;
else {
- if(other_choice == NULL)
+ if (other_choice == NULL)
return NULL;
else {
tmp = other_choice;
@@ -405,8 +407,8 @@ static bt_block * bt_find (void * ptr) {
/* CLEAN */
/*******************/
/* erase information about initialization of a block */
-static void bt_clean_block_init (bt_block * ptr) {
- if(ptr->init_ptr != NULL) {
+static void bt_clean_block_init(bt_block *ptr) {
+ if (ptr->init_ptr != NULL) {
private_free(ptr->init_ptr);
ptr->init_ptr = NULL;
}
@@ -414,8 +416,8 @@ static void bt_clean_block_init (bt_block * ptr) {
}
/* erase all information about a block */
-static void bt_clean_block (bt_block * ptr) {
- if(ptr) {
+static void bt_clean_block(bt_block *ptr) {
+ if (ptr) {
bt_clean_block_init(ptr);
private_free(ptr);
}
@@ -423,13 +425,13 @@ static void bt_clean_block (bt_block * ptr) {
/* called from bt_clean */
/* recursively erase the content of the structure */
-static void bt_clean_rec (bt_node * ptr) {
- if(ptr == NULL) return;
- else if(ptr->is_leaf) {
+static void bt_clean_rec(bt_node *ptr) {
+ if (ptr == NULL)
+ return;
+ else if (ptr->is_leaf) {
bt_clean_block(ptr->leaf);
ptr->leaf = NULL;
- }
- else {
+ } else {
bt_clean_rec(ptr->left);
bt_clean_rec(ptr->right);
ptr->left = ptr->right = NULL;
@@ -438,7 +440,7 @@ static void bt_clean_rec (bt_node * ptr) {
}
/* erase the content of the structure */
-static void bt_clean () {
+static void bt_clean() {
bt_clean_rec(bt_root);
bt_root = NULL;
}
@@ -447,32 +449,31 @@ static void bt_clean () {
/* DEBUG */
/*********************/
#ifdef E_ACSL_DEBUG
-static void eacsl_bt_print_block(bt_block * ptr) {
+static void eacsl_bt_print_block(bt_block *ptr) {
if (ptr != NULL) {
- DLOG("%a; %lu Bytes; %slitteral; [init] : %d ",
- (char*)ptr->ptr, ptr->size,
- ptr->is_readonly ? "" : "not ", ptr->init_bytes);
- if(ptr->init_ptr != NULL) {
+ DLOG("%a; %lu Bytes; %slitteral; [init] : %d ", (char *)ptr->ptr, ptr->size,
+ ptr->is_readonly ? "" : "not ", ptr->init_bytes);
+ if (ptr->init_ptr != NULL) {
unsigned i;
- for(i = 0; i < ptr->size/8; i++)
+ for (i = 0; i < ptr->size / 8; i++)
DLOG("%b ", ptr->init_ptr[i]);
}
DLOG("\n");
}
}
-static void bt_print_node(bt_node * ptr, int depth) {
+static void bt_print_node(bt_node *ptr, int depth) {
int i;
- if(ptr == NULL)
+ if (ptr == NULL)
return;
- for(i = 0; i < depth; i++)
+ for (i = 0; i < depth; i++)
DLOG(" ");
- if(ptr->is_leaf)
+ if (ptr->is_leaf)
eacsl_bt_print_block(ptr->leaf);
else {
- DLOG("%p -- %p\n", (void*)ptr->mask, (void*)ptr->addr);
- bt_print_node(ptr->left, depth+1);
- bt_print_node(ptr->right, depth+1);
+ DLOG("%p -- %p\n", (void *)ptr->mask, (void *)ptr->addr);
+ bt_print_node(ptr->left, depth + 1);
+ bt_print_node(ptr->right, depth + 1);
}
}
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.h b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.h
index a460e189c7c6968e8ab0f129bb0deb632e2e66f2..a6c465873895c60249d595200373e34825390ef1 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree.h
@@ -33,18 +33,18 @@
/*! \brief Structure representing an allocated memory block */
struct bt_block {
- size_t ptr; //!< Base address
- size_t size; //!< Block length (in bytes)
- unsigned char * init_ptr; //!< Per-bit initialization
- size_t init_bytes; //!< Number of initialized bytes within a block
- int is_readonly; //!< True if a block is marked read-only
- int is_freeable; //!< True if a block can be de-allocated using `free`
+ size_t ptr; //!< Base address
+ size_t size; //!< Block length (in bytes)
+ unsigned char *init_ptr; //!< Per-bit initialization
+ size_t init_bytes; //!< Number of initialized bytes within a block
+ int is_readonly; //!< True if a block is marked read-only
+ int is_freeable; //!< True if a block can be de-allocated using `free`
#ifdef E_ACSL_DEBUG
size_t line; //!< Line number where this block was recorded
- char* file; //!< File name where this block was recorded
+ char *file; //!< File name where this block was recorded
#endif
#ifdef E_ACSL_TEMPORAL
- uint32_t timestamp; //!< Temporal timestamp of a block's creation
+ uint32_t timestamp; //!< Temporal timestamp of a block's creation
void *temporal_shadow; //!< Temporal shadow for storing referent numbers
#endif
};
@@ -55,8 +55,8 @@ typedef struct bt_block bt_block;
struct bt_node {
int is_leaf;
size_t addr, mask;
- struct bt_node * left, * right, * parent;
- bt_block * leaf;
+ struct bt_node *left, *right, *parent;
+ bt_block *leaf;
};
typedef struct bt_node bt_node;
@@ -69,14 +69,14 @@ static void bt_insert(bt_block *b);
/*! \brief Look-up a memory block by its base address
NB: The function assumes that such a block exists. */
-static bt_block * bt_lookup(void *ptr);
+static bt_block *bt_lookup(void *ptr);
/*! \brief Find a memory block containing a given memory address
*
* Return block B such that:
* `\base_addr(B->ptr) <= ptr < (\base_addr(B->ptr) + size)`
* or NULL if such a block does not exist. */
-static bt_block * bt_find(void *ptr);
+static bt_block *bt_find(void *ptr);
/*! \brief Erase the contents of the structure */
static void bt_clean(void);
@@ -94,7 +94,7 @@ static void eacsl_bt_print_block(bt_block *b);
/*! \brief Recursively print the contents of the bittree starting from a
* given node */
/*@ assigns \nothing; */
-static void bt_print_node(bt_node * ptr, int depth);
+static void bt_print_node(bt_node *ptr, int depth);
/*! \brief Print the contents of the entire bittree */
/*@ assigns \nothing; */
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_observation_model.c b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_observation_model.c
index 95ddff024e0b98698377970a33f21126e19a7d6f..ae63e7c187b55d822374ba74a7223681b32bffb6 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_observation_model.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_observation_model.c
@@ -26,10 +26,10 @@
* on Patricia Trie. See e_acsl.h for details.
**************************************************************************/
+#include "../../instrumentation_model/e_acsl_temporal.h"
#include "../../internals/e_acsl_debug.h"
#include "../../internals/e_acsl_malloc.h"
#include "../../internals/e_acsl_private_assert.h"
-#include "../../instrumentation_model/e_acsl_temporal.h"
#include "../../numerical_model/e_acsl_floating_point.h"
#include "../internals/e_acsl_safe_locations.h"
#include "e_acsl_bittree.h"
@@ -39,11 +39,11 @@
/* Public API {{{ */
/* Debug */
#ifdef E_ACSL_DEBUG
-# define eacsl_bt_print_block export_alias(bt_print_block)
-# define eacsl_bt_print_tree export_alias(bt_print_tree)
-# define eacsl_block_info export_alias(block_info)
-# define eacsl_store_block_debug export_alias(store_block_debug)
-# define eacsl_delete_block_debug export_alias(delete_block_debug)
+# define eacsl_bt_print_block export_alias(bt_print_block)
+# define eacsl_bt_print_tree export_alias(bt_print_tree)
+# define eacsl_block_info export_alias(block_info)
+# define eacsl_store_block_debug export_alias(store_block_debug)
+# define eacsl_delete_block_debug export_alias(delete_block_debug)
#endif
/* }}} */
@@ -51,19 +51,21 @@
/* SUPPORT {{{ */
/**************************/
static const int nbr_bits_to_1[256] = {
- 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,2,3,
- 3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,1,2,2,3,2,3,3,4,2,3,3,4,
- 3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,
- 4,5,4,5,5,6,4,5,5,6,5,6,6,7,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,
- 3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,
- 6,7,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,3,4,4,5,
- 4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
-};
+ 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
+ 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,
+ 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
+ 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,
+ 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
+ 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
/* given the size of the memory block (_size) return (or rather evaluate to)
* size in bytes required to represent its partial initialization */
-#define needed_bytes(_size) \
- ((_size % 8) == 0 ? (_size/8) : (_size/8 + 1))
+#define needed_bytes(_size) ((_size % 8) == 0 ? (_size / 8) : (_size / 8 + 1))
/* }}} */
/**************************/
@@ -74,9 +76,13 @@ static const int nbr_bits_to_1[256] = {
static struct current_location {
int line;
char *file;
-} cloc = { 0, "undefined" };
+} cloc = {0, "undefined"};
-#define update_cloc(_file, _line) { cloc.line = _line; cloc.file = _file; }
+# define update_cloc(_file, _line) \
+ { \
+ cloc.line = _line; \
+ cloc.file = _file; \
+ }
#endif
/* }}} */
@@ -85,21 +91,21 @@ static struct current_location {
/**************************/
/* mark the size bytes of ptr as initialized */
-void eacsl_initialize (void * ptr, size_t size) {
- bt_block * tmp;
- if(!ptr)
+void eacsl_initialize(void *ptr, size_t size) {
+ bt_block *tmp;
+ if (!ptr)
return;
tmp = bt_find(ptr);
- if(tmp == NULL)
+ if (tmp == NULL)
return;
/* already fully initialized, do nothing */
- if(tmp->init_bytes == tmp->size)
+ if (tmp->init_bytes == tmp->size)
return;
/* fully uninitialized */
- if(tmp->init_bytes == 0) {
+ if (tmp->init_bytes == 0) {
int nb = needed_bytes(tmp->size);
tmp->init_ptr = private_malloc(nb);
memset(tmp->init_ptr, 0, nb);
@@ -112,31 +118,31 @@ void eacsl_initialize (void * ptr, size_t size) {
* The following sets individual bits in tmp->init_ptr that track
* initialization of `size' bytes starting from `ptr'. */
unsigned i;
- for(i = 0; i < size; i++) {
+ for (i = 0; i < size; i++) {
/* byte-offset within the block, i.e., mark `offset' byte as initialized */
size_t offset = (uintptr_t)ptr - tmp->ptr + i;
/* byte offset within tmp->init_ptr, i.e., a byte containing the bit to
be toggled */
- int byte = offset/8;
+ int byte = offset / 8;
/* bit-offset within the above byte, i.e., bit to be toggled */
- int bit = offset%8;
+ int bit = offset % 8;
if (!checkbit(bit, tmp->init_ptr[byte])) { /* if bit is unset ... */
- setbit(bit, tmp->init_ptr[byte]); /* ... set the bit ... */
+ setbit(bit, tmp->init_ptr[byte]); /* ... set the bit ... */
tmp->init_bytes++; /* ... and increment initialized bytes count */
}
}
/* now fully initialized */
- if(tmp->init_bytes == tmp->size) {
+ if (tmp->init_bytes == tmp->size) {
private_free(tmp->init_ptr);
tmp->init_ptr = NULL;
}
}
/* mark all bytes of ptr as initialized */
-void eacsl_full_init (void * ptr) {
- bt_block * tmp;
+void eacsl_full_init(void *ptr) {
+ bt_block *tmp;
if (ptr == NULL)
return;
@@ -152,8 +158,8 @@ void eacsl_full_init (void * ptr) {
}
/* mark a block as read-only */
-void eacsl_mark_readonly(void * ptr) {
- bt_block * tmp;
+void eacsl_mark_readonly(void *ptr) {
+ bt_block *tmp;
if (ptr == NULL)
return;
tmp = bt_lookup(ptr);
@@ -167,35 +173,35 @@ void eacsl_mark_readonly(void * ptr) {
/* PREDICATES {{{ */
/**************************/
-int eacsl_freeable(void* ptr) {
- bt_block * tmp;
- if(ptr == NULL)
+int eacsl_freeable(void *ptr) {
+ bt_block *tmp;
+ if (ptr == NULL)
return 0;
tmp = bt_lookup(ptr);
- if(tmp == NULL)
+ if (tmp == NULL)
return 0;
return tmp->is_freeable;
}
/* return whether the size bytes of ptr are initialized */
-int eacsl_initialized(void * ptr, size_t size) {
+int eacsl_initialized(void *ptr, size_t size) {
unsigned i;
- bt_block * tmp = bt_find(ptr);
- if(tmp == NULL)
+ bt_block *tmp = bt_find(ptr);
+ if (tmp == NULL)
return 0;
/* fully uninitialized */
- if(tmp->init_bytes == 0)
+ if (tmp->init_bytes == 0)
return 0;
/* fully initialized */
- if(tmp->init_bytes == tmp->size)
+ if (tmp->init_bytes == tmp->size)
return 1;
/* see implementation of function `eacsl_initialize` for details */
- for(i = 0; i < size; i++) {
+ for (i = 0; i < size; i++) {
size_t offset = (uintptr_t)ptr - tmp->ptr + i;
- int byte = offset/8;
- int bit = offset%8;
+ int byte = offset / 8;
+ int bit = offset % 8;
if (!checkbit(bit, tmp->init_ptr[byte]))
return 0;
}
@@ -203,8 +209,8 @@ int eacsl_initialized(void * ptr, size_t size) {
}
/** \brief \return the length (in bytes) of the block containing ptr */
-size_t eacsl_block_length(void* ptr) {
- bt_block * blk = bt_find(ptr);
+size_t eacsl_block_length(void *ptr) {
+ bt_block *blk = bt_find(ptr);
/* Hard failure when un-allocated memory is used */
private_assert(blk != NULL, "\\block_length of unallocated memory", NULL);
return blk->size;
@@ -214,12 +220,12 @@ size_t eacsl_block_length(void* ptr) {
of length `size` and with base address `ptr_base` belongs to tracked
allocation and return corresponding `bt_block` if so. Return NULL
otherwise. */
-static bt_block* lookup_allocated(void* ptr, size_t size, void *ptr_base) {
- bt_block * blk = bt_find(ptr);
+static bt_block *lookup_allocated(void *ptr, size_t size, void *ptr_base) {
+ bt_block *blk = bt_find(ptr);
if (blk == NULL)
return NULL;
#ifndef E_ACSL_WEAK_VALIDITY
- bt_block * blk_base = bt_find(ptr_base);
+ bt_block *blk_base = bt_find(ptr_base);
if (blk_base == NULL || blk->ptr != blk_base->ptr)
return NULL;
#endif
@@ -227,41 +233,38 @@ static bt_block* lookup_allocated(void* ptr, size_t size, void *ptr_base) {
}
/* return whether the size bytes of ptr are readable/writable */
-int eacsl_valid(void* ptr, size_t size, void *ptr_base, void *addrof_base) {
- bt_block * blk = lookup_allocated(ptr, size, ptr_base);
- return
- size == 0
- || (
- blk != NULL && !blk->is_readonly
+int eacsl_valid(void *ptr, size_t size, void *ptr_base, void *addrof_base) {
+ bt_block *blk = lookup_allocated(ptr, size, ptr_base);
+ return size == 0
+ || (blk != NULL && !blk->is_readonly
#ifdef E_ACSL_TEMPORAL
- && temporal_valid(ptr_base, addrof_base)
+ && temporal_valid(ptr_base, addrof_base)
#endif
- );
+ );
}
/* return whether the size bytes of ptr are readable */
-int eacsl_valid_read(void* ptr, size_t size, void *ptr_base, void *addrof_base) {
- bt_block * blk = lookup_allocated(ptr, size, ptr_base);
- return
- size == 0
- || (
- blk != NULL
+int eacsl_valid_read(void *ptr, size_t size, void *ptr_base,
+ void *addrof_base) {
+ bt_block *blk = lookup_allocated(ptr, size, ptr_base);
+ return size == 0
+ || (blk != NULL
#ifdef E_ACSL_TEMPORAL
- && temporal_valid(ptr_base, addrof_base)
+ && temporal_valid(ptr_base, addrof_base)
#endif
- );
+ );
}
/* return the base address of the block containing ptr */
-void* eacsl_base_addr(void* ptr) {
- bt_block * tmp = bt_find(ptr);
+void *eacsl_base_addr(void *ptr) {
+ bt_block *tmp = bt_find(ptr);
private_assert(tmp != NULL, "\\base_addr of unallocated memory", NULL);
- return (void*)tmp->ptr;
+ return (void *)tmp->ptr;
}
/* return the offset of `ptr` within its block */
-size_t eacsl_offset(void* ptr) {
- bt_block * tmp = bt_find(ptr);
+size_t eacsl_offset(void *ptr) {
+ bt_block *tmp = bt_find(ptr);
private_assert(tmp != NULL, "\\offset of unallocated memory", NULL);
return ((uintptr_t)ptr - tmp->ptr);
}
@@ -274,26 +277,28 @@ size_t eacsl_offset(void* ptr) {
/* STACK ALLOCATION {{{ */
/* store the block of size bytes starting at ptr, the new block is returned.
* Warning: the return type is implicitly (bt_block*). */
-void* eacsl_store_block(void *ptr, size_t size) {
+void *eacsl_store_block(void *ptr, size_t size) {
#ifdef E_ACSL_DEBUG
if (ptr == NULL)
private_abort("Attempt to record NULL block");
else {
- char *check = (char*)ptr;
+ char *check = (char *)ptr;
bt_block *exitsing_block = bt_find(ptr);
if (exitsing_block) {
private_abort("\nRecording %a [%lu] at %s:%d failed."
- " Overlapping block %a [%lu] found at %s:%d\n",
- ptr, size, cloc.file, cloc.line, eacsl_base_addr(check),
- eacsl_block_length(check), exitsing_block->file, exitsing_block->line);
+ " Overlapping block %a [%lu] found at %s:%d\n",
+ ptr, size, cloc.file, cloc.line, eacsl_base_addr(check),
+ eacsl_block_length(check), exitsing_block->file,
+ exitsing_block->line);
}
check += size - 1;
exitsing_block = bt_find(check);
if (exitsing_block) {
private_abort("\nRecording %a [%lu] at %d failed."
- " Overlapping block %a [%lu] found at %s:%d\n",
- ptr, size, cloc.file, cloc.line, eacsl_base_addr(check),
- eacsl_block_length(check), exitsing_block->file, exitsing_block->line);
+ " Overlapping block %a [%lu] found at %s:%d\n",
+ ptr, size, cloc.file, cloc.line, eacsl_base_addr(check),
+ eacsl_block_length(check), exitsing_block->file,
+ exitsing_block->line);
}
}
#endif
@@ -313,8 +318,8 @@ void* eacsl_store_block(void *ptr, size_t size) {
#endif
#ifdef E_ACSL_TEMPORAL
tmp->timestamp = NEW_TEMPORAL_TIMESTAMP();
- tmp->temporal_shadow = (size >= sizeof(void*)) ?
- private_malloc(size) : NULL;
+ tmp->temporal_shadow =
+ (size >= sizeof(void *)) ? private_malloc(size) : NULL;
#endif
}
return tmp;
@@ -360,15 +365,15 @@ void eacsl_delete_block(void *ptr) {
}
}
-void* eacsl_store_block_duplicate(void* ptr, size_t size) {
- bt_block * tmp = NULL;
+void *eacsl_store_block_duplicate(void *ptr, size_t size) {
+ bt_block *tmp = NULL;
if (ptr != NULL) {
- bt_block * tmp = bt_lookup(ptr);
+ bt_block *tmp = bt_lookup(ptr);
if (tmp) {
#ifdef E_ACSL_DEBUG
- /* Make sure that duplicate block, if so is of the same length */
- if (tmp->size != size)
- private_abort("Attempt to store duplicate block of different length");
+ /* Make sure that duplicate block, if so is of the same length */
+ if (tmp->size != size)
+ private_abort("Attempt to store duplicate block of different length");
#endif
eacsl_delete_block(ptr);
}
@@ -381,7 +386,7 @@ void* eacsl_store_block_duplicate(void* ptr, size_t size) {
/* HEAP ALLOCATION {{{ */
/*! \brief Replacement for `malloc` with memory tracking */
-void* malloc(size_t size) {
+void *malloc(size_t size) {
if (size == 0)
return NULL;
@@ -391,7 +396,7 @@ void* malloc(size_t size) {
}
/*! \brief Replacement for `calloc` with memory tracking */
-void* calloc(size_t nbr_block, size_t size_block) {
+void *calloc(size_t nbr_block, size_t size_block) {
/* FIXME: Need an integer overflow check here */
size_t size = nbr_block * size_block;
if (size == 0)
@@ -408,7 +413,7 @@ void *aligned_alloc(size_t alignment, size_t size) {
- size and alignment are greater than zero
- alignment is a power of 2
- size is a multiple of alignment */
- if (!size || !alignment || !is_pow_of_2(alignment) || (size%alignment))
+ if (!size || !alignment || !is_pow_of_2(alignment) || (size % alignment))
return NULL;
void *res = public_aligned_alloc(alignment, size);
@@ -418,14 +423,15 @@ void *aligned_alloc(size_t alignment, size_t size) {
/*! \brief Replacement for `posix_memalign` with memory tracking */
int posix_memalign(void **memptr, size_t alignment, size_t size) {
- /* Check if:
+ /* Check if:
* - size and alignment are greater than zero
* - alignment is a power of 2 and a multiple of sizeof(void*) */
- if (!size || !alignment || !is_pow_of_2(alignment) || alignment%sizeof(void*))
+ if (!size || !alignment || !is_pow_of_2(alignment)
+ || alignment % sizeof(void *))
return -1;
/* Make sure that the first argument to posix memalign is indeed allocated */
- DVALIDATE_WRITEABLE(memptr, sizeof(void*), memptr);
+ DVALIDATE_WRITEABLE(memptr, sizeof(void *), memptr);
int res = public_posix_memalign(memptr, alignment, size);
if (!res)
@@ -434,20 +440,20 @@ int posix_memalign(void **memptr, size_t alignment, size_t size) {
}
/*! \brief Replacement for `realloc` with memory tracking */
-void* realloc(void *ptr, size_t size) {
- bt_block * tmp;
- void * new_ptr;
+void *realloc(void *ptr, size_t size) {
+ bt_block *tmp;
+ void *new_ptr;
/* ptr is NULL - malloc */
- if(ptr == NULL)
+ if (ptr == NULL)
return malloc(size);
/* size is zero - free */
- if(size == 0) {
+ if (size == 0) {
free(ptr);
return NULL;
}
tmp = bt_lookup(ptr);
DASSERT(tmp != NULL);
- new_ptr = public_realloc((void*)tmp->ptr, size);
+ new_ptr = public_realloc((void *)tmp->ptr, size);
if (new_ptr == NULL)
return NULL;
@@ -462,7 +468,7 @@ void* realloc(void *ptr, size_t size) {
bt_insert(tmp);
}
/* uninitialized, do nothing */
- if(tmp->init_bytes == 0) {
+ if (tmp->init_bytes == 0) {
}
/* already fully initialized block */
else if (tmp->init_bytes == tmp->size) {
@@ -470,7 +476,7 @@ void* realloc(void *ptr, size_t size) {
if (size <= tmp->size) {
/* adjust new size, allocation not necessary */
tmp->init_bytes = size;
- /* realloc larger block */
+ /* realloc larger block */
} else {
/* size of tmp->init_ptr in the new block */
int nb = needed_bytes(size);
@@ -499,7 +505,7 @@ void* realloc(void *ptr, size_t size) {
}
tmp->size = size;
tmp->is_freeable = 1;
- return (void*)tmp->ptr;
+ return (void *)tmp->ptr;
}
/*! \brief Replacement for `free` with memory tracking */
@@ -538,17 +544,17 @@ void eacsl_memory_clean() {
extern char **environ;
/* add `argv` to the memory model */
-static void argv_alloca(int *argc_ref, char *** argv_ref) {
+static void argv_alloca(int *argc_ref, char ***argv_ref) {
/* Track a top-level containers */
- eacsl_store_block((void*)argc_ref, sizeof(int));
- eacsl_store_block((void*)argv_ref, sizeof(char**));
+ eacsl_store_block((void *)argc_ref, sizeof(int));
+ eacsl_store_block((void *)argv_ref, sizeof(char **));
int argc = *argc_ref;
- char** argv = *argv_ref;
+ char **argv = *argv_ref;
/* Track argv */
- size_t argvlen = (argc + 1)*sizeof(char*);
+ size_t argvlen = (argc + 1) * sizeof(char *);
eacsl_store_block(argv, argvlen);
- eacsl_initialize(argv, (argc + 1)*sizeof(char*));
+ eacsl_initialize(argv, (argc + 1) * sizeof(char *));
while (*argv) {
size_t arglen = strlen(*argv) + 1;
@@ -562,7 +568,7 @@ static void argv_alloca(int *argc_ref, char *** argv_ref) {
argv = *argv_ref;
eacsl_temporal_store_nblock(argv_ref, *argv_ref);
for (i = 0; i < argc; i++)
- eacsl_temporal_store_nblock(argv + i, *(argv+i));
+ eacsl_temporal_store_nblock(argv + i, *(argv + i));
#endif
while (*environ) {
@@ -587,9 +593,9 @@ void eacsl_memory_init(int *argc_ref, char ***argv_ref, size_t ptr_size) {
collect_safe_locations();
int i;
for (i = 0; i < get_safe_locations_count(); i++) {
- memory_location * loc = get_safe_location(i);
+ memory_location *loc = get_safe_location(i);
if (loc->is_on_static) {
- void *addr = (void*)loc->address;
+ void *addr = (void *)loc->address;
uintptr_t len = loc->length;
eacsl_store_block(addr, len);
if (loc->is_initialized)
@@ -616,9 +622,9 @@ void eacsl_memory_init(int *argc_ref, char ***argv_ref, size_t ptr_size) {
* The above macros with rewrite of instances of __e_acsl_store_block generating
* origin information of tracked memory blocks.
*/
-void* eacsl_store_block_debug(char *file, int line, void* ptr, size_t size) {
+void *eacsl_store_block_debug(char *file, int line, void *ptr, size_t size) {
update_cloc(file, line);
- bt_block * res = eacsl_store_block(ptr, size);
+ bt_block *res = eacsl_store_block(ptr, size);
if (res) {
res->line = line;
res->file = file;
@@ -626,9 +632,9 @@ void* eacsl_store_block_debug(char *file, int line, void* ptr, size_t size) {
return res;
}
-void eacsl_delete_block_debug(char *file, int line, void* ptr) {
+void eacsl_delete_block_debug(char *file, int line, void *ptr) {
update_cloc(file, line);
- bt_block * tmp = bt_lookup(ptr);
+ bt_block *tmp = bt_lookup(ptr);
if (!tmp) {
private_abort(
"Block with base address %a not found in the memory model at %s:%d",
@@ -639,10 +645,10 @@ void eacsl_delete_block_debug(char *file, int line, void* ptr) {
/* Debug print of block information */
void eacsl_block_info(char *p) {
- bt_block * res = bt_find(p);
+ bt_block *res = bt_find(p);
if (res) {
- DLOG(" << %a >> %a [%lu] => %lu \n",
- p, eacsl_base_addr(p), eacsl_offset(p), eacsl_block_length(p));
+ DLOG(" << %a >> %a [%lu] => %lu \n", p, eacsl_base_addr(p), eacsl_offset(p),
+ eacsl_block_length(p));
} else {
DLOG(" << %a >> not allocated\n", p);
}
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_omodel_debug.c b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_omodel_debug.c
index 60a0b3932093a2ffa52e0238d67784e70f26e864..11a4323d8e89ffcdafef626524609203bb120e4b 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_omodel_debug.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_omodel_debug.c
@@ -36,15 +36,15 @@ void describe_observation_model() {
allocated or not.
NOTE: Should have same signature in all models. */
int allocated(uintptr_t addr, long size, uintptr_t base) {
- return lookup_allocated((void*)addr, size, (void*)base) == NULL ? 0 : 1;
+ return lookup_allocated((void *)addr, size, (void *)base) == NULL ? 0 : 1;
}
-int readonly (void *ptr) {
- bt_block * blk = bt_find(ptr);
+int readonly(void *ptr) {
+ bt_block *blk = bt_find(ptr);
private_assert(blk != NULL, "Readonly on unallocated memory", NULL);
return blk->is_readonly;
}
int writeable(uintptr_t addr, long size, uintptr_t base_ptr) {
- return allocated(addr, size, base_ptr) && !readonly((void*)addr);
+ return allocated(addr, size, base_ptr) && !readonly((void *)addr);
}
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_timestamp_retrieval.c b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_timestamp_retrieval.c
index a6d0c2a9d01ca2cb4910f72381f753c560b9bbf3..f8678b898fc9f6e9c290fdd54391951c6b22de82 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_timestamp_retrieval.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/bittree_model/e_acsl_bittree_timestamp_retrieval.c
@@ -23,7 +23,7 @@
#include "../../internals/e_acsl_private_assert.h"
#include "e_acsl_bittree.h"
#ifdef E_ACSL_TEMPORAL
-# include "../../instrumentation_model/e_acsl_temporal_timestamp.h"
+# include "../../instrumentation_model/e_acsl_temporal_timestamp.h"
#endif
#include "../internals/e_acsl_timestamp_retrieval.h"
@@ -32,29 +32,31 @@
/* Remaining functionality (shared between all models) is located in e_acsl_temporal.h */
#ifdef E_ACSL_TEMPORAL
uint32_t origin_timestamp(void *ptr) {
- bt_block * blk = bt_find(ptr);
+ bt_block *blk = bt_find(ptr);
return blk != NULL ? blk->timestamp : INVALID_TEMPORAL_TIMESTAMP;
}
uintptr_t temporal_referent_shadow(void *ptr) {
bt_block *blk = bt_find(ptr);
private_assert(blk != NULL,
- "referent timestamp on unallocated memory address %a", (uintptr_t)ptr);
+ "referent timestamp on unallocated memory address %a",
+ (uintptr_t)ptr);
private_assert(blk->temporal_shadow != NULL,
- "no temporal shadow of block with base address", (uintptr_t)blk->ptr);
+ "no temporal shadow of block with base address",
+ (uintptr_t)blk->ptr);
return (uintptr_t)blk->temporal_shadow + eacsl_offset(ptr);
}
uint32_t referent_timestamp(void *ptr) {
- bt_block * blk = bt_find(ptr);
+ bt_block *blk = bt_find(ptr);
if (blk != NULL)
- return *((uint32_t*)temporal_referent_shadow(ptr));
+ return *((uint32_t *)temporal_referent_shadow(ptr));
else
return INVALID_TEMPORAL_TIMESTAMP;
}
void store_temporal_referent(void *ptr, uint32_t ref) {
- uint32_t *shadow = (uint32_t*)temporal_referent_shadow(ptr);
+ uint32_t *shadow = (uint32_t *)temporal_referent_shadow(ptr);
*shadow = ref;
}
#endif
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_heap.h b/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_heap.h
index 60ea8a8bfaa71367412bea7892c242c9c3dd93cd..0e570389b3a573e703c1f74b161646afd3a8a43b 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_heap.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_heap.h
@@ -43,11 +43,9 @@ extern size_t eacsl_heap_allocation_size;
extern size_t eacsl_heap_allocated_blocks;
/*! Return the number of bytes in heap application allocation. */
-size_t eacsl_get_heap_allocation_size()
- __attribute__((FC_BUILTIN));
+size_t eacsl_get_heap_allocation_size() __attribute__((FC_BUILTIN));
/*! Return the number of blocks in heap application allocation. */
-size_t eacsl_get_heap_allocated_blocks()
- __attribute__((FC_BUILTIN));
+size_t eacsl_get_heap_allocated_blocks() __attribute__((FC_BUILTIN));
#endif // E_ACSL_HEAP
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.c b/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.c
index 9b1baa7ad970fe5d9085f12e0c179b27a69b01b7..c0ec558842e69079800eb2511f075910d99b9663 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.c
@@ -38,34 +38,34 @@
* \return A non-zero value if the two memory locations are separated, zero
* otherwise.
*/
-int separated2(void * ptr1, size_t size1, void * ptr2, size_t size2) {
+int separated2(void *ptr1, size_t size1, void *ptr2, size_t size2) {
DASSERT(eacsl_valid_read(ptr1, size1, eacsl_base_addr(ptr1), NULL)
&& eacsl_valid_read(ptr2, size2, eacsl_base_addr(ptr2), NULL));
// Cast pointers to char* to be able to do pointer arithmetic without
// triggering undefined behavior
- char * cptr1 = ptr1;
- char * cptr2 = ptr2;
+ char *cptr1 = ptr1;
+ char *cptr2 = ptr2;
// If at least one of the memory location is an empty set (size == 0), then
// the memory is separated.
// Otherwise the memory is separated if `cptr1 + size1 <= cptr2` or
// `cptr2 + size2 <= cptr1`
- int sep = size1 == 0 || size2 == 0 ||
- (cptr1 + size1) <= cptr2 || (cptr2 + size2) <= cptr1;
+ int sep = size1 == 0 || size2 == 0 || (cptr1 + size1) <= cptr2
+ || (cptr2 + size2) <= cptr1;
return sep;
}
int eacsl_separated(size_t count, ...) {
- void * ptrs[count];
+ void *ptrs[count];
size_t sizes[count];
// Extract arguments in an array to be able to iterate over them several times
va_list args;
va_start(args, count);
- for (size_t i = 0 ; i < count ; ++i) {
- ptrs[i] = va_arg(args, void*);
+ for (size_t i = 0; i < count; ++i) {
+ ptrs[i] = va_arg(args, void *);
sizes[i] = va_arg(args, size_t);
}
va_end(args);
@@ -73,13 +73,13 @@ int eacsl_separated(size_t count, ...) {
int result = 1;
// Check that every pointer is separated with any other pointer
- void * ptr1;
+ void *ptr1;
size_t size1;
- for (size_t i = 0 ; result && i < count - 1 ; ++i) {
+ for (size_t i = 0; result && i < count - 1; ++i) {
ptr1 = ptrs[i];
size1 = sizes[i];
- for (size_t j = i + 1 ; result && j < count ; ++j) {
- result = separated2(ptr1, size1, ptrs[j], sizes[j]);
+ for (size_t j = i + 1; result && j < count; ++j) {
+ result = separated2(ptr1, size1, ptrs[j], sizes[j]);
}
}
@@ -88,7 +88,6 @@ int eacsl_separated(size_t count, ...) {
/* }}} */
-
/************************************************************************/
/*** Implementation of the memory model {{{ ***/
/************************************************************************/
@@ -99,18 +98,18 @@ int eacsl_separated(size_t count, ...) {
/* Select memory model, either segment-based or bittree-based model should
be defined */
#if defined E_ACSL_SEGMENT_MMODEL
-# include "segment_model/e_acsl_segment_observation_model.c"
-# include "segment_model/e_acsl_segment_tracking.c"
-# include "segment_model/e_acsl_shadow_layout.c"
-# include "segment_model/e_acsl_segment_omodel_debug.c"
-# include "segment_model/e_acsl_segment_timestamp_retrieval.c"
+# include "segment_model/e_acsl_segment_observation_model.c"
+# include "segment_model/e_acsl_segment_omodel_debug.c"
+# include "segment_model/e_acsl_segment_timestamp_retrieval.c"
+# include "segment_model/e_acsl_segment_tracking.c"
+# include "segment_model/e_acsl_shadow_layout.c"
#elif defined E_ACSL_BITTREE_MMODEL
-# include "bittree_model/e_acsl_bittree_observation_model.c"
-# include "bittree_model/e_acsl_bittree.c"
-# include "bittree_model/e_acsl_bittree_omodel_debug.c"
-# include "bittree_model/e_acsl_bittree_timestamp_retrieval.c"
+# include "bittree_model/e_acsl_bittree.c"
+# include "bittree_model/e_acsl_bittree_observation_model.c"
+# include "bittree_model/e_acsl_bittree_omodel_debug.c"
+# include "bittree_model/e_acsl_bittree_timestamp_retrieval.c"
#else
-# error "No E-ACSL memory model defined. Aborting compilation"
+# error "No E-ACSL memory model defined. Aborting compilation"
#endif
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.h b/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.h
index 44c88ec33ff7f369684eb4765f34a96b9d213056..7cabbe5457d673cff71272c39602a2a412fb9e0b 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/e_acsl_observation_model.h
@@ -38,7 +38,7 @@
#include "e_acsl_heap.h"
#ifdef __FC_STDLIB
-#include <__fc_alloc_axiomatic.h>
+# include <__fc_alloc_axiomatic.h>
#else
/*@ ghost extern int __fc_heap_status; */
@@ -59,8 +59,8 @@
/************************************************************************/
/* Memory state initialization */
-#define eacsl_memory_init export_alias(memory_init)
-#define eacsl_memory_clean export_alias(memory_clean)
+#define eacsl_memory_init export_alias(memory_init)
+#define eacsl_memory_clean export_alias(memory_clean)
/* Tracking */
#define eacsl_store_block export_alias(store_block)
@@ -68,19 +68,19 @@
#define eacsl_delete_block export_alias(delete_block)
/* Predicates */
-#define eacsl_offset export_alias(offset)
-#define eacsl_base_addr export_alias(base_addr)
-#define eacsl_block_length export_alias(block_length)
-#define eacsl_valid_read export_alias(valid_read)
-#define eacsl_valid export_alias(valid)
-#define eacsl_initialized export_alias(initialized)
-#define eacsl_freeable export_alias(freeable)
-#define eacsl_separated export_alias(separated)
+#define eacsl_offset export_alias(offset)
+#define eacsl_base_addr export_alias(base_addr)
+#define eacsl_block_length export_alias(block_length)
+#define eacsl_valid_read export_alias(valid_read)
+#define eacsl_valid export_alias(valid)
+#define eacsl_initialized export_alias(initialized)
+#define eacsl_freeable export_alias(freeable)
+#define eacsl_separated export_alias(separated)
/* Block initialization */
-#define eacsl_mark_readonly export_alias(mark_readonly)
-#define eacsl_initialize export_alias(initialize)
-#define eacsl_full_init export_alias(full_init)
+#define eacsl_mark_readonly export_alias(mark_readonly)
+#define eacsl_initialize export_alias(initialize)
+#define eacsl_full_init export_alias(full_init)
/* }}} */
@@ -112,8 +112,7 @@
assigns __e_acsl_heap_allocation_size \from indirect:size, __e_acsl_heap_allocation_size;
assigns __e_acsl_heap_allocated_blocks \from size, __e_acsl_heap_allocated_blocks;
*/
-void * malloc(size_t size)
- __attribute__((FC_BUILTIN));
+void *malloc(size_t size) __attribute__((FC_BUILTIN));
/*! \brief Drop-in replacement for \p calloc with memory tracking enabled.
* For further information, see \p calloc(3). */
@@ -129,8 +128,7 @@ void * malloc(size_t size)
assigns __e_acsl_heap_allocation_size \from indirect:nbr_elt, indirect:size_elt, __e_acsl_heap_allocation_size;
assigns __e_acsl_heap_allocated_blocks \from indirect:nbr_elt, indirect:size_elt, __e_acsl_heap_allocated_blocks;
*/
-void * calloc(size_t nbr_elt, size_t size_elt)
- __attribute__((FC_BUILTIN));
+void *calloc(size_t nbr_elt, size_t size_elt) __attribute__((FC_BUILTIN));
/*! \brief Drop-in replacement for \p realloc with memory tracking enabled.
* For further information, see realloc(3) */
@@ -151,8 +149,7 @@ void * calloc(size_t nbr_elt, size_t size_elt)
assigns __e_acsl_heap_allocation_size \from __e_acsl_heap_allocation_size;
assigns __e_acsl_heap_allocated_blocks \from __e_acsl_heap_allocated_blocks;
*/
-void * realloc(void * ptr, size_t size)
- __attribute__((FC_BUILTIN));
+void *realloc(void *ptr, size_t size) __attribute__((FC_BUILTIN));
/*! \brief Drop-in replacement for \p free with memory tracking enabled.
* For further information, see \p free(3). */
@@ -168,8 +165,7 @@ void * realloc(void * ptr, size_t size)
assigns __e_acsl_heap_allocation_size \from __e_acsl_heap_allocation_size;
assigns __e_acsl_heap_allocated_blocks \from __e_acsl_heap_allocated_blocks;
*/
-void free(void * ptr)
- __attribute__((FC_BUILTIN));
+void free(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Allocate `size` bytes of memory such that the allocation's base
* address is an even multiple of alignment.
@@ -182,8 +178,7 @@ void free(void * ptr)
assigns __e_acsl_heap_allocation_size \from indirect:alignment, size, __e_acsl_heap_allocation_size;
assigns __e_acsl_heap_allocated_blocks \from indirect:alignment, size, __e_acsl_heap_allocated_blocks;
*/
-void *aligned_alloc(size_t alignment, size_t size)
- __attribute__((FC_BUILTIN));
+void *aligned_alloc(size_t alignment, size_t size) __attribute__((FC_BUILTIN));
/*! \brief Allocate size bytes and place the address of the allocated memory in
* `*memptr`. The address of the allocated memory will be a multiple of
@@ -202,7 +197,7 @@ void *aligned_alloc(size_t alignment, size_t size)
assigns __e_acsl_heap_allocated_blocks \from indirect:alignment, size, __e_acsl_heap_allocated_blocks;
*/
int posix_memalign(void **memptr, size_t alignment, size_t size)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/* }}} */
/************************************************************************/
@@ -213,12 +208,11 @@ int posix_memalign(void **memptr, size_t alignment, size_t size)
* Called before any other statement in \p main */
/*@ assigns \nothing; */
void eacsl_memory_init(int *argc_ref, char ***argv, size_t ptr_size)
- __attribute__((FC_BUILTIN));
+ __attribute__((FC_BUILTIN));
/*! \brief Clean-up memory tracking state before a program's termination. */
/*@ assigns \nothing; */
-void eacsl_memory_clean(void)
- __attribute__((FC_BUILTIN));
+void eacsl_memory_clean(void) __attribute__((FC_BUILTIN));
/*! \brief Store stack or globally-allocated memory block
* starting at an address given by \p ptr.
@@ -227,8 +221,7 @@ void eacsl_memory_clean(void)
* \param size size of the tracked block in bytes */
/*@ ensures \result == ptr;
@ assigns \result \from *(((char*)ptr)+(0..size-1)), ptr, size; */
-void * eacsl_store_block(void * ptr, size_t size)
- __attribute__((FC_BUILTIN));
+void *eacsl_store_block(void *ptr, size_t size) __attribute__((FC_BUILTIN));
/*! \brief Same as `eacsl_store_block`, but first check
* checks whether a block with a base address given by `ptr` exists in the
@@ -238,31 +231,27 @@ void * eacsl_store_block(void * ptr, size_t size)
* \param size size of the tracked block in bytes */
/*@ ensures \result == ptr;
@ assigns \result \from *(((char*)ptr)+(0..size-1)), ptr, size; */
-void * eacsl_store_block_duplicate(void * ptr, size_t size)
- __attribute__((FC_BUILTIN));
+void *eacsl_store_block_duplicate(void *ptr, size_t size)
+ __attribute__((FC_BUILTIN));
/*! \brief Remove a memory block which base address is \p ptr from tracking. */
/*@ assigns \nothing; */
-void eacsl_delete_block(void * ptr)
- __attribute__((FC_BUILTIN));
+void eacsl_delete_block(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Mark the \p size bytes starting at an address given by \p ptr as
* initialized. */
/*@ assigns \nothing; */
-void eacsl_initialize(void * ptr, size_t size)
- __attribute__((FC_BUILTIN));
+void eacsl_initialize(void *ptr, size_t size) __attribute__((FC_BUILTIN));
/*! \brief Mark all bytes belonging to a memory block which start address is
* given by \p ptr as initialized. */
/*@ assigns \nothing; */
-void eacsl_full_init(void * ptr)
- __attribute__((FC_BUILTIN));
+void eacsl_full_init(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Mark a memory block which start address is given by \p ptr as
* read-only. */
/*@ assigns \nothing; */
-void eacsl_mark_readonly(void * ptr)
- __attribute__((FC_BUILTIN));
+void eacsl_mark_readonly(void *ptr) __attribute__((FC_BUILTIN));
/* }}} */
@@ -275,8 +264,7 @@ void eacsl_mark_readonly(void * ptr)
* Evaluate to a non-zero value if \p ptr points to a start address of
* a block allocated via \p malloc, \p calloc or \p realloc. */
/*@ assigns \result \from ptr; */
-int eacsl_freeable(void * ptr)
- __attribute__((FC_BUILTIN));
+int eacsl_freeable(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\valid predicate of E-ACSL.
*
@@ -320,8 +308,8 @@ int eacsl_freeable(void * ptr)
@ complete behaviors;
@ disjoint behaviors;
@ */
-int eacsl_valid(void * ptr, size_t size, void *base, void *addrof_base)
- __attribute__((FC_BUILTIN));
+int eacsl_valid(void *ptr, size_t size, void *base, void *addrof_base)
+ __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\valid_read predicate of E-ACSL.
*
@@ -346,32 +334,29 @@ int eacsl_valid(void * ptr, size_t size, void *base, void *addrof_base)
@ complete behaviors;
@ disjoint behaviors;
@ */
-int eacsl_valid_read(void * ptr, size_t size, void *base, void *addrof_base)
- __attribute__((FC_BUILTIN));
+int eacsl_valid_read(void *ptr, size_t size, void *base, void *addrof_base)
+ __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\base_addr predicate of E-ACSL.
* Return the base address of the memory block containing an address given
* by \p ptr */
/*@ ensures \result == \base_addr(ptr);
@ assigns \result \from ptr; */
-void * eacsl_base_addr(void * ptr)
- __attribute__((FC_BUILTIN));
+void *eacsl_base_addr(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\block_length predicate of E-ACSL.
* Return the byte length of the memory block of the block containing a memory
* address given by \p ptr */
/*@ ensures \result == \block_length(ptr);
@ assigns \result \from ptr; */
-size_t eacsl_block_length(void * ptr)
- __attribute__((FC_BUILTIN));
+size_t eacsl_block_length(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\offset predicate of E-ACSL.
* Return the byte offset of address given by \p ptr within a memory blocks
* it belongs to */
/*@ ensures \result == \offset(ptr);
@ assigns \result \from ptr; */
-size_t eacsl_offset(void * ptr)
- __attribute__((FC_BUILTIN));
+size_t eacsl_offset(void *ptr) __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\initialized predicate of E-ACSL.
* Return a non-zero value if \p size bytes starting from an address given by
@@ -386,8 +371,7 @@ size_t eacsl_offset(void * ptr)
@ complete behaviors;
@ disjoint behaviors;
@ */
-int eacsl_initialized(void * ptr, size_t size)
- __attribute__((FC_BUILTIN));
+int eacsl_initialized(void *ptr, size_t size) __attribute__((FC_BUILTIN));
/*! \brief Implementation of the \b \\separated predicate of E-ACSL.
*
@@ -407,8 +391,7 @@ int eacsl_initialized(void * ptr, size_t size)
*/
/*@ assigns \result \from indirect:count;
@ ensures \result == 0 || \result == 1; */
-int eacsl_separated(size_t count, ...)
- __attribute__((FC_BUILTIN));
+int eacsl_separated(size_t count, ...) __attribute__((FC_BUILTIN));
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_heap_tracking.c b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_heap_tracking.c
index b4e6ae48a5703c532c1ff3ad4959936878845157..1ff94c2f78a248b7bd924b053e137b7a02db1240 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_heap_tracking.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_heap_tracking.c
@@ -20,8 +20,8 @@
/* */
/**************************************************************************/
-#include "../../internals/e_acsl_rtl_io.h"
#include "e_acsl_heap_tracking.h"
+#include "../../internals/e_acsl_rtl_io.h"
/* Variable tracking byte-count of user-allocated heap memory. */
static size_t heap_internal_allocation_size = 0;
@@ -61,7 +61,7 @@ void report_heap_leaks() {
size_t blocks = eacsl_get_heap_allocated_blocks();
if (size) {
rtl_printf(" *** WARNING: Leaked %lu bytes of heap memory in %ld block%s\n",
- size, blocks, (blocks == 1) ? "" : "s");
+ size, blocks, (blocks == 1) ? "" : "s");
}
#endif
}
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_omodel_debug.h b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_omodel_debug.h
index 19d8c34e4be3721bbd770c9021a4309299f41dc4..cc6ad8f4f6ed57ddc08c3df46500d61c8ecba57e 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_omodel_debug.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_omodel_debug.h
@@ -23,34 +23,34 @@
#ifndef E_ACSL_OMODEL_DEBUG_H
#define E_ACSL_OMODEL_DEBUG_H
-#include <stdint.h>
#include "../../internals/e_acsl_rtl_string.h"
+#include <stdint.h>
/* Assertions in debug mode */
#ifdef E_ACSL_DEBUG
/* Assert that a memory block [_addr, _addr + _size] is nullified */
-# define DVALIDATE_NULLIFIED(_addr, _size) \
- DVASSERT(zeroed_out((void *)_addr, _size), \
- "Block [%a, %a+%lu] not nullified", _addr, _addr, _size)
+# define DVALIDATE_NULLIFIED(_addr, _size) \
+ DVASSERT(zeroed_out((void *)_addr, _size), \
+ "Block [%a, %a+%lu] not nullified", _addr, _addr, _size)
/* Assert that memory block [_addr, _addr + _size] is allocated */
-# define DVALIDATE_ALLOCATED(_addr, _size, _base) \
- private_assert(allocated((uintptr_t)_addr, _size, (uintptr_t)_base), \
- "Operation on unallocated block [%a + %lu] with base %a\n", \
- _addr, _size, _base);
+# define DVALIDATE_ALLOCATED(_addr, _size, _base) \
+ private_assert(allocated((uintptr_t)_addr, _size, (uintptr_t)_base), \
+ "Operation on unallocated block [%a + %lu] with base %a\n", \
+ _addr, _size, _base);
/* Assert that memory block [_addr, _addr + _size] is allocated
* and can be written to */
-# define DVALIDATE_WRITEABLE(_addr, _size, _base) \
- private_assert(writeable((uintptr_t)_addr, _size, (uintptr_t)_base), \
- "Operation on unallocated block [%a + %lu] with base %a\n", \
- _addr, _size, _base);
+# define DVALIDATE_WRITEABLE(_addr, _size, _base) \
+ private_assert(writeable((uintptr_t)_addr, _size, (uintptr_t)_base), \
+ "Operation on unallocated block [%a + %lu] with base %a\n", \
+ _addr, _size, _base);
#else
-# define DVALIDATE_NULLIFIED(_addr, _size)
-# define DVALIDATE_ALLOCATED(_ptr, _size, _base)
-# define DVALIDATE_WRITEABLE(_ptr, _size, _base)
+# define DVALIDATE_NULLIFIED(_addr, _size)
+# define DVALIDATE_ALLOCATED(_ptr, _size, _base)
+# define DVALIDATE_WRITEABLE(_ptr, _size, _base)
#endif
/*! Print to stdout the parameters of the model */
@@ -66,7 +66,7 @@ void describe_observation_model();
int allocated(uintptr_t addr, long size, uintptr_t base_ptr);
/** \brief Return 1 if a given memory location is read-only and 0 otherwise */
-int readonly (void *ptr);
+int readonly(void *ptr);
/** \brief Return 1 if a given memory location is writable and 0 otherwise */
int writeable(uintptr_t addr, long size, uintptr_t base_ptr);
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.c b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.c
index 9c2e61b587126620383f4c16337b7a457d4a3f58..8b5f04edcf87bc3db0e4ca11df99d449a4289241 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.c
@@ -20,8 +20,8 @@
/* */
/**************************************************************************/
-#include <stdio.h>
#include <errno.h>
+#include <stdio.h>
#include "../../internals/e_acsl_config.h"
#include "e_acsl_safe_locations.h"
@@ -29,16 +29,17 @@
/* An array storing safe locations up to `safe_location_counter` position.
* This array should be initialized via a below function called
* `collect_safe_locations`. */
-static memory_location safe_locations [16];
+static memory_location safe_locations[16];
static int safe_location_counter = 0;
-#define add_safe_location(_addr,_len,_init,_on_static) do { \
- safe_locations[safe_location_counter].address = _addr; \
- safe_locations[safe_location_counter].length = _len; \
- safe_locations[safe_location_counter].is_initialized = _init; \
- safe_locations[safe_location_counter].is_on_static = _on_static; \
- safe_location_counter++; \
-} while (0)
+#define add_safe_location(_addr, _len, _init, _on_static) \
+ do { \
+ safe_locations[safe_location_counter].address = _addr; \
+ safe_locations[safe_location_counter].length = _len; \
+ safe_locations[safe_location_counter].is_initialized = _init; \
+ safe_locations[safe_location_counter].is_on_static = _on_static; \
+ safe_location_counter++; \
+ } while (0)
void collect_safe_locations() {
/* Tracking of errno and standard streams */
@@ -52,6 +53,6 @@ size_t get_safe_locations_count() {
return safe_location_counter;
}
-memory_location * get_safe_location(size_t i) {
+memory_location *get_safe_location(size_t i) {
return &safe_locations[i];
}
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.h b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.h
index 87e8ce88e481324fe0c2d24d838e15880974133b..1bd160a30f9f277c6d0c0e7f4eac2962da130ca1 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_safe_locations.h
@@ -31,8 +31,8 @@
#ifndef E_ACSL_SAFE_LOCATIONS_H
#define E_ACSL_SAFE_LOCATIONS_H
-#include <stdint.h>
#include <stddef.h>
+#include <stdint.h>
/*! Simple representation of a safe location */
struct memory_location {
@@ -55,6 +55,6 @@ void collect_safe_locations();
size_t get_safe_locations_count();
/*! \return The i-th safe location collected */
-memory_location * get_safe_location(size_t i);
+memory_location *get_safe_location(size_t i);
#endif // E_ACSL_SAFE_LOCATIONS_H
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_timestamp_retrieval.h b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_timestamp_retrieval.h
index bada031246756ca42b656c7ce29c8cd4166c49f7..85ee37455a328c563dfd92b6d721cc3380404fab 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_timestamp_retrieval.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/internals/e_acsl_timestamp_retrieval.h
@@ -30,7 +30,7 @@
#ifdef E_ACSL_TEMPORAL
-#include <stdint.h>
+# include <stdint.h>
/*! \brief Return origin time stamp associated with a memory block containing
* address given by `ptr`. `0` indicates an invalid timestamp, i.e., timestamp
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_observation_model.c b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_observation_model.c
index 2b40ff66c6f3bf381692b9791844026f41151547..b67b9b3fe6f28a15dc797310715a6ac13241fdcb 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_observation_model.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_observation_model.c
@@ -29,19 +29,19 @@
#include <stddef.h>
#include <stdint.h>
+#include "../../instrumentation_model/e_acsl_temporal.h"
#include "../../internals/e_acsl_debug.h"
#include "../../internals/e_acsl_malloc.h"
#include "../../internals/e_acsl_private_assert.h"
-#include "../../instrumentation_model/e_acsl_temporal.h"
#include "../../numerical_model/e_acsl_floating_point.h"
#include "../internals/e_acsl_safe_locations.h"
#include "e_acsl_segment_tracking.h"
#include "e_acsl_shadow_layout.h"
-#include "../internals/e_acsl_timestamp_retrieval.h"
#include "../e_acsl_observation_model.h"
+#include "../internals/e_acsl_timestamp_retrieval.h"
-void * eacsl_store_block(void *ptr, size_t size) {
+void *eacsl_store_block(void *ptr, size_t size) {
/* Only stack-global memory blocks are recorded explicitly via this function.
Heap blocks should be tracked internally using memory allocation functions
such as malloc or calloc. */
@@ -55,7 +55,7 @@ void eacsl_delete_block(void *ptr) {
shadow_freea(ptr);
}
-void * eacsl_store_block_duplicate(void *ptr, size_t size) {
+void *eacsl_store_block_duplicate(void *ptr, size_t size) {
if (allocated((uintptr_t)ptr, size, (uintptr_t)ptr))
eacsl_delete_block(ptr);
shadow_alloca(ptr, size);
@@ -65,11 +65,8 @@ void * eacsl_store_block_duplicate(void *ptr, size_t size) {
/*! \brief Initialize a chunk of memory given by its start address (`addr`)
* and byte length (`n`). */
void eacsl_initialize(void *ptr, size_t n) {
- TRY_SEGMENT(
- (uintptr_t)ptr,
- initialize_heap_region((uintptr_t)ptr, n),
- initialize_static_region((uintptr_t)ptr, n)
- )
+ TRY_SEGMENT((uintptr_t)ptr, initialize_heap_region((uintptr_t)ptr, n),
+ initialize_static_region((uintptr_t)ptr, n))
}
void eacsl_full_init(void *ptr) {
@@ -85,35 +82,31 @@ void eacsl_mark_readonly(void *ptr) {
/* ********************** */
int eacsl_valid(void *ptr, size_t size, void *ptr_base, void *addrof_base) {
- return
- size == 0
- || (
- allocated((uintptr_t)ptr, size, (uintptr_t)ptr_base)
- && !readonly(ptr)
+ return size == 0
+ || (allocated((uintptr_t)ptr, size, (uintptr_t)ptr_base)
+ && !readonly(ptr)
#ifdef E_ACSL_TEMPORAL
- && temporal_valid(ptr_base, addrof_base)
+ && temporal_valid(ptr_base, addrof_base)
#endif
- );
+ );
}
-int eacsl_valid_read(void *ptr, size_t size, void *ptr_base, void *addrof_base) {
- return
- size == 0
- || (
- allocated((uintptr_t)ptr, size, (uintptr_t)ptr_base)
+int eacsl_valid_read(void *ptr, size_t size, void *ptr_base,
+ void *addrof_base) {
+ return size == 0
+ || (allocated((uintptr_t)ptr, size, (uintptr_t)ptr_base)
#ifdef E_ACSL_TEMPORAL
- && temporal_valid(ptr_base, addrof_base)
+ && temporal_valid(ptr_base, addrof_base)
#endif
- );
+ );
}
/*! NB: The implementation for this function can also be specified via
\p _base_addr macro that will eventually call ::TRY_SEGMENT. The following
implementation is preferred for performance reasons. */
-void * eacsl_base_addr(void *ptr) {
- TRY_SEGMENT(ptr,
- return (void*)heap_info((uintptr_t)ptr, 'B'),
- return (void*)static_info((uintptr_t)ptr, 'B'));
+void *eacsl_base_addr(void *ptr) {
+ TRY_SEGMENT(ptr, return (void *)heap_info((uintptr_t)ptr, 'B'),
+ return (void *)static_info((uintptr_t)ptr, 'B'));
return NULL;
}
@@ -121,24 +114,21 @@ void * eacsl_base_addr(void *ptr) {
via \p _block_length macro. A more direct approach via ::TRY_SEGMENT
is preferred for performance reasons. */
size_t eacsl_block_length(void *ptr) {
- TRY_SEGMENT(ptr,
- return heap_info((uintptr_t)ptr, 'L'),
- return static_info((uintptr_t)ptr, 'L'))
+ TRY_SEGMENT(ptr, return heap_info((uintptr_t)ptr, 'L'),
+ return static_info((uintptr_t)ptr, 'L'))
return 0;
}
size_t eacsl_offset(void *ptr) {
- TRY_SEGMENT(ptr,
- return heap_info((uintptr_t)ptr, 'O'),
- return static_info((uintptr_t)ptr, 'O'));
+ TRY_SEGMENT(ptr, return heap_info((uintptr_t)ptr, 'O'),
+ return static_info((uintptr_t)ptr, 'O'));
return 0;
}
int eacsl_initialized(void *ptr, size_t size) {
uintptr_t addr = (uintptr_t)ptr;
- TRY_SEGMENT_WEAK(addr,
- return heap_initialized(addr, size),
- return static_initialized(addr, size));
+ TRY_SEGMENT_WEAK(addr, return heap_initialized(addr, size),
+ return static_initialized(addr, size));
return 0;
}
/* }}} */
@@ -146,18 +136,18 @@ int eacsl_initialized(void *ptr, size_t size) {
/* Track program arguments (ARGC/ARGV) {{{ */
/* POSIX-compliant array of character pointers to the environment strings. */
-extern char ** environ;
+extern char **environ;
-static void argv_alloca(int *argc_ref, char *** argv_ref) {
+static void argv_alloca(int *argc_ref, char ***argv_ref) {
/* Track a top-level containers */
- shadow_alloca((void*)argc_ref, sizeof(int));
- shadow_alloca((void*)argv_ref, sizeof(char**));
+ shadow_alloca((void *)argc_ref, sizeof(int));
+ shadow_alloca((void *)argv_ref, sizeof(char **));
int argc = *argc_ref;
- char** argv = *argv_ref;
+ char **argv = *argv_ref;
/* Track argv */
- size_t argvlen = (argc + 1)*sizeof(char*);
+ size_t argvlen = (argc + 1) * sizeof(char *);
shadow_alloca(argv, argvlen);
- initialize_static_region((uintptr_t)argv, (argc + 1)*sizeof(char*));
+ initialize_static_region((uintptr_t)argv, (argc + 1) * sizeof(char *));
/* Track argument strings */
while (*argv) {
@@ -187,7 +177,7 @@ static void argv_alloca(int *argc_ref, char *** argv_ref) {
argv = *argv_ref;
eacsl_temporal_store_nblock(argv_ref, *argv_ref);
for (i = 0; i < argc; i++)
- eacsl_temporal_store_nblock(argv + i, *(argv+i));
+ eacsl_temporal_store_nblock(argv + i, *(argv + i));
#endif
while (*environ) {
@@ -211,9 +201,9 @@ void mspaces_init() {
e.g. in presence of a GCC's constructors that invokes malloc possibly
several times before calling main. */
static char already_run = 0;
- if (! already_run) {
+ if (!already_run) {
describe_run();
- eacsl_make_memory_spaces(64*MB, get_heap_size());
+ eacsl_make_memory_spaces(64 * MB, get_heap_size());
/* Allocate and log shadow memory layout of the execution.
Case of the segments available before main. */
init_shadow_layout_pre_main();
@@ -221,11 +211,11 @@ void mspaces_init() {
}
}
-void eacsl_memory_init(int *argc_ref, char *** argv_ref, size_t ptr_size) {
+void eacsl_memory_init(int *argc_ref, char ***argv_ref, size_t ptr_size) {
/* [already_run] avoids reentrancy issue (see Gitlab issue #83),
e.g. in presence of a recursive call to 'main' */
static char already_run = 0;
- if (! already_run) {
+ if (!already_run) {
mspaces_init();
/* Verify that the given size of a pointer matches the one in the present
architecture. This is a guard against Frama-C instrumentations using
@@ -234,7 +224,7 @@ void eacsl_memory_init(int *argc_ref, char *** argv_ref, size_t ptr_size) {
/* Initialize report file with debug logs (only in debug mode). */
initialize_report_file(argc_ref, argv_ref);
/* Lift stack limit to account for extra stack memory overhead. */
- increase_stack_limit(get_stack_size()*2);
+ increase_stack_limit(get_stack_size() * 2);
/* Allocate and log shadow memory layout of the execution. Case of the
segments available after main. */
init_shadow_layout_main(argc_ref, argv_ref);
@@ -251,9 +241,9 @@ void eacsl_memory_init(int *argc_ref, char *** argv_ref, size_t ptr_size) {
collect_safe_locations();
int i;
for (i = 0; i < get_safe_locations_count(); i++) {
- memory_location * loc = get_safe_location(i);
+ memory_location *loc = get_safe_location(i);
if (loc->is_on_static) {
- void *addr = (void*)loc->address;
+ void *addr = (void *)loc->address;
uintptr_t len = loc->length;
shadow_alloca(addr, len);
if (loc->is_initialized)
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_omodel_debug.c b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_omodel_debug.c
index d6be5cd96e4abbc8a2202e9fa44ad4b7b1139b0d..d9943723c01f6f6ae9ddf88dca8c5f1c5474ff27 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_omodel_debug.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_omodel_debug.c
@@ -36,19 +36,18 @@ void describe_observation_model() {
}
int allocated(uintptr_t addr, long size, uintptr_t base) {
- TRY_SEGMENT_WEAK(addr,
- return heap_allocated(addr, size, base),
- return static_allocated(addr, size, base));
+ TRY_SEGMENT_WEAK(addr, return heap_allocated(addr, size, base),
+ return static_allocated(addr, size, base));
if (!IS_ON_VALID(addr))
return 0;
return 0;
}
-int readonly (void *ptr) {
+int readonly(void *ptr) {
uintptr_t addr = (uintptr_t)ptr;
return IS_ON_GLOBAL(addr) && global_readonly(addr) ? 1 : 0;
}
int writeable(uintptr_t addr, long size, uintptr_t base_ptr) {
- return allocated(addr, size, base_ptr) && !readonly((void*)addr);
+ return allocated(addr, size, base_ptr) && !readonly((void *)addr);
}
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_timestamp_retrieval.c b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_timestamp_retrieval.c
index 6e4edc7b1eccee4299759ea6b636396b415255d3..ae8832d1f088da05f2eb4b63a90fe0405ae01b32 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_timestamp_retrieval.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_timestamp_retrieval.c
@@ -22,7 +22,7 @@
#include "e_acsl_segment_tracking.h"
#ifdef E_ACSL_TEMPORAL
-# include "../../instrumentation_model/e_acsl_temporal_timestamp.h"
+# include "../../instrumentation_model/e_acsl_temporal_timestamp.h"
#endif
#include "../internals/e_acsl_timestamp_retrieval.h"
@@ -31,30 +31,26 @@
/* Remaining functionality (shared between all models) is located in e_acsl_temporal.h */
#ifdef E_ACSL_TEMPORAL
uintptr_t temporal_referent_shadow(void *addr) {
- TRY_SEGMENT(addr,
- return TEMPORAL_HEAP_SHADOW(addr),
- return TEMPORAL_SECONDARY_STATIC_SHADOW(addr));
+ TRY_SEGMENT(addr, return TEMPORAL_HEAP_SHADOW(addr),
+ return TEMPORAL_SECONDARY_STATIC_SHADOW(addr));
return 0;
}
uint32_t origin_timestamp(void *ptr) {
- TRY_SEGMENT_WEAK(ptr,
- return heap_origin_timestamp((uintptr_t)ptr),
- return static_origin_timestamp((uintptr_t)ptr));
+ TRY_SEGMENT_WEAK(ptr, return heap_origin_timestamp((uintptr_t)ptr),
+ return static_origin_timestamp((uintptr_t)ptr));
return INVALID_TEMPORAL_TIMESTAMP;
}
uint32_t referent_timestamp(void *ptr) {
- TRY_SEGMENT(ptr,
- return heap_referent_timestamp((uintptr_t)ptr),
- return static_referent_timestamp((uintptr_t)ptr));
+ TRY_SEGMENT(ptr, return heap_referent_timestamp((uintptr_t)ptr),
+ return static_referent_timestamp((uintptr_t)ptr));
return INVALID_TEMPORAL_TIMESTAMP;
}
void store_temporal_referent(void *ptr, uint32_t ref) {
- TRY_SEGMENT(ptr,
- heap_store_temporal_referent((uintptr_t)ptr, ref),
- static_store_temporal_referent((uintptr_t)ptr,ref));
+ TRY_SEGMENT(ptr, heap_store_temporal_referent((uintptr_t)ptr, ref),
+ static_store_temporal_referent((uintptr_t)ptr, ref));
}
#endif
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.c b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.c
index e633b1a98969109004618005b0763567f65a4150..264d0e555f7d3fc817723aba8a4708a5f632c759 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.c
@@ -23,9 +23,9 @@
#include <stddef.h>
#include <stdint.h>
+#include "../../instrumentation_model/e_acsl_temporal_timestamp.h"
#include "../../internals/e_acsl_bits.h"
#include "../../internals/e_acsl_rtl_string.h"
-#include "../../instrumentation_model/e_acsl_temporal_timestamp.h"
#include "../internals/e_acsl_omodel_debug.h"
#include "e_acsl_shadow_layout.h"
@@ -34,28 +34,26 @@
/* Segment settings and shadow values interpretation {{{ */
/*! \brief Decrease _n to be a multiple of _m */
-#define ALIGN_LEFT(_n, _m) (_n - _n%_m)
+#define ALIGN_LEFT(_n, _m) (_n - _n % _m)
/*! \brief Increase _n to be a multiple of _m */
-#define ALIGN_RIGHT(_n, _m) (_n + ((_n%_m) ? (_m - _n%_m) : 0))
+#define ALIGN_RIGHT(_n, _m) (_n + ((_n % _m) ? (_m - _n % _m) : 0))
/*! \brief Heap shadow address aligned at a segment boundary */
-#define ALIGNED_HEAP_SHADOW(_addr) \
- HEAP_SHADOW(ALIGN_LEFT(_addr,HEAP_SEGMENT))
+#define ALIGNED_HEAP_SHADOW(_addr) HEAP_SHADOW(ALIGN_LEFT(_addr, HEAP_SEGMENT))
/* \brief Maximal size_t value that does not cause overflow via addition
* when segment size is added. */
-static const size_t max_allocated = ALIGN_LEFT(SIZE_MAX,HEAP_SEGMENT);
+static const size_t max_allocated = ALIGN_LEFT(SIZE_MAX, HEAP_SEGMENT);
/* \brief Return actual allocation size which takes into account aligned
* allocation. In the present implementation it is the requested size of
* a heap block aligned at a segment boundary */
-#define ALLOC_SIZE(_s) \
- (_s < max_allocated ? ALIGN_RIGHT(_s, HEAP_SEGMENT) : 0)
+#define ALLOC_SIZE(_s) (_s < max_allocated ? ALIGN_RIGHT(_s, HEAP_SEGMENT) : 0)
/** \brief Evaluate to `true` if address _addr belongs to a memory block
* with base address _base and length _length */
-#define BELONGS(_addr, _base, _length) \
+#define BELONGS(_addr, _base, _length) \
(_addr >= _base && _addr < _base + _length)
/*! \brief For short blocks numbers 1 to 36 represent lengths and offsets,
@@ -116,16 +114,16 @@ static const uint64_t heap_init_mask = ~(ONE << HEAP_SEGMENT);
*
* For instance, mark first X bytes of a number N as initialised:
* N |= static_init_masks[X] */
-static const uint64_t static_init_masks [] = {
- 0, /* 0 bytes */
- 1, /* 1 byte */
- 257, /* 2 bytes */
- 65793, /* 3 bytes */
- 16843009, /* 4 bytes */
- 4311810305, /* 5 bytes */
- 1103823438081, /* 6 bytes */
- 282578800148737, /* 7 bytes */
- 72340172838076673 /* 8 bytes */
+static const uint64_t static_init_masks[] = {
+ 0, /* 0 bytes */
+ 1, /* 1 byte */
+ 257, /* 2 bytes */
+ 65793, /* 3 bytes */
+ 16843009, /* 4 bytes */
+ 4311810305, /* 5 bytes */
+ 1103823438081, /* 6 bytes */
+ 282578800148737, /* 7 bytes */
+ 72340172838076673 /* 8 bytes */
};
/*! \brief Bit masks for setting read-only (second least significant) bits.
@@ -141,16 +139,16 @@ static const uint64_t static_init_masks [] = {
*
* For instance, mark first X bytes of a number N as read-only:
* N |= static_readonly_masks[X] */
-static const uint64_t static_readonly_masks [] = {
- 0, /* 0 bytes */
- 2, /* 1 byte */
- 514, /* 2 bytes */
- 131586, /* 3 bytes */
- 33686018, /* 4 bytes */
- 8623620610, /* 5 bytes */
- 2207646876162, /* 6 bytes */
- 565157600297474, /* 7 bytes */
- 144680345676153346 /* 8 bytes */
+static const uint64_t static_readonly_masks[] = {
+ 0, /* 0 bytes */
+ 2, /* 1 byte */
+ 514, /* 2 bytes */
+ 131586, /* 3 bytes */
+ 33686018, /* 4 bytes */
+ 8623620610, /* 5 bytes */
+ 2207646876162, /* 6 bytes */
+ 565157600297474, /* 7 bytes */
+ 144680345676153346 /* 8 bytes */
};
/* }}} */
@@ -160,55 +158,55 @@ void validate_shadow_layout() {
/* Check that the struct holding memory layout is marked as initialized. */
DVALIDATE_MEMORY_INIT;
-#ifdef E_ACSL_DEBUG_VERBOSE
+# ifdef E_ACSL_DEBUG_VERBOSE
DEBUG_PRINT_LAYOUT;
-#endif
+# endif
/* Each segment has 3 partitions:
- application memory
- primary/secondary shadows */
- int num_partitions = sizeof(mem_partitions)/sizeof(memory_partition*);
+ int num_partitions = sizeof(mem_partitions) / sizeof(memory_partition *);
int num_seg_in_part = 3;
-#ifdef E_ACSL_TEMPORAL
+# ifdef E_ACSL_TEMPORAL
num_seg_in_part = 5;
-#endif
- int num_segments = num_partitions*num_seg_in_part;
+# endif
+ int num_segments = num_partitions * num_seg_in_part;
uintptr_t segments[num_segments][2];
- const char * segment_names[num_segments];
+ const char *segment_names[num_segments];
size_t i, app_idx, primary_idx, secondary_idx;
-#ifdef E_ACSL_TEMPORAL
+# ifdef E_ACSL_TEMPORAL
size_t primary_temporal_idx, secondary_temporal_idx;
-#endif
+# endif
for (i = 0; i < num_partitions; i++) {
memory_partition *p = mem_partitions[i];
- app_idx = num_seg_in_part*i;
+ app_idx = num_seg_in_part * i;
segment_names[app_idx] = p->application.name;
segments[app_idx][0] = p->application.start;
segments[app_idx][1] = p->application.end;
- primary_idx = num_seg_in_part*i+1;
+ primary_idx = num_seg_in_part * i + 1;
segment_names[primary_idx] = p->primary.name;
segments[primary_idx][0] = p->primary.start;
segments[primary_idx][1] = p->primary.end;
- secondary_idx = num_seg_in_part*i+2;
+ secondary_idx = num_seg_in_part * i + 2;
segment_names[secondary_idx] = p->secondary.name;
segments[secondary_idx][0] = p->secondary.start;
segments[secondary_idx][1] = p->secondary.end;
-#ifdef E_ACSL_TEMPORAL
- primary_temporal_idx = num_seg_in_part*i+3;
+# ifdef E_ACSL_TEMPORAL
+ primary_temporal_idx = num_seg_in_part * i + 3;
segment_names[primary_temporal_idx] = p->temporal_primary.name;
segments[primary_temporal_idx][0] = p->temporal_primary.start;
segments[primary_temporal_idx][1] = p->temporal_primary.end;
- secondary_temporal_idx = num_seg_in_part*i+4;
+ secondary_temporal_idx = num_seg_in_part * i + 4;
segment_names[secondary_temporal_idx] = p->temporal_secondary.name;
segments[secondary_temporal_idx][0] = p->temporal_secondary.start;
segments[secondary_temporal_idx][1] = p->temporal_secondary.end;
-#endif
+# endif
}
/* Make sure all segments (shadow or otherwise) are disjoint */
@@ -217,15 +215,15 @@ void validate_shadow_layout() {
uintptr_t *src = segments[i];
const char *src_name = segment_names[i];
DVASSERT(src[0] < src[1],
- "Segment %s start is greater than segment end %a < %a\n",
- src_name, src[0], src[1]);
+ "Segment %s start is greater than segment end %a < %a\n", src_name,
+ src[0], src[1]);
for (j = 0; j < num_segments; j++) {
if (i != j) {
uintptr_t *dest = segments[j];
const char *dest_name = segment_names[j];
DVASSERT(src[1] < dest[0] || src[0] > dest[1],
- "Segment %s [%a, %a] overlaps with segment %s [%a, %a]",
- src_name, src[0], src[1], dest_name, dest[0], dest[1]);
+ "Segment %s [%a, %a] overlaps with segment %s [%a, %a]",
+ src_name, src[0], src[1], dest_name, dest[0], dest[1]);
}
}
}
@@ -235,10 +233,8 @@ void validate_shadow_layout() {
/* E-ACSL predicates {{{ */
uintptr_t predicate(uintptr_t addr, char p) {
- TRY_SEGMENT(
- addr,
- return heap_info((uintptr_t)addr, p),
- return static_info((uintptr_t)addr, p));
+ TRY_SEGMENT(addr, return heap_info((uintptr_t)addr, p),
+ return static_info((uintptr_t)addr, p));
return 0;
}
/* }}} */
@@ -254,20 +250,18 @@ uintptr_t predicate(uintptr_t addr, char p) {
* length 4, offset 2 => 9,
* length 4, offset 3 => 10,
* and then for a block of 5 bytes its base offset if 11 etc. */
-static const char short_offsets_base [] = { 0, 1, 2, 4, 7, 11, 16, 22, 29 };
+static const char short_offsets_base[] = {0, 1, 2, 4, 7, 11, 16, 22, 29};
/** Shadow masks for setting values of short blocks */
-static const uint64_t short_shadow_masks[] = {
- 0UL,
- 4UL,
- 3080UL,
- 1578000UL,
- 673456156UL,
- 258640982060UL,
- 92703853921344UL,
- 31644393008028760UL,
- 10415850140873816180UL
-};
+static const uint64_t short_shadow_masks[] = {0UL,
+ 4UL,
+ 3080UL,
+ 1578000UL,
+ 673456156UL,
+ 258640982060UL,
+ 92703853921344UL,
+ 31644393008028760UL,
+ 10415850140873816180UL};
void shadow_alloca(void *ptr, size_t size) {
DVALIDATE_IS_ON_STATIC(ptr, size);
@@ -281,9 +275,9 @@ void shadow_alloca(void *ptr, size_t size) {
}
#endif
- unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(ptr);
+ unsigned char *prim_shadow = (unsigned char *)PRIMARY_SHADOW(ptr);
uint64_t *prim_shadow_alt = (uint64_t *)PRIMARY_SHADOW(ptr);
- unsigned int *sec_shadow = (unsigned int*)SECONDARY_SHADOW(ptr);
+ unsigned int *sec_shadow = (unsigned int *)SECONDARY_SHADOW(ptr);
/* Make sure shadows are nullified */
DVALIDATE_NULLIFIED(prim_shadow, size);
@@ -309,7 +303,8 @@ void shadow_alloca(void *ptr, size_t size) {
/* Write out the remainder */
for (i = boundary; i < size; i++) {
- unsigned char offset = i%LONG_BLOCK + LONG_BLOCK_INDEX_START + LONG_BLOCK;
+ unsigned char offset =
+ i % LONG_BLOCK + LONG_BLOCK_INDEX_START + LONG_BLOCK;
prim_shadow[i] = (offset << 2);
}
} else { /* Short blocks */
@@ -324,7 +319,7 @@ void shadow_alloca(void *ptr, size_t size) {
* are never deallocated, an origin time stamp of any global block is given
* via `GLOBAL_TEMPORAL_TIMESTAMP` */
if (!IS_ON_GLOBAL(ptr)) {
- uint32_t* temporal_shadow = (uint32_t*)TEMPORAL_PRIMARY_STATIC_SHADOW(ptr);
+ uint32_t *temporal_shadow = (uint32_t *)TEMPORAL_PRIMARY_STATIC_SHADOW(ptr);
*temporal_shadow = NEW_TEMPORAL_TIMESTAMP();
}
#endif /*}}} E_ACSL_TEMPORAL*/
@@ -334,21 +329,21 @@ void shadow_alloca(void *ptr, size_t size) {
/* Deletion of static blocks {{{ */
void shadow_freea(void *ptr) {
DVALIDATE_STATIC_LOCATION(ptr);
- DASSERT(ptr == (void*)_base_addr(ptr));
+ DASSERT(ptr == (void *)_base_addr(ptr));
size_t size = _block_length(ptr);
- memset((void*)PRIMARY_SHADOW(ptr), 0, size);
- memset((void*)SECONDARY_SHADOW(ptr), 0, size);
+ memset((void *)PRIMARY_SHADOW(ptr), 0, size);
+ memset((void *)SECONDARY_SHADOW(ptr), 0, size);
#ifdef E_ACSL_TEMPORAL /*{{{*/
- memset((void*)TEMPORAL_PRIMARY_STATIC_SHADOW(ptr), 0, size);
- memset((void*)TEMPORAL_SECONDARY_STATIC_SHADOW(ptr), 0, size);
-#endif /*}}} E_ACSL_TEMPORAL*/
+ memset((void *)TEMPORAL_PRIMARY_STATIC_SHADOW(ptr), 0, size);
+ memset((void *)TEMPORAL_SECONDARY_STATIC_SHADOW(ptr), 0, size);
+#endif /*}}} E_ACSL_TEMPORAL*/
}
/* }}} */
/* Static querying {{{ */
int static_allocated(uintptr_t addr, long size, uintptr_t base_ptr) {
- unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(addr);
+ unsigned char *prim_shadow = (unsigned char *)PRIMARY_SHADOW(addr);
/* Unless the address belongs to tracked allocation 0 is returned */
if (prim_shadow[0]) {
unsigned int code = (prim_shadow[0] >> 2);
@@ -357,7 +352,7 @@ int static_allocated(uintptr_t addr, long size, uintptr_t base_ptr) {
if (long_block) {
offset = code - LONG_BLOCK_INDEX_START;
unsigned int *sec_shadow =
- (unsigned int*)SECONDARY_SHADOW(addr - offset) ;
+ (unsigned int *)SECONDARY_SHADOW(addr - offset);
length = sec_shadow[0];
offset = sec_shadow[1] + offset;
} else {
@@ -368,7 +363,7 @@ int static_allocated(uintptr_t addr, long size, uintptr_t base_ptr) {
#ifndef E_ACSL_WEAK_VALIDITY
if (addr != base_ptr) {
return BELONGS(base_ptr, addr - offset, length)
- && offset + size <= length;
+ && offset + size <= length;
}
#endif
return offset + size <= length;
@@ -384,7 +379,7 @@ int static_initialized(uintptr_t addr, long size) {
DVALIDATE_STATIC_ACCESS(addr, size);
int result = 1;
- uint64_t *shadow = (uint64_t*)PRIMARY_SHADOW(addr);
+ uint64_t *shadow = (uint64_t *)PRIMARY_SHADOW(addr);
while (size > 0) {
int rem = (size >= ULONG_BYTES) ? ULONG_BYTES : size;
uint64_t mask = static_init_masks[rem];
@@ -400,7 +395,7 @@ int static_initialized(uintptr_t addr, long size) {
uintptr_t static_info(uintptr_t addr, char type) {
DVALIDATE_STATIC_LOCATION(addr);
- unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(addr);
+ unsigned char *prim_shadow = (unsigned char *)PRIMARY_SHADOW(addr);
/* Unless the address belongs to tracked allocation 0 is returned */
if (prim_shadow[0]) {
@@ -409,27 +404,27 @@ uintptr_t static_info(uintptr_t addr, char type) {
if (long_block) {
unsigned int offset = code - LONG_BLOCK_INDEX_START;
unsigned int *sec_shadow =
- (unsigned int*)SECONDARY_SHADOW(addr - offset) ;
- switch(type) {
- case 'B': /* Base address */
- return addr - offset - sec_shadow[1];
- case 'O': /* Offset */
- return sec_shadow[1] + offset;
- case 'L': /* Length */
- return sec_shadow[0];
- default:
- DASSERT(0 && "Unknown static query type");
+ (unsigned int *)SECONDARY_SHADOW(addr - offset);
+ switch (type) {
+ case 'B': /* Base address */
+ return addr - offset - sec_shadow[1];
+ case 'O': /* Offset */
+ return sec_shadow[1] + offset;
+ case 'L': /* Length */
+ return sec_shadow[0];
+ default:
+ DASSERT(0 && "Unknown static query type");
}
} else {
- switch(type) {
- case 'B': /* Base address */
- return addr - short_offsets[code];
- case 'O': /* Offset */
- return short_offsets[code];
- case 'L': /* Length */
- return short_lengths[code];
- default:
- DASSERT(0 && "Unknown static query type");
+ switch (type) {
+ case 'B': /* Base address */
+ return addr - short_offsets[code];
+ case 'O': /* Offset */
+ return short_offsets[code];
+ case 'L': /* Length */
+ return short_lengths[code];
+ default:
+ DASSERT(0 && "Unknown static query type");
}
}
}
@@ -445,31 +440,31 @@ uint32_t static_temporal_info(uintptr_t addr, int origin) {
int allocated = static_allocated_one(addr);
if (allocated && !IS_ON_GLOBAL(addr)) {
uintptr_t base = static_info(addr, 'B');
- return *((uint32_t*)TEMPORAL_PRIMARY_STATIC_SHADOW(base));
+ return *((uint32_t *)TEMPORAL_PRIMARY_STATIC_SHADOW(base));
} else if (allocated && IS_ON_GLOBAL(addr)) {
return GLOBAL_TEMPORAL_TIMESTAMP;
} else {
return INVALID_TEMPORAL_TIMESTAMP;
}
} else {
- return *((uint32_t*)TEMPORAL_SECONDARY_STATIC_SHADOW(addr));
+ return *((uint32_t *)TEMPORAL_SECONDARY_STATIC_SHADOW(addr));
}
}
void static_store_temporal_referent(uintptr_t addr, uint32_t ref) {
DVALIDATE_STATIC_ACCESS(addr, PTR_SZ);
- *((uint32_t*)TEMPORAL_SECONDARY_STATIC_SHADOW(addr)) = ref;
+ *((uint32_t *)TEMPORAL_SECONDARY_STATIC_SHADOW(addr)) = ref;
}
-#endif/*}}} E_ACSL_TEMPORAL*/
+#endif /*}}} E_ACSL_TEMPORAL*/
/* }}} */
/* Static initialization {{{ */
void initialize_static_region(uintptr_t addr, long size) {
DVALIDATE_STATIC_ACCESS(addr, size);
DVASSERT(!(addr - _base_addr(addr) + size > _block_length(addr)),
- "Attempt to initialize %lu bytes past block boundaries\n"
- "starting at %a with block length %lu at base address %a\n",
- size, addr, _block_length(addr), _base_addr(addr));
+ "Attempt to initialize %lu bytes past block boundaries\n"
+ "starting at %a with block length %lu at base address %a\n",
+ size, addr, _block_length(addr), _base_addr(addr));
/* Below code marks `size` bytes following `addr` in the stack shadow as
* initialized. That is, least significant bits of all 9 bytes following
@@ -493,7 +488,7 @@ void initialize_static_region(uintptr_t addr, long size) {
* That is, `*shadow |= static_init_masks[1]` will set only the least
* significant bit in *shadow. */
- uint64_t *shadow = (uint64_t*)PRIMARY_SHADOW(addr);
+ uint64_t *shadow = (uint64_t *)PRIMARY_SHADOW(addr);
while (size > 0) {
int rem = (size >= ULONG_BYTES) ? ULONG_BYTES : size;
size -= ULONG_BYTES;
@@ -504,18 +499,18 @@ void initialize_static_region(uintptr_t addr, long size) {
/* }}} */
/* Read-only {{{ */
-void mark_readonly_region (uintptr_t addr, long size) {
+void mark_readonly_region(uintptr_t addr, long size) {
/* Since read-only blocks can only be stored in the globals segments (e.g.,
* TEXT), this function required ptr carry a global address. */
DASSERT(IS_ON_GLOBAL(addr));
DASSERT(static_allocated_one(addr));
DVASSERT(!(addr - _base_addr(addr) + size > _block_length(addr)),
- "Attempt to mark read-only %lu bytes past block boundaries\n"
- "starting at %a with block length %lu at base address %a\n",
- size, addr, _block_length(addr), _base_addr(addr));
+ "Attempt to mark read-only %lu bytes past block boundaries\n"
+ "starting at %a with block length %lu at base address %a\n",
+ size, addr, _block_length(addr), _base_addr(addr));
/* See comments in ::initialize_static_region for details */
- uint64_t *shadow = (uint64_t*)PRIMARY_GLOBAL_SHADOW(addr);
+ uint64_t *shadow = (uint64_t *)PRIMARY_GLOBAL_SHADOW(addr);
while (size > 0) {
int rem = (size >= ULONG_BYTES) ? ULONG_BYTES : size;
size -= ULONG_BYTES;
@@ -536,37 +531,38 @@ void mark_readonly_region (uintptr_t addr, long size) {
* \b WARNING: Current implementation assumes that the size of a heap segment
* does not exceed 64 bytes. */
static void set_heap_segment(void *ptr, size_t size, size_t alloc_size,
- size_t init, const char *function) {
+ size_t init, const char *function) {
/* Make sure that heap memspace has not been moved. This is likely if
a really large chunk has been requested to be allocated. */
- private_assert(mem_spaces.heap_mspace_least ==
- (uintptr_t)eacsl_mspace_least_addr(mem_spaces.heap_mspace),
- "Exceeded heap allocation limit of %luMB -- heap memory space moved. \n",
- E_ACSL_HEAP_SIZE);
+ private_assert(
+ mem_spaces.heap_mspace_least
+ == (uintptr_t)eacsl_mspace_least_addr(mem_spaces.heap_mspace),
+ "Exceeded heap allocation limit of %luMB -- heap memory space moved. \n",
+ E_ACSL_HEAP_SIZE);
/* Similar check, make sure that allocated space does not exceed given
allocation limit for mspace */
uintptr_t max_addr = (uintptr_t)ptr + alloc_size;
private_assert(mem_spaces.heap_end > max_addr,
- "Exceeded heap allocation limit of %luMB\n", E_ACSL_HEAP_SIZE);
+ "Exceeded heap allocation limit of %luMB\n", E_ACSL_HEAP_SIZE);
DVALIDATE_MEMORY_PRE_MAIN_INIT;
/* Ensure the shadowed block in on the tracked heap portion */
DVALIDATE_IS_ON_HEAP(((uintptr_t)ptr) - HEAP_SEGMENT, size);
- DVALIDATE_ALIGNMENT(ptr); /* Make sure alignment is right */
+ DVALIDATE_ALIGNMENT(ptr); /* Make sure alignment is right */
update_heap_allocation(size); /* Adjust tracked allocation size */
/* Get aligned size of the block, i.e., an actual size of the
* allocated block */
- unsigned char *shadow = (unsigned char*)HEAP_SHADOW(ptr);
+ unsigned char *shadow = (unsigned char *)HEAP_SHADOW(ptr);
/* Make sure shadow is nullified before setting it */
DVALIDATE_NULLIFIED(shadow, alloc_size);
/* The overall number of block segments in a tracked memory block */
- size_t segments = alloc_size/HEAP_SEGMENT;
- uintptr_t *segment = (uintptr_t*)(shadow);
+ size_t segments = alloc_size / HEAP_SEGMENT;
+ uintptr_t *segment = (uintptr_t *)(shadow);
segment[1] = size;
#ifdef E_ACSL_TEMPORAL /*{{{*/
@@ -577,25 +573,25 @@ static void set_heap_segment(void *ptr, size_t size, size_t alloc_size,
int i;
/* Write the offsets per segment */
for (i = 0; i < segments; i++) {
- segment = (uintptr_t*)(shadow + i*HEAP_SEGMENT);
+ segment = (uintptr_t *)(shadow + i * HEAP_SEGMENT);
*segment = (uintptr_t)ptr;
}
/* If init is a non-zero value then mark all allocated bytes as initialized */
if (init) {
- memset((void*)HEAP_INIT_SHADOW(ptr), (unsigned int)ONE, alloc_size/8);
+ memset((void *)HEAP_INIT_SHADOW(ptr), (unsigned int)ONE, alloc_size / 8);
}
}
-void* malloc(size_t size) {
+void *malloc(size_t size) {
size_t alloc_size = ALLOC_SIZE(size);
/* Return NULL if the size is too large to be aligned */
- char* res;
+ char *res;
if (alloc_size) {
mspaces_init();
- res = (char*)public_malloc(alloc_size);
+ res = (char *)public_malloc(alloc_size);
} else
res = NULL;
@@ -607,21 +603,21 @@ void* malloc(size_t size) {
return res;
}
-void* calloc(size_t nmemb, size_t size) {
+void *calloc(size_t nmemb, size_t size) {
/* Since both `nmemb` and `size` are both of size `size_t` the multiplication
* of the arguments (which gives the actual allocation size) might lead to an
* integer overflow. The below code checks for an overflow and sets the
* `alloc_size` (argument a memory allocation function) to zero. */
- size = (size && nmemb > SIZE_MAX/size) ? 0 : nmemb*size;
+ size = (size && nmemb > SIZE_MAX / size) ? 0 : nmemb * size;
size_t alloc_size = ALLOC_SIZE(size);
/* Since aligned size is required by the model do the allocation through
* `malloc` and nullify the memory space by hand */
- char* res;
+ char *res;
if (size) {
mspaces_init();
- res = (char*)public_malloc(alloc_size);
+ res = (char *)public_malloc(alloc_size);
} else
res = NULL;
@@ -634,7 +630,7 @@ void* calloc(size_t nmemb, size_t size) {
}
void *shadow_copy(const void *ptr, size_t size, int init) {
- char *ret = (init) ? calloc(1, size) : malloc(size);
+ char *ret = (init) ? calloc(1, size) : malloc(size);
private_assert(ret != NULL, "Shadow copy failed\n", NULL);
/* Shadow copy is internal, therefore heap status should not be updated.
Since it is set via `set_heap_segment`, it needs to be reverted back. */
@@ -661,7 +657,7 @@ static void unset_heap_segment(void *ptr, int init, const char *function) {
DVALIDATE_MEMORY_PRE_MAIN_INIT;
DVALIDATE_FREEABLE(((uintptr_t)ptr));
/* Base address of shadow block */
- uintptr_t *base_shadow = (uintptr_t*)HEAP_SHADOW(ptr);
+ uintptr_t *base_shadow = (uintptr_t *)HEAP_SHADOW(ptr);
/* Physical allocation size */
size_t alloc_size = ALLOC_SIZE(base_shadow[1]);
/* Actual block length */
@@ -672,12 +668,12 @@ static void unset_heap_segment(void *ptr, int init, const char *function) {
update_heap_allocation(-length);
#ifdef E_ACSL_TEMPORAL /*{{{*/
/* Nullify temporal shadow */
- uintptr_t *t_base_shadow = (uintptr_t*)TEMPORAL_HEAP_SHADOW(ptr);
+ uintptr_t *t_base_shadow = (uintptr_t *)TEMPORAL_HEAP_SHADOW(ptr);
memset(t_base_shadow, ZERO, alloc_size);
#endif /*}}} E_ACSL_TEMPORAL*/
/* Nullify init shadow */
if (init) {
- memset((void*)HEAP_INIT_SHADOW(ptr), 0, alloc_size/8);
+ memset((void *)HEAP_INIT_SHADOW(ptr), 0, alloc_size / 8);
}
}
@@ -702,7 +698,7 @@ void free(void *ptr) {
/* }}} */
/* Heap reallocation (realloc) {{{ */
-void* realloc(void *ptr, size_t size) {
+void *realloc(void *ptr, size_t size) {
char *res = NULL; /* Resulting pointer */
/* If the pointer is NULL then realloc is equivalent to malloc(size) */
if (ptr == NULL)
@@ -730,16 +726,17 @@ void* realloc(void *ptr, size_t size) {
set_heap_segment(res, size, alloc_size, 0, "realloc");
/* Move init shadow */
- unsigned char* old_init_shadow = (unsigned char*)HEAP_INIT_SHADOW(ptr);
- unsigned char* new_init_shadow = (unsigned char*)HEAP_INIT_SHADOW(res);
+ unsigned char *old_init_shadow = (unsigned char *)HEAP_INIT_SHADOW(ptr);
+ unsigned char *new_init_shadow = (unsigned char *)HEAP_INIT_SHADOW(res);
/* If realloc truncates allocation in the old init shadow it is first
* needed to clear the old init shadow from the boundary of the old
* shadow block to the size of the new allocation */
if (old_size > size) {
- clearbits_right(
- old_alloc_size - size, // size in bits
- old_init_shadow + old_alloc_size/8); // end of the old init shadow
+ clearbits_right(old_alloc_size - size, // size in bits
+ old_init_shadow
+ + old_alloc_size
+ / 8); // end of the old init shadow
}
/* Keep in mind that there is a ratio of 8 between the actual heap
@@ -760,19 +757,20 @@ void* realloc(void *ptr, size_t size) {
* the amount of bytes of init shadow that must be kept including any
* incomplete byte, and the number of bits that must be kept in the last
* byte if it is incomplete */
- size_t rem_keep_bits = keep_bits%8;
- size_t keep_bytes = keep_bits/8 + (rem_keep_bits > 0 ? 1 : 0);
+ size_t rem_keep_bits = keep_bits % 8;
+ size_t keep_bytes = keep_bits / 8 + (rem_keep_bits > 0 ? 1 : 0);
/* If the pointer has been moved, then we need to copy `keep_bytes`
* from the old shadow to the new shadow to carry over all the needed
* information. Then the old init shadow can be reset. */
if (res != ptr) {
- DVASSERT(keep_bytes <= alloc_size/8 && keep_bytes < old_alloc_size/8,
- "Attempt to access out of bound init shadow. Accessing %lu bytes, \
+ DVASSERT(
+ keep_bytes <= alloc_size / 8 && keep_bytes < old_alloc_size / 8,
+ "Attempt to access out of bound init shadow. Accessing %lu bytes, \
old init shadow size: %lu bytes, new init shadow size: %lu bytes.",
- keep_bytes, old_alloc_size/8, alloc_size/8);
+ keep_bytes, old_alloc_size / 8, alloc_size / 8);
memcpy(new_init_shadow, old_init_shadow, keep_bytes);
- memset(old_init_shadow, 0, old_alloc_size/8);
+ memset(old_init_shadow, 0, old_alloc_size / 8);
}
if (size > old_size) {
@@ -783,9 +781,11 @@ void* realloc(void *ptr, size_t size) {
* is incomplete (`rem_keep_bits > 0`), then reset the unkept bits of
* the last byte in the new init shadow */
if (rem_keep_bits > 0) {
- DVASSERT(idx < alloc_size/8,
- "Attempt to access out of bound init shadow. Accessing index %lu \
- with init shadow of size %lu bytes.", idx, alloc_size/8);
+ DVASSERT(
+ idx < alloc_size / 8,
+ "Attempt to access out of bound init shadow. Accessing index %lu \
+ with init shadow of size %lu bytes.",
+ idx, alloc_size / 8);
unsigned char mask = 0;
setbits64(rem_keep_bits, mask);
*(new_init_shadow + idx) &= mask;
@@ -800,13 +800,14 @@ void* realloc(void *ptr, size_t size) {
++idx;
// Number of bytes between the index and the end of the init
// shadow corresponding to the new allocated memory
- size_t count = size/8 - idx;
+ size_t count = size / 8 - idx;
- DVASSERT((idx+count) <= alloc_size/8,
- "Attempt to access out of bound init shadow. Accessing %lu bytes \
+ DVASSERT(
+ (idx + count) <= alloc_size / 8,
+ "Attempt to access out of bound init shadow. Accessing %lu bytes \
from index %lu with init shadow of size %lu bytes.",
- count, idx, alloc_size/8);
- memset(new_init_shadow+idx, 0, count);
+ count, idx, alloc_size / 8);
+ memset(new_init_shadow + idx, 0, count);
}
}
}
@@ -824,7 +825,7 @@ void *aligned_alloc(size_t alignment, size_t size) {
* - size and alignment are greater than zero
* - alignment is a power of 2
* - size is a multiple of alignment */
- if (!size || !alignment || !is_pow_of_2(alignment) || (size%alignment))
+ if (!size || !alignment || !is_pow_of_2(alignment) || (size % alignment))
return NULL;
char *res = public_aligned_alloc(alignment, size);
@@ -833,20 +834,22 @@ void *aligned_alloc(size_t alignment, size_t size) {
set_heap_segment(res, size, ALLOC_SIZE(size), 0, "aligned_alloc");
}
- return (void*)res;
+ return (void *)res;
}
/* }}} */
/* Heap aligned allocation (posix_memalign) {{{ */
int posix_memalign(void **memptr, size_t alignment, size_t size) {
- /* Check if:
+ /* Check if:
* - size and alignment are greater than zero
* - alignment is a power of 2 and a multiple of sizeof(void*) */
- if (!size || !alignment || !is_pow_of_2(alignment) || alignment%sizeof(void*))
+ if (!size || !alignment || !is_pow_of_2(alignment)
+ || alignment % sizeof(void *))
return -1;
/* Make sure that the first argument to posix memalign is indeed allocated */
- private_assert(allocated((uintptr_t)memptr, sizeof(void*), (uintptr_t)memptr),
+ private_assert(
+ allocated((uintptr_t)memptr, sizeof(void *), (uintptr_t)memptr),
"\\invalid memptr in posix_memalign", NULL);
int res = public_posix_memalign(memptr, alignment, size);
@@ -860,13 +863,13 @@ int posix_memalign(void **memptr, size_t alignment, size_t size) {
/* Heap querying {{{ */
int heap_allocated(uintptr_t addr, size_t size, uintptr_t base_ptr) {
/* Base address of the shadow segment the address belongs to */
- uintptr_t *shadow = (uintptr_t*)HEAP_SHADOW(addr - addr%HEAP_SEGMENT);
+ uintptr_t *shadow = (uintptr_t *)HEAP_SHADOW(addr - addr % HEAP_SEGMENT);
/* Non-zero if the segment belongs to heap allocation */
if (shadow[0]) {
uintptr_t *base_shadow =
- (uintptr_t*)HEAP_SHADOW(base_ptr - base_ptr%HEAP_SEGMENT);
- uintptr_t *first_segment = (uintptr_t*)HEAP_SHADOW(shadow[0]);
+ (uintptr_t *)HEAP_SHADOW(base_ptr - base_ptr % HEAP_SEGMENT);
+ uintptr_t *first_segment = (uintptr_t *)HEAP_SHADOW(shadow[0]);
/* shadow[0] - base address of the tracked block
* fist_segment[1] - length (i.e., location in the first segment
* after base address)
@@ -878,8 +881,8 @@ int heap_allocated(uintptr_t addr, size_t size, uintptr_t base_ptr) {
* (i.e., E_ACSL_WEAK_VALIDITY macro undefined) make sure that both
* `addr` and `base_ptr` belong to the same block. */
#ifndef E_ACSL_WEAK_VALIDITY
- return base_shadow[0] == shadow[0] &&
- (addr - shadow[0]) + size <= first_segment[1];
+ return base_shadow[0] == shadow[0]
+ && (addr - shadow[0]) + size <= first_segment[1];
#else
return (addr - shadow[0]) + size <= first_segment[1];
#endif
@@ -894,7 +897,7 @@ int eacsl_freeable(void *ptr) { /* + */
return 0;
/* Address of the shadow segment the address belongs to */
- uintptr_t *shadow = (uintptr_t*)ALIGNED_HEAP_SHADOW(addr);
+ uintptr_t *shadow = (uintptr_t *)ALIGNED_HEAP_SHADOW(addr);
/* Non-zero if the segment belongs to heap allocation with *shadow
* capturing the base address of the tracked block */
if (*shadow) {
@@ -910,41 +913,41 @@ uintptr_t heap_info(uintptr_t addr, char type) {
/* Base address of the shadow segment the address belongs to.
* First `sizeof(uintptr_t)` bytes of each segment store application-level
* base address of the tracked block */
- uintptr_t *aligned_shadow = (uintptr_t*)ALIGNED_HEAP_SHADOW(addr);
-
- switch(type) {
- case 'B': /* Base address */
- return *aligned_shadow;
- case 'L': { /* Block length */
- /* Pointer to the first-segment in the shadow block */
- uintptr_t *base_segment = (uintptr_t*)HEAP_SHADOW(*aligned_shadow);
- /* Length of the stored block is captured in `sizeof(uintptr_t)` bytes
+ uintptr_t *aligned_shadow = (uintptr_t *)ALIGNED_HEAP_SHADOW(addr);
+
+ switch (type) {
+ case 'B': /* Base address */
+ return *aligned_shadow;
+ case 'L': { /* Block length */
+ /* Pointer to the first-segment in the shadow block */
+ uintptr_t *base_segment = (uintptr_t *)HEAP_SHADOW(*aligned_shadow);
+ /* Length of the stored block is captured in `sizeof(uintptr_t)` bytes
* past `sizeof(uintptr_t)` tracking the base address */
- return base_segment[1];
- }
- case 'O':
- /* Offset of a given address within its block. This is the difference
+ return base_segment[1];
+ }
+ case 'O':
+ /* Offset of a given address within its block. This is the difference
* between the input address and the base address of the block. */
- return addr - *aligned_shadow;
- default:
- DASSERT(0 && "Unknown heap query type");
+ return addr - *aligned_shadow;
+ default:
+ DASSERT(0 && "Unknown heap query type");
}
return 0;
}
int heap_initialized(uintptr_t addr, long len) {
/* Base address of a shadow segment addr belongs to */
- unsigned char *shadow = (unsigned char*)(HEAP_INIT_SHADOW(addr));
+ unsigned char *shadow = (unsigned char *)(HEAP_INIT_SHADOW(addr));
/* See comments in the `initialize_heap_region` function for more details */
- unsigned skip = (addr - HEAP_START)%8;
+ unsigned skip = (addr - HEAP_START) % 8;
unsigned set;
if (skip) {
set = 8 - skip;
set = (len > set) ? set : len;
len -= set;
unsigned char mask = 0;
- setbits64_skip(set,mask,skip);
+ setbits64_skip(set, mask, skip);
if ((*shadow & mask) != mask)
return 0;
@@ -962,37 +965,37 @@ uint32_t heap_temporal_info(uintptr_t addr, int origin) {
timestamp is zero and unused memory is nullified then an invalid
timestamp is also returned for allocated memory */
if (origin) {
- uintptr_t *aligned_shadow = (uintptr_t*)ALIGNED_HEAP_SHADOW(addr);
- uintptr_t *base_shadow = (uintptr_t*)HEAP_SHADOW(*aligned_shadow);
+ uintptr_t *aligned_shadow = (uintptr_t *)ALIGNED_HEAP_SHADOW(addr);
+ uintptr_t *base_shadow = (uintptr_t *)HEAP_SHADOW(*aligned_shadow);
return (uint32_t)base_shadow[2];
} else {
- return *((uint32_t*)TEMPORAL_HEAP_SHADOW(addr));
+ return *((uint32_t *)TEMPORAL_HEAP_SHADOW(addr));
}
}
void heap_store_temporal_referent(uintptr_t addr, uint32_t ref) {
DVALIDATE_HEAP_ACCESS(addr, PTR_SZ);
- uint32_t *temporal_shadow = (uint32_t*)TEMPORAL_HEAP_SHADOW(addr);
+ uint32_t *temporal_shadow = (uint32_t *)TEMPORAL_HEAP_SHADOW(addr);
*temporal_shadow = ref;
}
-#endif/*}}} E_ACSL_TEMPORAL*/
+#endif /*}}} E_ACSL_TEMPORAL*/
/* Heap initialization {{{ */
void initialize_heap_region(uintptr_t addr, long len) {
DVALIDATE_HEAP_ACCESS(addr, len);
DVASSERT(!(addr - _base_addr(addr) + len > _block_length(addr)),
- "Attempt to initialize %lu bytes past block boundaries\n"
- "starting at %a with block length %lu at base address %a\n",
- len, addr, _block_length(addr), _base_addr(addr));
+ "Attempt to initialize %lu bytes past block boundaries\n"
+ "starting at %a with block length %lu at base address %a\n",
+ len, addr, _block_length(addr), _base_addr(addr));
/* Address within init shadow tracking initialization */
- unsigned char *shadow = (unsigned char*)(HEAP_INIT_SHADOW(addr));
+ unsigned char *shadow = (unsigned char *)(HEAP_INIT_SHADOW(addr));
/* First check whether the address in the init shadow is divisible by 8
* (i.e., located on a byte boundary) */
/* Leading bits in `*shadow` byte which do not need to be set
* (i.e., skipped) */
- short skip = (addr - HEAP_START)%8;
+ short skip = (addr - HEAP_START) % 8;
if (skip) {
/* The remaining bits in the shadow byte */
short set = 8 - skip;
@@ -1019,12 +1022,12 @@ void initialize_heap_region(uintptr_t addr, long len) {
void printbyte(unsigned char c, char buf[]) {
if (c >> 2 < LONG_BLOCK_INDEX_START) {
rtl_sprintf(buf, "PRIMARY: I{%u} RO{%u} OF{%2u} => %u[%u]",
- checkbit(INIT_BIT,c), checkbit(READONLY_BIT,c), c >> 2,
- short_lengths[c >> 2], short_offsets[c >> 2]);
+ checkbit(INIT_BIT, c), checkbit(READONLY_BIT, c), c >> 2,
+ short_lengths[c >> 2], short_offsets[c >> 2]);
} else {
rtl_sprintf(buf, "SECONDARY: I{%u} RO{%u} OF{%u} => %4u",
- checkbit(INIT_BIT,c), checkbit(READONLY_BIT,c),
- (c >> 2), (c >> 2) - LONG_BLOCK_INDEX_START);
+ checkbit(INIT_BIT, c), checkbit(READONLY_BIT, c), (c >> 2),
+ (c >> 2) - LONG_BLOCK_INDEX_START);
}
}
@@ -1032,18 +1035,18 @@ void print_static_shadows(uintptr_t addr, size_t size) {
char prim_buf[256];
char sec_buf[256];
- unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(addr);
- unsigned int *sec_shadow = (unsigned int*)SECONDARY_SHADOW(addr);
+ unsigned char *prim_shadow = (unsigned char *)PRIMARY_SHADOW(addr);
+ unsigned int *sec_shadow = (unsigned int *)SECONDARY_SHADOW(addr);
int i, j = 0;
for (i = 0; i < size; i++) {
sec_buf[0] = '\0';
printbyte(prim_shadow[i], prim_buf);
- if (IS_LONG_BLOCK(size) && (i%LONG_BLOCK) == 0) {
+ if (IS_LONG_BLOCK(size) && (i % LONG_BLOCK) == 0) {
j += 2;
if (i < LONG_BLOCK_BOUNDARY(size)) {
- rtl_sprintf(sec_buf, " %a SZ{%u} OF{%u}",
- &sec_shadow[j], sec_shadow[j-2], sec_shadow[j-1]);
+ rtl_sprintf(sec_buf, " %a SZ{%u} OF{%u}", &sec_shadow[j],
+ sec_shadow[j - 2], sec_shadow[j - 1]);
}
if (i) {
DLOG("---------------------------------------------\n");
@@ -1051,28 +1054,28 @@ void print_static_shadows(uintptr_t addr, size_t size) {
}
DLOG("| [%2d] %a | %s || %s\n", i, &prim_shadow[i], prim_buf, sec_buf);
}
-#ifdef E_ACSL_TEMPORAL /* {{{ */
- uint32_t* origin_shadow = (uint32_t*)TEMPORAL_PRIMARY_STATIC_SHADOW(addr);
- uint32_t* ref_shadow = (uint32_t*)TEMPORAL_SECONDARY_STATIC_SHADOW(addr);
+# ifdef E_ACSL_TEMPORAL /* {{{ */
+ uint32_t *origin_shadow = (uint32_t *)TEMPORAL_PRIMARY_STATIC_SHADOW(addr);
+ uint32_t *ref_shadow = (uint32_t *)TEMPORAL_SECONDARY_STATIC_SHADOW(addr);
DLOG(" | > Blk ID: %u\n", i, *origin_shadow);
- for (i = 0; i < size; i+=PTR_SZ)
- DLOG(" | > Ref ID[%u]: %u\n", i/8, *(ref_shadow + 1));
-#endif /*}}} E_ACSL_TEMPORAL*/
+ for (i = 0; i < size; i += PTR_SZ)
+ DLOG(" | > Ref ID[%u]: %u\n", i / 8, *(ref_shadow + 1));
+# endif /*}}} E_ACSL_TEMPORAL*/
}
void print_heap_shadows(uintptr_t addr) {
- unsigned char *block_shadow = (unsigned char*)HEAP_SHADOW(addr);
- unsigned char *init_shadow = (unsigned char*)HEAP_INIT_SHADOW(addr);
+ unsigned char *block_shadow = (unsigned char *)HEAP_SHADOW(addr);
+ unsigned char *init_shadow = (unsigned char *)HEAP_INIT_SHADOW(addr);
- size_t length = (size_t)((uintptr_t*)(block_shadow))[1];
+ size_t length = (size_t)((uintptr_t *)(block_shadow))[1];
size_t alloc_size = ALLOC_SIZE(length);
- size_t segments = alloc_size/HEAP_SEGMENT;
- uintptr_t *segment = (uintptr_t*)(block_shadow);
+ size_t segments = alloc_size / HEAP_SEGMENT;
+ uintptr_t *segment = (uintptr_t *)(block_shadow);
DLOG(" | === Block Shadow ======================================\n");
- DLOG(" | Access addr: %a\n", addr);
- DLOG(" | Block Shadow: %a\n", block_shadow);
- DLOG(" | Init Shadow: %a\n", init_shadow);
+ DLOG(" | Access addr: %a\n", addr);
+ DLOG(" | Block Shadow: %a\n", block_shadow);
+ DLOG(" | Init Shadow: %a\n", init_shadow);
DLOG(" | Segments: %lu\n", segments);
DLOG(" | Actual size: %lu bytes\n", alloc_size);
DLOG(" | Tracked Length: %lu bytes\n", length);
@@ -1080,19 +1083,19 @@ void print_heap_shadows(uintptr_t addr) {
if (zeroed_out(block_shadow, alloc_size))
DLOG(" | << Nullified >> \n");
-#ifdef E_ACSL_TEMPORAL /*{{{*/
+# ifdef E_ACSL_TEMPORAL /*{{{*/
DLOG(" | Origin TS: %u\n", (uint32_t)segment[2]);
-#endif /*}}}*/
+# endif /*}}}*/
size_t i;
for (i = 0; i < segments; i++) {
- segment = (uintptr_t*)(block_shadow + i*HEAP_SEGMENT);
+ segment = (uintptr_t *)(block_shadow + i * HEAP_SEGMENT);
DLOG(" | Segment: %lu, Base: %a \n", i, *segment);
}
DLOG(" | Initialization: \n | ");
- for (i = 0; i < alloc_size/8; i++) {
- if (i > 0 && (i*8)%HEAP_SEGMENT == 0)
+ for (i = 0; i < alloc_size / 8; i++) {
+ if (i > 0 && (i * 8) % HEAP_SEGMENT == 0)
DLOG("\n | ");
DLOG("%8b ", init_shadow[i], init_shadow[i]);
}
@@ -1117,10 +1120,10 @@ void print_memory_partition(struct memory_partition *p) {
print_memory_segment(&p->application, "Application", 0);
print_memory_segment(&p->primary, "Primary ", 1);
print_memory_segment(&p->secondary, "Secondary ", 1);
-#ifdef E_ACSL_TEMPORAL
+# ifdef E_ACSL_TEMPORAL
print_memory_segment(&p->temporal_primary, "Temporal Primary ", 1);
print_memory_segment(&p->temporal_secondary, "Temporal Secondary ", 1);
-#endif
+# endif
}
void print_shadow_layout() {
@@ -1128,12 +1131,12 @@ void print_shadow_layout() {
print_memory_partition(&mem_layout.heap);
DLOG(">>> STACK --------------------\n");
print_memory_partition(&mem_layout.stack);
-#if E_ACSL_OS_IS_LINUX
+# if E_ACSL_OS_IS_LINUX
DLOG(">>> GLOBAL -------------------\n");
print_memory_partition(&mem_layout.global);
DLOG(">>> TLS ----------------------\n");
print_memory_partition(&mem_layout.tls);
-#elif E_ACSL_OS_IS_WINDOWS
+# elif E_ACSL_OS_IS_WINDOWS
DLOG(">>> TEXT ---------------------\n");
print_memory_partition(&mem_layout.text);
DLOG(">>> BSS ----------------------\n");
@@ -1144,22 +1147,22 @@ void print_shadow_layout() {
print_memory_partition(&mem_layout.idata);
DLOG(">>> RDATA --------------------\n");
print_memory_partition(&mem_layout.rdata);
-#endif
+# endif
DLOG(">>> --------------------------\n");
}
-const char* which_segment(uintptr_t addr) {
+const char *which_segment(uintptr_t addr) {
const char *loc = NULL;
if (IS_ON_STACK(addr))
loc = "stack";
else if (IS_ON_HEAP(addr))
loc = "heap";
-#if E_ACSL_OS_IS_LINUX
+# if E_ACSL_OS_IS_LINUX
else if (IS_ON_GLOBAL(addr))
loc = "global";
else if (IS_ON_TLS(addr))
loc = "TLS";
-#elif E_ACSL_OS_IS_WINDOWS
+# elif E_ACSL_OS_IS_WINDOWS
else if (IS_ON_TEXT(addr))
loc = "text";
else if (IS_ON_BSS(addr))
@@ -1170,7 +1173,7 @@ const char* which_segment(uintptr_t addr) {
loc = "idata";
else if (IS_ON_RDATA(addr))
loc = "rdata";
-#endif
+# endif
else
loc = "untracked";
return loc;
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.h b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.h
index cc7851e3420cbff0663318db21ba32328eb79cf7..26e06ad028752e94482227c9bd9cadf595f3dbc1 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_segment_tracking.h
@@ -90,7 +90,7 @@
* the block are shadowed (storing block offset and size) and bytes 8-10 are
* not. This is because 3 bytes are not sufficient to store size and offset.
* These remaining bytes reuse the shadow of [0,7]. */
-#define LONG_BLOCK_BOUNDARY(_size) (_size - _size%LONG_BLOCK)
+#define LONG_BLOCK_BOUNDARY(_size) (_size - _size % LONG_BLOCK)
/*! \brief Primary shadow of a long block consists of a 8-byte segment + a
* remainder. For instance, a 18-byte block is represented by two 8-byte
@@ -110,22 +110,22 @@
/* Runtime assertions (debug mode) {{{ */
#ifdef E_ACSL_DEBUG
-#define DVALIDATE_ALIGNMENT(_addr) \
- DVASSERT(((uintptr_t)_addr) % HEAP_SEGMENT == 0, \
- "Heap base address %a is unaligned", _addr)
+# define DVALIDATE_ALIGNMENT(_addr) \
+ DVASSERT(((uintptr_t)_addr) % HEAP_SEGMENT == 0, \
+ "Heap base address %a is unaligned", _addr)
-#define DVALIDATE_MEMORY_PRE_MAIN_INIT \
- DVASSERT(mem_layout.is_initialized_pre_main != 0, \
- "Un-initialized pre-main shadow layout", NULL)
+# define DVALIDATE_MEMORY_PRE_MAIN_INIT \
+ DVASSERT(mem_layout.is_initialized_pre_main != 0, \
+ "Un-initialized pre-main shadow layout", NULL)
-#define DVALIDATE_MEMORY_MAIN_INIT \
- DVASSERT(mem_layout.is_initialized_main != 0, \
- "Un-initialized main shadow layout", NULL)
+# define DVALIDATE_MEMORY_MAIN_INIT \
+ DVASSERT(mem_layout.is_initialized_main != 0, \
+ "Un-initialized main shadow layout", NULL)
-#define DVALIDATE_MEMORY_INIT \
- DVASSERT(mem_layout.is_initialized_pre_main != 0 && \
- mem_layout.is_initialized_main != 0, \
- "Un-initialized shadow layout", NULL)
+# define DVALIDATE_MEMORY_INIT \
+ DVASSERT(mem_layout.is_initialized_pre_main != 0 \
+ && mem_layout.is_initialized_main != 0, \
+ "Un-initialized shadow layout", NULL)
/* Debug function making sure that the order of program segments is as expected
* and that the program and the shadow segments used do not overlap. */
@@ -133,114 +133,122 @@ void validate_shadow_layout();
/* Assert that memory layout has been initialized and all segments appear
* in the expected order */
-# define DVALIDATE_SHADOW_LAYOUT validate_shadow_layout()
+# define DVALIDATE_SHADOW_LAYOUT validate_shadow_layout()
/* Assert that boundaries of a block [_addr, _addr+_size] are within a segment
* given by `_s`. `_s` is either HEAP, STACK, TLS, GLOBAL or STATIC. */
-#define DVALIDATE_IS_ON(_addr, _size, _s) \
- DVASSERT(IS_ON_##_s(_addr), "Address %a not on %s", _addr, #_s); \
- DVASSERT(IS_ON_##_s(_addr+_size), "Address %a not on %s", _addr+_size, #_s)
+# define DVALIDATE_IS_ON(_addr, _size, _s) \
+ DVASSERT(IS_ON_##_s(_addr), "Address %a not on %s", _addr, #_s); \
+ DVASSERT(IS_ON_##_s(_addr + _size), "Address %a not on %s", _addr + _size, \
+ #_s)
/* Assert that [_addr, _addr+_size] are within heap segment */
-#define DVALIDATE_IS_ON_HEAP(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, HEAP)
+# define DVALIDATE_IS_ON_HEAP(_addr, _size) DVALIDATE_IS_ON(_addr, _size, HEAP)
/* Assert that [_addr, _addr+_size] are within stack segment */
-#define DVALIDATE_IS_ON_STACK(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, STACK)
-#if E_ACSL_OS_IS_LINUX
+# define DVALIDATE_IS_ON_STACK(_addr, _size) \
+ DVALIDATE_IS_ON(_addr, _size, STACK)
+# if E_ACSL_OS_IS_LINUX
/* Assert that [_addr, _addr+_size] are within global segment */
-# define DVALIDATE_IS_ON_GLOBAL(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, GLOBAL)
+# define DVALIDATE_IS_ON_GLOBAL(_addr, _size) \
+ DVALIDATE_IS_ON(_addr, _size, GLOBAL)
/* Assert that [_addr, _addr+_size] are within TLS segment */
-# define DVALIDATE_IS_ON_TLS(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, TLS)
-#elif E_ACSL_OS_IS_WINDOWS
+# define DVALIDATE_IS_ON_TLS(_addr, _size) DVALIDATE_IS_ON(_addr, _size, TLS)
+# elif E_ACSL_OS_IS_WINDOWS
/* Assert that [_addr, _addr+_size] are within text segment */
-# define DVALIDATE_IS_ON_TEXT(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, TEXT)
+# define DVALIDATE_IS_ON_TEXT(_addr, _size) \
+ DVALIDATE_IS_ON(_addr, _size, TEXT)
/* Assert that [_addr, _addr+_size] are within bss segment */
-# define DVALIDATE_IS_ON_BSS(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, BSS)
+# define DVALIDATE_IS_ON_BSS(_addr, _size) DVALIDATE_IS_ON(_addr, _size, BSS)
/* Assert that [_addr, _addr+_size] are within idata segment */
-# define DVALIDATE_IS_ON_IDATA(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, IDATA)
-#endif
+# define DVALIDATE_IS_ON_IDATA(_addr, _size) \
+ DVALIDATE_IS_ON(_addr, _size, IDATA)
+# endif
/* Assert that [_addr, _addr+_size] are within stack, global or TLS segments */
-#define DVALIDATE_IS_ON_STATIC(_addr, _size) \
- DVALIDATE_IS_ON(_addr, _size, STATIC)
+# define DVALIDATE_IS_ON_STATIC(_addr, _size) \
+ DVALIDATE_IS_ON(_addr, _size, STATIC)
/* Assert that `_addr` is on heap and it is the base address of an allocated
* heap memory block */
-#define DVALIDATE_FREEABLE(_addr) \
- DVASSERT(IS_ON_HEAP(_addr), "Expected heap location: %a\n", _addr); \
- DVASSERT(_addr == _base_addr(_addr), \
- "Expected base address, i.e., %a, not %a\n", _base_addr(_addr), _addr);
+# define DVALIDATE_FREEABLE(_addr) \
+ DVASSERT(IS_ON_HEAP(_addr), "Expected heap location: %a\n", _addr); \
+ DVASSERT(_addr == _base_addr(_addr), \
+ "Expected base address, i.e., %a, not %a\n", _base_addr(_addr), \
+ _addr);
/* Assert that a memory block [_addr, _addr + _size] is allocated on a
* program's heap */
-# define DVALIDATE_HEAP_ACCESS(_addr, _size) \
- DVASSERT(IS_ON_HEAP(_addr), "Expected heap location: %a\n", _addr); \
- DVASSERT(heap_allocated((uintptr_t)_addr, _size, (uintptr_t)_addr), \
- "Operation on unallocated heap block [%a + %lu]\n", _addr, _size)
+# define DVALIDATE_HEAP_ACCESS(_addr, _size) \
+ DVASSERT(IS_ON_HEAP(_addr), "Expected heap location: %a\n", _addr); \
+ DVASSERT(heap_allocated((uintptr_t)_addr, _size, (uintptr_t)_addr), \
+ "Operation on unallocated heap block [%a + %lu]\n", _addr, _size)
/* Assert that every location belonging to the range [_addr, _addr + _size] is
* - belongs to a tracked static region (i.e., stack, TLS or global)
* - not allocated */
-# define DVALIDATE_HEAP_FREE(_addr, _size) { \
- uintptr_t i, a = (uintptr_t)_addr; \
- for (i = 0; i < _size; i++) { \
- DVASSERT(IS_ON_HEAP(a + i), "Expected heap location: %a\n", a + i); \
- DVASSERT(!heap_allocated(a + i, 1, a + i), \
- "Expected heap unallocated location: [%a + %lu]\n", a, i); \
- } \
-}
+# define DVALIDATE_HEAP_FREE(_addr, _size) \
+ { \
+ uintptr_t i, a = (uintptr_t)_addr; \
+ for (i = 0; i < _size; i++) { \
+ DVASSERT(IS_ON_HEAP(a + i), "Expected heap location: %a\n", a + i); \
+ DVASSERT(!heap_allocated(a + i, 1, a + i), \
+ "Expected heap unallocated location: [%a + %lu]\n", a, i); \
+ } \
+ }
/* Assert that memory block [_addr, _addr + _size] is allocated on stack, TLS
* or globally */
-# define DVALIDATE_STATIC_ACCESS(_addr, _size) \
- DVASSERT(IS_ON_STATIC(_addr), \
- "Expected static location: [%a + %lu], \n", _addr, _size); \
- DVASSERT(static_allocated((uintptr_t)_addr, _size,(uintptr_t)_addr), \
- "Operation on unallocated static block [%a + %lu]\n", _addr, _size)
+# define DVALIDATE_STATIC_ACCESS(_addr, _size) \
+ DVASSERT(IS_ON_STATIC(_addr), "Expected static location: [%a + %lu], \n", \
+ _addr, _size); \
+ DVASSERT(static_allocated((uintptr_t)_addr, _size, (uintptr_t)_addr), \
+ "Operation on unallocated static block [%a + %lu]\n", _addr, \
+ _size)
/* Same as ::DVALIDATE_STATIC_LOCATION but for a single memory location */
-# define DVALIDATE_STATIC_LOCATION(_addr) \
- DVASSERT(IS_ON_STATIC(_addr), \
- "Expected static location: %a\n", _addr); \
- DVASSERT(static_allocated_one((uintptr_t)_addr), \
- "Operation on unallocated static block [%a]\n", _addr)
+# define DVALIDATE_STATIC_LOCATION(_addr) \
+ DVASSERT(IS_ON_STATIC(_addr), "Expected static location: %a\n", _addr); \
+ DVASSERT(static_allocated_one((uintptr_t)_addr), \
+ "Operation on unallocated static block [%a]\n", _addr)
/* Assert that every location belonging to the range [_addr, _addr + _size] is
* - belongs to a tracked static region (i.e., stack, TLS or global)
* - not allocated */
-# define DVALIDATE_STATIC_FREE(_addr, _size) { \
- uintptr_t i, a = (uintptr_t)_addr; \
- for (i = 0; i < _size; i++) { \
- DVASSERT(IS_ON_STATIC(a + i), \
- "Expected static location in freea: %a\n", a + i); \
- DVASSERT(!static_allocated_one(a + i), \
- "Expected static unallocated location in freea: [%a + %lu]\n", a, i); \
- } \
-}
+# define DVALIDATE_STATIC_FREE(_addr, _size) \
+ { \
+ uintptr_t i, a = (uintptr_t)_addr; \
+ for (i = 0; i < _size; i++) { \
+ DVASSERT(IS_ON_STATIC(a + i), \
+ "Expected static location in freea: %a\n", a + i); \
+ DVASSERT( \
+ !static_allocated_one(a + i), \
+ "Expected static unallocated location in freea: [%a + %lu]\n", a, \
+ i); \
+ } \
+ }
/* Assert that neither of `_len - 1` addresses immediately preceding `_addr`
* are base addresses of some other block and that `_len` addresses past
* `_addr` are free */
-#define DVALIDATE_STATIC_SUFFICIENTLY_ALIGNED(_addr, _len) { \
- int _i; \
- for (_i = 0; _i < _len; _i++) { \
- uintptr_t _prev = _addr - _i; \
- if (static_allocated_one(_prev)) { \
- private_assert(_base_addr(_prev) != _prev, \
- "Potential backward overlap of: \n previous block [%a]\n" \
- " with allocated block [%a]\n", _prev, _addr); \
- } \
- uintptr_t _next = _addr + _i; \
- private_assert(!static_allocated_one(_next), \
- "Potential forward overlap of:\n following block location [%a]\n" \
- " with allocated block [%a]\n", _next, _addr); \
- } \
-}
+# define DVALIDATE_STATIC_SUFFICIENTLY_ALIGNED(_addr, _len) \
+ { \
+ int _i; \
+ for (_i = 0; _i < _len; _i++) { \
+ uintptr_t _prev = _addr - _i; \
+ if (static_allocated_one(_prev)) { \
+ private_assert( \
+ _base_addr(_prev) != _prev, \
+ "Potential backward overlap of: \n previous block [%a]\n" \
+ " with allocated block [%a]\n", \
+ _prev, _addr); \
+ } \
+ uintptr_t _next = _addr + _i; \
+ private_assert( \
+ !static_allocated_one(_next), \
+ "Potential forward overlap of:\n following block location [%a]\n" \
+ " with allocated block [%a]\n", \
+ _next, _addr); \
+ } \
+ }
#else
/*! \cond exclude from doxygen */
@@ -256,8 +264,8 @@ void validate_shadow_layout();
# define DVALIDATE_IS_ON_HEAP
# define DVALIDATE_IS_ON_STACK
# if E_ACSL_OS_IS_LINUX
-# define DVALIDATE_IS_ON_GLOBAL
-# define DVALIDATE_IS_ON_TLS
+# define DVALIDATE_IS_ON_GLOBAL
+# define DVALIDATE_IS_ON_TLS
# elif E_ACSL_OS_IS_WINDOWS
# define DVALIDATE_IS_ON_TEXT
# define DVALIDATE_IS_ON_BSS
@@ -277,19 +285,18 @@ void validate_shadow_layout();
/*! \brief Quick test to check if a static location belongs to allocation.
* This macro really belongs where static_allocated is defined, but
* since it is used across this whole file it needs to be defined here. */
-#define static_allocated_one(_addr) \
- (*((unsigned char*)PRIMARY_SHADOW(_addr)))
+#define static_allocated_one(_addr) (*((unsigned char *)PRIMARY_SHADOW(_addr)))
/*! \brief Shortcut for executing statements based on the segment a given
* address belongs to.
* \param intptr_t _addr - a memory address
* \param code_block _heap_stmt - code executed if `_addr` is a heap address
* \param code_block _static_stmt - code executed if `_addr` is a static address */
-#define TRY_SEGMENT_WEAK(_addr, _heap_stmt, _static_stmt) \
- if (IS_ON_HEAP(_addr)) { \
- _heap_stmt; \
- } else if (IS_ON_STATIC(_addr)) { \
- _static_stmt; \
+#define TRY_SEGMENT_WEAK(_addr, _heap_stmt, _static_stmt) \
+ if (IS_ON_HEAP(_addr)) { \
+ _heap_stmt; \
+ } else if (IS_ON_STATIC(_addr)) { \
+ _static_stmt; \
}
/*! \brief Same as TRY_SEGMENT but performs additional checks aborting the
@@ -299,12 +306,13 @@ void validate_shadow_layout();
*
* The \b WEAK notion refers to the behaviour where no action is performed if
* the given address does not belong to any of the known segments. */
-#define TRY_SEGMENT(_addr, _heap_stmt, _static_stmt) { \
- TRY_SEGMENT_WEAK(_addr, _heap_stmt, _static_stmt) \
- else { \
- private_assert(0, "Use of invalid address %a in %s\n", _addr, __func__); \
- } \
-}
+#define TRY_SEGMENT(_addr, _heap_stmt, _static_stmt) \
+ { \
+ TRY_SEGMENT_WEAK(_addr, _heap_stmt, _static_stmt) \
+ else { \
+ private_assert(0, "Use of invalid address %a in %s\n", _addr, __func__); \
+ } \
+ }
/*! \brief Wrapper around ::heap_info and ::static_info functions that
* dispatches one of the above functions based on the type of supplied memory
@@ -344,8 +352,8 @@ void shadow_freea(void *ptr);
* relies on the fact that a single block cannot contain read/write and
* read-only parts, that is to check whether the block has read-only access it
* is sufficient to check any of its bytes. */
-#define global_readonly(_addr) \
- checkbit(READONLY_BIT, (*(char*)PRIMARY_GLOBAL_SHADOW(_addr)))
+#define global_readonly(_addr) \
+ checkbit(READONLY_BIT, (*(char *)PRIMARY_GLOBAL_SHADOW(_addr)))
/*! \brief Return a non-zero value if a memory region of length `size`
* starting at address `addr` belongs to a tracked stack, tls or
@@ -382,13 +390,15 @@ uintptr_t static_info(uintptr_t addr, char type);
* associated with a static address `addr` */
uint32_t static_temporal_info(uintptr_t addr, int origin);
-#define static_origin_timestamp(_ptr) static_temporal_info((uintptr_t)(_ptr),1)
-#define static_referent_timestamp(_ptr) static_temporal_info((uintptr_t)(_ptr),0)
+# define static_origin_timestamp(_ptr) \
+ static_temporal_info((uintptr_t)(_ptr), 1)
+# define static_referent_timestamp(_ptr) \
+ static_temporal_info((uintptr_t)(_ptr), 0)
/*! Store a referent time stamp associated with a static pointer.
* Origin timestamps are generated via `shadow_alloca` */
void static_store_temporal_referent(uintptr_t addr, uint32_t ref);
-#endif/*}}} E_ACSL_TEMPORAL*/
+#endif /*}}} E_ACSL_TEMPORAL*/
/* }}} */
/* Static initialization {{{ */
@@ -404,7 +414,7 @@ void initialize_static_region(uintptr_t addr, long size);
* The functionality, however is preferred to be kept separate
* because the ::eacsl_mark_readonly should operate only on the global shadow.
*/
-void mark_readonly_region (uintptr_t addr, long size);
+void mark_readonly_region(uintptr_t addr, long size);
/* }}} */
/* Heap allocation {{{ (malloc/calloc) */
@@ -458,11 +468,11 @@ int heap_initialized(uintptr_t addr, long len);
#ifdef E_ACSL_TEMPORAL
uint32_t heap_temporal_info(uintptr_t addr, int origin);
-#define heap_origin_timestamp(_ptr) heap_temporal_info((uintptr_t)(_ptr),1)
-#define heap_referent_timestamp(_ptr) heap_temporal_info((uintptr_t)(_ptr),0)
+# define heap_origin_timestamp(_ptr) heap_temporal_info((uintptr_t)(_ptr), 1)
+# define heap_referent_timestamp(_ptr) heap_temporal_info((uintptr_t)(_ptr), 0)
void heap_store_temporal_referent(uintptr_t addr, uint32_t ref);
-#endif/*}}} E_ACSL_TEMPORAL*/
+#endif /*}}} E_ACSL_TEMPORAL*/
/* Heap initialization {{{ */
/*! \brief Mark n bytes on the heap starting from address addr as initialized */
@@ -493,7 +503,7 @@ void print_memory_partition(struct memory_partition *p);
void print_shadow_layout();
/*! \brief Output the shadow segment the address belongs to */
-const char* which_segment(uintptr_t addr);
+const char *which_segment(uintptr_t addr);
/* NOTE: Above functions are designed to be used only through the following
* macros or debug functions included/defined based on the value of the
@@ -502,28 +512,32 @@ const char* which_segment(uintptr_t addr);
/*! \brief Print program layout. This function outputs start/end addresses of
* various program segments, their shadow counterparts and sizes of shadow
* regions used. */
-#define DEBUG_PRINT_LAYOUT print_shadow_layout()
-void ___e_acsl_debug_print_layout() { DEBUG_PRINT_LAYOUT; }
+# define DEBUG_PRINT_LAYOUT print_shadow_layout()
+void ___e_acsl_debug_print_layout() {
+ DEBUG_PRINT_LAYOUT;
+}
/*! \brief Print the shadow segment address addr belongs to */
-#define DEBUG_PRINT_SEGMENT(_addr) which_segment(_addr)
-void ___e_acsl_debug_print_segment(uintptr_t addr) { DEBUG_PRINT_SEGMENT(addr); }
+# define DEBUG_PRINT_SEGMENT(_addr) which_segment(_addr)
+void ___e_acsl_debug_print_segment(uintptr_t addr) {
+ DEBUG_PRINT_SEGMENT(addr);
+}
/*! \brief Print human-readable representation of a shadow region corresponding
* to a memory address addr. The second argument (size) if the size of the
* shadow region to be printed. Normally addr argument is a base address of a
* memory block and size is its length. */
-#define DEBUG_PRINT_SHADOW(addr, size) \
- print_shadows((uintptr_t)addr, (size_t)size)
+# define DEBUG_PRINT_SHADOW(addr, size) \
+ print_shadows((uintptr_t)addr, (size_t)size)
void ___e_acsl_debug_print_shadow(uintptr_t addr, size_t size) {
DEBUG_PRINT_SHADOW(addr, size);
}
#else
/* \cond exclude from doxygen */
-#define DEBUG_PRINT_SHADOW(addr, size)
-#define DEBUG_PRINT_LAYOUT
-#define DEBUG_PRINT_SEGMENT(addr)
+# define DEBUG_PRINT_SHADOW(addr, size)
+# define DEBUG_PRINT_LAYOUT
+# define DEBUG_PRINT_SEGMENT(addr)
/* \endcond */
#endif
/* }}} */
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.c b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.c
index de441d0c8c1bd0de59c6609ad8e8070a15093fb8..e37c4ad740aa884609476b7fcb18b40006045860 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.c
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.c
@@ -23,14 +23,14 @@
#include <errno.h>
#include <stddef.h>
-#include "../../internals/e_acsl_private_assert.h"
#include "../../internals/e_acsl_malloc.h"
+#include "../../internals/e_acsl_private_assert.h"
#include "e_acsl_shadow_layout.h"
#if E_ACSL_OS_IS_LINUX
-#include <sys/resource.h>
+# include <sys/resource.h>
/** Program stack information {{{ */
@@ -51,7 +51,8 @@ size_t increase_stack_limit(const size_t size) {
int result = getrlimit(RLIMIT_STACK, &rl);
if (result == 0) {
if (rl.rlim_cur < stacksz) {
- if (stacksz>rl.rlim_max) stacksz = rl.rlim_max;
+ if (stacksz > rl.rlim_max)
+ stacksz = rl.rlim_max;
rl.rlim_cur = stacksz;
result = setrlimit(RLIMIT_STACK, &rl);
if (result != 0) {
@@ -69,19 +70,18 @@ size_t increase_stack_limit(const size_t size) {
size_t get_stack_size() {
struct rlimit rlim;
private_assert(!getrlimit(RLIMIT_STACK, &rlim),
- "Cannot detect program's stack size", NULL);
+ "Cannot detect program's stack size", NULL);
return rlim.rlim_cur;
}
-
-extern char ** environ;
+extern char **environ;
/*! \brief Return the greatest (known) address on a program's stack.
* This function presently determines the address using the address of the
* last string in `environ`. That is, it assumes that argc and argv are
* stored below environ, which holds for GCC or Clang and Glibc but is not
* necessarily true for some other compilers/libraries. */
-static uintptr_t get_stack_start(int *argc_ref, char *** argv_ref) {
+static uintptr_t get_stack_start(int *argc_ref, char ***argv_ref) {
char **env = environ;
while (env[1])
env++;
@@ -99,19 +99,19 @@ static uintptr_t get_stack_start(int *argc_ref, char *** argv_ref) {
// the stack holds
if (argc_ref) {
DVASSERT(stack_start <= (uintptr_t)argc_ref
- && (uintptr_t)argc_ref <= stack_end,
- "Assumption that argc is stored below environ is not verified.\n"
- "\tStack: [%a - %a]\n"
- "\t&argc: %a\n",
- stack_start, stack_end, argc_ref);
+ && (uintptr_t)argc_ref <= stack_end,
+ "Assumption that argc is stored below environ is not verified.\n"
+ "\tStack: [%a - %a]\n"
+ "\t&argc: %a\n",
+ stack_start, stack_end, argc_ref);
}
if (argv_ref) {
DVASSERT(stack_start <= (uintptr_t)argv_ref
- && (uintptr_t)argv_ref <= stack_end,
- "Assumption that argv is stored below environ is not verified.\n"
- "\tStack: [%a - %a]\n"
- "\t&argv: %a\n",
- stack_start, stack_end, argv_ref);
+ && (uintptr_t)argv_ref <= stack_end,
+ "Assumption that argv is stored below environ is not verified.\n"
+ "\tStack: [%a - %a]\n"
+ "\t&argv: %a\n",
+ stack_start, stack_end, argv_ref);
}
return stack_start;
@@ -167,24 +167,22 @@ static __thread int id_tbss;
/*! \brief Return start address of a program's TLS */
static uintptr_t get_tls_start() {
size_t tls_size = get_tls_size();
- uintptr_t data = (uintptr_t)&id_tdata,
- bss = (uintptr_t)&id_tbss;
+ uintptr_t data = (uintptr_t)&id_tdata, bss = (uintptr_t)&id_tbss;
/* It could happen that the shadow allocated before bss is too big.
Indeed allocating PGM_TLS_SIZE/2 could cause an overlap with the other
shadow segments AND heap.application (in case the latter is too big too).
In such cases, take the smallest available address (the max used +1). */
- uintptr_t tls_start_half = (data > bss ? bss : data) - tls_size/2;
- memory_partition pheap = mem_layout.heap,
- pglobal = mem_layout.global;
+ uintptr_t tls_start_half = (data > bss ? bss : data) - tls_size / 2;
+ memory_partition pheap = mem_layout.heap, pglobal = mem_layout.global;
uintptr_t max_shadow = pheap.primary.end;
- max_shadow = pheap.secondary.end > max_shadow ?
- pheap.secondary.end : max_shadow;
- max_shadow = pglobal.primary.end > max_shadow ?
- pglobal.primary.end : max_shadow;
- max_shadow = pglobal.secondary.end > max_shadow ?
- pglobal.secondary.end : max_shadow;
- max_shadow = pheap.application.end > max_shadow ?
- pheap.application.end : max_shadow;
+ max_shadow =
+ pheap.secondary.end > max_shadow ? pheap.secondary.end : max_shadow;
+ max_shadow =
+ pglobal.primary.end > max_shadow ? pglobal.primary.end : max_shadow;
+ max_shadow =
+ pglobal.secondary.end > max_shadow ? pglobal.secondary.end : max_shadow;
+ max_shadow =
+ pheap.application.end > max_shadow ? pheap.application.end : max_shadow;
/* Shadow stacks are not yet allocated at his point since
init_shadow_layout_stack is called after
init_shadow_layout_heap_global_tls (for reasons related to memory
@@ -204,46 +202,56 @@ static uintptr_t get_tls_start() {
static void init_shadow_layout_global() {
memory_partition *pglobal = &mem_layout.global;
set_application_segment(&pglobal->application, get_global_start(),
- get_global_size(), "global", NULL);
- set_shadow_segment(&pglobal->primary, &pglobal->application, 1, "global_primary");
- set_shadow_segment(&pglobal->secondary, &pglobal->application, 1, "global_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pglobal->temporal_primary, &pglobal->application, 1, "temporal_global_primary");
- set_shadow_segment(&pglobal->temporal_secondary, &pglobal->application, 1, "temporal_global_secondary");
-#endif
+ get_global_size(), "global", NULL);
+ set_shadow_segment(&pglobal->primary, &pglobal->application, 1,
+ "global_primary");
+ set_shadow_segment(&pglobal->secondary, &pglobal->application, 1,
+ "global_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&pglobal->temporal_primary, &pglobal->application, 1,
+ "temporal_global_primary");
+ set_shadow_segment(&pglobal->temporal_secondary, &pglobal->application, 1,
+ "temporal_global_secondary");
+# endif
}
static void init_shadow_layout_tls() {
memory_partition *ptls = &mem_layout.tls;
- set_application_segment(&ptls->application, get_tls_start(),
- get_tls_size(), "tls", NULL);
+ set_application_segment(&ptls->application, get_tls_start(), get_tls_size(),
+ "tls", NULL);
set_shadow_segment(&ptls->primary, &ptls->application, 1, "tls_primary");
set_shadow_segment(&ptls->secondary, &ptls->application, 1, "tls_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&ptls->temporal_primary, &ptls->application, 1, "temporal_tls_primary");
- set_shadow_segment(&ptls->temporal_secondary, &ptls->application, 1, "temporal_tls_secondary");
-#endif
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&ptls->temporal_primary, &ptls->application, 1,
+ "temporal_tls_primary");
+ set_shadow_segment(&ptls->temporal_secondary, &ptls->application, 1,
+ "temporal_tls_secondary");
+# endif
}
static void init_shadow_layout_stack(int *argc_ref, char ***argv_ref) {
memory_partition *pstack = &mem_layout.stack;
- set_application_segment(&pstack->application, get_stack_start(argc_ref, argv_ref),
- get_stack_size(), "stack", NULL);
+ set_application_segment(&pstack->application,
+ get_stack_start(argc_ref, argv_ref), get_stack_size(),
+ "stack", NULL);
/* Changes of the ratio in the following will require changes in get_tls_start */
- set_shadow_segment(&pstack->primary, &pstack->application, 1, "stack_primary");
- set_shadow_segment(&pstack->secondary, &pstack->application, 1, "stack_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pstack->temporal_primary, &pstack->application, 1, "temporal_stack_primary");
- set_shadow_segment(&pstack->temporal_secondary, &pstack->application, 1, "temporal_stack_secondary");
-#endif
+ set_shadow_segment(&pstack->primary, &pstack->application, 1,
+ "stack_primary");
+ set_shadow_segment(&pstack->secondary, &pstack->application, 1,
+ "stack_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&pstack->temporal_primary, &pstack->application, 1,
+ "temporal_stack_primary");
+ set_shadow_segment(&pstack->temporal_secondary, &pstack->application, 1,
+ "temporal_stack_secondary");
+# endif
}
/** }}} */
#elif E_ACSL_OS_IS_WINDOWS
-#include <processthreadsapi.h>
-#include <windows.h>
-#include <dbghelp.h>
-
+# include <dbghelp.h>
+# include <processthreadsapi.h>
+# include <windows.h>
/** Program segment informations {{{ */
typedef struct mem_loc_info {
@@ -251,28 +259,30 @@ typedef struct mem_loc_info {
size_t size;
} mem_loc_info_t;
-static mem_loc_info_t get_section_info(HANDLE hModule, const char * section_name) {
+static mem_loc_info_t get_section_info(HANDLE hModule,
+ const char *section_name) {
// Get the location of the module's IMAGE_NT_HEADERS structure
IMAGE_NT_HEADERS *pNtHdr = ImageNtHeader(hModule);
// Section table immediately follows the IMAGE_NT_HEADERS
IMAGE_SECTION_HEADER *pSectionHdr = (IMAGE_SECTION_HEADER *)(pNtHdr + 1);
- const char* imageBase = (const char*)hModule;
+ const char *imageBase = (const char *)hModule;
size_t scnNameSize = sizeof(pSectionHdr->Name);
char scnName[scnNameSize + 1];
// Enforce nul-termination for scn names that are the whole length of
// pSectionHdr->Name[]
scnName[scnNameSize] = '\0';
- mem_loc_info_t res = { .start = 0, .size = 0 };
+ mem_loc_info_t res = {.start = 0, .size = 0};
- for (int scn = 0; scn < pNtHdr->FileHeader.NumberOfSections; ++scn, ++pSectionHdr) {
+ for (int scn = 0; scn < pNtHdr->FileHeader.NumberOfSections;
+ ++scn, ++pSectionHdr) {
// Note: pSectionHdr->Name[] is 8-byte long. If the scn name is 8-byte
// long, ->Name[] will not be nul-terminated. For this reason, copy it to a
// local buffer that is nul-terminated to be sure we only print the real scn
// name, and no extra garbage beyond it.
- strncpy(scnName, (const char*)pSectionHdr->Name, scnNameSize);
+ strncpy(scnName, (const char *)pSectionHdr->Name, scnNameSize);
if (strcmp(scnName, section_name) == 0) {
res.start = (uintptr_t)imageBase + pSectionHdr->VirtualAddress;
@@ -290,10 +300,7 @@ static mem_loc_info_t get_stack_mem_loc_info() {
ULONG_PTR low;
ULONG_PTR high;
GetCurrentThreadStackLimits(&low, &high);
- return (mem_loc_info_t) {
- .start = low,
- .size = high - low + 1
- };
+ return (mem_loc_info_t){.start = low, .size = high - low + 1};
}
size_t increase_stack_limit(const size_t size) {
@@ -302,7 +309,7 @@ size_t increase_stack_limit(const size_t size) {
DLOG("Increasing stack size at runtime is unsupported on Windows.\n\
\t Actual stack size: %lu\n\
\tRequested stack size: %lu\n",
- actual_size, size);
+ actual_size, size);
}
return actual_size;
}
@@ -317,13 +324,17 @@ static void init_shadow_layout_stack(int *argc_ref, char ***argv_ref) {
memory_partition *pstack = &mem_layout.stack;
mem_loc_info_t stack_loc_info = get_stack_mem_loc_info();
set_application_segment(&pstack->application, stack_loc_info.start,
- stack_loc_info.size, "stack", NULL);
- set_shadow_segment(&pstack->primary, &pstack->application, 1, "stack_primary");
- set_shadow_segment(&pstack->secondary, &pstack->application, 1, "stack_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pstack->temporal_primary, &pstack->application, 1, "temporal_stack_primary");
- set_shadow_segment(&pstack->temporal_secondary, &pstack->application, 1, "temporal_stack_secondary");
-#endif
+ stack_loc_info.size, "stack", NULL);
+ set_shadow_segment(&pstack->primary, &pstack->application, 1,
+ "stack_primary");
+ set_shadow_segment(&pstack->secondary, &pstack->application, 1,
+ "stack_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&pstack->temporal_primary, &pstack->application, 1,
+ "temporal_stack_primary");
+ set_shadow_segment(&pstack->temporal_secondary, &pstack->application, 1,
+ "temporal_stack_secondary");
+# endif
}
static void init_shadow_layout_text(HMODULE module) {
@@ -331,14 +342,17 @@ static void init_shadow_layout_text(HMODULE module) {
mem_loc_info_t text = get_section_info(module, ".text");
memory_partition *ptext = &mem_layout.text;
- set_application_segment(&ptext->application, text.start,
- text.size, "text", NULL);
+ set_application_segment(&ptext->application, text.start, text.size, "text",
+ NULL);
set_shadow_segment(&ptext->primary, &ptext->application, 1, "text_primary");
- set_shadow_segment(&ptext->secondary, &ptext->application, 1, "text_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&ptext->temporal_primary, &ptext->application, 1, "temporal_text_primary");
- set_shadow_segment(&ptext->temporal_secondary, &ptext->application, 1, "temporal_text_secondary");
-#endif
+ set_shadow_segment(&ptext->secondary, &ptext->application, 1,
+ "text_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&ptext->temporal_primary, &ptext->application, 1,
+ "temporal_text_primary");
+ set_shadow_segment(&ptext->temporal_secondary, &ptext->application, 1,
+ "temporal_text_secondary");
+# endif
}
static void init_shadow_layout_bss(HMODULE module) {
@@ -349,10 +363,12 @@ static void init_shadow_layout_bss(HMODULE module) {
set_application_segment(&pbss->application, bss.start, bss.size, "bss", NULL);
set_shadow_segment(&pbss->primary, &pbss->application, 1, "bss_primary");
set_shadow_segment(&pbss->secondary, &pbss->application, 1, "bss_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pbss->temporal_primary, &pbss->application, 1, "temporal_bss_primary");
- set_shadow_segment(&pbss->temporal_secondary, &pbss->application, 1, "temporal_bss_secondary");
-#endif
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&pbss->temporal_primary, &pbss->application, 1,
+ "temporal_bss_primary");
+ set_shadow_segment(&pbss->temporal_secondary, &pbss->application, 1,
+ "temporal_bss_secondary");
+# endif
}
static void init_shadow_layout_data(HMODULE module) {
@@ -360,13 +376,17 @@ static void init_shadow_layout_data(HMODULE module) {
mem_loc_info_t data = get_section_info(module, ".data");
memory_partition *pdata = &mem_layout.data;
- set_application_segment(&pdata->application, data.start, data.size, "data", NULL);
+ set_application_segment(&pdata->application, data.start, data.size, "data",
+ NULL);
set_shadow_segment(&pdata->primary, &pdata->application, 1, "data_primary");
- set_shadow_segment(&pdata->secondary, &pdata->application, 1, "data_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pdata->temporal_primary, &pdata->application, 1, "temporal_data_primary");
- set_shadow_segment(&pdata->temporal_secondary, &pdata->application, 1, "temporal_data_secondary");
-#endif
+ set_shadow_segment(&pdata->secondary, &pdata->application, 1,
+ "data_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&pdata->temporal_primary, &pdata->application, 1,
+ "temporal_data_primary");
+ set_shadow_segment(&pdata->temporal_secondary, &pdata->application, 1,
+ "temporal_data_secondary");
+# endif
}
static void init_shadow_layout_idata(HMODULE module) {
@@ -374,13 +394,18 @@ static void init_shadow_layout_idata(HMODULE module) {
mem_loc_info_t idata = get_section_info(module, ".idata");
memory_partition *pidata = &mem_layout.idata;
- set_application_segment(&pidata->application, idata.start, idata.size, "idata", NULL);
- set_shadow_segment(&pidata->primary, &pidata->application, 1, "idata_primary");
- set_shadow_segment(&pidata->secondary, &pidata->application, 1, "idata_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pidata->temporal_primary, &pidata->application, 1, "temporal_idata_primary");
- set_shadow_segment(&pidata->temporal_secondary, &pidata->application, 1, "temporal_idata_secondary");
-#endif
+ set_application_segment(&pidata->application, idata.start, idata.size,
+ "idata", NULL);
+ set_shadow_segment(&pidata->primary, &pidata->application, 1,
+ "idata_primary");
+ set_shadow_segment(&pidata->secondary, &pidata->application, 1,
+ "idata_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&pidata->temporal_primary, &pidata->application, 1,
+ "temporal_idata_primary");
+ set_shadow_segment(&pidata->temporal_secondary, &pidata->application, 1,
+ "temporal_idata_secondary");
+# endif
}
static void init_shadow_layout_rdata(HMODULE module) {
@@ -388,13 +413,18 @@ static void init_shadow_layout_rdata(HMODULE module) {
mem_loc_info_t rdata = get_section_info(module, ".rdata");
memory_partition *prdata = &mem_layout.rdata;
- set_application_segment(&prdata->application, rdata.start, rdata.size, "rdata", NULL);
- set_shadow_segment(&prdata->primary, &prdata->application, 1, "rdata_primary");
- set_shadow_segment(&prdata->secondary, &prdata->application, 1, "rdata_secondary");
-#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&prdata->temporal_primary, &prdata->application, 1, "temporal_rdata_primary");
- set_shadow_segment(&prdata->temporal_secondary, &prdata->application, 1, "temporal_rdata_secondary");
-#endif
+ set_application_segment(&prdata->application, rdata.start, rdata.size,
+ "rdata", NULL);
+ set_shadow_segment(&prdata->primary, &prdata->application, 1,
+ "rdata_primary");
+ set_shadow_segment(&prdata->secondary, &prdata->application, 1,
+ "rdata_secondary");
+# ifdef E_ACSL_TEMPORAL
+ set_shadow_segment(&prdata->temporal_primary, &prdata->application, 1,
+ "temporal_rdata_primary");
+ set_shadow_segment(&prdata->temporal_secondary, &prdata->application, 1,
+ "temporal_rdata_secondary");
+# endif
}
/** }}} */
#endif
@@ -409,26 +439,29 @@ size_t get_heap_size() {
}
static size_t get_heap_init_size() {
- return get_heap_size()/8;
+ return get_heap_size() / 8;
}
static void init_shadow_layout_heap() {
memory_partition *pheap = &mem_layout.heap;
set_application_segment(&pheap->application, get_heap_start(),
- get_heap_size(), "heap", mem_spaces.heap_mspace);
+ get_heap_size(), "heap", mem_spaces.heap_mspace);
set_shadow_segment(&pheap->primary, &pheap->application, 1, "heap_primary");
- set_shadow_segment(&pheap->secondary, &pheap->application, 8, "heap_secondary");
+ set_shadow_segment(&pheap->secondary, &pheap->application, 8,
+ "heap_secondary");
#ifdef E_ACSL_TEMPORAL
- set_shadow_segment(&pheap->temporal_primary, &pheap->application, 1, "temporal_heap_primary");
- set_shadow_segment(&pheap->temporal_secondary, &pheap->application, 1, "temporal_heap_secondary");
+ set_shadow_segment(&pheap->temporal_primary, &pheap->application, 1,
+ "temporal_heap_primary");
+ set_shadow_segment(&pheap->temporal_secondary, &pheap->application, 1,
+ "temporal_heap_secondary");
#endif
}
/** }}} */
/** Shadow Layout {{{ */
-void set_application_segment(memory_segment *seg, uintptr_t start,
- size_t size, const char *name, mspace msp) {
+void set_application_segment(memory_segment *seg, uintptr_t start, size_t size,
+ const char *name, mspace msp) {
seg->name = name;
seg->start = start;
seg->size = size;
@@ -440,13 +473,13 @@ void set_application_segment(memory_segment *seg, uintptr_t start,
}
void set_shadow_segment(memory_segment *seg, memory_segment *parent,
- size_t ratio, const char *name) {
+ size_t ratio, const char *name) {
seg->parent = parent;
seg->name = name;
seg->shadow_ratio = ratio;
- seg->size = parent->size/seg->shadow_ratio;
+ seg->size = parent->size / seg->shadow_ratio;
seg->mspace = eacsl_create_mspace(seg->size + SHADOW_SEGMENT_PADDING, 0);
- seg->start = (uintptr_t)eacsl_mspace_malloc(seg->mspace,1);
+ seg->start = (uintptr_t)eacsl_mspace_malloc(seg->mspace, 1);
seg->end = seg->start + seg->size - 1;
seg->shadow_offset = parent->start - seg->start;
}
@@ -469,7 +502,7 @@ void init_shadow_layout_pre_main() {
mem_layout.is_initialized_pre_main = 1;
}
-void init_shadow_layout_main(int *argc_ref, char *** argv_ref) {
+void init_shadow_layout_main(int *argc_ref, char ***argv_ref) {
init_shadow_layout_stack(argc_ref, argv_ref);
mem_layout.is_initialized_main = 1;
@@ -478,7 +511,7 @@ void init_shadow_layout_main(int *argc_ref, char *** argv_ref) {
void clean_shadow_layout() {
if (mem_layout.is_initialized_pre_main && mem_layout.is_initialized_main) {
int i;
- for (i = 0; i < sizeof(mem_partitions)/sizeof(memory_partition*); i++) {
+ for (i = 0; i < sizeof(mem_partitions) / sizeof(memory_partition *); i++) {
if (mem_partitions[i]->primary.mspace)
eacsl_destroy_mspace(mem_partitions[i]->primary.mspace);
if (mem_partitions[i]->secondary.mspace)
diff --git a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.h b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.h
index f5e0bb82127784d3a789abcb8254f209b5c4815b..93de48c4ad3b99bcc137ca40ccaa3c76fb620bb4 100644
--- a/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.h
+++ b/src/plugins/e-acsl/share/e-acsl/observation_model/segment_model/e_acsl_shadow_layout.h
@@ -36,19 +36,19 @@
/* Default size of a program's heap tracked via shadow memory */
#ifndef E_ACSL_HEAP_SIZE
-#define E_ACSL_HEAP_SIZE 512
+# define E_ACSL_HEAP_SIZE 512
#endif
/* Default size of a program's stack tracked via shadow memory */
#ifndef E_ACSL_STACK_SIZE
-#define E_ACSL_STACK_SIZE 64
+# define E_ACSL_STACK_SIZE 64
#endif
/* MAP_ANONYMOUS is a mmap flag indicating that the contents of allocated blocks
* should be nullified. Set value from <bits/mman-linux.h>, if MAP_ANONYMOUS is
* undefined */
#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS 0x20
+# define MAP_ANONYMOUS 0x20
#endif
/* \endcond */
@@ -72,14 +72,14 @@
it may occur that the given size is not enough,
in which case it MUST be increased. */
#ifndef PGM_TLS_SIZE
-#define PGM_TLS_SIZE (64 * MB)
+# define PGM_TLS_SIZE (64 * MB)
#endif
/*! \brief Mspace padding used by shadow segments. This is to make sure that
* some allocation which exceeds the size of an initial memspace does not
* move the mspace somewhere else. 512KB is a bit of an overkill, but should
* not hurt too much in general unless memory space is really a constraint */
-#define SHADOW_SEGMENT_PADDING (512*KB)
+#define SHADOW_SEGMENT_PADDING (512 * KB)
/* }}} */
/** Program stack information {{{ */
@@ -151,13 +151,13 @@ NOTE: Above memory layout scheme generally applies to Linux Kernel/gcc/glibc.
* used to track them. */
struct memory_segment {
const char *name; //!< Symbolic name
- size_t size; //!< Byte-size
- uintptr_t start; //!< Least address
- uintptr_t end; //!< Greatest address
- mspace mspace; // !< Mspace used for the partition
+ size_t size; //!< Byte-size
+ uintptr_t start; //!< Least address
+ uintptr_t end; //!< Greatest address
+ mspace mspace; // !< Mspace used for the partition
/* The following are only set if the segment is a shadow segment */
struct memory_segment *parent; //!< Pointer to the tracked segment
- size_t shadow_ratio; //!< Ratio of shadow to application memory
+ size_t shadow_ratio; //!< Ratio of shadow to application memory
/*!< Offset between the start of the tracked segment and the start of this
segment */
intptr_t shadow_offset;
@@ -169,10 +169,10 @@ typedef struct memory_segment memory_segment;
* shadow spaces. */
struct memory_partition {
memory_segment application; /* Application memory segment */
- memory_segment primary; /* Primary shadow segment */
- memory_segment secondary; /* Secondary shadow segment */
+ memory_segment primary; /* Primary shadow segment */
+ memory_segment secondary; /* Secondary shadow segment */
#ifdef E_ACSL_TEMPORAL
- memory_segment temporal_primary; /* Primary temporal shadow segment */
+ memory_segment temporal_primary; /* Primary temporal shadow segment */
memory_segment temporal_secondary; /* Secondary temporal shadow segment */
#endif
};
@@ -208,23 +208,20 @@ struct memory_layout {
/*! \brief Full program memory layout. */
struct memory_layout mem_layout = {
- .is_initialized_pre_main = 0,
- .is_initialized_main = 0,
+ .is_initialized_pre_main = 0,
+ .is_initialized_main = 0,
};
/*! \brief Array of used partitions */
-memory_partition *mem_partitions [] = {
- &mem_layout.heap,
- &mem_layout.stack,
+memory_partition *mem_partitions[] = {
+ &mem_layout.heap,
+ &mem_layout.stack,
#if E_ACSL_OS_IS_LINUX
- &mem_layout.global,
- &mem_layout.tls,
+ &mem_layout.global,
+ &mem_layout.tls,
#elif E_ACSL_OS_IS_WINDOWS
- &mem_layout.text,
- &mem_layout.bss,
- &mem_layout.data,
- &mem_layout.idata,
- &mem_layout.rdata,
+ &mem_layout.text, &mem_layout.bss, &mem_layout.data,
+ &mem_layout.idata, &mem_layout.rdata,
#endif
};
@@ -235,8 +232,8 @@ memory_partition *mem_partitions [] = {
* \param size - size in bytes
* \param name - segment name
* \param msp - mspace used for this segment (defined only for heap) */
-void set_application_segment(memory_segment *seg, uintptr_t start,
- size_t size, const char *name, mspace msp);
+void set_application_segment(memory_segment *seg, uintptr_t start, size_t size,
+ const char *name, mspace msp);
/*! \brief Set a shadow memory segment
*
@@ -246,7 +243,7 @@ void set_application_segment(memory_segment *seg, uintptr_t start,
* \param name - symbolic name of the segment
*/
void set_shadow_segment(memory_segment *seg, memory_segment *parent,
- size_t ratio, const char *name);
+ size_t ratio, const char *name);
/*! \brief Initialize memory layout, i.e., determine bounds of program segments,
* allocate shadow memory spaces and compute offsets. This function populates
@@ -285,32 +282,32 @@ void clean_shadow_layout();
* are given by following macros.
*/
-#define heap_primary_offset mem_layout.heap.primary.shadow_offset
-#define heap_secondary_offset mem_layout.heap.secondary.shadow_offset
-#define stack_primary_offset mem_layout.stack.primary.shadow_offset
-#define stack_secondary_offset mem_layout.stack.secondary.shadow_offset
+#define heap_primary_offset mem_layout.heap.primary.shadow_offset
+#define heap_secondary_offset mem_layout.heap.secondary.shadow_offset
+#define stack_primary_offset mem_layout.stack.primary.shadow_offset
+#define stack_secondary_offset mem_layout.stack.secondary.shadow_offset
#if E_ACSL_OS_IS_LINUX
-# define global_primary_offset mem_layout.global.primary.shadow_offset
-# define global_secondary_offset mem_layout.global.secondary.shadow_offset
-# define tls_primary_offset mem_layout.tls.primary.shadow_offset
-# define tls_secondary_offset mem_layout.tls.secondary.shadow_offset
+# define global_primary_offset mem_layout.global.primary.shadow_offset
+# define global_secondary_offset mem_layout.global.secondary.shadow_offset
+# define tls_primary_offset mem_layout.tls.primary.shadow_offset
+# define tls_secondary_offset mem_layout.tls.secondary.shadow_offset
#elif E_ACSL_OS_IS_WINDOWS
-# define text_primary_offset mem_layout.text.primary.shadow_offset
-# define text_secondary_offset mem_layout.text.secondary.shadow_offset
-# define bss_primary_offset mem_layout.bss.primary.shadow_offset
-# define bss_secondary_offset mem_layout.bss.secondary.shadow_offset
-# define data_primary_offset mem_layout.data.primary.shadow_offset
-# define data_secondary_offset mem_layout.data.secondary.shadow_offset
-# define idata_primary_offset mem_layout.idata.primary.shadow_offset
-# define idata_secondary_offset mem_layout.idata.secondary.shadow_offset
-# define rdata_primary_offset mem_layout.rdata.primary.shadow_offset
-# define rdata_secondary_offset mem_layout.rdata.secondary.shadow_offset
+# define text_primary_offset mem_layout.text.primary.shadow_offset
+# define text_secondary_offset mem_layout.text.secondary.shadow_offset
+# define bss_primary_offset mem_layout.bss.primary.shadow_offset
+# define bss_secondary_offset mem_layout.bss.secondary.shadow_offset
+# define data_primary_offset mem_layout.data.primary.shadow_offset
+# define data_secondary_offset mem_layout.data.secondary.shadow_offset
+# define idata_primary_offset mem_layout.idata.primary.shadow_offset
+# define idata_secondary_offset mem_layout.idata.secondary.shadow_offset
+# define rdata_primary_offset mem_layout.rdata.primary.shadow_offset
+# define rdata_secondary_offset mem_layout.rdata.secondary.shadow_offset
#endif
/*! \brief Compute a shadow address using displacement offset
* @param _addr - an application space address
* @param _offset - a shadow displacement offset */
-#define SHADOW_ACCESS(_addr,_offset) \
+#define SHADOW_ACCESS(_addr, _offset) \
((intptr_t)((intptr_t)_addr - (intptr_t)_offset))
/*! \brief Same as SHADOW_ACCESS but with an additional scale factor given via
@@ -318,87 +315,76 @@ void clean_shadow_layout();
* for instance if one bit shadow memory is used to track one byte of
* application memory then the scale factor is 8.
* Here, scale factor is the ration of application to shadow memory. */
-#define SCALED_SHADOW_ACCESS(_addr, _start, _offset, _scale) \
- (((uintptr_t)_start - _offset) + \
- ((uintptr_t)_addr - (uintptr_t)_start)/_scale)
+#define SCALED_SHADOW_ACCESS(_addr, _start, _offset, _scale) \
+ (((uintptr_t)_start - _offset) \
+ + ((uintptr_t)_addr - (uintptr_t)_start) / _scale)
/*! \brief Convert a heap address into its shadow counterpart */
-#define HEAP_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, heap_primary_offset)
+#define HEAP_SHADOW(_addr) SHADOW_ACCESS(_addr, heap_primary_offset)
/*! \brief Convert a heap address into its init shadow counterpart */
-#define HEAP_INIT_SHADOW(_addr) \
- SCALED_SHADOW_ACCESS(_addr, \
- mem_layout.heap.application.start, \
- mem_layout.heap.secondary.shadow_offset, \
- mem_layout.heap.secondary.shadow_ratio)
+#define HEAP_INIT_SHADOW(_addr) \
+ SCALED_SHADOW_ACCESS(_addr, mem_layout.heap.application.start, \
+ mem_layout.heap.secondary.shadow_offset, \
+ mem_layout.heap.secondary.shadow_ratio)
#define HEAP_START mem_layout.heap.application.start
/*! \brief Convert a stack address into its primary shadow counterpart */
-#define PRIMARY_STACK_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, stack_primary_offset)
+#define PRIMARY_STACK_SHADOW(_addr) SHADOW_ACCESS(_addr, stack_primary_offset)
/*! \brief Convert a stack address into its secondary shadow counterpart */
-#define SECONDARY_STACK_SHADOW(_addr) \
+#define SECONDARY_STACK_SHADOW(_addr) \
SHADOW_ACCESS(_addr, stack_secondary_offset)
#if E_ACSL_OS_IS_LINUX
/*! \brief Convert a global address into its primary shadow counterpart */
-# define PRIMARY_GLOBAL_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, global_primary_offset)
+# define PRIMARY_GLOBAL_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, global_primary_offset)
/*! \brief Convert a global address into its secondary shadow counterpart */
-# define SECONDARY_GLOBAL_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, global_secondary_offset)
+# define SECONDARY_GLOBAL_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, global_secondary_offset)
/*! \brief Convert a TLS address into its primary shadow counterpart */
-# define PRIMARY_TLS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, tls_primary_offset)
+# define PRIMARY_TLS_SHADOW(_addr) SHADOW_ACCESS(_addr, tls_primary_offset)
/*! \brief Convert a TLS address into its secondary shadow counterpart */
-# define SECONDARY_TLS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, tls_secondary_offset)
+# define SECONDARY_TLS_SHADOW(_addr) SHADOW_ACCESS(_addr, tls_secondary_offset)
#elif E_ACSL_OS_IS_WINDOWS
/*! \brief Convert a text address into its primary shadow counterpart */
-# define PRIMARY_TEXT_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, text_primary_offset)
+# define PRIMARY_TEXT_SHADOW(_addr) SHADOW_ACCESS(_addr, text_primary_offset)
/*! \brief Convert a text address into its secondary shadow counterpart */
-# define SECONDARY_TEXT_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, text_secondary_offset)
+# define SECONDARY_TEXT_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, text_secondary_offset)
/*! \brief Convert a bss address into its primary shadow counterpart */
-# define PRIMARY_BSS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, bss_primary_offset)
+# define PRIMARY_BSS_SHADOW(_addr) SHADOW_ACCESS(_addr, bss_primary_offset)
/*! \brief Convert a bss address into its secondary shadow counterpart */
-# define SECONDARY_BSS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, bss_secondary_offset)
+# define SECONDARY_BSS_SHADOW(_addr) SHADOW_ACCESS(_addr, bss_secondary_offset)
/*! \brief Convert an data address into its primary shadow counterpart */
-# define PRIMARY_DATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, data_primary_offset)
+# define PRIMARY_DATA_SHADOW(_addr) SHADOW_ACCESS(_addr, data_primary_offset)
/*! \brief Convert an data address into its secondary shadow counterpart */
-# define SECONDARY_DATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, data_secondary_offset)
+# define SECONDARY_DATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, data_secondary_offset)
/*! \brief Convert an idata address into its primary shadow counterpart */
-# define PRIMARY_IDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, idata_primary_offset)
+# define PRIMARY_IDATA_SHADOW(_addr) SHADOW_ACCESS(_addr, idata_primary_offset)
/*! \brief Convert an idata address into its secondary shadow counterpart */
-# define SECONDARY_IDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, idata_secondary_offset)
+# define SECONDARY_IDATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, idata_secondary_offset)
/*! \brief Convert an rdata address into its primary shadow counterpart */
-# define PRIMARY_RDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, rdata_primary_offset)
+# define PRIMARY_RDATA_SHADOW(_addr) SHADOW_ACCESS(_addr, rdata_primary_offset)
/*! \brief Convert an rdata address into its secondary shadow counterpart */
-# define SECONDARY_RDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, rdata_secondary_offset)
+# define SECONDARY_RDATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, rdata_secondary_offset)
/*! \brief Convert a global address into its primary shadow counterpart */
// clang-format off
@@ -460,10 +446,8 @@ void clean_shadow_layout();
* \param _addr - a memory address
* \param _seg - a memory segment (one of the structs within ::mem_layout)
*/
-#define IS_ON(_addr,_seg) ( \
- ((uintptr_t)_addr) >= _seg.start && \
- ((uintptr_t)_addr) <= _seg.end \
-)
+#define IS_ON(_addr, _seg) \
+ (((uintptr_t)_addr) >= _seg.start && ((uintptr_t)_addr) <= _seg.end)
/*! \brief Evaluate to true if `_addr` is a heap address */
#define IS_ON_HEAP(_addr) IS_ON(_addr, mem_layout.heap.application)
@@ -473,119 +457,118 @@ void clean_shadow_layout();
#if E_ACSL_OS_IS_LINUX
/*! \brief Evaluate to true if `_addr` is a global address */
-# define IS_ON_GLOBAL(_addr) IS_ON(_addr, mem_layout.global.application)
+# define IS_ON_GLOBAL(_addr) IS_ON(_addr, mem_layout.global.application)
/*! \brief Evaluate to true if _addr is a TLS address */
-# define IS_ON_TLS(_addr) IS_ON(_addr, mem_layout.tls.application)
+# define IS_ON_TLS(_addr) IS_ON(_addr, mem_layout.tls.application)
/*! \brief Shortcut for evaluating an address via ::IS_ON_STACK,
* ::IS_ON_GLOBAL or ::IS_ON_TLS */
-# define IS_ON_STATIC(_addr) \
+# define IS_ON_STATIC(_addr) \
(IS_ON_STACK(_addr) || IS_ON_GLOBAL(_addr) || IS_ON_TLS(_addr))
#elif E_ACSL_OS_IS_WINDOWS
/*! \brief Evaluate to true if `_addr` is a text address */
-# define IS_ON_TEXT(_addr) IS_ON(_addr, mem_layout.text.application)
+# define IS_ON_TEXT(_addr) IS_ON(_addr, mem_layout.text.application)
/*! \brief Evaluate to true if `_addr` is a bss address */
-# define IS_ON_BSS(_addr) IS_ON(_addr, mem_layout.bss.application)
+# define IS_ON_BSS(_addr) IS_ON(_addr, mem_layout.bss.application)
/*! \brief Evaluate to true if `_addr` is an idata address */
-# define IS_ON_DATA(_addr) IS_ON(_addr, mem_layout.data.application)
+# define IS_ON_DATA(_addr) IS_ON(_addr, mem_layout.data.application)
/*! \brief Evaluate to true if `_addr` is an idata address */
-# define IS_ON_IDATA(_addr) IS_ON(_addr, mem_layout.idata.application)
+# define IS_ON_IDATA(_addr) IS_ON(_addr, mem_layout.idata.application)
/*! \brief Evaluate to true if `_addr` is an rdata address */
-# define IS_ON_RDATA(_addr) IS_ON(_addr, mem_layout.rdata.application)
+# define IS_ON_RDATA(_addr) IS_ON(_addr, mem_layout.rdata.application)
/*! \brief Evaluate to true if `_addr` is a global address */
-# define IS_ON_GLOBAL(_addr) \
- (IS_ON_TEXT(_addr) || IS_ON_BSS(_addr) || IS_ON_DATA(_addr) || \
- IS_ON_IDATA(_addr) || IS_ON_RDATA(_addr))
+# define IS_ON_GLOBAL(_addr) \
+ (IS_ON_TEXT(_addr) || IS_ON_BSS(_addr) || IS_ON_DATA(_addr) \
+ || IS_ON_IDATA(_addr) || IS_ON_RDATA(_addr))
/*! \brief Shortcut for evaluating an address via ::IS_ON_STACK,
* ::IS_ON_TEXT, :: IS_ON_BSS, ::IS_ON_IDATA, or ::IS_ON_RDATA */
-# define IS_ON_STATIC(_addr) \
- (IS_ON_STACK(_addr) || IS_ON_TEXT(_addr) || IS_ON_BSS(_addr) || \
- IS_ON_DATA(_addr) || IS_ON_IDATA(_addr) || IS_ON_RDATA(_addr))
+# define IS_ON_STATIC(_addr) \
+ (IS_ON_STACK(_addr) || IS_ON_TEXT(_addr) || IS_ON_BSS(_addr) \
+ || IS_ON_DATA(_addr) || IS_ON_IDATA(_addr) || IS_ON_RDATA(_addr))
#endif
/*! \brief Evaluate to a true value if a given address belongs to tracked
* allocation (i.e., found within static or dynamic allocation) */
-#define IS_ON_VALID(_addr) \
- (IS_ON_STATIC(_addr) || IS_ON_HEAP(_addr))
+#define IS_ON_VALID(_addr) (IS_ON_STATIC(_addr) || IS_ON_HEAP(_addr))
/* }}} */
#ifdef E_ACSL_TEMPORAL /* {{{ */
/*! \brief Convert a heap address into its shadow counterpart */
-#define TEMPORAL_HEAP_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.heap.temporal_primary.shadow_offset)
+# define TEMPORAL_HEAP_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.heap.temporal_primary.shadow_offset)
/*! \brief Convert a stack address into its primary temporal shadow counterpart */
-#define TEMPORAL_PRIMARY_STACK_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.stack.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_STACK_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.stack.temporal_primary.shadow_offset)
/*! \brief Convert a stack address into its secondary temporal shadow counterpart */
-#define TEMPORAL_SECONDARY_STACK_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.stack.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_STACK_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.stack.temporal_secondary.shadow_offset)
-#if E_ACSL_OS_IS_LINUX
+# if E_ACSL_OS_IS_LINUX
/*! \brief Convert a global address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_GLOBAL_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.global.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_GLOBAL_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.global.temporal_primary.shadow_offset)
/*! \brief Convert a global address into its primary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_GLOBAL_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.global.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_GLOBAL_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.global.temporal_secondary.shadow_offset)
/*! \brief Convert a TLS address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_TLS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.tls.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_TLS_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.tls.temporal_primary.shadow_offset)
/*! \brief Convert a TLS address into its secondary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_TLS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.tls.temporal_secondary.shadow_offset)
-#elif E_ACSL_OS_IS_WINDOWS
+# define TEMPORAL_SECONDARY_TLS_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.tls.temporal_secondary.shadow_offset)
+# elif E_ACSL_OS_IS_WINDOWS
/*! \brief Convert a text address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_TEXT_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.text.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_TEXT_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.text.temporal_primary.shadow_offset)
/*! \brief Convert a text address into its primary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_TEXT_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.text.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_TEXT_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.text.temporal_secondary.shadow_offset)
/*! \brief Convert a bss address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_BSS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.bss.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_BSS_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.bss.temporal_primary.shadow_offset)
/*! \brief Convert a bss address into its primary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_BSS_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.bss.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_BSS_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.bss.temporal_secondary.shadow_offset)
/*! \brief Convert an data address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_DATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.data.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_DATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.data.temporal_primary.shadow_offset)
/*! \brief Convert an data address into its primary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_DATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.data.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_DATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.data.temporal_secondary.shadow_offset)
/*! \brief Convert an idata address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_IDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.idata.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_IDATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.idata.temporal_primary.shadow_offset)
/*! \brief Convert an idata address into its primary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_IDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.idata.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_IDATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.idata.temporal_secondary.shadow_offset)
/*! \brief Convert an rdata address into its primary temporal shadow counterpart */
-# define TEMPORAL_PRIMARY_RDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.rdata.temporal_primary.shadow_offset)
+# define TEMPORAL_PRIMARY_RDATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.rdata.temporal_primary.shadow_offset)
/*! \brief Convert an rdata address into its primary temporal shadow counterpart */
-# define TEMPORAL_SECONDARY_RDATA_SHADOW(_addr) \
- SHADOW_ACCESS(_addr, mem_layout.rdata.temporal_secondary.shadow_offset)
+# define TEMPORAL_SECONDARY_RDATA_SHADOW(_addr) \
+ SHADOW_ACCESS(_addr, mem_layout.rdata.temporal_secondary.shadow_offset)
/*! \brief Convert a global address into its primary temporal shadow counterpart */
// clang-format off
@@ -611,12 +594,12 @@ void clean_shadow_layout();
# endif
/*! \brief Temporal primary shadow address of a non-dynamic region */
-#define TEMPORAL_PRIMARY_STATIC_SHADOW(_addr) \
- SHADOW_REGION_ADDRESS(_addr, TEMPORAL_PRIMARY)
+# define TEMPORAL_PRIMARY_STATIC_SHADOW(_addr) \
+ SHADOW_REGION_ADDRESS(_addr, TEMPORAL_PRIMARY)
/*! \brief Temporal secondary shadow address of a non-dynamic region */
-#define TEMPORAL_SECONDARY_STATIC_SHADOW(_addr) \
- SHADOW_REGION_ADDRESS(_addr, TEMPORAL_SECONDARY)
+# define TEMPORAL_SECONDARY_STATIC_SHADOW(_addr) \
+ SHADOW_REGION_ADDRESS(_addr, TEMPORAL_SECONDARY)
#endif /* }}} */
#endif // E_ACSL_SHADOW_LAYOUT
diff --git a/src/plugins/e-acsl/tests/arith/arith.i b/src/plugins/e-acsl/tests/arith/arith.i
index df97877fb148968c52cd69013790c311dcf6160b..472780f9f1c5780b5c57b9ebcda4cb953b62ad47 100644
--- a/src/plugins/e-acsl/tests/arith/arith.i
+++ b/src/plugins/e-acsl/tests/arith/arith.i
@@ -7,27 +7,27 @@ int main(void) {
int y = 2;
long z = 2L;
- /*@ assert -3 == x; */ ;
- /*@ assert x == -3; */ ;
- /*@ assert 0 != ~0; */ ;
-
- /*@ assert x+1 == -2; */ ;
- /*@ assert x-1 == -4; */ ;
- /*@ assert x*3 == -9; */ ;
- /*@ assert x/3 == -1; */ ;
- /*@ assert 0xffffffffffffffffffffff/0xffffffffffffffffffffff == 1; */ ;
- /*@ assert x % 2 == -1; */ ;
- /*@ assert -3 % -2 == -1; */ ;
- /*@ assert 3 % -2 == 1; */ ;
-
- /*@ assert x * 2 + (3 + y) - 4 + (x - y) == -10; */ ;
-
- /*@ assert (0 == 1) == !(0 == 0); */ ;
- /*@ assert (0 <= -1) == (0 > 0); */ ;
- /*@ assert (0 >= -1) == (0 <= 0); */ ;
- /*@ assert (0 != 1) == !(0 != 0); */ ;
-
- /*@ assert 0 == !1; */ ;
+ /*@ assert -3 == x; */;
+ /*@ assert x == -3; */;
+ /*@ assert 0 != ~0; */;
+
+ /*@ assert x+1 == -2; */;
+ /*@ assert x-1 == -4; */;
+ /*@ assert x*3 == -9; */;
+ /*@ assert x/3 == -1; */;
+ /*@ assert 0xffffffffffffffffffffff/0xffffffffffffffffffffff == 1; */;
+ /*@ assert x % 2 == -1; */;
+ /*@ assert -3 % -2 == -1; */;
+ /*@ assert 3 % -2 == 1; */;
+
+ /*@ assert x * 2 + (3 + y) - 4 + (x - y) == -10; */;
+
+ /*@ assert (0 == 1) == !(0 == 0); */;
+ /*@ assert (0 <= -1) == (0 > 0); */;
+ /*@ assert (0 >= -1) == (0 <= 0); */;
+ /*@ assert (0 != 1) == !(0 != 0); */;
+
+ /*@ assert 0 == !1; */;
/*@ assert 4 / y == 2; */ // non trivial division added when fixing bts #751
// example from the JFLA'15 paper (but for a 64-bit architecture)
diff --git a/src/plugins/e-acsl/tests/arith/array.i b/src/plugins/e-acsl/tests/arith/array.i
index eca3cdeea30ac0823b5d58ce32382e1639acd774..2aa9ff6b5e7d9e4c09af907fe596e05139eba4e6 100644
--- a/src/plugins/e-acsl/tests/arith/array.i
+++ b/src/plugins/e-acsl/tests/arith/array.i
@@ -3,108 +3,109 @@
STDOPT: #"-eva-slevel 5"
*/
-int T1[3],T2[4];
+int T1[3], T2[4];
void arrays() {
- // Pure logic arrays
- // (Unsupported at the moment by the kernel)
- // /*@ assert {[0] = 1, [1] = 2, [2] = 3} == {[0] = 1, [1] = 2, [2] = 3}; */
- // /*@ assert {[0] = 1, [1] = 2, [2] = 3} != {[0] = 4, [1] = 5, [2] = 6}; */
- // /*@ assert {[0] = 1, [1] = 2, [2] = 3} !=
- // {[0] = 1, [1] = 2, [2] = 3, [3] = 4, [4] = 5, [5] = 6}; */
-
- // C arrays
- int a[] = {1, 2, 3};
- int b[] = {4, 5, 6};
- int c[] = {1, 2, 3};
- int d[] = {1, 2, 3, 4, 5, 6};
- /*@ assert a != b; */
- /*@ assert a == c; */
- /*@ assert a != d; */
-
- // Pointers to arrays
- int * e = a;
- int * f = b;
- int * g = c;
- int * h = a;
- /*@ assert e != f; */
- /*@ assert e != g; */
- /*@ assert e == h; */
-
- // Comparison between C arrays, logic arrays and pointer to arrays
- // /*@ assert a == {[0] = 1, [1] = 2, [2] = 3}; */ UNSUPPORTED by the kernel
- /*@ assert e == (int *) a; */
- /*@ assert e != (int *) c; */
- // /*@ assert (int[3])e == {[0] = 1, [1] = 2, [2] = 3}; */ UNSUPPORTED by the kernel
- // /*@ assert (int[])e == {[0] = 1, [1] = 2, [2] = 3}; */ UNSUPPORTED by the kernel
- /*@ assert a == (int[3])g; */
- /*@ assert a == (int[])g; */
- /*@ assert a != (int[3])f; */
- /*@ assert a != (int[])f; */
-
- // Comparison between sub-arrays
- int i[] = {1, 2, 3, 4, 5, 6};
- int j[] = {4, 5, 6, 1, 2, 3};
- int k[] = {4, 5, 6, 4, 5, 6};
- /*@ assert i != j; */
- /*@ assert i != k; */
- /*@ assert j != k; */
- int * l = &i[3];
- int * m = &j[3];
- int * n = &k[3];
- /*@ assert (int[3])l != (int[3])m; */
- /*@ assert (int[3])l == (int[3])n; */
-
- // Array truncation
- /*@ assert (int[3])i != (int[3])k; */
- /*@ assert (int[3])j == (int[3])k; */
- /*@ assert (int[2])l != (int[2])m; */
- /*@ assert (int[2])l == (int[2])n; */
-
- // Errors if trying an array extension
- /*ERROR assert (int[10])i != (int[10])k; */
- /*ERROR assert (int[10])j != (int[10])k; */
- /*ERROR assert (int[6])l != (int[6])m; */
- /*ERROR assert (int[6])l == (int[6])n; */
-
-
- // Errors while comparing a pointer to array with an array (logic or C)
- /*ERROR: assert e == a; */
- /*ERROR: assert e == {[0] = 1, [1] = 2, [2] = 3}; */
-
- // Error while casting a logic array to a pointer to array
- /*ERROR: assert e != (int*){[0] = 1, [1] = 2, [2] = 3}; */
+ // Pure logic arrays
+ // (Unsupported at the moment by the kernel)
+ // /*@ assert {[0] = 1, [1] = 2, [2] = 3} == {[0] = 1, [1] = 2, [2] = 3}; */
+ // /*@ assert {[0] = 1, [1] = 2, [2] = 3} != {[0] = 4, [1] = 5, [2] = 6}; */
+ // /*@ assert {[0] = 1, [1] = 2, [2] = 3} !=
+ // {[0] = 1, [1] = 2, [2] = 3, [3] = 4, [4] = 5, [5] = 6}; */
+
+ // C arrays
+ int a[] = {1, 2, 3};
+ int b[] = {4, 5, 6};
+ int c[] = {1, 2, 3};
+ int d[] = {1, 2, 3, 4, 5, 6};
+ /*@ assert a != b; */
+ /*@ assert a == c; */
+ /*@ assert a != d; */
+
+ // Pointers to arrays
+ int *e = a;
+ int *f = b;
+ int *g = c;
+ int *h = a;
+ /*@ assert e != f; */
+ /*@ assert e != g; */
+ /*@ assert e == h; */
+
+ // Comparison between C arrays, logic arrays and pointer to arrays
+ // /*@ assert a == {[0] = 1, [1] = 2, [2] = 3}; */ UNSUPPORTED by the kernel
+ /*@ assert e == (int *) a; */
+ /*@ assert e != (int *) c; */
+ // /*@ assert (int[3])e == {[0] = 1, [1] = 2, [2] = 3}; */ UNSUPPORTED by the kernel
+ // /*@ assert (int[])e == {[0] = 1, [1] = 2, [2] = 3}; */ UNSUPPORTED by the kernel
+ /*@ assert a == (int[3])g; */
+ /*@ assert a == (int[])g; */
+ /*@ assert a != (int[3])f; */
+ /*@ assert a != (int[])f; */
+
+ // Comparison between sub-arrays
+ int i[] = {1, 2, 3, 4, 5, 6};
+ int j[] = {4, 5, 6, 1, 2, 3};
+ int k[] = {4, 5, 6, 4, 5, 6};
+ /*@ assert i != j; */
+ /*@ assert i != k; */
+ /*@ assert j != k; */
+ int *l = &i[3];
+ int *m = &j[3];
+ int *n = &k[3];
+ /*@ assert (int[3])l != (int[3])m; */
+ /*@ assert (int[3])l == (int[3])n; */
+
+ // Array truncation
+ /*@ assert (int[3])i != (int[3])k; */
+ /*@ assert (int[3])j == (int[3])k; */
+ /*@ assert (int[2])l != (int[2])m; */
+ /*@ assert (int[2])l == (int[2])n; */
+
+ // Errors if trying an array extension
+ /*ERROR assert (int[10])i != (int[10])k; */
+ /*ERROR assert (int[10])j != (int[10])k; */
+ /*ERROR assert (int[6])l != (int[6])m; */
+ /*ERROR assert (int[6])l == (int[6])n; */
+
+ // Errors while comparing a pointer to array with an array (logic or C)
+ /*ERROR: assert e == a; */
+ /*ERROR: assert e == {[0] = 1, [1] = 2, [2] = 3}; */
+
+ // Error while casting a logic array to a pointer to array
+ /*ERROR: assert e != (int*){[0] = 1, [1] = 2, [2] = 3}; */
}
void vlas(int n) {
- // FIXME: There is currently an error with the support of VLA in E-ACSL
- // https://git.frama-c.com/frama-c/e-acsl/-/issues/119
-
- // // Declare VLAs
- // int a[n+1];
- // int b[n+1];
- // int c[n+1];
-
- // // Initialize arrays
- // for (int i = 0; i < (n+1) ; ++i) {
- // a[i] = i;
- // b[i] = n + 1 - i;
- // c[i] = i;
- // }
-
- // // // Compare VLAs
- // // // The naive comparison compare pointers
- // // /*@ assert a != b; */
- // // /*@ assert a == c; */
- // // // We need to cast to int[] to have an array comparison
- // // /*@ assert (int[])a != (int[])b; */
- // // /*@ assert (int[])a == (int[])c; */
+ // FIXME: There is currently an error with the support of VLA in E-ACSL
+ // https://git.frama-c.com/frama-c/e-acsl/-/issues/119
+
+ // // Declare VLAs
+ // int a[n+1];
+ // int b[n+1];
+ // int c[n+1];
+
+ // // Initialize arrays
+ // for (int i = 0; i < (n+1) ; ++i) {
+ // a[i] = i;
+ // b[i] = n + 1 - i;
+ // c[i] = i;
+ // }
+
+ // // // Compare VLAs
+ // // // The naive comparison compare pointers
+ // // /*@ assert a != b; */
+ // // /*@ assert a == c; */
+ // // // We need to cast to int[] to have an array comparison
+ // // /*@ assert (int[])a != (int[])b; */
+ // // /*@ assert (int[])a == (int[])c; */
}
int main(void) {
- for(int i = 0; i < 3; i++) T1[i] = i;
- for(int i = 0; i < 4; i++) T2[i] = 2*i;
+ for (int i = 0; i < 3; i++)
+ T1[i] = i;
+ for (int i = 0; i < 4; i++)
+ T2[i] = 2 * i;
/*@ assert T1[0] == T2[0]; */
/*@ assert T1[1] != T2[1]; */
diff --git a/src/plugins/e-acsl/tests/arith/at.i b/src/plugins/e-acsl/tests/arith/at.i
index fd3830e91d0bb02db49c6cef81caff9f8c600c57..700be22bf0e01fa9fff701c7cc3584ab165370b2 100644
--- a/src/plugins/e-acsl/tests/arith/at.i
+++ b/src/plugins/e-acsl/tests/arith/at.i
@@ -7,7 +7,8 @@ int A = 0;
/*@ ensures \at(A,Post) == 3; */
void f(void) {
A = 1;
- F: A = 2;
+F:
+ A = 2;
/*@ assert \at(A,Pre) == 0; */
/*@ assert \at(A,F) == 1; */
/*@ assert \at(A,Here) == 2; */
@@ -17,30 +18,35 @@ void f(void) {
void g(int *p, int *q) {
*p = 0;
- *(p+1) = 1;
+ *(p + 1) = 1;
*q = 0;
- L1: *p = 2;
- *(p+1) = 3;
+L1:
+ *p = 2;
+ *(p + 1) = 3;
*q = 1;
- L2: A = 4;
+L2:
+ A = 4;
/*@ assert (\at(*(p+\at(*q,L1)),L2) == 2); */
- L3:
+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; */
- return ;
+ return;
}
/*@ ensures \result == x; */
-int h(int x) { return x; }
+int h(int x) {
+ return x;
+}
int main(void) {
int x;
x = h(0);
- L: /*@ assert x == 0; */ x = 1;
+L: /*@ assert x == 0; */
+ x = 1;
x = 2;
f();
@@ -50,7 +56,7 @@ int main(void) {
/*@ assert \at(x,L)+1 == 1; */
int t[2];
- g(t,&x);
+ g(t, &x);
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 2cabc95d6ef85b73a4f35450a8587aac909da1a5..1f29ad1a608dc817f537cfec6eb65e84a07d3273 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
@@ -11,38 +11,40 @@ void f(int *t) {}
void g() {
int m;
m = 8;
- Q: ;
+Q:;
m = 10;
- /*@ assert \exists integer w; 3 <= w < 6 && \at(m + w == 12, Q); */ ;
+ /*@ assert \exists integer w; 3 <= w < 6 && \at(m + w == 12, Q); */;
}
int main(void) {
int n;
n = 7;
- L: ;
+L:;
n = 9;
- K: ;
+K:;
n = 666;
// Predicates:
- /*@ assert \let i = 3; \at(n + i == 10, L); */ ;
- /*@ assert \exists integer j; 2 <= j < 5 && \at(n + j == 11, L); */ ;
+ /*@ assert \let i = 3; \at(n + i == 10, L); */;
+ /*@ assert \exists integer j; 2 <= j < 5 && \at(n + j == 11, L); */;
/*@ assert
\let k = -7;
\exists integer u; 9 <= u < 21 &&
\forall integer v; -5 < v <= 6 ==>
- \at((u > 0 ? n + k : u + v) > 0, K); */ ;
+ \at((u > 0 ? n + k : u + v) > 0, K); */
+ ;
// Terms:
- /*@ assert \let i = 3; \at(n + i, L) == 10; */ ;
+ /*@ assert \let i = 3; \at(n + i, L) == 10; */;
unsigned int m = 3;
- G: ;
+G:;
m = -3;
- /*@ assert \exists integer k; -9 < k < 0 && \at(m + k, G) == 0; */ ;
+ /*@ assert \exists integer k; -9 < k < 0 && \at(m + k, G) == 0; */;
/*@ 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 > 0, K); */
+ ;
// Function calls:
int t[5] = {9, 12, 12, 12, -4};
@@ -56,14 +58,17 @@ int main(void) {
&& \exists integer w; 100 < w <= 200
&& \at(n - u +
(\let u = 42; u) // yet another u
- + v + w > 0, K); */ ;
+ + v + w > 0, K); */
+ ;
// Not yet:
/*@ assert
\exists integer j; 2 <= j < 10000000000000000 // too big => not_yet
- && \at(n + j == 11, L); */ ;
+ && \at(n + j == 11, L); */
+ ;
/*@ assert \let i = n; // lv defined with C var => not_yet
- \at(n + i == 10, L); */ ;
+ \at(n + i == 10, L); */
+ ;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/arith/bitwise.c b/src/plugins/e-acsl/tests/arith/bitwise.c
index 37e967a40b26ae9dbd89213a75e1be964e2c2761..142338a6666960c9f6a29041918140d282ab3592 100644
--- a/src/plugins/e-acsl/tests/arith/bitwise.c
+++ b/src/plugins/e-acsl/tests/arith/bitwise.c
@@ -10,68 +10,68 @@
// Operations on signed C integers
void f_signed(int a, int b) {
- int c = a << 2;
- /*@ assert c == (a<<2); */
- int d = b >> 2;
- /*@ assert d == (b>>2); */
- int e = a | b;
- /*@ assert e == (a | b); */
- int f = a & b;
- /*@ assert f == (a & b); */
- int g = a ^ b;
- /*@ assert g == (a ^ b); */
+ int c = a << 2;
+ /*@ assert c == (a<<2); */
+ int d = b >> 2;
+ /*@ assert d == (b>>2); */
+ int e = a | b;
+ /*@ assert e == (a | b); */
+ int f = a & b;
+ /*@ assert f == (a & b); */
+ int g = a ^ b;
+ /*@ assert g == (a ^ b); */
}
// Operations on unsigned C integers
void f_unsigned(unsigned int a, unsigned int b) {
- unsigned int c = a << 2u;
- /*@ assert c == (a<<2); */
- unsigned int d = b >> 2u;
- /*@ assert d == (b>>2); */
- unsigned int e = a | b;
- /*@ assert e == (a | b); */
- unsigned int f = a & b;
- /*@ assert f == (a & b); */
- unsigned int g = a ^ b;
- /*@ assert g == (a ^ b); */
+ unsigned int c = a << 2u;
+ /*@ assert c == (a<<2); */
+ unsigned int d = b >> 2u;
+ /*@ assert d == (b>>2); */
+ unsigned int e = a | b;
+ /*@ assert e == (a | b); */
+ unsigned int f = a & b;
+ /*@ assert f == (a & b); */
+ unsigned int g = a ^ b;
+ /*@ assert g == (a ^ b); */
}
// Operations on arbitrary precision signed integers
void g_signed(int a, int b) {
- int c = a << b;
- /*@ assert c == (a<<b); */
- int d = a >> b;
- /*@ assert d == (a>>b); */
+ int c = a << b;
+ /*@ assert c == (a<<b); */
+ int d = a >> b;
+ /*@ assert d == (a>>b); */
- /*@ assert ((ULLONG_MAX + 1) << 1) != 0; */
- /*@ assert ((ULLONG_MAX + 1) >> 1) != 0; */
- /*@ assert (1 << 65) != 0; */
- /*@ assert ((ULLONG_MAX + 1) | (LLONG_MIN - 1)) != 0; */
- /*@ assert ((ULLONG_MAX + 1) & (LLONG_MIN - 1)) !=
+ /*@ assert ((ULLONG_MAX + 1) << 1) != 0; */
+ /*@ assert ((ULLONG_MAX + 1) >> 1) != 0; */
+ /*@ assert (1 << 65) != 0; */
+ /*@ assert ((ULLONG_MAX + 1) | (LLONG_MIN - 1)) != 0; */
+ /*@ assert ((ULLONG_MAX + 1) & (LLONG_MIN - 1)) !=
((ULLONG_MAX + 1) ^ (LLONG_MIN - 1)); */
}
// Operations on arbitrary precision unsigned integers
void g_unsigned(unsigned int a, unsigned int b) {
- unsigned int c = a << b;
- /*@ assert c == (a<<b); */
- unsigned int d = a >> b;
- /*@ assert d == (a>>b); */
+ unsigned int c = a << b;
+ /*@ assert c == (a<<b); */
+ unsigned int d = a >> b;
+ /*@ assert d == (a>>b); */
- /*@ assert ((ULLONG_MAX + 1u) << 1u) != 0; */
- /*@ assert ((ULLONG_MAX + 1u) >> 1u) != 0; */
- /*@ assert (1u << 65u) != 0; */
- /*@ assert ((ULLONG_MAX + 1u) | 1u) != 0; */
- /*@ assert ((ULLONG_MAX + 1u) & 1u) !=
+ /*@ assert ((ULLONG_MAX + 1u) << 1u) != 0; */
+ /*@ assert ((ULLONG_MAX + 1u) >> 1u) != 0; */
+ /*@ assert (1u << 65u) != 0; */
+ /*@ assert ((ULLONG_MAX + 1u) | 1u) != 0; */
+ /*@ assert ((ULLONG_MAX + 1u) & 1u) !=
((ULLONG_MAX + 1u) ^ 1u); */
}
int main() {
- int a = 4;
- int b = 8;
- f_signed(a,b);
- f_unsigned(a,b);
- g_signed(a,b);
- g_unsigned(a,b);
- return 0;
+ int a = 4;
+ int b = 8;
+ f_signed(a, b);
+ f_unsigned(a, b);
+ g_signed(a, b);
+ g_unsigned(a, b);
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/arith/cast.i b/src/plugins/e-acsl/tests/arith/cast.i
index 910ca8b40d183e54f664850186174b06b5df7508..5315b5191aee1c1a6ee27bac70bce409c58513a2 100644
--- a/src/plugins/e-acsl/tests/arith/cast.i
+++ b/src/plugins/e-acsl/tests/arith/cast.i
@@ -6,19 +6,19 @@ int main(void) {
long x = 0;
int y = 0;
- /*@ assert (int)x == y; */ ;
- /*@ assert x == (long)y; */ ;
+ /*@ assert (int)x == y; */;
+ /*@ assert x == (long)y; */;
- /*@ assert y == (int)0; */ ; // cast from integer to int
- /*@ assert (unsigned int) y == (unsigned int)0; */ ; /* cast from integer
+ /*@ assert y == (int)0; */; // cast from integer to int
+ /*@ assert (unsigned int) y == (unsigned int)0; */; /* cast from integer
to unsigned int */
- /*@ assert y != (int)0xfffffffffffffff; */ ; // cast from integer to int
- /*@ assert (unsigned int) y != (unsigned int)0xfffffffffffffff; */ ;
+ /*@ assert y != (int)0xfffffffffffffff; */; // cast from integer to int
+ /*@ assert (unsigned int) y != (unsigned int)0xfffffffffffffff; */;
/* cast from integer to unsigned int */
/* heterogeneous casts from/to integers */
- int t[2] = { 0, 1 };
+ int t[2] = {0, 1};
/*@ assert (float)x == t[(int)0.1]; */
return 0;
diff --git a/src/plugins/e-acsl/tests/arith/functions.c b/src/plugins/e-acsl/tests/arith/functions.c
index 9d0bc001ab61c0b89201f3c3ecffae481965c120..802b5f343ad81eadb7468fc9e75cda1df8df18fe 100644
--- a/src/plugins/e-acsl/tests/arith/functions.c
+++ b/src/plugins/e-acsl/tests/arith/functions.c
@@ -15,7 +15,9 @@
/*@ logic int g_hidden(int x) = x; */
/*@ logic int g(int x) = g_hidden(x); */
-struct mystruct { int k, l; };
+struct mystruct {
+ int k, l;
+};
typedef struct mystruct mystruct;
/*@ logic mystruct t1(mystruct m) = m; */
/*@ logic integer t2(mystruct m) = m.k + m.l; */
@@ -37,35 +39,36 @@ int glob = 5;
/*@ predicate p_notyet{L}(integer x) = x > 0; */
/*@ logic integer f_notyet{L}(integer x) = x; */
-int main (void) {
+int main(void) {
int x = 1, y = 2;
- /*@ assert p1(x, y); */ ;
- /*@ assert p2(3, 4); */ ;
- /*@ assert p2(5, 99999999999999999999999999999); */ ;
+ /*@ assert p1(x, y); */;
+ /*@ assert p2(3, 4); */;
+ /*@ assert p2(5, 99999999999999999999999999999); */;
- /*@ assert f1(x, y) == 3; */ ;
- /*@ assert p2(x, f1(3, 4)); */ ;
- /*@ assert f1(9, 99999999999999999999999999999) > 0; */ ;
+ /*@ assert f1(x, y) == 3; */;
+ /*@ assert p2(x, f1(3, 4)); */;
+ /*@ assert f1(9, 99999999999999999999999999999) > 0; */;
/*@ assert f1(99999999999999999999999999999,
99999999999999999999999999999) ==
- 199999999999999999999999999998; */ ;
+ 199999999999999999999999999998; */
+ ;
- /*@ assert g(x) == x; */ ;
+ /*@ assert g(x) == x; */;
char c = 'c';
- /*@ assert h_char(c) == c; */ ;
+ /*@ assert h_char(c) == c; */;
short s = 1;
- /*@ assert h_short(s) == s; */ ;
+ /*@ assert h_short(s) == s; */;
mystruct m;
m.k = 8;
m.l = 9;
- /*@ assert t2(t1(m)) == 17; */ ;
+ /*@ assert t2(t1(m)) == 17; */;
k(9);
double d = 2.0;
- /*@ assert f2(d) > 0; */ ;
+ /*@ assert f2(d) > 0; */;
// not yet supported
/* /\*@ assert p_notyet(27); *\/ ; */
diff --git a/src/plugins/e-acsl/tests/arith/functions_rec.c b/src/plugins/e-acsl/tests/arith/functions_rec.c
index c50124bb9de035fc031e4bbab33608bcb1df5640..8e39fbc3c6bcb44024412eb1d4c7cb59386a0a5f 100644
--- a/src/plugins/e-acsl/tests/arith/functions_rec.c
+++ b/src/plugins/e-acsl/tests/arith/functions_rec.c
@@ -24,19 +24,18 @@
/*@ logic integer f5(integer n) =
n >= 0 ? 0 : f5(n + 1) + n; */
-int main (void) {
- /*@ assert f1(0) == 0; */ ;
- /*@ assert f1(1) == 1; */ ;
- /*@ assert f1(100) == 5050; */ ;
+int main(void) {
+ /*@ assert f1(0) == 0; */;
+ /*@ assert f1(1) == 1; */;
+ /*@ assert f1(100) == 5050; */;
- /*@ assert f2(7) == 1; */ ;
+ /*@ assert f2(7) == 1; */;
- /*@ assert f3(6) == -5; */ ;
+ /*@ assert f3(6) == -5; */;
- /*@ assert f4(9) > 0; */ ;
+ /*@ assert f4(9) > 0; */;
/*@ assert f5(0) == 0; */
/*@ assert (\let n = (0 == 0) ? 0x7fffffffffffffffL : -1; f5(n) == 0);*/
}
-
diff --git a/src/plugins/e-acsl/tests/arith/let.c b/src/plugins/e-acsl/tests/arith/let.c
index c96df720e37cfef3cf0e1317277bdc855f6cdeac..9066e9463a5aa71380391202d184c0f266114a29 100644
--- a/src/plugins/e-acsl/tests/arith/let.c
+++ b/src/plugins/e-acsl/tests/arith/let.c
@@ -4,40 +4,48 @@
int main(void) {
int n = -2;
- /*@ assert \let u = n*n; u >= 0; */ ;
+ /*@ assert \let u = n*n; u >= 0; */;
/*@ assert
\let u = n*n;
- \let v = u + 1; u > 0; */ ;
+ \let v = u + 1; u > 0; */
+ ;
- /*@ assert ((\let u = 1; u) + 1) == 2; */ ;
+ /*@ assert ((\let u = 1; u) + 1) == 2; */;
/*@ assert
\let u = 1;
- (\let v = u + 1; v) == 2; */ ;
+ (\let v = u + 1; v) == 2; */
+ ;
/*@ assert
\let u = 1;
- (\let u = u + 1; u) == 2; */ ;
+ (\let u = u + 1; u) == 2; */
+ ;
long m = 0x7fffffffffffffffL;
- /*@ assert (\let u = m; u*u) > m; */ ;
+ /*@ assert (\let u = m; u*u) > m; */;
char c = 'a';
- /*@ assert \let u = 'b'; c < u; */ ;
+ /*@ assert \let u = 'b'; c < u; */;
float f = 1.0f;
- /*@ assert \let u = f; u == f; */ ;
+ /*@ assert \let u = f; u == f; */;
- int t[4] = {1,2,3,4};
+ int t[4] = {1, 2, 3, 4};
// testing warnings when using let on pointers/arrays
/*@ assert \let u = t + 1; 1 == 1; */;
// same but for terms
/*@ assert (\let u = t + 1; 1) == 1; */;
- struct {int x, y;} r = {1, 2};
- /*@ assert \let u = r; u.x + u.y == 3; */ ;
+ struct {
+ int x, y;
+ } r = {1, 2};
+ /*@ assert \let u = r; u.x + u.y == 3; */;
- union {int x; char *y;} s;
+ union {
+ int x;
+ char *y;
+ } s;
s.x = 5;
- /*@ assert (\let u = s; u.x) > 0; */ ;
+ /*@ assert (\let u = s; u.x) > 0; */;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/arith/longlong.i b/src/plugins/e-acsl/tests/arith/longlong.i
index 851d7a13c56ae978d4a5b678f3c5e37379966231..cfad37a979da883b3cb249ebaf55ba18029371fb 100644
--- a/src/plugins/e-acsl/tests/arith/longlong.i
+++ b/src/plugins/e-acsl/tests/arith/longlong.i
@@ -5,10 +5,12 @@
unsigned long long my_pow(unsigned int x, unsigned int n) {
int tmp;
- if (n <= 1) return 1;
+ if (n <= 1)
+ return 1;
tmp = my_pow(x, n / 2);
tmp *= tmp;
- if (n % 2 == 0) return tmp;
+ if (n % 2 == 0)
+ return tmp;
return x * tmp;
}
diff --git a/src/plugins/e-acsl/tests/arith/quantif.i b/src/plugins/e-acsl/tests/arith/quantif.i
index 7b5c28036c5dcc50a9314346cda413beccd109e2..c98110962b0f47441c9883ffa6c5d90249de46fd 100644
--- a/src/plugins/e-acsl/tests/arith/quantif.i
+++ b/src/plugins/e-acsl/tests/arith/quantif.i
@@ -42,10 +42,11 @@ int main(void) {
// Empty quantifications
/*@ assert \forall integer x; 0 < x < 1 ==> \false; */
- /*@ assert ! \exists char c; 10 <= c < 10 && c == 10; */ ;
+ /*@ assert ! \exists char c; 10 <= c < 10 && c == 10; */;
/*@ assert
\let u = 5;
- \forall integer x,y; 0 <= x < 2 && 4 < y < u ==> \false; */ ;
+ \forall integer x,y; 0 <= x < 2 && 4 < y < u ==> \false; */
+ ;
// Quantification with multiple binders (frama-c/e-acsl#127)
/*@ assert forall_multiple_binders_1:
diff --git a/src/plugins/e-acsl/tests/arith/rationals.c b/src/plugins/e-acsl/tests/arith/rationals.c
index dbd2704d9a182eddc59ef1bef383fca8b45ce2d9..07e6bf6e1093f416461e4c4999524d92ad100a3a 100644
--- a/src/plugins/e-acsl/tests/arith/rationals.c
+++ b/src/plugins/e-acsl/tests/arith/rationals.c
@@ -5,28 +5,27 @@
\let avg_real = (a+b)/2;
avg_real - delta < \result < avg_real + delta; */
double avg(double a, double b) {
- return (a+b)/2;
+ return (a + b) / 2;
}
int main(void) {
- /*@ assert 3 == 1.5 + 1.5; */ ;
- /*@ assert 0.1 == 0.1; */ ;
- /*@ assert (double)1.0 == 1.0; */ ;
- /*@ assert (double)0.1 != 0.1; */ ;
- /*@ assert (float)0.1 != (double)0.1; */ ;
- /*@ assert (double)1.1 != 1 + 0.1 ;*/ ;
- /*@ assert 1 + 0.1 == 2 - 0.9; */ ;
- float x = 0.2f,
- y = 0.3f,
- sum = x + y;
- /*@ assert sum != x * y; */ ;
- /* @ assert \let n = 1; 4 == n + 3.0; */ ; // TODO: fail at runtime, I don't know why
+ /*@ assert 3 == 1.5 + 1.5; */;
+ /*@ assert 0.1 == 0.1; */;
+ /*@ assert (double)1.0 == 1.0; */;
+ /*@ assert (double)0.1 != 0.1; */;
+ /*@ assert (float)0.1 != (double)0.1; */;
+ /*@ assert (double)1.1 != 1 + 0.1 ;*/;
+ /*@ assert 1 + 0.1 == 2 - 0.9; */;
+ float x = 0.2f, y = 0.3f, sum = x + y;
+ /*@ assert sum != x * y; */;
+ /* @ assert \let n = 1; 4 == n + 3.0; */
+ ; // TODO: fail at runtime, I don't know why
double d = 0.1;
avg(4.3, 11.7);
- /*@ assert 1.1d != 1 + 0.1; */ ;
+ /*@ assert 1.1d != 1 + 0.1; */;
short a = 1, b = 1;
//@ assert a+b > 2. - 1.; // gitlab public issue #14
diff --git a/src/plugins/e-acsl/tests/arith/sum.i b/src/plugins/e-acsl/tests/arith/sum.i
index 63e6f14458192bd2928214bfefcb5fd10d927787..3737ad347a01d3413e4193a1d408d75902f98522 100644
--- a/src/plugins/e-acsl/tests/arith/sum.i
+++ b/src/plugins/e-acsl/tests/arith/sum.i
@@ -15,8 +15,8 @@ int main(void) {
/*@ assert \sum(x*x,2,\lambda integer k; k) == 0; */;
- /*@ assert \sum(18446744073709551610,18446744073709551615,\lambda integer k; 1) == 6; */;
-
+ /*@ assert \sum(18446744073709551610,18446744073709551615,\lambda integer k; 1) == 6; */
+ ;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts1304.i b/src/plugins/e-acsl/tests/bts/bts1304.i
index 70dd51300e28c0864b11b6a8ef14c4e68aa11b4e..698e50282021defe45de6e50a18477c219a5e1c8 100644
--- a/src/plugins/e-acsl/tests/bts/bts1304.i
+++ b/src/plugins/e-acsl/tests/bts/bts1304.i
@@ -3,15 +3,23 @@
STDOPT: +"-eva-precision=1"
*/
-struct msgA { int type; int a[2]; };
-struct msgB { int type; double x; };
+struct msgA {
+ int type;
+ int a[2];
+};
+struct msgB {
+ int type;
+ double x;
+};
union msg {
- struct { int type; } T;
+ struct {
+ int type;
+ } T;
struct msgA A;
struct msgB B;
};
-void read_sensor_4(unsigned* m) {
+void read_sensor_4(unsigned *m) {
/* put 4 bytes from sensors into m */
*m = 0;
}
@@ -19,8 +27,8 @@ void read_sensor_4(unsigned* m) {
int main(void) {
unsigned char buf[sizeof(union msg)];
int i;
- for(i = 0; i < sizeof(buf)/4; i++)
- read_sensor_4((unsigned*)buf+i);
+ for (i = 0; i < sizeof(buf) / 4; i++)
+ read_sensor_4((unsigned *)buf + i);
/*@ assert \initialized((union msg*)buf); */
return 0;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts1307.i b/src/plugins/e-acsl/tests/bts/bts1307.i
index 2932f7253cf920f4546e25badf495df2c1e7b384..476784c287f428c0f8074136e79df658a5853c61 100644
--- a/src/plugins/e-acsl/tests/bts/bts1307.i
+++ b/src/plugins/e-acsl/tests/bts/bts1307.i
@@ -10,7 +10,7 @@
@ assumes \true;
@ ensures *Mtmax_out != *Mtmax_in + (5 - (((5 / 80) * *Mwmax) * 0.4));
@*/
-void foo(float* Mtmax_in, float* Mwmax, float* Mtmax_out) {
+void foo(float *Mtmax_in, float *Mwmax, float *Mtmax_out) {
/* Real semantics and floating-point semantics give different results because:
1) Mtmax_out is 5.975 is in R
2) The float closest to 5.975 is 5.97499999999999964472863211995 */
@@ -25,7 +25,7 @@ void foo(float* Mtmax_in, float* Mwmax, float* Mtmax_out) {
@ assumes \true;
@ ensures *Mtmin_out == *Mtmin_in < 0.85 * *Mwmin ? *Mtmin_in : 0.85 * *Mwmin;
@*/
-void bar(float* Mtmin_in, float* Mwmin, float* Mtmin_out) {
+void bar(float *Mtmin_in, float *Mwmin, float *Mtmin_out) {
*Mtmin_out = 0.85 * *Mwmin;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts1324.i b/src/plugins/e-acsl/tests/bts/bts1324.i
index 690b29043baca4b8e32f5c69afd63f00caa10df0..a9fce97867e692adba4aadfb4ae92a82e4965f6a 100644
--- a/src/plugins/e-acsl/tests/bts/bts1324.i
+++ b/src/plugins/e-acsl/tests/bts/bts1324.i
@@ -6,19 +6,19 @@
@ assumes \forall int i; 0 < i < n ==> t[i-1] <= t[i];
@ ensures \result == 1;
@*/
-int sorted(int * t, int n) {
+int sorted(int *t, int n) {
int b = 1;
- if(n <= 1)
+ if (n <= 1)
return 1;
- for(b = 1; b < n; b++) {
- if(t[b-1] > t[b])
+ for (b = 1; b < n; b++) {
+ if (t[b - 1] > t[b])
return 0;
}
return 1;
}
int main(void) {
- int t[7] = { 1, 4, 4, 5, 5, 5, 7 };
+ int t[7] = {1, 4, 4, 5, 5, 5, 7};
int n = sorted(t, 7);
/*@ assert n == 1; */
return 0;
diff --git a/src/plugins/e-acsl/tests/bts/bts1326.i b/src/plugins/e-acsl/tests/bts/bts1326.i
index c8e7429eefcca32ce60658c4a83bbd0223216dcb..e0cb8d90989fc04b62827b13ce408e97043f58e6 100644
--- a/src/plugins/e-acsl/tests/bts/bts1326.i
+++ b/src/plugins/e-acsl/tests/bts/bts1326.i
@@ -7,14 +7,13 @@ typedef int ArrayInt[5];
/*@ ensures
*AverageAccel ==
((*Accel)[4] + (*Accel)[3] + (*Accel)[2] + (*Accel)[1] + (*Accel)[0]) / 5; @*/
-void atp_NORMAL_computeAverageAccel(ArrayInt* Accel,int* AverageAccel)
-{
- *AverageAccel =
- ((*Accel)[4] + (*Accel)[3] + (*Accel)[2] + (*Accel)[1] + (*Accel)[0]) / 5;
+void atp_NORMAL_computeAverageAccel(ArrayInt *Accel, int *AverageAccel) {
+ *AverageAccel =
+ ((*Accel)[4] + (*Accel)[3] + (*Accel)[2] + (*Accel)[1] + (*Accel)[0]) / 5;
}
int main(void) {
- ArrayInt Accel = { 1, 2, 3, 4, 5 };
+ ArrayInt Accel = {1, 2, 3, 4, 5};
int av;
atp_NORMAL_computeAverageAccel(&Accel, &av);
return 0;
diff --git a/src/plugins/e-acsl/tests/bts/bts1386_complex_flowgraph.c b/src/plugins/e-acsl/tests/bts/bts1386_complex_flowgraph.c
index d04c742e75b9c290b3966422718697cf4c3f00a3..11a259f7b28b1791a94fc87874ac7d27c9be0b4a 100644
--- a/src/plugins/e-acsl/tests/bts/bts1386_complex_flowgraph.c
+++ b/src/plugins/e-acsl/tests/bts/bts1386_complex_flowgraph.c
@@ -16,68 +16,58 @@
*
*----------------------------------------------------------------------*/
- /*
+/*
* Changes: JG 2005/12/21: Changed type of main to int
Indented program.
*/
#include "stdio.h"
-#define ARRAYSIZE 100
-#define INVOCATION_COUNT 43 /* exec time depends on this one! */
+#define ARRAYSIZE 100
+#define INVOCATION_COUNT 43 /* exec time depends on this one! */
+void duffcopy(char *to, char *from, int count) {
-void
-duffcopy(char *to, char *from, int count)
-{
-
- int n = (count + 7) / 8;
- switch (count % 8) {
- case 0:
- do {
- *to++ = *from++;
- case 7:
- *to++ = *from++;
- case 6:
- *to++ = *from++;
- case 5:
- *to++ = *from++;
- case 4:
- *to++ = *from++;
- case 3:
- *to++ = *from++;
- case 2:
- *to++ = *from++;
- case 1:
- *to++ = *from++;
-
- } while (--n > 0);
- }
-}
-
+ int n = (count + 7) / 8;
+ switch (count % 8) {
+ case 0:
+ do {
+ *to++ = *from++;
+ case 7:
+ *to++ = *from++;
+ case 6:
+ *to++ = *from++;
+ case 5:
+ *to++ = *from++;
+ case 4:
+ *to++ = *from++;
+ case 3:
+ *to++ = *from++;
+ case 2:
+ *to++ = *from++;
+ case 1:
+ *to++ = *from++;
-void
-initialize(char *arr, int length)
-{
- int i;
- for (i = 0; i < length; i++) {
- arr[i] = length - i;
- }
+ } while (--n > 0);
+ }
}
+void initialize(char *arr, int length) {
+ int i;
+ for (i = 0; i < length; i++) {
+ arr[i] = length - i;
+ }
+}
-char source[ARRAYSIZE];
-char target[ARRAYSIZE];
+char source[ARRAYSIZE];
+char target[ARRAYSIZE];
-int
-main(void)
-{
- initialize(source, ARRAYSIZE);
- duffcopy(source, target, INVOCATION_COUNT);
- return 0;
+int main(void) {
+ initialize(source, ARRAYSIZE);
+ duffcopy(source, target, INVOCATION_COUNT);
+ return 0;
}
-
/*------------------------------------------------------------
* $Id: duff.c,v 1.4 2005/12/21 09:43:07 jgn Exp $
*------------------------------------------------------------
diff --git a/src/plugins/e-acsl/tests/bts/bts1390.c b/src/plugins/e-acsl/tests/bts/bts1390.c
index 74cba86cdbefc49eb207bda3bdbe6f3178c5f15c..5d1e14e3cb1ad34a8e5de4259e3adb8594c9db24 100644
--- a/src/plugins/e-acsl/tests/bts/bts1390.c
+++ b/src/plugins/e-acsl/tests/bts/bts1390.c
@@ -13,11 +13,12 @@
void *memchr(const void *buf, int c, size_t n) {
int i;
char *s = buf;
- for(i = 0; i < n; i++) {
- if(*s == c) return s;
+ for (i = 0; i < n; i++) {
+ if (*s == c)
+ return s;
s++;
}
- return (void*)0;
+ return (void *)0;
}
int main(void) {
diff --git a/src/plugins/e-acsl/tests/bts/bts1395.i b/src/plugins/e-acsl/tests/bts/bts1395.i
index 01c399aa67785e1cd1887203c633f24b11a18842..91b08e98c1e8df878dc8d4758c651ef871534e77 100644
--- a/src/plugins/e-acsl/tests/bts/bts1395.i
+++ b/src/plugins/e-acsl/tests/bts/bts1395.i
@@ -5,7 +5,8 @@
/*@ requires n > 0; */
int fact(int n) {
- if (n == 1) return 1;
+ if (n == 1)
+ return 1;
return n * fact(n - 1);
}
diff --git a/src/plugins/e-acsl/tests/bts/bts1399.c b/src/plugins/e-acsl/tests/bts/bts1399.c
index 4e2266935d9412df8b276bbcf2706953c3fb3bba..732847286b563f6aa28a4938ecb700828cb867bd 100644
--- a/src/plugins/e-acsl/tests/bts/bts1399.c
+++ b/src/plugins/e-acsl/tests/bts/bts1399.c
@@ -5,14 +5,14 @@
#include "stdlib.h"
struct spongeStateStruct {
- unsigned char __attribute__((__aligned__(32))) state[1600 / 8] ;
- unsigned char __attribute__((__aligned__(32))) dataQueue[1536 / 8] ;
- unsigned int bitsInQueue ;
+ unsigned char __attribute__((__aligned__(32))) state[1600 / 8];
+ unsigned char __attribute__((__aligned__(32))) dataQueue[1536 / 8];
+ unsigned int bitsInQueue;
} __attribute__((__aligned__(32)));
typedef struct spongeStateStruct spongeState;
int main(void) {
- spongeState* state = (spongeState*) malloc(sizeof(spongeState));
+ spongeState *state = (spongeState *)malloc(sizeof(spongeState));
state->bitsInQueue = 16;
/*@ assert
@@ -22,4 +22,3 @@ int main(void) {
free(state);
return 0;
}
-
diff --git a/src/plugins/e-acsl/tests/bts/bts1478.c b/src/plugins/e-acsl/tests/bts/bts1478.c
index b949470b2d922eef32802141472f23a9c8bc42ab..3781da0997d02b5d4c37cd93150f638fd9a023d4 100644
--- a/src/plugins/e-acsl/tests/bts/bts1478.c
+++ b/src/plugins/e-acsl/tests/bts/bts1478.c
@@ -3,13 +3,13 @@
*/
int global_i;
-int* global_i_ptr = &global_i;
+int *global_i_ptr = &global_i;
int global_i = 0;
/*@ requires global_i == 0;
requires \valid(global_i_ptr);
requires global_i_ptr == &global_i; */
-void loop(void) { }
+void loop(void) {}
int main(void) {
loop();
diff --git a/src/plugins/e-acsl/tests/bts/bts1717.i b/src/plugins/e-acsl/tests/bts/bts1717.i
index 71ce1f22484e46ae5c111ff9ba9692ed1a647d31..e47c04f6c377419b5015c5e865fb02c1bb1dda21 100644
--- a/src/plugins/e-acsl/tests/bts/bts1717.i
+++ b/src/plugins/e-acsl/tests/bts/bts1717.i
@@ -6,11 +6,11 @@ int main(void) {
int a = 10, *p;
goto lbl_1;
- lbl_2:
+lbl_2:
/*@ assert \valid(p); */
return 0;
- lbl_1:
+lbl_1:
p = &a;
goto lbl_2;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts1718.i b/src/plugins/e-acsl/tests/bts/bts1718.i
index 2434f530b8607ff42c7032f45f1ed70bd1029cd9..ecbd5622f9b1b448e3bbc359871a1a69ce1c925c 100644
--- a/src/plugins/e-acsl/tests/bts/bts1718.i
+++ b/src/plugins/e-acsl/tests/bts/bts1718.i
@@ -9,11 +9,11 @@ int main(void) {
int a = 10, *p;
goto lbl_1;
- lbl_2:
+lbl_2:
/*@ assert \valid(p); */
return 0;
- lbl_1:
+lbl_1:
p = &a;
goto lbl_2;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts1740.i b/src/plugins/e-acsl/tests/bts/bts1740.i
index 98e99dc7358c69c4d66e322b75829050a4dacb71..836c9bad17c475fc483938b734b9788a6117159c 100644
--- a/src/plugins/e-acsl/tests/bts/bts1740.i
+++ b/src/plugins/e-acsl/tests/bts/bts1740.i
@@ -12,7 +12,7 @@ int main(void) {
goto L;
}
- L:
+L:
/*@ assert ! \valid(p); */
return 0;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts2191.c b/src/plugins/e-acsl/tests/bts/bts2191.c
index 8ce8acf7fa83169d40763aed125cca1b7817f8a8..6b435d905e8c4cf0ebdadc5c06c0aa289b1b95ca 100644
--- a/src/plugins/e-acsl/tests/bts/bts2191.c
+++ b/src/plugins/e-acsl/tests/bts/bts2191.c
@@ -3,22 +3,14 @@
*/
struct ST {
- char *str;
- int num;
+ char *str;
+ int num;
};
-struct ST _G[] = {
- {
- .str = "Struct_G[0]",
- .num = 99
- },
- {
- .str = "Struct_G[1]",
- .num = 147
- }
-};
+struct ST _G[] = {{.str = "Struct_G[0]", .num = 99},
+ {.str = "Struct_G[1]", .num = 147}};
int main(int argc, char **argv) {
- /*@ assert \valid_read(_G[0].str); */
- return 0;
+ /*@ assert \valid_read(_G[0].str); */
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/bts/bts2252.c b/src/plugins/e-acsl/tests/bts/bts2252.c
index 7bd739ccc4fe5826554b48a894bb58c5c1264992..ddd5fa275b35640d0d8afdfd54b5131d60be91aa 100644
--- a/src/plugins/e-acsl/tests/bts/bts2252.c
+++ b/src/plugins/e-acsl/tests/bts/bts2252.c
@@ -6,10 +6,10 @@
#include <string.h>
int main() {
- char* srcbuf = "Test Code";
+ char *srcbuf = "Test Code";
int i, loc = 1;
- char * destbuf = (char*)malloc(10*sizeof(char));
+ char *destbuf = (char *)malloc(10 * sizeof(char));
char ch = 'o';
if (destbuf != NULL) {
@@ -20,7 +20,7 @@ int main() {
}
}
- strncpy (&destbuf[loc], &srcbuf[loc], 1);
+ strncpy(&destbuf[loc], &srcbuf[loc], 1);
free(destbuf);
}
}
diff --git a/src/plugins/e-acsl/tests/bts/bts2305.c b/src/plugins/e-acsl/tests/bts/bts2305.c
index 4b35e986c7601c42f74cd6e44841c2f8e9cfef3a..9e72500b8d1830e5807bbf1671ceaf031598d6a6 100644
--- a/src/plugins/e-acsl/tests/bts/bts2305.c
+++ b/src/plugins/e-acsl/tests/bts/bts2305.c
@@ -9,13 +9,11 @@ struct bitfields {
bool j : 1;
} t;
-int test(struct bitfields *a)
-{
+int test(struct bitfields *a) {
return a->i;
}
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
//@ assert \valid_read(&(t.j));
//@ assert \valid_read(&(t.j) + (1..3));
t.j = 1;
diff --git a/src/plugins/e-acsl/tests/bts/bts2406.c b/src/plugins/e-acsl/tests/bts/bts2406.c
index 30c52958e421f3d6cb4e2b49561a4b28456620e6..05886010ca327aa157c25fd158b04f97062f1996 100644
--- a/src/plugins/e-acsl/tests/bts/bts2406.c
+++ b/src/plugins/e-acsl/tests/bts/bts2406.c
@@ -3,7 +3,7 @@
*/
const char tab[]; /* not monitored */
-char t[10]; /* monitored */
+char t[10]; /* monitored */
int main(void) {
char *p = tab; /* monitored */
diff --git a/src/plugins/e-acsl/tests/bts/issue-eacsl-105.c b/src/plugins/e-acsl/tests/bts/issue-eacsl-105.c
index 23814838fe918ecb2843468da319d307ea556318..3878a97a1d6a1b319cf5893a152b6d3b65d85b7e 100644
--- a/src/plugins/e-acsl/tests/bts/issue-eacsl-105.c
+++ b/src/plugins/e-acsl/tests/bts/issue-eacsl-105.c
@@ -7,11 +7,11 @@ int f() {
int a = 10;
goto lbl_1;
- lbl_2:
+lbl_2:
/*@ assert \valid(&a); */
return 0;
- lbl_1:
+lbl_1:
goto lbl_2;
}
diff --git a/src/plugins/e-acsl/tests/bts/issue-eacsl-139.c b/src/plugins/e-acsl/tests/bts/issue-eacsl-139.c
index 8222c0e3c22db38e45093403e4c508f67ef89ad9..74f3fd6b72407b38d44f239829fd3fe630d771e1 100644
--- a/src/plugins/e-acsl/tests/bts/issue-eacsl-139.c
+++ b/src/plugins/e-acsl/tests/bts/issue-eacsl-139.c
@@ -3,15 +3,14 @@
COMMENT: of crashing Frama-C (issue frama-c/e-acsl#139).
*/
struct X {
- int i ;
+ int i;
};
/*@ ensures *\old(item) == \old(*item); */
-void f(struct X *item){
-}
+void f(struct X *item) {}
int main() {
- struct X x = {.i = 1};
- f(&x);
- return 0;
+ struct X x = {.i = 1};
+ f(&x);
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/bts/issue-eacsl-149.c b/src/plugins/e-acsl/tests/bts/issue-eacsl-149.c
index 64c896816225bc4e3c40874e3ae0bb8a6a8e34f6..ac4223d0d69d8f01c9874d835cc160acfe864723 100644
--- a/src/plugins/e-acsl/tests/bts/issue-eacsl-149.c
+++ b/src/plugins/e-acsl/tests/bts/issue-eacsl-149.c
@@ -1,6 +1,6 @@
#include <limits.h>
-int main (int argc, char *argv[]) {
+int main(int argc, char *argv[]) {
/*@ assert \exists unsigned int x; -1 < x < 5 && x == 0;*/
/*@ assert !(\forall unsigned int x; -1 < x < 5 ==> x != 0);*/
return 0;
diff --git a/src/plugins/e-acsl/tests/bts/issue-eacsl-177.c b/src/plugins/e-acsl/tests/bts/issue-eacsl-177.c
index affaf754bb995c7438e2b4c6e71f350cb4c288c3..6a73e64a1204ace39c34765acd6f89b801884fc3 100644
--- a/src/plugins/e-acsl/tests/bts/issue-eacsl-177.c
+++ b/src/plugins/e-acsl/tests/bts/issue-eacsl-177.c
@@ -3,14 +3,13 @@
STDOPT: +"-eva-unroll-recursive-calls 100"
*/
-#include<limits.h>
+#include <limits.h>
/*@ logic integer f(integer n) =
n <= INT_MAX+1 || n >= LONG_MAX+1 ? 0 : f(n + 1) + n; */
-int main (void) {
- /*@ assert f(0) == 0; */ ;
+int main(void) {
+ /*@ assert f(0) == 0; */;
/*@ assert (\let n = (0 == 0) ? LONG_MAX : -1; f(n) != 0); */
-
}
diff --git a/src/plugins/e-acsl/tests/bts/issue-eacsl-91.c b/src/plugins/e-acsl/tests/bts/issue-eacsl-91.c
index 232f7d14e3320c6ba6608c233da2c5fdf04ad0ec..c2381b4a8680cbd17000d0caec7eb925088080e0 100644
--- a/src/plugins/e-acsl/tests/bts/issue-eacsl-91.c
+++ b/src/plugins/e-acsl/tests/bts/issue-eacsl-91.c
@@ -4,10 +4,8 @@
STDOPT: #"-e-acsl-full-mtracking"
*/
short a;
-char b()
-{
- switch (a)
- {
+char b() {
+ switch (a) {
int c = 0;
case 0:
goto d;
@@ -19,8 +17,7 @@ d:
return 2;
}
-int main()
-{
+int main() {
b();
return 0;
}
diff --git a/src/plugins/e-acsl/tests/bts/issue69.c b/src/plugins/e-acsl/tests/bts/issue69.c
index c571c92c749ba327e179f07346aa802a0092f204..bf0aa43048305f29dfaf410104bba8fe30f46de4 100644
--- a/src/plugins/e-acsl/tests/bts/issue69.c
+++ b/src/plugins/e-acsl/tests/bts/issue69.c
@@ -3,10 +3,11 @@
*/
int main(void) {
- /*@ assert \forall unsigned char c; 4 <= c <= 300 ==> 0 <= c <= 255; */ ;
+ /*@ assert \forall unsigned char c; 4 <= c <= 300 ==> 0 <= c <= 255; */;
int n = 5;
/*@ assert
\let m = n > 0 ? 4 : 341;
- \forall char u; 1 < u < m ==> u > 0; */ ;
+ \forall char u; 1 < u < m ==> u > 0; */
+ ;
}
diff --git a/src/plugins/e-acsl/tests/builtin/strcat.c b/src/plugins/e-acsl/tests/builtin/strcat.c
index c5490e04736fc38ea7518a6b4e47cafe4f458bd7..2c4888ccb582a2161714936c998d05712b08e207 100644
--- a/src/plugins/e-acsl/tests/builtin/strcat.c
+++ b/src/plugins/e-acsl/tests/builtin/strcat.c
@@ -4,8 +4,8 @@
*/
#include "../utils/signalled.h"
-#include <string.h>
#include <stdlib.h>
+#include <string.h>
void test_memory_tracking() {
{
@@ -53,55 +53,54 @@ int main(int argc, const char **argv) {
char *empty_str = "";
free(unalloc_str);
{
- /* strcat */
- char dest1[9] = "dcba";
- char dest2[8] = "dcba";
- char dest3[5] = "----";
- char dest4[10] = "dcba";
- char *pd1 = &dest1;
- char *pd2 = &dest2;
- char *pd3 = &dest3;
- char *pd4 = &dest4;
+ /* strcat */
+ char dest1[9] = "dcba";
+ char dest2[8] = "dcba";
+ char dest3[5] = "----";
+ char dest4[10] = "dcba";
+ char *pd1 = &dest1;
+ char *pd2 = &dest2;
+ char *pd3 = &dest3;
+ char *pd4 = &dest4;
- /* strcat */
- OK(strcat(dest1, const_str)); // enough space in dest [ok]
- OK(strcat(dest3, empty_str)); // enough space in dest (concat with empty) [ok]
- ABRT(strcat(dest2, const_str)); // insufficient space in dest [abort]
- ABRT(strcat(unalloc_str, const_str)); // unallocated in dest [abort]
- ABRT(strcat(dest2, unalloc_str)); // unallocated in src [abort]
- ABRT(strcat(NULL, "")); // NULL in dest [abort]
- ABRT(strcat(dest1, NULL)); // NULL in src [abort]
- ABRT(strcat(const_str, const_str)); // immutable in dest [abort]
- ABRT(strcat(pd1, pd1)); // overlapping spaces (same address) [abort]
- ABRT(strcat(pd1 + 3, pd1)); // overlapping spaces [abort]
- ABRT(strcat(pd4 + 4, pd4)); // overlapping spaces [abort]
- OK(pd4[5] = '\0'; strcat(pd4 + 5, pd4)); // non-overlapping
+ /* strcat */
+ OK(strcat(dest1, const_str)); // enough space in dest [ok]
+ OK(strcat(dest3,
+ empty_str)); // enough space in dest (concat with empty) [ok]
+ ABRT(strcat(dest2, const_str)); // insufficient space in dest [abort]
+ ABRT(strcat(unalloc_str, const_str)); // unallocated in dest [abort]
+ ABRT(strcat(dest2, unalloc_str)); // unallocated in src [abort]
+ ABRT(strcat(NULL, "")); // NULL in dest [abort]
+ ABRT(strcat(dest1, NULL)); // NULL in src [abort]
+ ABRT(strcat(const_str, const_str)); // immutable in dest [abort]
+ ABRT(strcat(pd1, pd1)); // overlapping spaces (same address) [abort]
+ ABRT(strcat(pd1 + 3, pd1)); // overlapping spaces [abort]
+ ABRT(strcat(pd4 + 4, pd4)); // overlapping spaces [abort]
+ OK(pd4[5] = '\0'; strcat(pd4 + 5, pd4)); // non-overlapping
}
{
- /* strncat */
- char dest1[9] = "dcba";
- char dest2[8] = "dcba";
- char dest3[5] = "----";
- char dest4[10] = "dcba";
- char *pd1 = &dest1;
- char *pd2 = &dest2;
- char *pd3 = &dest3;
- char *pd4 = &dest4;
- /* strncat */
- OK(strncat(dest1, const_str, 4)); // enough space in dest
- ABRT(strncat(dest2, const_str, 4)); // insufficient space in dest
- ABRT(strncat(unalloc_str, const_str, 1)); // unallocated in dest [abort]
- ABRT(strncat(dest2, unalloc_str, 1)); // unallocated in src [abort]
- ABRT(strncat(NULL, const_str, 1)); // NULL in dest [abort]
- ABRT(strncat(dest2, NULL, 1)); // NULL in src [abort]
- ABRT(strncat(const_str, const_str, 1)); // immutable in dest [abort]
+ /* strncat */
+ char dest1[9] = "dcba";
+ char dest2[8] = "dcba";
+ char dest3[5] = "----";
+ char dest4[10] = "dcba";
+ char *pd1 = &dest1;
+ char *pd2 = &dest2;
+ char *pd3 = &dest3;
+ char *pd4 = &dest4;
+ /* strncat */
+ OK(strncat(dest1, const_str, 4)); // enough space in dest
+ ABRT(strncat(dest2, const_str, 4)); // insufficient space in dest
+ ABRT(strncat(unalloc_str, const_str, 1)); // unallocated in dest [abort]
+ ABRT(strncat(dest2, unalloc_str, 1)); // unallocated in src [abort]
+ ABRT(strncat(NULL, const_str, 1)); // NULL in dest [abort]
+ ABRT(strncat(dest2, NULL, 1)); // NULL in src [abort]
+ ABRT(strncat(const_str, const_str, 1)); // immutable in dest [abort]
- ABRT(strncat(pd1, pd1, 1)); // overlapping spaces (same address) [abort]
- ABRT(strncat(pd1 + 3, pd1, 5)); // overlapping spaces [abort]
- ABRT(strncat(pd4 + 4, pd4, 5)); // overlapping spaces [abort]
+ ABRT(strncat(pd1, pd1, 1)); // overlapping spaces (same address) [abort]
+ ABRT(strncat(pd1 + 3, pd1, 5)); // overlapping spaces [abort]
+ ABRT(strncat(pd4 + 4, pd4, 5)); // overlapping spaces [abort]
}
test_memory_tracking();
return 0;
}
-
-
diff --git a/src/plugins/e-acsl/tests/builtin/strcmp.c b/src/plugins/e-acsl/tests/builtin/strcmp.c
index 3618105f7e3928623b29811582a4a927e7b63264..add8cc87f8972b6ee3aec792ec31c91878021d23 100644
--- a/src/plugins/e-acsl/tests/builtin/strcmp.c
+++ b/src/plugins/e-acsl/tests/builtin/strcmp.c
@@ -3,8 +3,8 @@
*/
#include "../utils/signalled.h"
-#include <string.h>
#include <stdlib.h>
+#include <string.h>
static inline void fail_ncomp(int cond, char *fmt, int l, int r) {
if (cond) {
@@ -13,77 +13,78 @@ static inline void fail_ncomp(int cond, char *fmt, int l, int r) {
}
}
-#define EQ(l,r) fail_ncomp(l != r, "comparison failure: %d == %d\n", l, r)
-#define NEQ(l,r) fail_ncomp(l == r, "comparison failure: %d != %d\n", l, r)
+#define EQ(l, r) fail_ncomp(l != r, "comparison failure: %d == %d\n", l, r)
+#define NEQ(l, r) fail_ncomp(l == r, "comparison failure: %d != %d\n", l, r)
int main(int argc, const char **argv) {
- const char *cl = "abc",
- *cr = "abc";
+ const char *cl = "abc", *cr = "abc";
- char al[4] = "abc",
- ar[4] = "abc";
+ char al[4] = "abc", ar[4] = "abc";
- char *dl = strdup("abc"),
- *dr = strdup("abc");
+ char *dl = strdup("abc"), *dr = strdup("abc");
int res;
/* strcmp {{{ */
- OK(EQ(strcmp(cl, cr),0)); // valid comparison of constants [ok]
- OK(EQ(strcmp(al, ar),0)); // valid comparison of stack strings [ok]
- OK(EQ(strcmp(dl, dr),0)); // valid comparison of heap strings [ok]
+ OK(EQ(strcmp(cl, cr), 0)); // valid comparison of constants [ok]
+ OK(EQ(strcmp(al, ar), 0)); // valid comparison of stack strings [ok]
+ OK(EQ(strcmp(dl, dr), 0)); // valid comparison of heap strings [ok]
al[3] = 'a';
- ABRT(EQ(strcmp(al, ar),0)); // unterminated in left stack [ok]
- ar[3] = 'a'; al[3] = 0;
- ABRT(EQ(strcmp(al, ar),0)); // unterminated in right stack [ok]
+ ABRT(EQ(strcmp(al, ar), 0)); // unterminated in left stack [ok]
+ ar[3] = 'a';
+ al[3] = 0;
+ ABRT(EQ(strcmp(al, ar), 0)); // unterminated in right stack [ok]
dl[3] = 'a';
- ABRT(EQ(strcmp(dl, dr),0)); // unterminated in left heap [ok]
- dr[3] = 'a'; dl[3] = 0;
- ABRT(EQ(strcmp(dl, dr),0)); // unterminated in right heap [ok]
+ ABRT(EQ(strcmp(dl, dr), 0)); // unterminated in left heap [ok]
+ dr[3] = 'a';
+ dl[3] = 0;
+ ABRT(EQ(strcmp(dl, dr), 0)); // unterminated in right heap [ok]
- ABRT(EQ(strcmp(dl, NULL),0)); // NULL in left [ok]
- ABRT(EQ(strcmp(NULL, dr),0)); // NULL in right [ok]
+ ABRT(EQ(strcmp(dl, NULL), 0)); // NULL in left [ok]
+ ABRT(EQ(strcmp(NULL, dr), 0)); // NULL in right [ok]
free(dl);
free(dr);
- ABRT(EQ(strcmp(dl, ar),0)); // dangling in left [ok]
- ABRT(EQ(strcmp(al, dr),0)); // dangling in right [ok]
+ ABRT(EQ(strcmp(dl, ar), 0)); // dangling in left [ok]
+ ABRT(EQ(strcmp(al, dr), 0)); // dangling in right [ok]
/* }}} */
/* strncmp {{{ */
- dl = strdup("abc"),
- dr = strdup("abc");
+ dl = strdup("abc"), dr = strdup("abc");
- char nal[4] = "abc",
- nar[4] = "abc";
+ char nal[4] = "abc", nar[4] = "abc";
- OK(EQ(strncmp(cl, cr, 3),0)); // valid comparison of constants [ok]
- OK(EQ(strncmp(nal, nar, 3),0)); // valid comparison of stack strings [ok]
- OK(EQ(strncmp(dl, dr, 3),0)); // valid comparison of heap strings [ok]
+ OK(EQ(strncmp(cl, cr, 3), 0)); // valid comparison of constants [ok]
+ OK(EQ(strncmp(nal, nar, 3), 0)); // valid comparison of stack strings [ok]
+ OK(EQ(strncmp(dl, dr, 3), 0)); // valid comparison of heap strings [ok]
// Still ok because there is a terminator
- OK(EQ(strncmp(nal, nar, 6),0)); // valid comparison of stack strings [ok]
- OK(EQ(strncmp(dl, dr, 6),0)); // valid comparison of heap strings [ok]
+ OK(EQ(strncmp(nal, nar, 6), 0)); // valid comparison of stack strings [ok]
+ OK(EQ(strncmp(dl, dr, 6), 0)); // valid comparison of heap strings [ok]
nal[3] = 'd';
// no terminator but within allocated length [ok]
- OK(NEQ(strncmp(nal, nar, 4),0));
- nar[3] = 'd'; nal[3] = 0;
- OK(NEQ(strncmp(nal, nar, 4),0));
+ OK(NEQ(strncmp(nal, nar, 4), 0));
+ nar[3] = 'd';
+ nal[3] = 0;
+ OK(NEQ(strncmp(nal, nar, 4), 0));
dl[3] = 'd';
- OK(NEQ(strncmp(dl, dr, 4),0));
- dr[3] = 'd'; dl[3] = 0;
- OK(NEQ(strncmp(dl, dr, 4),0));
+ OK(NEQ(strncmp(dl, dr, 4), 0));
+ dr[3] = 'd';
+ dl[3] = 0;
+ OK(NEQ(strncmp(dl, dr, 4), 0));
// no terminator but outside allocated length [abort]
ABRT(res = strncmp(nal, nar, 5));
- nal[3] = 'd'; nar[3] = 0;
+ nal[3] = 'd';
+ nar[3] = 0;
ABRT(res = strncmp(al, ar, 5));
ABRT(res = strncmp(dl, dr, 5));
- dl[3] = 'd'; dr[3] = 0;
+ dl[3] = 'd';
+ dr[3] = 0;
ABRT(res = strncmp(dl, dr, 5));
free(dl);
diff --git a/src/plugins/e-acsl/tests/builtin/strcpy.c b/src/plugins/e-acsl/tests/builtin/strcpy.c
index 4aaa1722b185f12e572b07614bf2054fbd7ac10f..64a0571c23ad5177247836e1cbd210196447f9a5 100644
--- a/src/plugins/e-acsl/tests/builtin/strcpy.c
+++ b/src/plugins/e-acsl/tests/builtin/strcpy.c
@@ -3,8 +3,8 @@
*/
#include "../utils/signalled.h"
-#include <string.h>
#include <stdlib.h>
+#include <string.h>
void test_memory_tracking() {
{
@@ -48,27 +48,29 @@ int main(int argc, const char **argv) {
char dest3[256] = "abcd";
size_t len = 0;
- char *unalloc_str = malloc(5); char* _barrier = malloc(1); free(unalloc_str);
+ char *unalloc_str = malloc(5);
+ char *_barrier = malloc(1);
+ free(unalloc_str);
/* strcpy */
- OK(strcpy(dest1, src)); // heap allocated, sufficient space [ok]
- OK(strcpy(empty_str, "")); // copy empty string [ok]
- ABRT(strcpy(dest2, src)); // heap allocated, insufficient space [abort]
+ OK(strcpy(dest1, src)); // heap allocated, sufficient space [ok]
+ OK(strcpy(empty_str, "")); // copy empty string [ok]
+ ABRT(strcpy(dest2, src)); // heap allocated, insufficient space [abort]
ABRT(strcpy(unalloc_str, src)); // unallocated [abort]
- ABRT(strcpy(const_str, src)); // read-only in dest [abort]
- OK(strcpy(src, const_str)); // read-only in src [ok]
- ABRT(strcpy(src, src)); // same address, overlapping [abort]
- OK(strcpy(dest3 + 5, dest3)); // same string, non-overlapping [ok]
+ ABRT(strcpy(const_str, src)); // read-only in dest [abort]
+ OK(strcpy(src, const_str)); // read-only in src [ok]
+ ABRT(strcpy(src, src)); // same address, overlapping [abort]
+ OK(strcpy(dest3 + 5, dest3)); // same string, non-overlapping [ok]
ABRT(strcpy(dest3 + 4, dest3)); // same string, overlapping [abort]
/* strncpy */
- OK(strncpy(dest1, src, 5)); // heap allocated, sufficient space [ok]
+ OK(strncpy(dest1, src, 5)); // heap allocated, sufficient space [ok]
ABRT(strncpy(dest1, src, 6)); // heap allocated, insufficient space [abort]
ABRT(strncpy(unalloc_str, src, 5)); // unallocated [abort]
- ABRT(strncpy(const_str, src, 5)); // read-only in dest [abort]
- OK(strncpy(src, const_str, 5)); // read-only in src [ok]
- ABRT(strncpy(src, src, 5)); // same address, overlapping [abort]
- OK(strncpy(dest3 + 5, dest3, 5)); // same string, non-overlapping [ok]
+ ABRT(strncpy(const_str, src, 5)); // read-only in dest [abort]
+ OK(strncpy(src, const_str, 5)); // read-only in src [ok]
+ ABRT(strncpy(src, src, 5)); // same address, overlapping [abort]
+ OK(strncpy(dest3 + 5, dest3, 5)); // same string, non-overlapping [ok]
ABRT(strncpy(dest3 + 4, dest3, 5)); // same string, overlapping [abort]
free(src);
diff --git a/src/plugins/e-acsl/tests/builtin/strlen.c b/src/plugins/e-acsl/tests/builtin/strlen.c
index b64c51052e10014e8a8ca7c70cf68c238c04a3bc..fa4b27884db767f43d747ca5010e83344d046045 100644
--- a/src/plugins/e-acsl/tests/builtin/strlen.c
+++ b/src/plugins/e-acsl/tests/builtin/strlen.c
@@ -3,10 +3,12 @@
*/
#include "../utils/signalled.h"
-#include <string.h>
#include <stdlib.h>
+#include <string.h>
-#define EQ(l,r) if (l != r) abort();
+#define EQ(l, r) \
+ if (l != r) \
+ abort();
int main(int argc, const char **argv) {
int len;
@@ -15,18 +17,19 @@ int main(int argc, const char **argv) {
char stack_str[] = "the dog";
char *const_str = "the hog";
- OK(EQ(len = strlen(empty_str),0)); // strlen on a valid (zero-length) string [ok]
- OK(EQ(len = strlen(heap_str),7)); // strlen on a heap string [ok]
- OK(EQ(len = strlen(stack_str),7)); // strlen on a stack string [ok]
- OK(EQ(len = strlen(const_str),7)); // strlen on a const string [ok]
+ OK(EQ(len = strlen(empty_str),
+ 0)); // strlen on a valid (zero-length) string [ok]
+ OK(EQ(len = strlen(heap_str), 7)); // strlen on a heap string [ok]
+ OK(EQ(len = strlen(stack_str), 7)); // strlen on a stack string [ok]
+ OK(EQ(len = strlen(const_str), 7)); // strlen on a const string [ok]
heap_str[7] = 'a';
stack_str[7] = 'a';
- ABRT(EQ(len = strlen(heap_str),7)); // strlen on unterminated heap string [abort]
- ABRT(EQ(len = strlen(stack_str),7)); // strlen on unterminated stack string [abort]
+ ABRT(EQ(len = strlen(heap_str),
+ 7)); // strlen on unterminated heap string [abort]
+ ABRT(EQ(len = strlen(stack_str),
+ 7)); // strlen on unterminated stack string [abort]
free(heap_str);
- ABRT(EQ(len = strlen(heap_str),7)); // strlen on invalid heap string [abort]
+ ABRT(EQ(len = strlen(heap_str), 7)); // strlen on invalid heap string [abort]
return 0;
}
-
-
diff --git a/src/plugins/e-acsl/tests/constructs/acsl_check.c b/src/plugins/e-acsl/tests/constructs/acsl_check.c
index 177b6c71a82be5dc2bf1093b0f7e04decf402901..7c7659f8dda7fe7dfc3e42102563799849306fcc 100644
--- a/src/plugins/e-acsl/tests/constructs/acsl_check.c
+++ b/src/plugins/e-acsl/tests/constructs/acsl_check.c
@@ -8,7 +8,7 @@ int f(int a) {
return a;
}
-void g(int a, int * b) {
+void g(int a, int *b) {
//@ check a / b[1] == 0;
}
diff --git a/src/plugins/e-acsl/tests/constructs/decrease.c b/src/plugins/e-acsl/tests/constructs/decrease.c
index 4e32701dbebbabe29db2ce924d45c7f7df62d1e4..95793b4e46e1ebd5c4cd380a5a4bdddc1e16eac0 100644
--- a/src/plugins/e-acsl/tests/constructs/decrease.c
+++ b/src/plugins/e-acsl/tests/constructs/decrease.c
@@ -43,8 +43,8 @@ size_t fact2(size_t n) {
size_t result = n;
/*@ loop invariant 1 <= i < n;
loop variant n - i; */
- for (size_t i = 1UL ; i < (n - 1UL) ; i++) {
- result *= (n - i);
+ for (size_t i = 1UL; i < (n - 1UL); i++) {
+ result *= (n - i);
}
return result;
}
@@ -52,8 +52,10 @@ size_t fact2(size_t n) {
// Test decreases on recursive function
/*@ decreases n; */
int fib(int n) {
- if (n == 1) return 1;
- if (n <= 0) return 0;
+ if (n == 1)
+ return 1;
+ if (n <= 0)
+ return 0;
return fib(n - 1) + fib(n - 2);
}
@@ -62,13 +64,15 @@ int odd(int);
/*@ requires n >= 0;
decreases n; */
int even(int n) {
- if (n == 0) return 1;
+ if (n == 0)
+ return 1;
return odd(n - 1);
}
/*@ requires n >= 0;
decreases n; */
int odd(int n) {
- if (n == 0) return 0;
+ if (n == 0)
+ return 0;
return even(n - 1);
}
diff --git a/src/plugins/e-acsl/tests/constructs/false.i b/src/plugins/e-acsl/tests/constructs/false.i
index bda3a1bb9941ff5a13dffdb9cf0b74bf5e65eb78..818cfe631b8c2b3b241b05955112de7ada1388fd 100644
--- a/src/plugins/e-acsl/tests/constructs/false.i
+++ b/src/plugins/e-acsl/tests/constructs/false.i
@@ -4,7 +4,7 @@
int main(void) {
int x = 0;
if (x) {
- /*@ assert \false; */ ;
+ /*@ assert \false; */;
}
return 0;
}
diff --git a/src/plugins/e-acsl/tests/constructs/function_contract.i b/src/plugins/e-acsl/tests/constructs/function_contract.i
index 512c41f6474f048d0bf26e64360764d289df8b21..fad50bd997b5bb812e5979fa4ef6bdbfe16765d1 100644
--- a/src/plugins/e-acsl/tests/constructs/function_contract.i
+++ b/src/plugins/e-acsl/tests/constructs/function_contract.i
@@ -6,21 +6,29 @@ int X = 0, Y = 2;
// one ensures
/*@ ensures X == 1; */
-void f(void) { X = 1; }
+void f(void) {
+ X = 1;
+}
// several ensures
/*@ ensures X == 2;
@ ensures Y == 2; */
-void g(void) { X = 2; }
+void g(void) {
+ X = 2;
+}
// one requires
/*@ requires X == 2; */
-void h(void) { X += 1; }
+void h(void) {
+ X += 1;
+}
// several requires
/*@ requires X == 3;
@ requires Y == 2; */
-void i(void) { X += Y; }
+void i(void) {
+ X += Y;
+}
// several behaviors
/*@ behavior b1:
@@ -30,7 +38,9 @@ void i(void) { X += Y; }
@ requires X == 3 + Y;
@ requires Y == 2;
@ ensures X == Y + 1; */
-void j(void) { X = 3; }
+void j(void) {
+ X = 3;
+}
// mix requires and assumes
/*@ behavior b1:
@@ -41,7 +51,9 @@ void j(void) { X = 3; }
@ assumes Y == 2;
@ requires X == 3;
@ requires X + Y == 5; */
-void k(void) { X += Y; }
+void k(void) {
+ X += Y;
+}
// mix ensures + contract on return
/*@ ensures X == 5; */
@@ -59,7 +71,9 @@ int l() {
@ assumes Y == 2;
@ ensures X == 7;
@ ensures X == \old(X) + Y; */
-void m(void) { X += Y; }
+void m(void) {
+ X += Y;
+}
// mix requires, ensures and assumes
/*@ requires X > 0;
@@ -70,7 +84,9 @@ void m(void) { X += Y; }
@ behavior b2:
@ assumes X == 5;
@ ensures X == 98; */
-void n(void) { X ++; }
+void n(void) {
+ X++;
+}
// several complete and disjoint clauses
/*@
@@ -104,7 +120,9 @@ void n(void) { X ++; }
disjoint behaviors neg, pos;
disjoint behaviors odd, even;
*/
-void o(void) { X = Y; }
+void o(void) {
+ X = Y;
+}
int main(void) {
f();
diff --git a/src/plugins/e-acsl/tests/constructs/ghost.i b/src/plugins/e-acsl/tests/constructs/ghost.i
index 9f76188f2356ebab7a7499902a9e3ab8de30b030..8fdfd90a2fc5baf53c185797e63058cb7a7c1bdf 100644
--- a/src/plugins/e-acsl/tests/constructs/ghost.i
+++ b/src/plugins/e-acsl/tests/constructs/ghost.i
@@ -8,16 +8,16 @@
// /*@ ghost int foo(int *x) { return *x + 1; } */
int main(void) {
- /*@ ghost P = &G; */ ;
+ /*@ ghost P = &G; */;
/*@ ghost int \ghost *q = P; */
/*@ ghost (*P)++; */
/*@ assert *q == G; */
// /*@ ghost G = foo(&G); */
// /*@ assert G == 2; */
- int x = 1 ;
- if(x){
- x++ ;
+ int x = 1;
+ if (x) {
+ x++;
} /*@ ghost else {
G++ ;
G++ ;
diff --git a/src/plugins/e-acsl/tests/constructs/invariant.i b/src/plugins/e-acsl/tests/constructs/invariant.i
index 6458296dc3d3cce7f5f97b3a143928d0e960516a..de6c64fc1555308dcd8f5e9193bfaabf344dcb26 100644
--- a/src/plugins/e-acsl/tests/constructs/invariant.i
+++ b/src/plugins/e-acsl/tests/constructs/invariant.i
@@ -5,7 +5,7 @@
int main(void) {
int x = 0;
- for(int i = 0; i < 10; i++) {
+ for (int i = 0; i < 10; i++) {
/*@ invariant 0 <= i < 10; */
x += i;
/*@ invariant i <= x; */
diff --git a/src/plugins/e-acsl/tests/constructs/labeled_stmt.i b/src/plugins/e-acsl/tests/constructs/labeled_stmt.i
index 1c4be5a49017c78ada50299b0efa4ccd603a8084..a725bb10c67b3526c798a144eb990e6ff1ff31e5 100644
--- a/src/plugins/e-acsl/tests/constructs/labeled_stmt.i
+++ b/src/plugins/e-acsl/tests/constructs/labeled_stmt.i
@@ -7,9 +7,14 @@ int X = 0;
/*@ ensures X == 3; */
int main(void) {
goto L1;
- L1: /*@ assert X == 0; */ X = 1;
+L1: /*@ assert X == 0; */
+ X = 1;
goto L2;
- L2: /*@ requires X == 1; ensures X == 2; */ X = 2;
- if (X) { X = 3; return 0; }
+L2: /*@ requires X == 1; ensures X == 2; */
+ X = 2;
+ if (X) {
+ X = 3;
+ return 0;
+ }
return 0;
}
diff --git a/src/plugins/e-acsl/tests/constructs/loop.i b/src/plugins/e-acsl/tests/constructs/loop.i
index c16fb84a349af09e44d83908996d6ed8d5400fb4..d6afe1eaceec5ee77fb78ec9d22f799e1fdd03b9 100644
--- a/src/plugins/e-acsl/tests/constructs/loop.i
+++ b/src/plugins/e-acsl/tests/constructs/loop.i
@@ -6,26 +6,27 @@
void simple_loop() {
int sum = 0;
/*@ loop invariant 0 <= i <= 10; */
- for(int i = 0; i < 10; i++)
- sum +=i;
+ for (int i = 0; i < 10; i++)
+ sum += i;
}
void nested_loops() {
int t[4][8];
/*@ loop invariant 0 <= i <= 4; */
- for(int i = 0; i < 4; i++)
+ for (int i = 0; i < 4; i++)
/*@ loop invariant 0 <= j <= 8;
@ loop invariant
@ \forall integer k,l; 0 <= k < i && 0 <= l < j ==> t[k][l] == k * l; */
- for(int j = 0; j < 8; j++)
+ for (int j = 0; j < 8; j++)
t[i][j] = i * j;
}
void unnatural_loop() {
int x = 0;
/*@ loop invariant 0 <= i <= 6; */
- for(int i = 0; i < 10; i++) {
- if (x == 5) break;
+ for (int i = 0; i < 10; i++) {
+ if (x == 5)
+ break;
x = i;
}
}
diff --git a/src/plugins/e-acsl/tests/constructs/nested_code_annot.i b/src/plugins/e-acsl/tests/constructs/nested_code_annot.i
index f7beebccc7387cc3cc9da41e3cebf5775c7811ae..1e960db4b017348b90f8697c692596c68319e369 100644
--- a/src/plugins/e-acsl/tests/constructs/nested_code_annot.i
+++ b/src/plugins/e-acsl/tests/constructs/nested_code_annot.i
@@ -9,9 +9,8 @@ int main(void) {
@ ensures x >= 1; */
{
if (x) {
- /*@ assert \false; */ ;
- }
- else {
+ /*@ assert \false; */;
+ } else {
/*@ requires x == 0;
@ ensures x == 1; */
x++;
@@ -19,8 +18,8 @@ int main(void) {
/*@ requires x == 1;
@ ensures x == 2; */
x++;
- }
- else /*@ assert \false; */ ;
+ } else /*@ assert \false; */
+ ;
}
}
return 0;
diff --git a/src/plugins/e-acsl/tests/constructs/result.i b/src/plugins/e-acsl/tests/constructs/result.i
index bae320b69ff040d389d0a712c98ad690f109ccc0..9d39c29ab84c287c8c8f0c0ccec644cd0c5af3da 100644
--- a/src/plugins/e-acsl/tests/constructs/result.i
+++ b/src/plugins/e-acsl/tests/constructs/result.i
@@ -3,20 +3,23 @@
*/
/*@ ensures \result == (int)(x - x); */
-int f(int x) {
- x = 0;
- return x; }
+int f(int x) {
+ x = 0;
+ return x;
+}
int Y = 1;
/*@ ensures \result == x;
@ ensures \result == Y; */
-int g(int x) {
- return x;
+int g(int x) {
+ return x;
}
/*@ ensures \result == 0; */
-int h() { return 0; }
+int h() {
+ return 0;
+}
int main(void) {
f(1);
diff --git a/src/plugins/e-acsl/tests/constructs/rte.i b/src/plugins/e-acsl/tests/constructs/rte.i
index 8b4578d3b3f81bac3883f9486e5da3c199631b6a..931f0eebca824267545f4b6d35d085018b2c90f2 100644
--- a/src/plugins/e-acsl/tests/constructs/rte.i
+++ b/src/plugins/e-acsl/tests/constructs/rte.i
@@ -17,8 +17,8 @@
requires \exists integer var; 0 <= var < l && var % l == var;
ensures 1 % e == 1;
*/
-void 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) {
-}
+void 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) {}
int main(void) {
test(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
diff --git a/src/plugins/e-acsl/tests/constructs/typedef.i b/src/plugins/e-acsl/tests/constructs/typedef.i
index afbbc15a43a2494579bbadc35c131c2e4f2590b8..614db705cc97cfabc44db08f1d00d2d29fc294e1 100644
--- a/src/plugins/e-acsl/tests/constructs/typedef.i
+++ b/src/plugins/e-acsl/tests/constructs/typedef.i
@@ -6,6 +6,6 @@ typedef unsigned char uint8;
int main(void) {
uint8 x = 0;
- /*@ assert x == 0; */ ;
+ /*@ assert x == 0; */;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/examples/functions_contiki.c b/src/plugins/e-acsl/tests/examples/functions_contiki.c
index 180c70afd8bb5be37581ff25f00292ca0f34df63..2ff9daebd5d78c03b9fa541bf0fc71461d27285b 100644
--- a/src/plugins/e-acsl/tests/examples/functions_contiki.c
+++ b/src/plugins/e-acsl/tests/examples/functions_contiki.c
@@ -2,8 +2,8 @@
COMMENT: functions used in Contiki
*/
-#include <stdlib.h>
#include <limits.h>
+#include <stdlib.h>
struct list {
struct list *next;
@@ -19,10 +19,10 @@ struct list {
logic integer length(struct list *l) = length_aux(l, 0);
*/
-int main (void) {
+int main(void) {
struct list node1, node2, node3;
node1.next = &node2;
node2.next = &node3;
struct list *l = &node1;
- /*@ assert length(l) == 3; */ ;
+ /*@ assert length(l) == 3; */;
}
diff --git a/src/plugins/e-acsl/tests/examples/linear_search.i b/src/plugins/e-acsl/tests/examples/linear_search.i
index deaecad449293967d541cf34c15763192f8397e7..ecf6e806d7a8e8062504179ec1abbf2e54337375 100644
--- a/src/plugins/e-acsl/tests/examples/linear_search.i
+++ b/src/plugins/e-acsl/tests/examples/linear_search.i
@@ -11,21 +11,24 @@ int A[10];
behavior not_exists:
assumes \forall integer j; 0 <= j < 10 ==> A[j] != elt;
ensures \result == 0; */
-int search(int elt){
+int search(int elt) {
int k;
// linear search in a sorted array
/*@ loop invariant 0 <= k <= 10;
@ loop invariant \forall integer i; 0 <= i < k ==> A[i] < elt; */
- for(k = 0; k < 10; k++)
- if(A[k] == elt) return 1; // element found
- else if(A[k] > elt) return 0; // element not found (sorted array)
- return 0; // element not found
-}
+ for (k = 0; k < 10; k++)
+ if (A[k] == elt)
+ return 1; // element found
+ else if (A[k] > elt)
+ return 0; // element not found (sorted array)
+ return 0; // element not found
+}
int main(void) {
int found;
- for(int i = 0; i < 10; i++) A[i] = i * i;
+ for (int i = 0; i < 10; i++)
+ A[i] = i * i;
found = search(36);
/*@ assert found == 1; */
diff --git a/src/plugins/e-acsl/tests/format/fprintf.c b/src/plugins/e-acsl/tests/format/fprintf.c
index b604a83af4de8f79bbda4b4c50a5f6a4f620dd18..87178190a11e980881a6d02ec4f09235a212752b 100644
--- a/src/plugins/e-acsl/tests/format/fprintf.c
+++ b/src/plugins/e-acsl/tests/format/fprintf.c
@@ -3,13 +3,13 @@
STDOPT: +"-eva-precision=1"
*/
-#include <stdlib.h>
-#include <stdio.h>
#include "../utils/signalled.h"
+#include <stdio.h>
+#include <stdlib.h>
int main(int argc, const char **argv) {
char *pstr = "Hello world!";
- char template [256];
+ char template[256];
/* *** fprintf *** */
// The first argument to printf should be allocated valid FILE
@@ -20,7 +20,7 @@ int main(int argc, const char **argv) {
OK(fprintf(fh, "foobar %s\n", "foobar"));
fclose(fh);
ABRT(fprintf(fh, "foobar %s\n", "foobar"));
- ABRT(fprintf((FILE*)&argc, "foobar %s\n", "foobar"));
+ ABRT(fprintf((FILE *)&argc, "foobar %s\n", "foobar"));
}
/* *** dprintf *** */
@@ -32,18 +32,19 @@ int main(int argc, const char **argv) {
// The buffer used with sprintf should be allocated, writeable and large
// enough
char buf[5];
- OK(sprintf(buf, "-%s-", "1")); // 4 chars, fits
- OK(sprintf(buf, "-%s-", "12")); // 5 chars, still fits
- ABRT(sprintf(buf, "-%s-", "123")); // 6 chars, no space for NUL
+ OK(sprintf(buf, "-%s-", "1")); // 4 chars, fits
+ OK(sprintf(buf, "-%s-", "12")); // 5 chars, still fits
+ ABRT(sprintf(buf, "-%s-", "123")); // 6 chars, no space for NUL
ABRT(sprintf(NULL, "-%s-", "123")); // try NULL
ABRT(sprintf(pstr, "-%s-", "123")); // try read-only
/* *** snprintf *** */
- OK(snprintf(buf, 4, "-%s-", "123")); // 4 chars, fits
- OK(snprintf(buf, 5, "-%s-", "123")); // 4 chars, fits
+ OK(snprintf(buf, 4, "-%s-", "123")); // 4 chars, fits
+ OK(snprintf(buf, 5, "-%s-", "123")); // 4 chars, fits
ABRT(snprintf(pstr, 6, "-%s-", "123")); // try read-only
- ABRT(snprintf(buf, 6, "-%s-", "123")); // not enough space
+ ABRT(snprintf(buf, 6, "-%s-", "123")); // not enough space
ABRT(snprintf(NULL, 6, "-%s-", "123")); // not enough space
- OK(snprintf(NULL, 0, "-%s-", "123")); // NULL should be file because of 0 chars to write
+ OK(snprintf(NULL, 0, "-%s-",
+ "123")); // NULL should be file because of 0 chars to write
return 0;
}
diff --git a/src/plugins/e-acsl/tests/format/printf.c b/src/plugins/e-acsl/tests/format/printf.c
index 2dd37da128665e536cc796a7c31e68d81a269d7a..4b4c505ef0766a749f193a70695e519cff1b3fa0 100644
--- a/src/plugins/e-acsl/tests/format/printf.c
+++ b/src/plugins/e-acsl/tests/format/printf.c
@@ -6,19 +6,19 @@
MACRO: ROOT_EACSL_GCC_OPTS_EXT @ROOT_EACSL_GCC_OPTS_EXT@ -e "-Wno-maybe-uninitialized"
*/
+#include "../utils/signalled.h"
+#include <limits.h>
+#include <signal.h>
#include <stddef.h>
-#include <stdlib.h>
+#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
-#include <signal.h>
#include <unistd.h>
-#include <stdint.h>
-#include <limits.h>
#include <wchar.h>
-#include "../utils/signalled.h"
-#define ABRT_AT(code,at) SIGNALLED_AT(code, 1, at)
-#define OK_AT(code,at) SIGNALLED_AT(code, 0, at)
+#define ABRT_AT(code, at) SIGNALLED_AT(code, 1, at)
+#define OK_AT(code, at) SIGNALLED_AT(code, 0, at)
/* All valid format specifiers */
const char *valid_specifiers = "diouxfFeEgGaAcspn";
@@ -49,7 +49,8 @@ void apply_specifier(char *format, int spec) {
run positive tests for all specifiers from `allowed` and negative ones
for the remaining one. If `only_negative` is true then only negative tests
are run */
-void test_specifier_application(const char *allowed, const char *fmt, int only_negative, char *at) {
+void test_specifier_application(const char *allowed, const char *fmt,
+ int only_negative, char *at) {
int len = strlen(fmt);
char format[len + 1];
strcpy(format, fmt);
@@ -59,10 +60,10 @@ void test_specifier_application(const char *allowed, const char *fmt, int only_n
format[len - 1] = c;
if (strchr(allowed, c)) {
if (!only_negative) {
- OK_AT(apply_specifier(format,c),at);
+ OK_AT(apply_specifier(format, c), at);
}
} else {
- ABRT_AT(apply_specifier(format,c),at);
+ ABRT_AT(apply_specifier(format, c), at);
}
}
}
@@ -72,7 +73,7 @@ int main(int argc, const char **argv) {
char *pstr = "Hello world!";
char astr[] = "Hello world!";
signed char *sastr = astr;
- void *vptr = (void*)&argc;
+ void *vptr = (void *)&argc;
// char
char chr = 'T';
unsigned char uchr = 'U';
@@ -225,7 +226,7 @@ int main(int argc, const char **argv) {
// Undef 9. there are more than one LM per one CS
OK(printf("%ld\n", 1L));
- OK(printf("%lld\n",1LL));
+ OK(printf("%lld\n", 1LL));
ABRT(printf("%llld\n", 1LL));
// FIXME: an issue with positive tests here. This is because length modifiers
@@ -233,26 +234,41 @@ int main(int argc, const char **argv) {
// Undef 10. 'hh' used with a CS other than [diouxXn]
test_specifier_application("diouxXn", "%hhX", 1, AT);
- OK(printf("%hhd", 1)); OK(printf("%hhi", 1));
- OK(printf("%hhu", 1)); OK(printf("%hho", 1));
- OK(printf("%hhx", 1)); OK(printf("%hhX", 1)); OK(printf("%hhn", &chr));
+ OK(printf("%hhd", 1));
+ OK(printf("%hhi", 1));
+ OK(printf("%hhu", 1));
+ OK(printf("%hho", 1));
+ OK(printf("%hhx", 1));
+ OK(printf("%hhX", 1));
+ OK(printf("%hhn", &chr));
// Undef 11. 'h' used with a CS other than [diouxXn]
test_specifier_application("diouxXn", "%hX", 1, AT);
- OK(printf("%hd", 1)); OK(printf("%hi", 1));
- OK(printf("%hu", 1)); OK(printf("%ho", 1));
- OK(printf("%hx", 1)); OK(printf("%hX", 1)); OK(printf("%hn", &shrt));
+ OK(printf("%hd", 1));
+ OK(printf("%hi", 1));
+ OK(printf("%hu", 1));
+ OK(printf("%ho", 1));
+ OK(printf("%hx", 1));
+ OK(printf("%hX", 1));
+ OK(printf("%hn", &shrt));
// Undef 12. 'l' used with a CS other than [diouxXncsaAeEfFgG]
test_specifier_application("diouxXncsaAeEfFgG", "%lX", 1, AT);
- OK(printf("%ld", 1L)); OK(printf("%li", 1L));
- OK(printf("%lu", 1UL)); OK(printf("%lo", 1UL));
- OK(printf("%lx", 1UL)); OK(printf("%lX", 1UL));
+ OK(printf("%ld", 1L));
+ OK(printf("%li", 1L));
+ OK(printf("%lu", 1UL));
+ OK(printf("%lo", 1UL));
+ OK(printf("%lx", 1UL));
+ OK(printf("%lX", 1UL));
// No effect on [aAeEfFgG]
- OK(printf("%f", dbl)); OK(printf("%F", dbl));
- OK(printf("%e", dbl)); OK(printf("%E", dbl));
- OK(printf("%a", dbl)); OK(printf("%A", dbl));
- OK(printf("%g", dbl)); OK(printf("%G", dbl));
+ OK(printf("%f", dbl));
+ OK(printf("%F", dbl));
+ OK(printf("%e", dbl));
+ OK(printf("%E", dbl));
+ OK(printf("%a", dbl));
+ OK(printf("%A", dbl));
+ OK(printf("%g", dbl));
+ OK(printf("%G", dbl));
// Pointer to long int for [n]
OK(printf("%ln", &li));
// wint_t for [c], since wint_t is essentially short then it is the subject
@@ -261,15 +277,23 @@ int main(int argc, const char **argv) {
// Undef 13. 'll' used with a CS other than [diouxXn]
//test_specifier_application("diouxXn", "%llX", 1, AT);
- OK(printf("%lld", 1LL)); OK(printf("%lli", 1LL));
- OK(printf("%llu", 1ULL)); OK(printf("%llo", 1ULL));
- OK(printf("%llx", 1ULL)); OK(printf("%llX", 1ULL)); OK(printf("%lln", &lli));
+ OK(printf("%lld", 1LL));
+ OK(printf("%lli", 1LL));
+ OK(printf("%llu", 1ULL));
+ OK(printf("%llo", 1ULL));
+ OK(printf("%llx", 1ULL));
+ OK(printf("%llX", 1ULL));
+ OK(printf("%lln", &lli));
// Undef 14. 'j' used with a CS other than [diouxXn]
test_specifier_application("diouxXn", "%jX", 1, AT);
- OK(printf("%jd", imax)); OK(printf("%ji", imax));
- OK(printf("%ju", uimax)); OK(printf("%jo", uimax));
- OK(printf("%jx", uimax)); OK(printf("%jX", uimax)); OK(printf("%jn", &imax));
+ OK(printf("%jd", imax));
+ OK(printf("%ji", imax));
+ OK(printf("%ju", uimax));
+ OK(printf("%jo", uimax));
+ OK(printf("%jx", uimax));
+ OK(printf("%jX", uimax));
+ OK(printf("%jn", &imax));
// Undef 15. 'z' used with a CS other than [diouxXn]
test_specifier_application("diouxXn", "%zX", 1, AT);
@@ -277,117 +301,216 @@ int main(int argc, const char **argv) {
// For simplicity the below assumes that in a 32-bit system it is `int` and
// `long` in 64 bit. This may fail though, so use with caution.
#if __WORDSIZE == 64
- OK(printf("%zd", li)); OK(printf("%zi", li));
-#elif __WORDSIZE == 32
- OK(printf("%zd", i)); OK(printf("%zi", i));
+ OK(printf("%zd", li));
+ OK(printf("%zi", li));
+#elif __WORDSIZE == 32
+ OK(printf("%zd", i));
+ OK(printf("%zi", i));
#endif
- OK(printf("%zu", szt)); OK(printf("%zo", szt));
- OK(printf("%zx", szt)); OK(printf("%zX", szt)); OK(printf("%zn", &szt));
+ OK(printf("%zu", szt));
+ OK(printf("%zo", szt));
+ OK(printf("%zx", szt));
+ OK(printf("%zX", szt));
+ OK(printf("%zn", &szt));
// Undef 16. 't' used with a CS other than [diouxXn]
// Same as above but since ptrdiff_t is sizned we have to tweak types for
// [uoxX]
test_specifier_application("diouxXn", "%tX", 1, AT);
#if __WORDSIZE == 64
- OK(printf("%tu", lu)); OK(printf("%to", lu));
- OK(printf("%tx", lu)); OK(printf("%tX", lu));
-#elif __WORDSIZE == 32
- OK(printf("%tu", ui)); OK(printf("%to", ui));
- OK(printf("%tx", ui)); OK(printf("%tX", ui));
+ OK(printf("%tu", lu));
+ OK(printf("%to", lu));
+ OK(printf("%tx", lu));
+ OK(printf("%tX", lu));
+#elif __WORDSIZE == 32
+ OK(printf("%tu", ui));
+ OK(printf("%to", ui));
+ OK(printf("%tx", ui));
+ OK(printf("%tX", ui));
#endif
- OK(printf("%td", ptrdf)); OK(printf("%ti", ptrdf));
+ OK(printf("%td", ptrdf));
+ OK(printf("%ti", ptrdf));
OK(printf("%tn", &ptrdf));
// Undef 17. 'L' used with a CS other than [aAeEfFgG]
test_specifier_application("aAeEfFgG", "%LX", 1, AT);
- OK(printf("%Lf", ldbl)); OK(printf("%LF", ldbl));
- OK(printf("%Le", ldbl)); OK(printf("%LE", ldbl));
- OK(printf("%La", ldbl)); OK(printf("%LA", ldbl));
- OK(printf("%Lg", ldbl)); OK(printf("%LG", ldbl));
+ OK(printf("%Lf", ldbl));
+ OK(printf("%LF", ldbl));
+ OK(printf("%Le", ldbl));
+ OK(printf("%LE", ldbl));
+ OK(printf("%La", ldbl));
+ OK(printf("%LA", ldbl));
+ OK(printf("%Lg", ldbl));
+ OK(printf("%LG", ldbl));
// Undef 18. CS is not one of [diouxfFeEgGaAcspnCS%]
// Try some of specifiers supported by GLIBC printf but not in C99
- ABRT(printf("%C\n",1));
- ABRT(printf("%S\n",1));
- ABRT(printf("%m\n",1));
+ ABRT(printf("%C\n", 1));
+ ABRT(printf("%S\n", 1));
+ ABRT(printf("%m\n", 1));
// Undef 19. [di]: no LM is present and the argument is not of type 'int'
- OK(printf("%i\n", i)); OK(printf("%d\n", i));
- OK(printf("%i\n", chr)); OK(printf("%d\n", chr)); // promoted to int
- OK(printf("%i\n", shrt)); OK(printf("%d\n", shrt)); // promoted to int
- ABRT(printf("%i\n", li)); ABRT(printf("%d\n", li));
- ABRT(printf("%i\n", ui)); ABRT(printf("%d\n", ui));
- ABRT(printf("%i\n", vptr)); ABRT(printf("%d\n", vptr));
- ABRT(printf("%i\n", flt)); ABRT(printf("%d\n", flt));
+ OK(printf("%i\n", i));
+ OK(printf("%d\n", i));
+ OK(printf("%i\n", chr));
+ OK(printf("%d\n", chr)); // promoted to int
+ OK(printf("%i\n", shrt));
+ OK(printf("%d\n", shrt)); // promoted to int
+ ABRT(printf("%i\n", li));
+ ABRT(printf("%d\n", li));
+ ABRT(printf("%i\n", ui));
+ ABRT(printf("%d\n", ui));
+ ABRT(printf("%i\n", vptr));
+ ABRT(printf("%d\n", vptr));
+ ABRT(printf("%i\n", flt));
+ ABRT(printf("%d\n", flt));
// Undef 20. [di]: LM is present and the argument is not of type given by LM
- OK(printf("%li\n", li)); OK(printf("%ld\n", li));
- OK(printf("%lli\n", lli)); OK(printf("%lld\n", lli));
- OK(printf("%hi\n", shrt)); OK(printf("%hd\n", shrt));
- OK(printf("%hhi\n", chr)); OK(printf("%hhd\n", chr));
+ OK(printf("%li\n", li));
+ OK(printf("%ld\n", li));
+ OK(printf("%lli\n", lli));
+ OK(printf("%lld\n", lli));
+ OK(printf("%hi\n", shrt));
+ OK(printf("%hd\n", shrt));
+ OK(printf("%hhi\n", chr));
+ OK(printf("%hhd\n", chr));
#if __WORDSIZE == 64
- OK(printf("%ji\n", li)); OK(printf("%jd\n", li));
+ OK(printf("%ji\n", li));
+ OK(printf("%jd\n", li));
#elif __WORDSIZE == 32
- OK(printf("%zi\n", i)); OK(printf("%zd\n", i));
+ OK(printf("%zi\n", i));
+ OK(printf("%zd\n", i));
#endif
- OK(printf("%ti\n", ptrdf)); OK(printf("%td\n", ptrdf));
+ OK(printf("%ti\n", ptrdf));
+ OK(printf("%td\n", ptrdf));
// Undef 21. [ouxX]: no LM is present and the argument is not 'unsigned int'
- OK(printf("%u\n", ui)); OK(printf("%o\n", ui)); OK(printf("%x\n", ui)); OK(printf("%X\n", ui));
- ABRT(printf("%u\n", li)); ABRT(printf("%o\n", li)); ABRT(printf("%x\n", li)); ABRT(printf("%X\n", li));
- ABRT(printf("%u\n", lu)); ABRT(printf("%o\n", lu)); ABRT(printf("%x\n", lu)); ABRT(printf("%X\n", lu));
- ABRT(printf("%u\n", flt)); ABRT(printf("%o\n", flt)); ABRT(printf("%x\n", flt)); ABRT(printf("%X\n", flt));
- ABRT(printf("%u\n", vptr)); ABRT(printf("%o\n", vptr)); ABRT(printf("%x\n", vptr)); ABRT(printf("%X\n", vptr));
- ABRT(printf("%u\n", astr)); ABRT(printf("%o\n", astr)); ABRT(printf("%x\n", astr)); ABRT(printf("%X\n", astr));
+ OK(printf("%u\n", ui));
+ OK(printf("%o\n", ui));
+ OK(printf("%x\n", ui));
+ OK(printf("%X\n", ui));
+ ABRT(printf("%u\n", li));
+ ABRT(printf("%o\n", li));
+ ABRT(printf("%x\n", li));
+ ABRT(printf("%X\n", li));
+ ABRT(printf("%u\n", lu));
+ ABRT(printf("%o\n", lu));
+ ABRT(printf("%x\n", lu));
+ ABRT(printf("%X\n", lu));
+ ABRT(printf("%u\n", flt));
+ ABRT(printf("%o\n", flt));
+ ABRT(printf("%x\n", flt));
+ ABRT(printf("%X\n", flt));
+ ABRT(printf("%u\n", vptr));
+ ABRT(printf("%o\n", vptr));
+ ABRT(printf("%x\n", vptr));
+ ABRT(printf("%X\n", vptr));
+ ABRT(printf("%u\n", astr));
+ ABRT(printf("%o\n", astr));
+ ABRT(printf("%x\n", astr));
+ ABRT(printf("%X\n", astr));
// Undef 22. [ouxX]: LM is present and the argument is not of type given by the LM
- OK(printf("%lu\n", lu)); OK(printf("%lo\n", lu)); OK(printf("%lx\n", lu)); OK(printf("%lX\n", lu));
- OK(printf("%llu\n", llu)); OK(printf("%llo\n", llu)); OK(printf("%llx\n", llu)); OK(printf("%llX\n", llu));
+ OK(printf("%lu\n", lu));
+ OK(printf("%lo\n", lu));
+ OK(printf("%lx\n", lu));
+ OK(printf("%lX\n", lu));
+ OK(printf("%llu\n", llu));
+ OK(printf("%llo\n", llu));
+ OK(printf("%llx\n", llu));
+ OK(printf("%llX\n", llu));
// subject to promotion so expects int
- OK(printf("%hu\n", i)); OK(printf("%ho\n", i)); OK(printf("%hx\n", i)); OK(printf("%hX\n", i));
+ OK(printf("%hu\n", i));
+ OK(printf("%ho\n", i));
+ OK(printf("%hx\n", i));
+ OK(printf("%hX\n", i));
// subject to promotion so expects int
- OK(printf("%hhu\n", i)); OK(printf("%hho\n", i)); OK(printf("%hhx\n", i)); OK(printf("%hhX\n", i));
- OK(printf("%ju\n", uimax)); OK(printf("%jo\n", uimax)); OK(printf("%jx\n", uimax)); OK(printf("%jX\n", uimax));
- OK(printf("%zu\n", szt)); OK(printf("%zo\n", szt)); OK(printf("%zx\n", szt)); OK(printf("%zX\n", szt));
+ OK(printf("%hhu\n", i));
+ OK(printf("%hho\n", i));
+ OK(printf("%hhx\n", i));
+ OK(printf("%hhX\n", i));
+ OK(printf("%ju\n", uimax));
+ OK(printf("%jo\n", uimax));
+ OK(printf("%jx\n", uimax));
+ OK(printf("%jX\n", uimax));
+ OK(printf("%zu\n", szt));
+ OK(printf("%zo\n", szt));
+ OK(printf("%zx\n", szt));
+ OK(printf("%zX\n", szt));
#if __WORDSIZE == 64
- OK(printf("%tu\n", lu)); OK(printf("%to\n", lu)); OK(printf("%tx\n", lu)); OK(printf("%tX\n", lu));
+ OK(printf("%tu\n", lu));
+ OK(printf("%to\n", lu));
+ OK(printf("%tx\n", lu));
+ OK(printf("%tX\n", lu));
#endif
// Undef 23. [aAgGfFeE]: no LM is present and the argument is not of type 'double'
- OK(printf("%f\n",dbl)); OK(printf("%F\n",dbl));
- ABRT(printf("%f\n",ldbl)); ABRT(printf("%F\n",ldbl));
- ABRT(printf("%f\n",i)); ABRT(printf("%F\n",i));
- ABRT(printf("%f\n",lu)); ABRT(printf("%F\n",lu));
- OK(printf("%a\n",dbl)); OK(printf("%A\n",dbl));
- ABRT(printf("%a\n",ldbl)); ABRT(printf("%A\n",ldbl));
- ABRT(printf("%a\n",i)); ABRT(printf("%A\n",i));
- ABRT(printf("%a\n",lu)); ABRT(printf("%A\n",lu));
- OK(printf("%e\n",dbl)); OK(printf("%E\n",dbl));
- ABRT(printf("%e\n",ldbl)); ABRT(printf("%E\n",ldbl));
- ABRT(printf("%e\n",i)); ABRT(printf("%E\n",i));
- ABRT(printf("%e\n",lu)); ABRT(printf("%E\n",lu));
- OK(printf("%g\n",dbl)); OK(printf("%G\n",dbl));
- ABRT(printf("%g\n",ldbl)); ABRT(printf("%G\n",ldbl));
- ABRT(printf("%g\n",i)); ABRT(printf("%G\n",i));
- ABRT(printf("%g\n",lu)); ABRT(printf("%G\n",lu));
+ OK(printf("%f\n", dbl));
+ OK(printf("%F\n", dbl));
+ ABRT(printf("%f\n", ldbl));
+ ABRT(printf("%F\n", ldbl));
+ ABRT(printf("%f\n", i));
+ ABRT(printf("%F\n", i));
+ ABRT(printf("%f\n", lu));
+ ABRT(printf("%F\n", lu));
+ OK(printf("%a\n", dbl));
+ OK(printf("%A\n", dbl));
+ ABRT(printf("%a\n", ldbl));
+ ABRT(printf("%A\n", ldbl));
+ ABRT(printf("%a\n", i));
+ ABRT(printf("%A\n", i));
+ ABRT(printf("%a\n", lu));
+ ABRT(printf("%A\n", lu));
+ OK(printf("%e\n", dbl));
+ OK(printf("%E\n", dbl));
+ ABRT(printf("%e\n", ldbl));
+ ABRT(printf("%E\n", ldbl));
+ ABRT(printf("%e\n", i));
+ ABRT(printf("%E\n", i));
+ ABRT(printf("%e\n", lu));
+ ABRT(printf("%E\n", lu));
+ OK(printf("%g\n", dbl));
+ OK(printf("%G\n", dbl));
+ ABRT(printf("%g\n", ldbl));
+ ABRT(printf("%G\n", ldbl));
+ ABRT(printf("%g\n", i));
+ ABRT(printf("%G\n", i));
+ ABRT(printf("%g\n", lu));
+ ABRT(printf("%G\n", lu));
// 24. [aAgGfFeE]: 'L' LM is present and the argument is not of type 'long double'
- ABRT(printf("%Lf\n",dbl)); ABRT(printf("%LF\n",dbl));
- OK(printf("%Lf\n",ldbl)); OK(printf("%LF\n",ldbl));
- ABRT(printf("%Lf\n",i)); ABRT(printf("%LF\n",i));
- ABRT(printf("%Lf\n",lu)); ABRT(printf("%LF\n",lu));
- ABRT(printf("%La\n",dbl)); ABRT(printf("%LA\n",dbl));
- OK(printf("%La\n",ldbl)); OK(printf("%LA\n",ldbl));
- ABRT(printf("%La\n",i)); ABRT(printf("%LA\n",i));
- ABRT(printf("%La\n",lu)); ABRT(printf("%LA\n",lu));
- ABRT(printf("%Le\n",dbl)); ABRT(printf("%LE\n",dbl));
- OK(printf("%Le\n",ldbl)); OK(printf("%LE\n",ldbl));
- ABRT(printf("%Le\n",i)); ABRT(printf("%LE\n",i));
- ABRT(printf("%Le\n",lu)); ABRT(printf("%LE\n",lu));
- ABRT(printf("%Lg\n",dbl)); ABRT(printf("%LG\n",dbl));
- OK(printf("%Lg\n",ldbl)); OK(printf("%LG\n",ldbl));
- ABRT(printf("%Lg\n",i)); ABRT(printf("%LG\n",i));
- ABRT(printf("%Lg\n",lu)); ABRT(printf("%LG\n",lu));
+ ABRT(printf("%Lf\n", dbl));
+ ABRT(printf("%LF\n", dbl));
+ OK(printf("%Lf\n", ldbl));
+ OK(printf("%LF\n", ldbl));
+ ABRT(printf("%Lf\n", i));
+ ABRT(printf("%LF\n", i));
+ ABRT(printf("%Lf\n", lu));
+ ABRT(printf("%LF\n", lu));
+ ABRT(printf("%La\n", dbl));
+ ABRT(printf("%LA\n", dbl));
+ OK(printf("%La\n", ldbl));
+ OK(printf("%LA\n", ldbl));
+ ABRT(printf("%La\n", i));
+ ABRT(printf("%LA\n", i));
+ ABRT(printf("%La\n", lu));
+ ABRT(printf("%LA\n", lu));
+ ABRT(printf("%Le\n", dbl));
+ ABRT(printf("%LE\n", dbl));
+ OK(printf("%Le\n", ldbl));
+ OK(printf("%LE\n", ldbl));
+ ABRT(printf("%Le\n", i));
+ ABRT(printf("%LE\n", i));
+ ABRT(printf("%Le\n", lu));
+ ABRT(printf("%LE\n", lu));
+ ABRT(printf("%Lg\n", dbl));
+ ABRT(printf("%LG\n", dbl));
+ OK(printf("%Lg\n", ldbl));
+ OK(printf("%LG\n", ldbl));
+ ABRT(printf("%Lg\n", i));
+ ABRT(printf("%LG\n", i));
+ ABRT(printf("%Lg\n", lu));
+ ABRT(printf("%LG\n", lu));
// Undef 25. [c] no LM is present and the argument is not of type 'int'
OK(printf("%c\n", i));
@@ -424,10 +547,10 @@ int main(int argc, const char **argv) {
ABRT(printf("%s\n", s4)); // Not NUL-terminated
// Precision
- OK(printf("%.s\n", s1)); // The precision is zero, so print nothing
- OK(printf("%.0s\n", s1)); // The precision is zero, so print nothing
- OK(printf("%.3s\n", s4)); // Within allocated limits even though no NUL
- OK(printf("%.4s\n", s4)); // Within allocated limits even though no NUL
+ OK(printf("%.s\n", s1)); // The precision is zero, so print nothing
+ OK(printf("%.0s\n", s1)); // The precision is zero, so print nothing
+ OK(printf("%.3s\n", s4)); // Within allocated limits even though no NUL
+ OK(printf("%.4s\n", s4)); // Within allocated limits even though no NUL
ABRT(printf("%.5s\n", s4)); // Precision goes over limits
// Undef 29/30. Same as 27/28 but for '%ls' and wchar_t*
@@ -445,10 +568,10 @@ int main(int argc, const char **argv) {
OK(printf("%ls\n", ls4));
// Precision
- OK(printf("%.ls\n", ls1)); // The precision is zero, so print nothing
- OK(printf("%.0ls\n", ls1)); // The precision is zero, so print nothing
- OK(printf("%.3ls\n", ls4)); // Within allocated limits even though no NUL
- OK(printf("%.4ls\n", ls4)); // Within allocated limits even though no NUL
+ OK(printf("%.ls\n", ls1)); // The precision is zero, so print nothing
+ OK(printf("%.0ls\n", ls1)); // The precision is zero, so print nothing
+ OK(printf("%.3ls\n", ls4)); // Within allocated limits even though no NUL
+ OK(printf("%.4ls\n", ls4)); // Within allocated limits even though no NUL
ABRT(printf("%.5ls\n", ls4)); // Precision goes over limits
#endif
@@ -459,9 +582,9 @@ int main(int argc, const char **argv) {
// Undef 32. [n]: the argument is not a valid pointer of signed int type
OK(printf("%n", &i));
- ABRT(printf("%n", &ui)); // pointer to unsigned type
- ABRT(printf("%n", NULL)); // NULL
- ABRT(printf("%n", (int*)pstr)); // cast of read-only string
+ ABRT(printf("%n", &ui)); // pointer to unsigned type
+ ABRT(printf("%n", NULL)); // NULL
+ ABRT(printf("%n", (int *)pstr)); // cast of read-only string
// Undef 33. [n]: directive using [n] contains flags or field width or precision
ABRT(printf("%'n", &i));
diff --git a/src/plugins/e-acsl/tests/full-mtracking/addrOf.i b/src/plugins/e-acsl/tests/full-mtracking/addrOf.i
index c797facb0f9c1ea90d23dd783c7e380668314ce0..4f58b28daa1c236bb986ef5e8d43c6660e794aa0 100644
--- a/src/plugins/e-acsl/tests/full-mtracking/addrOf.i
+++ b/src/plugins/e-acsl/tests/full-mtracking/addrOf.i
@@ -2,7 +2,7 @@
COMMENT: addrOf
*/
-void f(){
+void f() {
int m, *u, *p;
u = &m;
p = u;
@@ -13,6 +13,6 @@ void f(){
int main(void) {
int x = 0;
f();
- /*@ assert &x == &x; */ ;
+ /*@ assert &x == &x; */;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/gmp-only/arith.i b/src/plugins/e-acsl/tests/gmp-only/arith.i
index c8ebfe292942522f999afb4a47965af629f183cb..9e6300a4fe0ccc906b2ab778594b2f6be1fa6c39 100644
--- a/src/plugins/e-acsl/tests/gmp-only/arith.i
+++ b/src/plugins/e-acsl/tests/gmp-only/arith.i
@@ -7,27 +7,27 @@ int main(void) {
int y = 2;
long z = 2L;
- /*@ assert -3 == x; */ ;
- /*@ assert x == -3; */ ;
- /*@ assert 0 != ~0; */ ;
-
- /*@ assert x+1 == -2; */ ;
- /*@ assert x-1 == -4; */ ;
- /*@ assert x*3 == -9; */ ;
- /*@ assert x/3 == -1; */ ;
- /*@ assert 0xffffffffffffffffffffff/0xffffffffffffffffffffff == 1; */ ;
- /*@ assert x % 2 == -1; */ ;
- /*@ assert -3 % -2 == -1; */ ;
- /*@ assert 3 % -2 == 1; */ ;
-
- /*@ assert x * 2 + (3 + y) - 4 + (x - y) == -10; */ ;
-
- /*@ assert (0 == 1) == !(0 == 0); */ ;
- /*@ assert (0 <= -1) == (0 > 0); */ ;
- /*@ assert (0 >= -1) == (0 <= 0); */ ;
- /*@ assert (0 != 1) == !(0 != 0); */ ;
-
- /*@ assert 0 == !1; */ ;
+ /*@ assert -3 == x; */;
+ /*@ assert x == -3; */;
+ /*@ assert 0 != ~0; */;
+
+ /*@ assert x+1 == -2; */;
+ /*@ assert x-1 == -4; */;
+ /*@ assert x*3 == -9; */;
+ /*@ assert x/3 == -1; */;
+ /*@ assert 0xffffffffffffffffffffff/0xffffffffffffffffffffff == 1; */;
+ /*@ assert x % 2 == -1; */;
+ /*@ assert -3 % -2 == -1; */;
+ /*@ assert 3 % -2 == 1; */;
+
+ /*@ assert x * 2 + (3 + y) - 4 + (x - y) == -10; */;
+
+ /*@ assert (0 == 1) == !(0 == 0); */;
+ /*@ assert (0 <= -1) == (0 > 0); */;
+ /*@ assert (0 >= -1) == (0 <= 0); */;
+ /*@ assert (0 != 1) == !(0 != 0); */;
+
+ /*@ assert 0 == !1; */;
/*@ assert 4 / y == 2; */ // non trivial division added when fixing bts #751
// example from the JFLA'15 paper (but for a 64-bit architecture)
diff --git a/src/plugins/e-acsl/tests/gmp-only/functions.c b/src/plugins/e-acsl/tests/gmp-only/functions.c
index 9d0bc001ab61c0b89201f3c3ecffae481965c120..802b5f343ad81eadb7468fc9e75cda1df8df18fe 100644
--- a/src/plugins/e-acsl/tests/gmp-only/functions.c
+++ b/src/plugins/e-acsl/tests/gmp-only/functions.c
@@ -15,7 +15,9 @@
/*@ logic int g_hidden(int x) = x; */
/*@ logic int g(int x) = g_hidden(x); */
-struct mystruct { int k, l; };
+struct mystruct {
+ int k, l;
+};
typedef struct mystruct mystruct;
/*@ logic mystruct t1(mystruct m) = m; */
/*@ logic integer t2(mystruct m) = m.k + m.l; */
@@ -37,35 +39,36 @@ int glob = 5;
/*@ predicate p_notyet{L}(integer x) = x > 0; */
/*@ logic integer f_notyet{L}(integer x) = x; */
-int main (void) {
+int main(void) {
int x = 1, y = 2;
- /*@ assert p1(x, y); */ ;
- /*@ assert p2(3, 4); */ ;
- /*@ assert p2(5, 99999999999999999999999999999); */ ;
+ /*@ assert p1(x, y); */;
+ /*@ assert p2(3, 4); */;
+ /*@ assert p2(5, 99999999999999999999999999999); */;
- /*@ assert f1(x, y) == 3; */ ;
- /*@ assert p2(x, f1(3, 4)); */ ;
- /*@ assert f1(9, 99999999999999999999999999999) > 0; */ ;
+ /*@ assert f1(x, y) == 3; */;
+ /*@ assert p2(x, f1(3, 4)); */;
+ /*@ assert f1(9, 99999999999999999999999999999) > 0; */;
/*@ assert f1(99999999999999999999999999999,
99999999999999999999999999999) ==
- 199999999999999999999999999998; */ ;
+ 199999999999999999999999999998; */
+ ;
- /*@ assert g(x) == x; */ ;
+ /*@ assert g(x) == x; */;
char c = 'c';
- /*@ assert h_char(c) == c; */ ;
+ /*@ assert h_char(c) == c; */;
short s = 1;
- /*@ assert h_short(s) == s; */ ;
+ /*@ assert h_short(s) == s; */;
mystruct m;
m.k = 8;
m.l = 9;
- /*@ assert t2(t1(m)) == 17; */ ;
+ /*@ assert t2(t1(m)) == 17; */;
k(9);
double d = 2.0;
- /*@ assert f2(d) > 0; */ ;
+ /*@ assert f2(d) > 0; */;
// not yet supported
/* /\*@ assert p_notyet(27); *\/ ; */
diff --git a/src/plugins/e-acsl/tests/libc/file.c b/src/plugins/e-acsl/tests/libc/file.c
index 6a44a67ff09ad69434cab4ae68b7d7ff0df8694d..eeb01ad1781f1bf7e0db364d6b89144d49607246 100644
--- a/src/plugins/e-acsl/tests/libc/file.c
+++ b/src/plugins/e-acsl/tests/libc/file.c
@@ -9,7 +9,7 @@ int main() {
FILE *f = fopen("/dev/urandom", "r");
// we assume this fopen will always succeed,
// to ensure the code below is always tested
- int res = fread(buf+1, sizeof(int), 4, f);
+ int res = fread(buf + 1, sizeof(int), 4, f);
//@ assert !\initialized(&buf[0]);
if (res == 0) {
//@ assert !\initialized(&buf[1]);
@@ -32,7 +32,7 @@ int main() {
// but we suppose in this test that it will always succeed
// and read 4 elements
int buf2[6];
- fread(buf2+1, sizeof(int), 4, f);
+ fread(buf2 + 1, sizeof(int), 4, f);
//@ assert !\initialized(&buf2[0]);
//@ assert \initialized(&buf2[1..4]);
//@ assert !\initialized(&buf2[5]);
diff --git a/src/plugins/e-acsl/tests/libc/mem.c b/src/plugins/e-acsl/tests/libc/mem.c
index a8b038156bb57e19b244f3c70a9d204e20a99efa..284ec17dd62f524f1dd3ae8c75b8aff6403b5465 100644
--- a/src/plugins/e-acsl/tests/libc/mem.c
+++ b/src/plugins/e-acsl/tests/libc/mem.c
@@ -9,22 +9,22 @@ int main() {
memset(a, 1, 1);
//@assert \initialized(&a[0]);
//@assert !\initialized(&a[1]);
- memset(a+1, 1, 1);
+ memset(a + 1, 1, 1);
//@assert \initialized(&a[1]);
int b[5];
- memset(&b[2], 42, 2*sizeof(b[0]));
+ memset(&b[2], 42, 2 * sizeof(b[0]));
//@assert !\initialized(&b[0]);
//@assert !\initialized(&b[1]);
//@assert \initialized(&b[2..3]);
//@assert !\initialized(&b[4]);
char c[4];
- memcpy(c+1, a, 2);
+ memcpy(c + 1, a, 2);
//@assert !\initialized(&c[0]);
//@assert \initialized(&c[1..2]);
//@assert !\initialized(&c[3]);
- memmove(c, c+1, 2);
+ memmove(c, c + 1, 2);
//@ assert \initialized(&c[0..2]);
//@ assert !\initialized(&c[3]);
}
diff --git a/src/plugins/e-acsl/tests/memory/addrOf.i b/src/plugins/e-acsl/tests/memory/addrOf.i
index c797facb0f9c1ea90d23dd783c7e380668314ce0..4f58b28daa1c236bb986ef5e8d43c6660e794aa0 100644
--- a/src/plugins/e-acsl/tests/memory/addrOf.i
+++ b/src/plugins/e-acsl/tests/memory/addrOf.i
@@ -2,7 +2,7 @@
COMMENT: addrOf
*/
-void f(){
+void f() {
int m, *u, *p;
u = &m;
p = u;
@@ -13,6 +13,6 @@ void f(){
int main(void) {
int x = 0;
f();
- /*@ assert &x == &x; */ ;
+ /*@ assert &x == &x; */;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/memory/alias.i b/src/plugins/e-acsl/tests/memory/alias.i
index b72de86ae978b540858d26329699dfd86a06e538..4d15e8c40d038a69e1aa06fb7d3bb462e1f4b6b5 100644
--- a/src/plugins/e-acsl/tests/memory/alias.i
+++ b/src/plugins/e-acsl/tests/memory/alias.i
@@ -2,8 +2,7 @@
COMMENT: alias
*/
-void f(int* dest, int val)
-{
+void f(int *dest, int val) {
int *ptr = dest;
*ptr = val;
}
diff --git a/src/plugins/e-acsl/tests/memory/array_overflow.c b/src/plugins/e-acsl/tests/memory/array_overflow.c
index c57e379c6c5805d53da72f3dc31d396808d10703..b902d7df088000009487f584c3288fcab5007372 100644
--- a/src/plugins/e-acsl/tests/memory/array_overflow.c
+++ b/src/plugins/e-acsl/tests/memory/array_overflow.c
@@ -2,9 +2,9 @@
COMMENT: Array overflow
*/
-#include <stdlib.h>
-#include <stdio.h>
#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
struct dat {
int arr[4];
@@ -15,29 +15,29 @@ struct dat2 {
};
struct dat3 {
- int * arr;
+ int *arr;
};
-void init4(int * arr, int start) {
- for (int i = 0 ; i < 4 ; ++i) {
+void init4(int *arr, int start) {
+ for (int i = 0; i < 4; ++i) {
arr[i] = start + i;
}
}
int main() {
- int a[4] = { 1, 2, 3, 4 };
- int b[4] = { 5, 6, 7, 8 };
+ int a[4] = {1, 2, 3, 4};
+ int b[4] = {5, 6, 7, 8};
/*@ assert ! \valid(&a[4]); */
- int * ap = a;
- int * bp = b;
+ int *ap = a;
+ int *bp = b;
/*@ assert ! \valid(&((int[])ap)[4]); */
- struct dat d = { .arr = { 4, 5, 6, 7 } };
- struct dat dd = { .arr = { 1, 2, 3, 9 } };
- struct dat2 d2 = { .p = { &d, &dd } };
+ struct dat d = {.arr = {4, 5, 6, 7}};
+ struct dat dd = {.arr = {1, 2, 3, 9}};
+ struct dat2 d2 = {.p = {&d, &dd}};
/*@ assert ! \valid(&d.arr[4]); */
/*@ assert \valid(&d2.p[1]->arr[2]); */
diff --git a/src/plugins/e-acsl/tests/memory/base_addr.c b/src/plugins/e-acsl/tests/memory/base_addr.c
index ad6c77d4a2ef7c556bd1979fe1808d30fa84f14a..462e005072d70d449b95d54e2a1054848d3c467b 100644
--- a/src/plugins/e-acsl/tests/memory/base_addr.c
+++ b/src/plugins/e-acsl/tests/memory/base_addr.c
@@ -4,12 +4,12 @@
#include <stdlib.h>
-int A[] = { 1, 2, 3, 4};
+int A[] = {1, 2, 3, 4};
int *PA;
int main(void) {
/* Global memory */
- PA = (int*)&A;
+ PA = (int *)&A;
/*@ assert \base_addr(&A[0]) == \base_addr(&A); */
/*@ assert \base_addr(&A[0]) == \base_addr(PA); */
/*@ assert \base_addr(A+3) == \base_addr(PA); */
@@ -18,9 +18,9 @@ int main(void) {
/*@ assert \base_addr(PA+2) == \base_addr(A+3); */
/* Stack memory [long blocks] */
- int a[] = { 1, 2, 3, 4 };
+ int a[] = {1, 2, 3, 4};
int *pa;
- pa = (int*)&a;
+ pa = (int *)&a;
/*@ assert \base_addr(&a[0]) == \base_addr(&a); */
/*@ assert \base_addr(&a[0]) == \base_addr(pa); */
@@ -31,10 +31,10 @@ int main(void) {
/* Stack memory [Short blocks] */
long l = 4;
- char *pl = (char*)&l;
+ char *pl = (char *)&l;
/*@ assert \base_addr(&l) == \base_addr(pl); */
/*@ assert \base_addr(pl+2) == \base_addr(&l); */
- short *pi = (short*)&l;
+ short *pi = (short *)&l;
pi++;
pl++;
/*@ assert \base_addr(pi) == \base_addr(pl); */
@@ -51,7 +51,7 @@ int main(void) {
/*@ assert \base_addr(p-5) == \base_addr(pd); */
/* Heap memory [multiple segments] */
- long *q = malloc(30*sizeof(long));
+ long *q = malloc(30 * sizeof(long));
long *qd = q;
/*@ assert \base_addr(q) == \base_addr(qd); */
diff --git a/src/plugins/e-acsl/tests/memory/block_length.c b/src/plugins/e-acsl/tests/memory/block_length.c
index 7fe414dba31188bc4c1fbfff870acf8027c15eee..1a86c67d167ab28dec52cd224cd9547fcb8b8d7e 100644
--- a/src/plugins/e-acsl/tests/memory/block_length.c
+++ b/src/plugins/e-acsl/tests/memory/block_length.c
@@ -4,12 +4,12 @@
#include <stdlib.h>
-int A[] = { 1, 2, 3, 4};
+int A[] = {1, 2, 3, 4};
int *PA;
int main(void) {
/* Global memory */
- PA = (int*)&A;
+ PA = (int *)&A;
/*@ assert \block_length(&A[0]) == sizeof(A); */
/*@ assert \block_length(A+3) == sizeof(A); */
/*@ assert \block_length(PA) == sizeof(A); */
@@ -17,8 +17,8 @@ int main(void) {
/*@ assert \block_length(PA+1) == \block_length(A+1); */
/* Stack memory [long blocks] */
- int a[] = { 1, 2, 3, 4};
- int *pa = (int*)&a;
+ int a[] = {1, 2, 3, 4};
+ int *pa = (int *)&a;
/*@ assert \block_length(&a[0]) == sizeof(a); */
/*@ assert \block_length(a+3) == sizeof(a); */
/*@ assert \block_length(pa) == sizeof(a); */
@@ -28,11 +28,11 @@ int main(void) {
/* Stack memory [Short blocks] */
long l = 4;
- char *pl = (char*)&l;
+ char *pl = (char *)&l;
/*@ assert \block_length(&l) == sizeof(long); */
/*@ assert \block_length(pl) == sizeof(long); */
- /*@ assert \block_length(pl+7) == sizeof(long); */
- int *pi = (int*)&l;
+ /*@ assert \block_length(pl+7) == sizeof(long); */
+ int *pi = (int *)&l;
/*@ assert \block_length(pi) == \block_length(&l); */
pi++;
/*@ assert \block_length(pi) == \block_length(&l); */
@@ -46,7 +46,7 @@ int main(void) {
/*@ assert \block_length(p+5) == \block_length(p-5); */
/* Heap memory [multiple segments] */
- size = 30*sizeof(long);
+ size = 30 * sizeof(long);
long *q = malloc(size);
/*@ assert \block_length(q) == size; */
diff --git a/src/plugins/e-acsl/tests/memory/block_valid.c b/src/plugins/e-acsl/tests/memory/block_valid.c
index fcda2fa54e15112b86b9bebe3dbdf4dcbe008d81..1ddaa1be5ef625fb5825def02b4c6432c2677833 100644
--- a/src/plugins/e-acsl/tests/memory/block_valid.c
+++ b/src/plugins/e-acsl/tests/memory/block_valid.c
@@ -3,22 +3,17 @@
COMMENT: through a pointer to another block
*/
-#include <stdlib.h>
#include <stdint.h>
+#include <stdlib.h>
#define ADDROF(_a) ((uintptr_t)_a)
-int A = 1,
- B = 2,
- C = 3;
+int A = 1, B = 2, C = 3;
int main(int argc, char **argv) {
- int *p = NULL,
- *q = NULL;
+ int *p = NULL, *q = NULL;
- int a = 1,
- b = 2,
- c = 3;
+ int a = 1, b = 2, c = 3;
p = &b;
/*@assert \valid(p); */
@@ -30,8 +25,8 @@ int main(int argc, char **argv) {
/* `p` points to `B`, `p+1` accesses either `A` or `C` */
/*@assert ! \valid(p+1); */
- char *pmin = (char*)malloc(sizeof(int));
- char *pmax = (char*)malloc(sizeof(int));
+ char *pmin = (char *)malloc(sizeof(int));
+ char *pmax = (char *)malloc(sizeof(int));
/* Since `pmin` is allocated before `pmax` it is likely that the start
* address of `pmin` is less than the start address of `pmax`, still,
diff --git a/src/plugins/e-acsl/tests/memory/bypassed_var.c b/src/plugins/e-acsl/tests/memory/bypassed_var.c
index 5201ef5f9cd6a62ba688ec1779d9c91deb5de918..0d44080eb7d996350cb534d07caad8f01ff799c9 100644
--- a/src/plugins/e-acsl/tests/memory/bypassed_var.c
+++ b/src/plugins/e-acsl/tests/memory/bypassed_var.c
@@ -6,8 +6,8 @@ int main(int argc, char const **argv) {
goto L;
{
int *p;
- L:
- p = &argc; /* Important to keep this statement here to make sure
+ L:
+ p = &argc; /* Important to keep this statement here to make sure
initialize is ran after store_block */
/*@ assert \valid(&p); */
diff --git a/src/plugins/e-acsl/tests/memory/compound_initializers.c b/src/plugins/e-acsl/tests/memory/compound_initializers.c
index 81f941e4e954169b232c951e0a0dbb7b5599a1cd..9c4d340b8ba036f4405736df3efea574cefafeb5 100644
--- a/src/plugins/e-acsl/tests/memory/compound_initializers.c
+++ b/src/plugins/e-acsl/tests/memory/compound_initializers.c
@@ -2,44 +2,34 @@
COMMENT: Compound initializers
*/
-
-
int _F;
-char *_A[2] = { "XX", "YY" };
+char *_A[2] = {"XX", "YY"};
char *_B = "ZZ";
char *_C;
-int _D[] = { 44, 88 };
+int _D[] = {44, 88};
int _E = 44;
-int _F = 9;;
+int _F = 9;
+;
struct ST {
- char *str;
- int num;
+ char *str;
+ int num;
};
-struct ST _G[] = {
- {
- .str = "First",
- .num = 99
- },
- {
- .str = "Second",
- .num = 147
- }
-};
+struct ST _G[] = {{.str = "First", .num = 99}, {.str = "Second", .num = 147}};
int main(int argc, char **argv) {
- /*@ assert \valid(&_A[0]); */
- /*@ assert \valid_read(_A[0]); */
- /*@ assert \valid_read(_A[1]); */
- /*@ assert \valid_read(_B); */
- /*@ assert \valid(&_C); */
- /*@ assert \valid(&_D[0]); */
- /*@ assert \valid(&_E); */
- /*@ assert \valid(&_F); */
- /*@ assert _E == 44; */
- /*@ assert \valid(&_G); */
- /*@ assert _G[0].num == 99; */
- return 0;
+ /*@ assert \valid(&_A[0]); */
+ /*@ assert \valid_read(_A[0]); */
+ /*@ assert \valid_read(_A[1]); */
+ /*@ assert \valid_read(_B); */
+ /*@ assert \valid(&_C); */
+ /*@ assert \valid(&_D[0]); */
+ /*@ assert \valid(&_E); */
+ /*@ assert \valid(&_F); */
+ /*@ assert _E == 44; */
+ /*@ assert \valid(&_G); */
+ /*@ assert _G[0].num == 99; */
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/memory/constructor.c b/src/plugins/e-acsl/tests/memory/constructor.c
index 4cedd70a7852643a423c4a76c61882a6e8fd6daa..24725111582dc4792dea18d448b402a564d25d91 100644
--- a/src/plugins/e-acsl/tests/memory/constructor.c
+++ b/src/plugins/e-acsl/tests/memory/constructor.c
@@ -5,10 +5,9 @@
#include <stdio.h>
#include <stdlib.h>
-__attribute__((constructor))
-void f() {
+__attribute__((constructor)) void f() {
printf("f\n");
- char *buf = (char*)malloc(10*sizeof(char));
+ char *buf = (char *)malloc(10 * sizeof(char));
free(buf);
}
diff --git a/src/plugins/e-acsl/tests/memory/decl_in_switch.c b/src/plugins/e-acsl/tests/memory/decl_in_switch.c
index 59ef8bedd5e95f746b6f9d0c31aa20a887e1353c..0cf133679d48c36163f6e1dc7261ff5d245c9689 100644
--- a/src/plugins/e-acsl/tests/memory/decl_in_switch.c
+++ b/src/plugins/e-acsl/tests/memory/decl_in_switch.c
@@ -4,13 +4,10 @@
*/
/// Simple declaration in switch
-void decl_in_switch(int value)
-{
- switch (value)
- {
+void decl_in_switch(int value) {
+ switch (value) {
int *p;
- default:
- {
+ default: {
p = &value;
/*! assert \valid(p); */
break;
@@ -20,13 +17,11 @@ void decl_in_switch(int value)
/// Declaration and initialization in a single statement
/// (local initializer)
-void compound_decl_and_init(int value)
-{
+void compound_decl_and_init(int value) {
int a = 0;
/*@ assert \valid(&a); */
- switch (value)
- {
+ switch (value) {
int b = 2;
/*@ assert \valid(&b); */
@@ -44,14 +39,12 @@ void compound_decl_and_init(int value)
/// Separate statements for declaration and initialization
/// (no local initializer)
-void separate_decl_and_init(int value)
-{
+void separate_decl_and_init(int value) {
int a;
a = 1;
/*@ assert \valid(&a); */
- switch (value)
- {
+ switch (value) {
int b;
b = 2;
/*@ assert \valid(&b); */
@@ -71,12 +64,10 @@ void separate_decl_and_init(int value)
}
/// Check label in switch
-void label_in_switch(int value)
-{
+void label_in_switch(int value) {
int done = 0;
- switch (value)
- {
+ switch (value) {
/* standalone label */
K:;
int d = 0;
@@ -94,22 +85,17 @@ void label_in_switch(int value)
break;
}
- if (!done)
- {
+ if (!done) {
done = 1;
- if (value < 10)
- {
+ if (value < 10) {
goto L;
- }
- else
- {
+ } else {
goto K;
}
}
}
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
decl_in_switch(argc);
compound_decl_and_init(argc);
separate_decl_and_init(argc);
diff --git a/src/plugins/e-acsl/tests/memory/early_exit.c b/src/plugins/e-acsl/tests/memory/early_exit.c
index df14d511f58d765d818ac938d92b7cc15d50516a..65ac06640b0f83240e545cceac6c14d8e9d27909 100644
--- a/src/plugins/e-acsl/tests/memory/early_exit.c
+++ b/src/plugins/e-acsl/tests/memory/early_exit.c
@@ -36,11 +36,11 @@ int goto_valid() {
goto FIRST;
/* Dead code */
- p = (void*)0;
+ p = (void *)0;
r = q = &a;
}
}
-FIRST:
+ FIRST:
/* at this point 'a1' is still in scope, while 'a2' and 'a3 are not,
thus 'q' and 'r' become invalid, whereas 'p' is still valid. */
/*@ assert \valid(p); */
@@ -66,22 +66,22 @@ int switch_valid() {
int *p, *q, *s;
{
s = &i;
- switch(i) {
- default: {
- int a1 = 0;
- p = &a1;
- {
- int a2 = 0;
- q = &a2;
- /*@ assert \valid(p); */
- /*@ assert \valid(q); */
- /*@ assert \valid(s); */
- break;
- }
- /* dead code */
- p = q = &i;
- s = (void*)0;
+ switch (i) {
+ default: {
+ int a1 = 0;
+ p = &a1;
+ {
+ int a2 = 0;
+ q = &a2;
+ /*@ assert \valid(p); */
+ /*@ assert \valid(q); */
+ /*@ assert \valid(s); */
+ break;
}
+ /* dead code */
+ p = q = &i;
+ s = (void *)0;
+ }
}
/* [break] invalidates 'p' and 'q' but 's' is still in scope. */
/*@ assert ! \valid(q); */
diff --git a/src/plugins/e-acsl/tests/memory/freeable.c b/src/plugins/e-acsl/tests/memory/freeable.c
index 86422bb512c3b18e9e6e5fadc6f0d3ec4b3aad9f..297ddd3bd8d59de808c7c5e60fd05f62f746db84 100644
--- a/src/plugins/e-acsl/tests/memory/freeable.c
+++ b/src/plugins/e-acsl/tests/memory/freeable.c
@@ -5,7 +5,7 @@
#include <stdlib.h>
extern void *malloc(size_t p);
-extern void free(void* p);
+extern void free(void *p);
char array[1024];
@@ -13,7 +13,7 @@ int main(void) {
int *p;
/*@ assert ! \freeable(p); */
/*@ assert ! \freeable((void*)0); */
- p = (int*)malloc(4*sizeof(int));
+ p = (int *)malloc(4 * sizeof(int));
/*@ assert ! \freeable(p+1); */
/*@ assert \freeable(p); */
free(p);
diff --git a/src/plugins/e-acsl/tests/memory/ghost_parameters.i b/src/plugins/e-acsl/tests/memory/ghost_parameters.i
index a3577b57397f410c825ff1529b6166fbb4d2a52b..cd13e0c7b764401a1524e9a5a8123069f0718ac3 100644
--- a/src/plugins/e-acsl/tests/memory/ghost_parameters.i
+++ b/src/plugins/e-acsl/tests/memory/ghost_parameters.i
@@ -3,13 +3,11 @@
STDOPT:
*/
-void function(int a, int b) /*@ ghost(int c, int d) */ {
+void function(int a, int b) /*@ ghost(int c, int d) */ {}
-}
-
-int main(void){
- int w = 0 ;
- int x = 1 ;
+int main(void) {
+ int w = 0;
+ int x = 1;
//@ ghost int y = 2 ;
//@ ghost int z = 3 ;
diff --git a/src/plugins/e-acsl/tests/memory/goto.c b/src/plugins/e-acsl/tests/memory/goto.c
index 9369b871b5a9e886f1c485ff19ff4020009bc910..e83bbea8241210973aded8a7cd514b5f94802260 100644
--- a/src/plugins/e-acsl/tests/memory/goto.c
+++ b/src/plugins/e-acsl/tests/memory/goto.c
@@ -9,9 +9,11 @@ char a;
int main(void) {
char *b;
goto _LOR;
- _LOR: b = &a;
- if (a) goto _LOR; // dead code in order to prevent infinite loop
- // but still meaningfull in term of code generated by E-ACSL
+_LOR:
+ b = &a;
+ if (a)
+ goto _LOR; // dead code in order to prevent infinite loop
+ // but still meaningfull in term of code generated by E-ACSL
/*@ assert \initialized(b); */
return 0;
}
diff --git a/src/plugins/e-acsl/tests/memory/initialized.c b/src/plugins/e-acsl/tests/memory/initialized.c
index 34f53edb19e059c2a8ff498d9e54d9c052536f36..d22fb9aa52462a7ef731d2faa0cc606cb1865ee7 100644
--- a/src/plugins/e-acsl/tests/memory/initialized.c
+++ b/src/plugins/e-acsl/tests/memory/initialized.c
@@ -7,7 +7,7 @@
int A = 0;
int B;
-#define ODD(_n) (_n%2 != 0)
+#define ODD(_n) (_n % 2 != 0)
int main(void) {
/* All globals are initialized, even if the initializer is not given */
@@ -22,7 +22,7 @@ int main(void) {
int a = 0;
int b;
long *r;
- long c[2] = { 1, 1 };
+ long c[2] = {1, 1};
long d[2];
p = &a;
q = &b;
@@ -61,16 +61,16 @@ int main(void) {
/*@assert \initialized(r+1); */
/* Malloc allocates un-initialized memory */
- p = (int*)malloc(sizeof(int*));
+ p = (int *)malloc(sizeof(int *));
/*@assert ! \initialized(p); */
/* Calloc allocates initialized memory */
- q = (int*)calloc(1, sizeof(int));
+ q = (int *)calloc(1, sizeof(int));
/*@ assert \initialized(q); */
/* Block reallocared using `realloc' carries initialization of the
* existing fragment but does not initialize the newly allocated one */
- q = (int*)realloc(q, 2*sizeof(int));
+ q = (int *)realloc(q, 2 * sizeof(int));
/*@assert \initialized(q); */
q++;
/*@assert ! \initialized(q); */
@@ -131,11 +131,11 @@ int main(void) {
free(q);
/* Spoofing access to a non-existing stack address */
- q = (int*)(&q - 1024*5);
+ q = (int *)(&q - 1024 * 5);
/*assert ! \initialized(q); */
/* Spoofing access to a non-existing global address */
- q = (int*)128;
+ q = (int *)128;
/*@assert ! \initialized(q); */
p = NULL;
@@ -143,8 +143,8 @@ int main(void) {
/* Partial initialization */
int size = 100;
- char *partsc = (char*)malloc(size*sizeof(char));
- char *partsi = (char*)malloc(size*sizeof(int));
+ char *partsc = (char *)malloc(size * sizeof(char));
+ char *partsi = (char *)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
if (ODD(i))
@@ -165,7 +165,7 @@ int main(void) {
/* Check duplicate initialization does not affect correct count of
* initialized bits (relevant for bittree model). */
- int dup [2];
+ int dup[2];
dup[0] = 1;
dup[0] = 1;
/* @assert ! \initialized(&dup); */
diff --git a/src/plugins/e-acsl/tests/memory/literal_string.i b/src/plugins/e-acsl/tests/memory/literal_string.i
index 553b9e3ed0dbcd42b9cf1841bc7d3c0facc87db8..890f177e4e312f0a1189b95f908b4bfd4948624a 100644
--- a/src/plugins/e-acsl/tests/memory/literal_string.i
+++ b/src/plugins/e-acsl/tests/memory/literal_string.i
@@ -8,7 +8,7 @@ char *T = "bar";
int G = 0;
void f(void) {
- /*@ assert T[G] == 'b'; */ ;
+ /*@ assert T[G] == 'b'; */;
G++;
}
diff --git a/src/plugins/e-acsl/tests/memory/local_goto.c b/src/plugins/e-acsl/tests/memory/local_goto.c
index 2defb67029366fd074c7708a3103dc7431a9947e..2701e2dd40fe504fa5d770358c86ab88e31b877f 100644
--- a/src/plugins/e-acsl/tests/memory/local_goto.c
+++ b/src/plugins/e-acsl/tests/memory/local_goto.c
@@ -4,39 +4,37 @@
*/
#include <stdio.h>
-#define describe(lab) \
- printf("t is %d, going to %s\n", t, #lab)
+#define describe(lab) printf("t is %d, going to %s\n", t, #lab)
int main(int argc, const char **argv) {
int t = 0;
{
-UP:
+ UP:
if (t == 2) {
describe(RET);
goto RET;
}
}
-AGAIN:
- {
- int a;
- a = 1;
- /*@assert \valid(&a); */
+AGAIN : {
+ int a;
+ a = 1;
+ /*@assert \valid(&a); */
- if (t == 2) {
- describe(UP);
- /* When jumping to UP label we need to make sure that the
+ if (t == 2) {
+ describe(UP);
+ /* When jumping to UP label we need to make sure that the
program transformation does not insert a call deleting [b]. */
- goto UP;
- } else
- t++;
+ goto UP;
+ } else
+ t++;
- int b = 15;
- /*@assert \valid(&b); */
- describe(AGAIN);
- goto AGAIN;
- }
+ int b = 15;
+ /*@assert \valid(&b); */
+ describe(AGAIN);
+ goto AGAIN;
+}
RET:
return 0;
diff --git a/src/plugins/e-acsl/tests/memory/local_var.c b/src/plugins/e-acsl/tests/memory/local_var.c
index e7239f6e861bcb73cba7ea12b285d572d58e2523..3fed7c531f6dbb41ed4c40171669e7b67550da91 100644
--- a/src/plugins/e-acsl/tests/memory/local_var.c
+++ b/src/plugins/e-acsl/tests/memory/local_var.c
@@ -6,11 +6,11 @@
struct list {
int element;
- struct list * next;
+ struct list *next;
};
-struct list * add(struct list * l, int i) {
- struct list * new;
+struct list *add(struct list *l, int i) {
+ struct list *new;
new = malloc(sizeof(struct list));
/*@ assert \valid(new); */
new->element = i;
@@ -19,7 +19,7 @@ struct list * add(struct list * l, int i) {
}
int main() {
- struct list * l = NULL;
+ struct list *l = NULL;
l = add(l, 4);
l = add(l, 7);
return 0;
diff --git a/src/plugins/e-acsl/tests/memory/memalign.c b/src/plugins/e-acsl/tests/memory/memalign.c
index f88e16873420998d41e04aa21655e3ae9524e8c3..e41ac0e10401012a7047526a6fc7a305633d37a3 100644
--- a/src/plugins/e-acsl/tests/memory/memalign.c
+++ b/src/plugins/e-acsl/tests/memory/memalign.c
@@ -8,8 +8,8 @@ int posix_memalign(void **memptr, size_t alignment, size_t size);
void *aligned_alloc(size_t alignment, size_t size);
int main(int argc, const char **argv) {
- char **memptr = malloc(sizeof(void*));
- int res2 = posix_memalign((void**)memptr, 256, 15);
+ char **memptr = malloc(sizeof(void *));
+ int res2 = posix_memalign((void **)memptr, 256, 15);
char *p = *memptr;
/*@assert \valid(p); */
diff --git a/src/plugins/e-acsl/tests/memory/memsize.c b/src/plugins/e-acsl/tests/memory/memsize.c
index ca285b6115b01f0a911aa2e93c03d56e7cab749f..58c291bc9498c6c77d5f4e37aff69fd70ef9876d 100644
--- a/src/plugins/e-acsl/tests/memory/memsize.c
+++ b/src/plugins/e-acsl/tests/memory/memsize.c
@@ -3,62 +3,62 @@
STDOPT: +"-eva-no-builtins-auto"
*/
-#include <stdlib.h>
-#include <stdio.h>
#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
extern size_t __e_acsl_heap_allocation_size;
int main(int argc, char **argv) {
- /* Allocation increases */
- char *a = malloc(7);
- /*@assert (__e_acsl_heap_allocation_size == 7); */
- char *b = malloc(14);
- /*@assert (__e_acsl_heap_allocation_size == 21); */
+ /* Allocation increases */
+ char *a = malloc(7);
+ /*@assert (__e_acsl_heap_allocation_size == 7); */
+ char *b = malloc(14);
+ /*@assert (__e_acsl_heap_allocation_size == 21); */
- /* Allocation decreases */
- free(a);
- /*@assert (__e_acsl_heap_allocation_size == 14); */
+ /* Allocation decreases */
+ free(a);
+ /*@assert (__e_acsl_heap_allocation_size == 14); */
- /* Make sure that free with NULL behaves and does not affect allocation */
- a = NULL;
- free(a);
- /*@assert (__e_acsl_heap_allocation_size == 14); */
+ /* Make sure that free with NULL behaves and does not affect allocation */
+ a = NULL;
+ free(a);
+ /*@assert (__e_acsl_heap_allocation_size == 14); */
- /* Realloc decreases allocation */
- b = realloc(b, 9);
- /*@assert (__e_acsl_heap_allocation_size == 9); */
+ /* Realloc decreases allocation */
+ b = realloc(b, 9);
+ /*@assert (__e_acsl_heap_allocation_size == 9); */
- /* Realloc increases allocation */
- b = realloc(b, 18);
- /*@assert (__e_acsl_heap_allocation_size == 18); */
+ /* Realloc increases allocation */
+ b = realloc(b, 18);
+ /*@assert (__e_acsl_heap_allocation_size == 18); */
- /* Realloc with 0 is equivalent to free */
- b = realloc(b, 0);
- b = NULL;
- /*@assert (__e_acsl_heap_allocation_size == 0); */
+ /* Realloc with 0 is equivalent to free */
+ b = realloc(b, 0);
+ b = NULL;
+ /*@assert (__e_acsl_heap_allocation_size == 0); */
- /* realloc with 0 is equivalent to malloc */
- b = realloc(b, 8);
- /*@assert (__e_acsl_heap_allocation_size == 8); */
+ /* realloc with 0 is equivalent to malloc */
+ b = realloc(b, 8);
+ /*@assert (__e_acsl_heap_allocation_size == 8); */
- /* Abandon b and behave like malloc again */
- b = realloc(NULL, 8);
- /*@assert (__e_acsl_heap_allocation_size == 16); */
+ /* Abandon b and behave like malloc again */
+ b = realloc(NULL, 8);
+ /*@assert (__e_acsl_heap_allocation_size == 16); */
- /* Make realloc fail by supplying a huge number */
- b = realloc(NULL, SIZE_MAX);
- /*@assert (__e_acsl_heap_allocation_size == 16); */
- /*@assert (b == NULL); */
+ /* Make realloc fail by supplying a huge number */
+ b = realloc(NULL, SIZE_MAX);
+ /*@assert (__e_acsl_heap_allocation_size == 16); */
+ /*@assert (b == NULL); */
- /* Same as test for calloc ... */
- b = calloc(SIZE_MAX, SIZE_MAX);
- /*@assert (__e_acsl_heap_allocation_size == 16); */
- /*@assert (b == NULL); */
+ /* Same as test for calloc ... */
+ b = calloc(SIZE_MAX, SIZE_MAX);
+ /*@assert (__e_acsl_heap_allocation_size == 16); */
+ /*@assert (b == NULL); */
- /* ... and for malloc */
- b = malloc(SIZE_MAX);
- /*@assert (__e_acsl_heap_allocation_size == 16); */
- /*@assert (b == NULL); */
- return 0;
+ /* ... and for malloc */
+ b = malloc(SIZE_MAX);
+ /*@assert (__e_acsl_heap_allocation_size == 16); */
+ /*@assert (b == NULL); */
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/memory/offset.c b/src/plugins/e-acsl/tests/memory/offset.c
index fc3dfa69b28685fd186254d7c67aa64ce17f96ec..88f1f1232a448cc69ce2ffd725391474ce873555 100644
--- a/src/plugins/e-acsl/tests/memory/offset.c
+++ b/src/plugins/e-acsl/tests/memory/offset.c
@@ -4,12 +4,12 @@
#include <stdlib.h>
-int A[] = { 1, 2, 3, 4};
+int A[] = {1, 2, 3, 4};
int *PA;
int main(void) {
/* Global memory */
- PA = (int*)&A;
+ PA = (int *)&A;
/*@ assert \offset(&A[0]) == 0; */
/*@ assert \offset(A+3) == 12; */
/*@ assert \offset(PA) == 0; */
@@ -17,19 +17,19 @@ int main(void) {
/*@ assert \offset(PA+1) == 8; */
/* Stack memory [long blocks] */
- int a[] = { 1, 2, 3, 4};
+ int a[] = {1, 2, 3, 4};
/*@ assert \offset(&a[0]) == 0; */
/*@ assert \offset(a+1) == 4; */
/*@ assert \offset(a+3) == 12; */
/* Stack memory [Short blocks] */
long l = 4;
- char *pl = (char*)&l;
+ char *pl = (char *)&l;
/*@ assert \offset(&l) == 0; */
/*@ assert \offset(pl) == 0; */
/*@ assert \offset(pl+1) == 1; */
/*@ assert \offset(pl+7) == 7; */
- int *pi = (int*)&l;
+ int *pi = (int *)&l;
/*@ assert \offset(pi) == 0; */
pi++;
/*@ assert \offset(pi) == 4; */
@@ -44,7 +44,7 @@ int main(void) {
/*@ assert \offset(p-5) == 0; */
/* Heap memory [multiple segments] */
- long *q = malloc(30*sizeof(long));
+ long *q = malloc(30 * sizeof(long));
/*@ assert \offset(q) == 0; */
q++;
diff --git a/src/plugins/e-acsl/tests/memory/ptr.i b/src/plugins/e-acsl/tests/memory/ptr.i
index 23fb0593d28b624216dca9113b3e92b5a6f6bba0..162ede7f49c77213d122e1c805673003efe7865e 100644
--- a/src/plugins/e-acsl/tests/memory/ptr.i
+++ b/src/plugins/e-acsl/tests/memory/ptr.i
@@ -6,7 +6,7 @@
int main(void) {
int x = 1;
- int t[3] = { 2, 3, 4 };
+ int t[3] = {2, 3, 4};
int *p = &x;
/*@ assert *p == 1; */
@@ -14,14 +14,14 @@ int main(void) {
/*@ assert *(t+2) == 4; */
/*@ assert *(t+2*sizeof(int)/sizeof((int)0x0)) == 4; */
- for(int i = 0; i < 2; i++) {
- /*@ assert (*(t+i) == i+2); */ ;
- /*@ assert (*(t+(2-i)) == 4-i); */ ;
- /*@ assert (*(t+2-i) == 4-i); */ ;
+ for (int i = 0; i < 2; i++) {
+ /*@ assert (*(t+i) == i+2); */;
+ /*@ assert (*(t+(2-i)) == 4-i); */;
+ /*@ assert (*(t+2-i) == 4-i); */;
;
}
- p = t+2;
+ p = t + 2;
t[2] = 5;
/*@ assert *p == 5; */
int k = -1;
diff --git a/src/plugins/e-acsl/tests/memory/ptr_init.c b/src/plugins/e-acsl/tests/memory/ptr_init.c
index e97796dbcbc048a6483d75ee56dd85168fcf253d..cc1f9acced200a84904854b83b87430c85ce8995 100644
--- a/src/plugins/e-acsl/tests/memory/ptr_init.c
+++ b/src/plugins/e-acsl/tests/memory/ptr_init.c
@@ -12,15 +12,15 @@ void f() {
A = B;
}
-void g(int *C, int* D) {
+void g(int *C, int *D) {
/*@ assert \initialized(&C); */
}
int main(void) {
int *x, *y;
- B = (int*) malloc(sizeof(int));
- y = (int*) malloc(sizeof(int));
- x = y;
+ B = (int *)malloc(sizeof(int));
+ y = (int *)malloc(sizeof(int));
+ x = y;
f();
/*@ assert \initialized(&A); */
/*@ assert \initialized(&x); */
diff --git a/src/plugins/e-acsl/tests/memory/ranges_in_builtins.c b/src/plugins/e-acsl/tests/memory/ranges_in_builtins.c
index c1ece90ee1e37526cccd51c4f2a8c24d0c72d98d..ba3d761f444c64f898d528c2e2db34eb7636eaa0 100644
--- a/src/plugins/e-acsl/tests/memory/ranges_in_builtins.c
+++ b/src/plugins/e-acsl/tests/memory/ranges_in_builtins.c
@@ -4,47 +4,51 @@
*/
#include "stdlib.h"
/*@ requires !\valid(s + (3..n+1000)); */
-void f(char *s, long n){}
+void f(char *s, long n) {}
/*@ requires \valid(ptr + (0 .. size - 1));
ensures ! \valid(ptr + (0 .. size + 1));
// In pure ACSL, the following predicate is true;
// however at runtime, its evalulation results in UB ==> false.
// ensures ! \valid(ptr + (0 .. SIZE_MAX*SIZE_MAX)); */
-void g(long *ptr, size_t size) { }
+void g(long *ptr, size_t size) {}
extern void *malloc(size_t p);
-extern void free(void* p);
-struct S { int a[2]; float *b; float *c;};
+extern void free(void *p);
+struct S {
+ int a[2];
+ float *b;
+ float *c;
+};
int main(void) {
int *a;
- a = malloc(10*sizeof(int));
- /*@ assert \valid(a + (0 .. 4)); */ ;
+ a = malloc(10 * sizeof(int));
+ /*@ assert \valid(a + (0 .. 4)); */;
int j = 2;
- /*@ assert \valid(a + (4 .. 7+j)); */ ;
- /*@ assert !\valid(a + (10 .. 11)); */ ;
+ /*@ assert \valid(a + (4 .. 7+j)); */;
+ /*@ assert !\valid(a + (10 .. 11)); */;
free(a);
char *b;
- b = malloc(10*sizeof(char));
- /*@ assert \valid(b + (0 .. 9)); */ ;
- /*@ assert !\valid(b + (10 .. 15)); */ ;
+ b = malloc(10 * sizeof(char));
+ /*@ assert \valid(b + (0 .. 9)); */;
+ /*@ assert !\valid(b + (10 .. 15)); */;
long t[3] = {7l, 8l, 9l};
- /*@ assert \valid(&t[0..2]); */ ;
- /*@ assert !\valid(&t[3..5]); */ ;
+ /*@ assert \valid(&t[0..2]); */;
+ /*@ assert !\valid(&t[3..5]); */;
g(t, 3);
double t2[4];
t2[0] = 0.5;
t2[1] = 1.5;
- /*@ assert \initialized(&t2[0..1]); */ ;
- /*@ assert !\initialized(&t2[2..3]); */ ;
+ /*@ assert \initialized(&t2[0..1]); */;
+ /*@ assert !\initialized(&t2[2..3]); */;
/*@ assert !\initialized(b + (0 .. 9));*/
free(b);
int n = 2;
float t3[7][2][4];
- /*@ assert !\initialized(&t3[(n-1)..(n+2)][1][0..1]); */ ;
+ /*@ assert !\initialized(&t3[(n-1)..(n+2)][1][0..1]); */;
/*@ assert !\valid_read(&t3[6][1][0] + (2..10)); */
/*@ assert \valid_read(&t3[(n-1)..(n+2)][1]); */
@@ -53,21 +57,22 @@ int main(void) {
/*@ assert \let x = 5; \valid(&t4[4][0..x][2]); */
struct S s;
- s.a[0] = 7; s.a[1] = 8;
- /*@ assert \initialized(&s.a[0] + (1..1)); */ ;
- /*@ assert !\initialized(s.b + (0..1)); */ ;
+ s.a[0] = 7;
+ s.a[1] = 8;
+ /*@ assert \initialized(&s.a[0] + (1..1)); */;
+ /*@ assert !\initialized(s.b + (0..1)); */;
int **multi_dynamic;
int size1 = 5, size2 = 9;
multi_dynamic = malloc(size1 * sizeof(*multi_dynamic));
int i;
- for(i = 0; i < size1; i++) {
+ for (i = 0; i < size1; i++) {
multi_dynamic[i] = malloc(size2 * sizeof(*(multi_dynamic[i])));
}
- /*@ assert \valid(&multi_dynamic[4][1..7]); */ // single call to builtin
+ /*@ assert \valid(&multi_dynamic[4][1..7]); */ // single call to builtin
/*@ assert \valid(&multi_dynamic[2..4][1..7]); */ // need to modify Mmodel
// => not_yet
- for(i = i-1 ; i >= 0 ; i--) {
+ for (i = i - 1; i >= 0; i--) {
free(multi_dynamic[i]);
}
free(multi_dynamic);
diff --git a/src/plugins/e-acsl/tests/memory/separated.c b/src/plugins/e-acsl/tests/memory/separated.c
index 4df0b435e5c0936e4e5b1d02f95c48492de66b2e..4e5611ed5135f9cc5ae4f9140036e1457f8ec784 100644
--- a/src/plugins/e-acsl/tests/memory/separated.c
+++ b/src/plugins/e-acsl/tests/memory/separated.c
@@ -5,64 +5,64 @@
#include <stdlib.h>
int main() {
- // Stack memory on different blocks
- {
- int a, b, c;
- a = b = c = 0;
- int * d = &a;
+ // Stack memory on different blocks
+ {
+ int a, b, c;
+ a = b = c = 0;
+ int *d = &a;
- //@ assert \separated(&a, &b, &c);
- //@ assert !\separated(&a, &b, &c, d);
- }
+ //@ assert \separated(&a, &b, &c);
+ //@ assert !\separated(&a, &b, &c, d);
+ }
- // Stack memory on the same block
- {
- double array[20] = {0};
- //@ assert \separated(array+(0..9), array+(10..19));
- //@ assert !\separated(&array[0..10], &array[5..15]);
- //@ assert !\separated(array+(0..19), array+(5..15));
- //@ assert \separated(&array[0], &array[1]);
- //@ assert !\separated(array+(0..1), array+(1..2));
- //@ assert \separated(&array[15..5], &array[0..19]);
- //@ assert \separated(array+(0..-3), array+(0..19));
- }
+ // Stack memory on the same block
+ {
+ double array[20] = {0};
+ //@ assert \separated(array+(0..9), array+(10..19));
+ //@ assert !\separated(&array[0..10], &array[5..15]);
+ //@ assert !\separated(array+(0..19), array+(5..15));
+ //@ assert \separated(&array[0], &array[1]);
+ //@ assert !\separated(array+(0..1), array+(1..2));
+ //@ assert \separated(&array[15..5], &array[0..19]);
+ //@ assert \separated(array+(0..-3), array+(0..19));
+ }
- // Heap memory on different blocks
- {
- int *a = malloc(sizeof(int));
- int *b = malloc(sizeof(int));
- int *c = a;
+ // Heap memory on different blocks
+ {
+ int *a = malloc(sizeof(int));
+ int *b = malloc(sizeof(int));
+ int *c = a;
- //@ assert \separated(a, b);
- //@ assert !\separated(a, b, c);
+ //@ assert \separated(a, b);
+ //@ assert !\separated(a, b, c);
- free(a);
- free(b);
- }
+ free(a);
+ free(b);
+ }
- // Heap memory on the same block
- {
- double * array = malloc(sizeof(double[20]));
- //@ assert \separated(&array[0..9], &array[10..19]);
- //@ assert !\separated(array+(0..10), array+(5..15));
- //@ assert !\separated(&array[0..19], &array[5..15]);
- //@ assert \separated(array+(0), array+(1));
- //@ assert !\separated(&array[0..1], &array[1..2]);
- //@ assert \separated(array+(15..5), array+(0..19));
- //@ assert \separated(&array[0..-3], &array[0..19]);
- free(array);
- }
+ // Heap memory on the same block
+ {
+ double *array = malloc(sizeof(double[20]));
+ //@ assert \separated(&array[0..9], &array[10..19]);
+ //@ assert !\separated(array+(0..10), array+(5..15));
+ //@ assert !\separated(&array[0..19], &array[5..15]);
+ //@ assert \separated(array+(0), array+(1));
+ //@ assert !\separated(&array[0..1], &array[1..2]);
+ //@ assert \separated(array+(15..5), array+(0..19));
+ //@ assert \separated(&array[0..-3], &array[0..19]);
+ free(array);
+ }
- // Non-contiguous memory locations
- {
- double array[10][10][10] = {0};
+ // Non-contiguous memory locations
+ {
+ double array[10][10][10] = {0};
- //@ assert \separated(&array[0][0..2][0], &array[0][3..5][0], &array[0][6..9][0]);
- //@ assert \separated(&array[0][0..2][0], &array[1][0..2][0], &array[2][0..2][0]);
- //@ assert \separated(&array[0..2][0..2][0], &array[0..2][3..5][0]);
- //@ assert !\separated(&array[0..3][0..2][0], &array[3..5][0..2][0]);
- //@ assert \separated(&array[0..3][2..0][0], &array[3..5][0..2][0]);
- }
+ //@ assert \separated(&array[0][0..2][0], &array[0][3..5][0], &array[0][6..9][0]);
+ //@ assert \separated(&array[0][0..2][0], &array[1][0..2][0], &array[2][0..2][0]);
+ //@ assert \separated(&array[0..2][0..2][0], &array[0..2][3..5][0]);
+ //@ assert !\separated(&array[0..3][0..2][0], &array[3..5][0..2][0]);
+ //@ assert \separated(&array[0..3][2..0][0], &array[3..5][0..2][0]);
+ }
- return 0;
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/memory/sizeof.i b/src/plugins/e-acsl/tests/memory/sizeof.i
index d52b87d39370fc4866257084e6c9d500d8cae218..b3e73552a1315f8e479f103260aa223369b42f98 100644
--- a/src/plugins/e-acsl/tests/memory/sizeof.i
+++ b/src/plugins/e-acsl/tests/memory/sizeof.i
@@ -5,6 +5,6 @@
int main(void) {
int x = 0;
x++; /* prevent GCC's warning */
- /*@ assert sizeof(int) == sizeof(x); */ ;
+ /*@ assert sizeof(int) == sizeof(x); */;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/memory/struct_initialized.c b/src/plugins/e-acsl/tests/memory/struct_initialized.c
index 87ee96337d2ebfbddd575f46715f31fbd7b338d3..d9f6864993800aed45067a06aaeab69a25403af2 100644
--- a/src/plugins/e-acsl/tests/memory/struct_initialized.c
+++ b/src/plugins/e-acsl/tests/memory/struct_initialized.c
@@ -22,7 +22,7 @@ int main() {
// Dynamic alloc
{
- int32_pair_t * heap_pair = malloc(sizeof(int32_pair_t));
+ int32_pair_t *heap_pair = malloc(sizeof(int32_pair_t));
//@ assert !\initialized(&heap_pair->a);
//@ assert !\initialized(&heap_pair->b);
heap_pair->a = 3;
diff --git a/src/plugins/e-acsl/tests/memory/valid.c b/src/plugins/e-acsl/tests/memory/valid.c
index 9d48defa0489f8e15e856dcfe425108282545090..bf4bfdb5c269a506f2802b05dfe7bcb82a9c1429 100644
--- a/src/plugins/e-acsl/tests/memory/valid.c
+++ b/src/plugins/e-acsl/tests/memory/valid.c
@@ -18,9 +18,9 @@ int *f(int *x) {
void g(void) {
int m, *u, **p;
- p=&u;
- u=&m;
- m=123;
+ p = &u;
+ u = &m;
+ m = 123;
//@ assert \valid(*p);
}
diff --git a/src/plugins/e-acsl/tests/memory/valid_in_contract.c b/src/plugins/e-acsl/tests/memory/valid_in_contract.c
index ed7db447fc4a4978bd1872808f3c086ffe413b63..b4b14555644b4ac1ac34ada28883e055e6915d61 100644
--- a/src/plugins/e-acsl/tests/memory/valid_in_contract.c
+++ b/src/plugins/e-acsl/tests/memory/valid_in_contract.c
@@ -6,7 +6,7 @@
struct list {
int element;
- struct list * next;
+ struct list *next;
};
/*@
@@ -17,11 +17,13 @@ struct list {
@ assumes ! \valid(l) || ! \valid(l->next);
@ ensures \result == l;
*/
-struct list * f(struct list * l) {
+struct list *f(struct list *l) {
/* length = 0 */
- if(l == NULL) return l;
+ if (l == NULL)
+ return l;
/* length = 1 : already sorted */
- if(l->next == NULL) return l;
+ if (l->next == NULL)
+ return l;
return NULL;
}
diff --git a/src/plugins/e-acsl/tests/memory/vector.c b/src/plugins/e-acsl/tests/memory/vector.c
index 3cae89e75383c978494c3cbfb33a4a1358d2ade4..34cc433b37ba70014fb96226695051ad02587694 100644
--- a/src/plugins/e-acsl/tests/memory/vector.c
+++ b/src/plugins/e-acsl/tests/memory/vector.c
@@ -3,22 +3,22 @@
STDOPT: +"-eva-precision=1"
*/
-#include<stdlib.h>
+#include <stdlib.h>
int LAST;
-int* new_inversed(int len, int *v) {
+int *new_inversed(int len, int *v) {
int i, *p;
//@ assert \valid(v) && \offset(v)+len*sizeof(int) <= \block_length(v);
- p = malloc(sizeof(int)*len);
- for(i=0; i<len; i++)
- p[i] = v[len-i-1];
+ p = malloc(sizeof(int) * len);
+ for (i = 0; i < len; i++)
+ p[i] = v[len - i - 1];
return p;
}
int main(void) {
int x = 3;
- int v1[3]= { 1, 2, x }, *v2;
+ int v1[3] = {1, 2, x}, *v2;
//@ assert \valid(&v1[2]);
LAST = v1[2];
//@ assert \initialized(v1+2);
diff --git a/src/plugins/e-acsl/tests/special/builtin.i b/src/plugins/e-acsl/tests/special/builtin.i
index fa933a4b19c280e39924ad73594bdb58270ca90e..3f0b09065bf34cbc03b29d0b99fbabefcb529d37 100644
--- a/src/plugins/e-acsl/tests/special/builtin.i
+++ b/src/plugins/e-acsl/tests/special/builtin.i
@@ -9,9 +9,14 @@
int incr(int);
/*@ ensures \result == incr(i); */
-int f(int i) { int j = i + 1; return j; }
+int f(int i) {
+ int j = i + 1;
+ return j;
+}
-int incr(int x) { return x + 1; }
+int incr(int x) {
+ return x + 1;
+}
int main() {
int i = f(2);
diff --git a/src/plugins/e-acsl/tests/special/e-acsl-functions.c b/src/plugins/e-acsl/tests/special/e-acsl-functions.c
index 3ae592f4332677e3ab3943901c2bd05469456f20..a2de26336eb3c0fb4c7a161b482fbd024679ac58 100644
--- a/src/plugins/e-acsl/tests/special/e-acsl-functions.c
+++ b/src/plugins/e-acsl/tests/special/e-acsl-functions.c
@@ -11,7 +11,8 @@
@ ensures \result == \old(*p); */
int f(int *p) {
/*@ loop invariant 0 <= i <= 1; */
- for(int i = 0; i < 1; i++) ;
+ for (int i = 0; i < 1; i++)
+ ;
return 0;
}
@@ -20,7 +21,8 @@ int f(int *p) {
@ ensures \result == \old(*p); */
int g(int *p) {
/*@ loop invariant 0 <= i <= 1; */
- for(int i = 0; i < 1; i++) ;
+ for (int i = 0; i < 1; i++)
+ ;
return 0;
}
diff --git a/src/plugins/e-acsl/tests/special/e-acsl-instrument.c b/src/plugins/e-acsl/tests/special/e-acsl-instrument.c
index 97b8c72a7791d5b1e13fe19ddf9d379b8328846b..4811173614f7cf845b5d938c7524ed70f90191cc 100644
--- a/src/plugins/e-acsl/tests/special/e-acsl-instrument.c
+++ b/src/plugins/e-acsl/tests/special/e-acsl-instrument.c
@@ -15,11 +15,12 @@ int uninstrument1(int *p) {
/*@ requires \valid(p); */
int uninstrument2(int *p) {
- { int *q = p;
+ {
+ int *q = p;
*p = 0;
goto L;
}
- L:
+L:
return 0;
}
@@ -30,11 +31,12 @@ int instrument1(int *p) {
/*@ requires \valid(p); */
int instrument2(int *p) {
- { int *q = p;
+ {
+ int *q = p;
*p = 0;
goto L;
}
- L:
+L:
return 0;
}
diff --git a/src/plugins/e-acsl/tests/special/e-acsl-valid.c b/src/plugins/e-acsl/tests/special/e-acsl-valid.c
index 44ad91d51e2abacbfa432bcae6866458f28bbcb8..05adbfccc49a71bffb92ccc0db02838820164ecb 100644
--- a/src/plugins/e-acsl/tests/special/e-acsl-valid.c
+++ b/src/plugins/e-acsl/tests/special/e-acsl-valid.c
@@ -30,7 +30,8 @@ void f(int *x, int *y) {
{ (*x)++; }
/*@ loop invariant 0 <= i <= 1;
@ loop variant 2 - i; */
- for(int i = 0; i < 1; i++) /*@ assert 1 == 1; */ /*@ assert \valid(y); */ ;
+ for (int i = 0; i < 1; i++) /*@ assert 1 == 1; */ /*@ assert \valid(y); */
+ ;
}
int main(void) {
diff --git a/src/plugins/e-acsl/tests/temporal/t_addr-by-val.c b/src/plugins/e-acsl/tests/temporal/t_addr-by-val.c
index 562cc4e026c35f45fdeb94e9e2c0b3aa32a65bf2..c04638dfdc2c8046df6b86527246e661b2a1479b 100644
--- a/src/plugins/e-acsl/tests/temporal/t_addr-by-val.c
+++ b/src/plugins/e-acsl/tests/temporal/t_addr-by-val.c
@@ -4,15 +4,13 @@
#include <stdint.h>
-int main (int argc, char **argv) {
+int main(int argc, char **argv) {
uintptr_t addr = (uintptr_t)&argc;
char *p;
int *q;
q = &argc;
/* Here the referent of p should be assigned from the value of addr */
- p = (char*)addr;
- p = (char*)0x123456;
- p = (char*)q;
+ p = (char *)addr;
+ p = (char *)0x123456;
+ p = (char *)q;
}
-
-
diff --git a/src/plugins/e-acsl/tests/temporal/t_array.c b/src/plugins/e-acsl/tests/temporal/t_array.c
index ff2e8be836240ac5e912b987a75f6279d755f697..ddc9e968b27f27fec40fb5413b34c45485c7036d 100644
--- a/src/plugins/e-acsl/tests/temporal/t_array.c
+++ b/src/plugins/e-acsl/tests/temporal/t_array.c
@@ -3,8 +3,7 @@
*/
int main() {
- int a = 111,
- b = 222;
+ int a = 111, b = 222;
int *src[3];
src[0] = &a;
@@ -15,4 +14,3 @@ int main() {
/*@assert ! \valid(src[2]); */
return 0;
}
-
diff --git a/src/plugins/e-acsl/tests/temporal/t_char.c b/src/plugins/e-acsl/tests/temporal/t_char.c
index e8f001a3a72234a6f6a1a7073b8ce02c82d9cd1f..7480960afb40cb9d7a2feefcde1dd1f512a49cc4 100644
--- a/src/plugins/e-acsl/tests/temporal/t_char.c
+++ b/src/plugins/e-acsl/tests/temporal/t_char.c
@@ -5,13 +5,11 @@
*/
int main(int argc, const char **argv) {
- char a = '1',
- b = '2';
+ char a = '1', b = '2';
/* Should fail here in debug mode due to overlapping shadow spaces
of [a] and [b]*/
- char *p = &a,
- *q = &b;
+ char *p = &a, *q = &b;
p = q;
/*@assert \valid(p); */
diff --git a/src/plugins/e-acsl/tests/temporal/t_darray.c b/src/plugins/e-acsl/tests/temporal/t_darray.c
index 88c1cf9712022c1c32ccf47259fe968c4f633f5b..b2fbb3e95c9fc1247dba43b8e6f8dc272fa872d6 100644
--- a/src/plugins/e-acsl/tests/temporal/t_darray.c
+++ b/src/plugins/e-acsl/tests/temporal/t_darray.c
@@ -18,10 +18,7 @@ double Vertices2[3][4] = {};
int main(int argc, const char **argv) {
double vertices[3][4] = {
- { 1.0, 2.0, 3.0, 4.0 },
- { 5.0, 6.0, 7.0, 8.0 },
- { 9.0, 10.0, 11.0, 12.0 }
- };
+ {1.0, 2.0, 3.0, 4.0}, {5.0, 6.0, 7.0, 8.0}, {9.0, 10.0, 11.0, 12.0}};
double vertices2[3][4];
double vertices3[3][4];
double triple_vertices[2][3][4];
diff --git a/src/plugins/e-acsl/tests/temporal/t_dpointer.c b/src/plugins/e-acsl/tests/temporal/t_dpointer.c
index 1fb24cfee56984508606506ca1baf6b307932659..9cc5847afbf91a3fdec694039a0917385b871c2f 100644
--- a/src/plugins/e-acsl/tests/temporal/t_dpointer.c
+++ b/src/plugins/e-acsl/tests/temporal/t_dpointer.c
@@ -6,17 +6,17 @@
#include <stdlib.h>
int main(void) {
- int **p = malloc(sizeof(int*)*3);
+ int **p = malloc(sizeof(int *) * 3);
int i = 0;
while (i < 3) {
/*@assert \valid(p+i); */
- *(p+i) = malloc(sizeof(int));
+ *(p + i) = malloc(sizeof(int));
/*@assert \valid(*(p+i)); */
i++;
}
- free(*(p+2));
+ free(*(p + 2));
malloc(sizeof(int));
/*@assert ! \valid(*(p+2)); */
return 0;
diff --git a/src/plugins/e-acsl/tests/temporal/t_fptr.c b/src/plugins/e-acsl/tests/temporal/t_fptr.c
index 0afcc96640d51099799db3fc1e9b96033fbb43a2..c52b327c087cc00515088bb3d0d5a7951b06fc38 100644
--- a/src/plugins/e-acsl/tests/temporal/t_fptr.c
+++ b/src/plugins/e-acsl/tests/temporal/t_fptr.c
@@ -2,16 +2,15 @@
COMMENT: Check simple case of calling functions via pointer derefernce
*/
-int* foo(int *p) {
+int *foo(int *p) {
int *q = p;
return q;
}
int main(int argc, const char **argv) {
- int *p = &argc,
- *q;
+ int *p = &argc, *q;
- int* (*fp)(int*) = &foo;
+ int *(*fp)(int *) = &foo;
fp = &foo;
/*@assert \valid_function(fp); */
diff --git a/src/plugins/e-acsl/tests/temporal/t_fun_lib.c b/src/plugins/e-acsl/tests/temporal/t_fun_lib.c
index d98643937bbd1161685ee1a6b7e265d41f53e0c1..60a369d99855a04d0fb3a9bde2933a2a99e9ca82 100644
--- a/src/plugins/e-acsl/tests/temporal/t_fun_lib.c
+++ b/src/plugins/e-acsl/tests/temporal/t_fun_lib.c
@@ -2,23 +2,22 @@
COMMENT: Check handling library functions (without definitions)
*/
-#include <stdlib.h>
#include <limits.h>
+#include <stdlib.h>
int main(void) {
char *c = ".";
/* Allocating function (such as malloc, recognized by name):
- take block number of the returned pointer (after) */
- char *p = malloc(PATH_MAX),
- *q = NULL;
- q = malloc(PATH_MAX);
+ char *p = malloc(PATH_MAX), *q = NULL;
+ q = malloc(PATH_MAX);
/*@assert \valid(q) && \valid(p); */
/* Function with no definition returning a pointer:
same treatment as allocating function */
char *path = realpath(c, q);
- path = realpath(c, q);
+ path = realpath(c, q);
/*@assert \valid(path); */
diff --git a/src/plugins/e-acsl/tests/temporal/t_fun_ptr.c b/src/plugins/e-acsl/tests/temporal/t_fun_ptr.c
index d0637544973e1bac493f0bc6e51b672fe7863aba..bc6d485cf075f1ecd81418ca3832ae793db39529 100644
--- a/src/plugins/e-acsl/tests/temporal/t_fun_ptr.c
+++ b/src/plugins/e-acsl/tests/temporal/t_fun_ptr.c
@@ -5,7 +5,7 @@
#include <stdint.h>
#include <stdlib.h>
-int* pfun(char c, int *p, int *p2, int *p3, int *p4, int i) {
+int *pfun(char c, int *p, int *p2, int *p3, int *p4, int i) {
int *q = p;
return q;
}
@@ -23,10 +23,8 @@ int main(int argc, const char **argv) {
+ call via value - save block number
- store return referent in return handler
- take referent number of the return value (via return handler) */
- p = pfun('a', p, &a, NULL, (int*)addr, 2);
+ p = pfun('a', p, &a, NULL, (int *)addr, 2);
/*@assert \valid(p); */
return 0;
}
-
-
diff --git a/src/plugins/e-acsl/tests/temporal/t_getenv.c b/src/plugins/e-acsl/tests/temporal/t_getenv.c
index 1bb3e9a7d47b6ceafbfae6a9d2efc32b3fc76a94..29463667638aacb035e0bfde9866544dad588885 100644
--- a/src/plugins/e-acsl/tests/temporal/t_getenv.c
+++ b/src/plugins/e-acsl/tests/temporal/t_getenv.c
@@ -2,9 +2,8 @@
COMMENT: Check temporal validity of environment string (via getenv function)
*/
-#include <stdlib.h>
#include <errno.h>
-
+#include <stdlib.h>
int main(int argc, const char **argv) {
char *g1 = NULL;
diff --git a/src/plugins/e-acsl/tests/temporal/t_global_init.c b/src/plugins/e-acsl/tests/temporal/t_global_init.c
index e6edd0e607f64408c6859d400df6d61aeb4f5c06..9354ff735c09f0488b32e97b4ff2c75316313ff3 100644
--- a/src/plugins/e-acsl/tests/temporal/t_global_init.c
+++ b/src/plugins/e-acsl/tests/temporal/t_global_init.c
@@ -3,35 +3,30 @@
*/
struct tree_desc {
- int *extra_bits ;
+ int *extra_bits;
};
typedef struct tree_desc tree_desc;
struct tree_desc2 {
- struct tree_desc desc;
+ struct tree_desc desc;
};
typedef struct tree_desc2 tree_desc2;
-static int extra_lbits[] = { 0 };
+static int extra_lbits[] = {0};
static tree_desc l_desc =
- /* This bit should be tracked via globals_init function */
- { .extra_bits = extra_lbits };
+ /* This bit should be tracked via globals_init function */
+ {.extra_bits = extra_lbits};
-static tree_desc descs [2] = {
- { .extra_bits = extra_lbits },
- { .extra_bits = extra_lbits }
-};
+static tree_desc descs[2] = {{.extra_bits = extra_lbits},
+ {.extra_bits = extra_lbits}};
-static tree_desc2 l_desc2 =
- { .desc = { .extra_bits = extra_lbits } };
+static tree_desc2 l_desc2 = {.desc = {.extra_bits = extra_lbits}};
-static tree_desc2 descs2 [2] = {
- { .desc = { .extra_bits = extra_lbits } },
- { .desc = { .extra_bits = extra_lbits } }
-};
+static tree_desc2 descs2[2] = {{.desc = {.extra_bits = extra_lbits}},
+ {.desc = {.extra_bits = extra_lbits}}};
void build_tree(tree_desc *desc) {
int *extra;
@@ -39,23 +34,20 @@ void build_tree(tree_desc *desc) {
/*@assert \valid(extra); */
}
-const char * strings [2][2] = {
- { "the", "tha" },
- { "thi", "tho" }
-};
+const char *strings[2][2] = {{"the", "tha"}, {"thi", "tho"}};
int main(int argc, const char **argv) {
- build_tree(&l_desc);
- build_tree(&descs[0]);
- build_tree(&descs[1]);
- build_tree(&l_desc2.desc);
- build_tree(&descs2[0].desc);
- build_tree(&descs2[1].desc);
+ build_tree(&l_desc);
+ build_tree(&descs[0]);
+ build_tree(&descs[1]);
+ build_tree(&l_desc2.desc);
+ build_tree(&descs2[0].desc);
+ build_tree(&descs2[1].desc);
- char **p = (char**)&strings[0];
+ char **p = (char **)&strings[0];
- /*@assert \valid_read(p); */
- /*@assert \valid_read(*p); */
+ /*@assert \valid_read(p); */
+ /*@assert \valid_read(*p); */
- return 0;
+ return 0;
}
diff --git a/src/plugins/e-acsl/tests/temporal/t_labels.c b/src/plugins/e-acsl/tests/temporal/t_labels.c
index 5d82c469b0fca0fea19e9c8867e9f6d1d05a8d60..7d05eae9ef388861702db1b4c033d3ed0563d5f7 100644
--- a/src/plugins/e-acsl/tests/temporal/t_labels.c
+++ b/src/plugins/e-acsl/tests/temporal/t_labels.c
@@ -11,17 +11,15 @@ void foo(int *a, int *b) {
}
int *Q;
-int* bar() {
+int *bar() {
RET:
return Q;
}
int main(int argc, const char **argv) {
- int a = 11,
- b = 12;
+ int a = 11, b = 12;
- int *p = &a,
- *q = &b;
+ int *p = &a, *q = &b;
LAB:
foo(p, q);
diff --git a/src/plugins/e-acsl/tests/temporal/t_local_init.c b/src/plugins/e-acsl/tests/temporal/t_local_init.c
index 01afaf3dbcc4216c7b0c5d3d85ef91fb51e63a5d..062ed999688242ff8e2f4fefd4f4fc8929fb2bdc 100644
--- a/src/plugins/e-acsl/tests/temporal/t_local_init.c
+++ b/src/plugins/e-acsl/tests/temporal/t_local_init.c
@@ -2,17 +2,17 @@
COMMENT: Check local compound variable initializers
*/
-#include <stdio.h>
#include <stddef.h>
+#include <stdio.h>
struct tree_desc {
- int *extra_bits ;
+ int *extra_bits;
};
typedef struct tree_desc tree_desc;
struct tree_desc2 {
- struct tree_desc desc;
+ struct tree_desc desc;
};
typedef struct tree_desc2 tree_desc2;
@@ -23,58 +23,46 @@ void build_tree(tree_desc *desc) {
/*@assert \valid(extra); */
}
-char * Strings [2][2] = {
- { "the", "tha" },
- { "thi", "tho" }
-};
+char *Strings[2][2] = {{"the", "tha"}, {"thi", "tho"}};
-char * Str [4] = { "foo", "bar", "baz", NULL };
+char *Str[4] = {"foo", "bar", "baz", NULL};
int main(int argc, const char **argv) {
- char * strings [2][2] = {
- { "the", "tha" },
- { "thi", "tho" }
- };
+ char *strings[2][2] = {{"the", "tha"}, {"thi", "tho"}};
- char **p = (char**)&strings[0];
+ char **p = (char **)&strings[0];
/*@assert \valid_read(p); */
/*@assert \valid_read(*p); */
- char * str [4] = { "foo", "bar", "baz", NULL };
+ char *str[4] = {"foo", "bar", "baz", NULL};
- p = (char**)&str;
+ p = (char **)&str;
/*@assert \valid_read(p); */
/*@assert \valid_read(*p); */
- char **P = (char**)&Strings[0];
+ char **P = (char **)&Strings[0];
/*@assert \valid_read(P); */
/*@assert \valid_read(*P); */
- P = (char**)&Str;
+ P = (char **)&Str;
/*@assert \valid_read(P); */
/*@assert \valid_read(*P); */
int extra_lbits[] = {0};
- tree_desc l_desc =
- { .extra_bits = extra_lbits };
+ tree_desc l_desc = {.extra_bits = extra_lbits};
- tree_desc descs [2] = {
- { .extra_bits = extra_lbits },
- { .extra_bits = extra_lbits }
- };
+ tree_desc descs[2] = {{.extra_bits = extra_lbits},
+ {.extra_bits = extra_lbits}};
- tree_desc2 l_desc2 =
- { .desc = { .extra_bits = extra_lbits } };
+ tree_desc2 l_desc2 = {.desc = {.extra_bits = extra_lbits}};
- tree_desc2 descs2 [2] = {
- { .desc = { .extra_bits = extra_lbits } },
- { .desc = { .extra_bits = extra_lbits } }
- };
+ tree_desc2 descs2[2] = {{.desc = {.extra_bits = extra_lbits}},
+ {.desc = {.extra_bits = extra_lbits}}};
build_tree(&l_desc);
build_tree(&descs[0]);
diff --git a/src/plugins/e-acsl/tests/temporal/t_malloc-asan.c b/src/plugins/e-acsl/tests/temporal/t_malloc-asan.c
index 78f96e9145f8a1189dab9aad45a56ea0b1da1fd4..7f59532fcd17100b098a01d57a0339de8c26d40d 100644
--- a/src/plugins/e-acsl/tests/temporal/t_malloc-asan.c
+++ b/src/plugins/e-acsl/tests/temporal/t_malloc-asan.c
@@ -5,17 +5,17 @@
COMMENT: Valgrind tools who are not capable of catching this bug
*/
-#include <stdlib.h>
#include <stdio.h>
+#include <stdlib.h>
-#define MB (1024*1024)
+#define MB (1024 * 1024)
int main(void) {
int *p, *q;
int counter = 0;
size_t limit = 10000;
- p = (int*)malloc(MB);
+ p = (int *)malloc(MB);
q = p;
free(p);
@@ -23,7 +23,7 @@ int main(void) {
/* Allocate and de-allocate a chunk of
memory until allocator reuses address */
while (counter < limit) {
- p = (int*)malloc(MB);
+ p = (int *)malloc(MB);
counter++;
if (p != q)
free(p);
@@ -42,4 +42,3 @@ int main(void) {
free(p);
return 0;
}
-
diff --git a/src/plugins/e-acsl/tests/temporal/t_malloc.c b/src/plugins/e-acsl/tests/temporal/t_malloc.c
index 9ae3b5d0a280fb86e55ce5f5f18fc32bc2022c58..65218abd367ce97bea24650fc494de1d2aa0cec7 100644
--- a/src/plugins/e-acsl/tests/temporal/t_malloc.c
+++ b/src/plugins/e-acsl/tests/temporal/t_malloc.c
@@ -11,7 +11,7 @@ int main(void) {
/*@assert ! \valid(p); */
/*@assert ! \valid(q); */
- p = (int*)malloc(sizeof(int));
+ p = (int *)malloc(sizeof(int));
q = p;
/*@assert \valid(p); */
@@ -22,7 +22,7 @@ int main(void) {
/*@assert ! \valid(p); */
/*@assert ! \valid(q); */
- p = (int*)malloc(sizeof(int));
+ p = (int *)malloc(sizeof(int));
/* q is temporally invalid: points to the block allocated by the first malloc
call which has been deallocated, while p is valid */
/*@assert \valid(p); */
@@ -31,11 +31,11 @@ int main(void) {
*p = 2;
/* ... and for calloc .. */
- q = (char*)calloc(4096,1);
+ q = (char *)calloc(4096, 1);
/*@assert \valid(q); */
/* ... and and realloc */
- q = (char*)realloc(q, 8192);
+ q = (char *)realloc(q, 8192);
/*@assert \valid(q); */
return 0;
}
diff --git a/src/plugins/e-acsl/tests/temporal/t_memcpy.c b/src/plugins/e-acsl/tests/temporal/t_memcpy.c
index c18b0fcc2504f613fc472eeb72ab0a85947b6465..bef5a357b6d8a1a08eeef03be34effa6e678ed4a 100644
--- a/src/plugins/e-acsl/tests/temporal/t_memcpy.c
+++ b/src/plugins/e-acsl/tests/temporal/t_memcpy.c
@@ -1,15 +1,13 @@
-#include <string.h>
#include <stdlib.h>
+#include <string.h>
int main() {
/* ********** STACK ********** */
- int a = 111,
- b = 222;
+ int a = 111, b = 222;
- int *src[2],
- *dest[2];
+ int *src[2], *dest[2];
- int size = sizeof(int*)*2;
+ int size = sizeof(int *) * 2;
src[0] = &a;
src[1] = &b;
@@ -37,14 +35,14 @@ int main() {
int **q = malloc(size);
*p = &a;
- *(p+1) = &a;
+ *(p + 1) = &a;
/*@assert \valid(*p); */
/*@assert \valid(*(p+1)); */
/*@assert ! \valid(*q); */
/*@assert ! \valid(*(q+1)); */
- *q = *(q+1) = NULL;
+ *q = *(q + 1) = NULL;
memcpy(q, p, size);
/*@assert \valid(*q); */
diff --git a/src/plugins/e-acsl/tests/temporal/t_scope.c b/src/plugins/e-acsl/tests/temporal/t_scope.c
index de4c6dc3bd74585c4c3d4a43b8ca669bc4c65733..bd6b68e5d07618b22bfdd7443163b7c271c2f5f9 100644
--- a/src/plugins/e-acsl/tests/temporal/t_scope.c
+++ b/src/plugins/e-acsl/tests/temporal/t_scope.c
@@ -5,8 +5,7 @@
#include <stddef.h>
int main() {
- int *p = NULL,
- *q = NULL;
+ int *p = NULL, *q = NULL;
{
int i = 9;
p = &i;
@@ -28,8 +27,7 @@ int main() {
/* Example from Arvid's report (Listing 3.12) */
int len = 3;
- p = NULL,
- q = NULL;
+ p = NULL, q = NULL;
while (len) {
int a;
/*@assert ! \valid(p); */
diff --git a/src/plugins/e-acsl/tests/temporal/t_struct.c b/src/plugins/e-acsl/tests/temporal/t_struct.c
index e72e879cf605c315e6b69d6579dc479e4e6648f2..2ff5482b264b1558fe6f2857771423a9242c6e3d 100644
--- a/src/plugins/e-acsl/tests/temporal/t_struct.c
+++ b/src/plugins/e-acsl/tests/temporal/t_struct.c
@@ -21,8 +21,7 @@ typedef struct larger_t larger;
/* }}} */
int main(void) {
- int a = 1,
- b = 2;
+ int a = 1, b = 2;
temporal t1, t2, *tp, tarr[2];
larger l, *lp, larr[2];
diff --git a/src/plugins/e-acsl/tests/temporal/t_while.c b/src/plugins/e-acsl/tests/temporal/t_while.c
index 10883a3ba1b7f0f4950b75ddd3fa9d088440fcfe..3d9b506347ced715336f77a52779eec684cb2002 100644
--- a/src/plugins/e-acsl/tests/temporal/t_while.c
+++ b/src/plugins/e-acsl/tests/temporal/t_while.c
@@ -15,8 +15,8 @@ int main(void) {
and that there is no gap betwee [arr] and [arr2]. This behaviour is
compiler specific but still likely. At least this is the case for some
current versions of GCC/Clang */
- int arr [] = {1, 2, 3, 4};
- int arr2 [] = {1, 2, 3, 4};
+ int arr[] = {1, 2, 3, 4};
+ int arr2[] = {1, 2, 3, 4};
/* Check that the above condition holds, otherwise there is no point
having this test */
diff --git a/src/plugins/e-acsl/tests/utils/signalled.h b/src/plugins/e-acsl/tests/utils/signalled.h
index 7f7d69ac0c96bb739b454c45b06d31f233f387bf..7d88530cb7b07ad2bfac4d737e639bb6667e41fa 100644
--- a/src/plugins/e-acsl/tests/utils/signalled.h
+++ b/src/plugins/e-acsl/tests/utils/signalled.h
@@ -1,13 +1,13 @@
-#include <stdlib.h>
#include <stdio.h>
+#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
+#define TOSTRING(x) STRINGIFY(x)
#ifndef __FRAMAC__
-#define __FC_FILENAME__ __FILE__
+# define __FC_FILENAME__ __FILE__
#endif
#define AT __FC_FILENAME__ ":" TOSTRING(__LINE__)
@@ -31,19 +31,20 @@ void signal_eval(int status, int expect_signal, const char *at) {
/* The following macro runs a chunk of code in a subprocess and evaluates
the result. This macro assumes that fork is always successful. */
-#define SIGNALLED_AT(code, expect_signal, at) { \
- pid_t pid = fork(); \
- if(!pid) { \
- code; \
- exit(0); \
- } else { \
- int process_status; \
- waitpid(pid, &process_status, 0); \
- signal_eval(process_status, expect_signal, at); \
- } \
-}
+#define SIGNALLED_AT(code, expect_signal, at) \
+ { \
+ pid_t pid = fork(); \
+ if (!pid) { \
+ code; \
+ exit(0); \
+ } else { \
+ int process_status; \
+ waitpid(pid, &process_status, 0); \
+ signal_eval(process_status, expect_signal, at); \
+ } \
+ }
-#define ABRT(code) SIGNALLED_AT(code, 1, AT)
-#define OK(code) SIGNALLED_AT(code, 0, AT);
-#define ABRT_AT(code,at) SIGNALLED_AT(code, 1, at)
-#define OK_AT(code,at) SIGNALLED_AT(code, 0, at)
+#define ABRT(code) SIGNALLED_AT(code, 1, AT)
+#define OK(code) SIGNALLED_AT(code, 0, AT);
+#define ABRT_AT(code, at) SIGNALLED_AT(code, 1, at)
+#define OK_AT(code, at) SIGNALLED_AT(code, 0, at)