From abe9a1a86da2874d29fdf4fea9e910121eec9bdd Mon Sep 17 00:00:00 2001
From: Kostyantyn Vorobyov <kostyantyn.vorobyov@cea.fr>
Date: Fri, 25 Nov 2016 14:18:04 +0100
Subject: [PATCH] Namespace changes as per changes of terminology of shadow
techniques
---
.../segment_model/e_acsl_segment_tracking.h | 84 ++++++++++---------
1 file changed, 43 insertions(+), 41 deletions(-)
diff --git a/src/plugins/e-acsl/share/e-acsl/segment_model/e_acsl_segment_tracking.h b/src/plugins/e-acsl/share/e-acsl/segment_model/e_acsl_segment_tracking.h
index ebc8c99abef..e1fb8c7bebb 100644
--- a/src/plugins/e-acsl/share/e-acsl/segment_model/e_acsl_segment_tracking.h
+++ b/src/plugins/e-acsl/share/e-acsl/segment_model/e_acsl_segment_tracking.h
@@ -65,7 +65,7 @@
* These remaining bytes reuse the shadow of [0,7]. */
#define LONG_BLOCK_BOUNDARY(_size) (_size - _size%LONG_BLOCK)
-/*! \brief Short shadow of a long block consists of a 8-byte segment + a
+/*! \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
* segments + 2 bytes. Each byte of a segment stores an offset in the secondary
* shadow. The offsets for each such segment can be expressed using the
@@ -225,7 +225,7 @@ static int freeable(void *ptr);
# define DVALIDATE_HEAP_ACCESS(_addr, _size) \
DVALIDATE_SHADOW_LAYOUT; \
- DVASSERT(IS_ON_HEAP((uintptr_t)_addr), \
+ DVASSERT(IS_ON_HEAP(_addr), \
"Expected heap location: %a\n ", _addr); \
DVASSERT(heap_allocated((uintptr_t)_addr, _size), \
"Operation on unallocated heap block [%a + %lu]\n ", _addr, _size)
@@ -233,7 +233,7 @@ static int freeable(void *ptr);
# define segstr(_global) ((_global) ? "global" : "stack")
# define DVALIDATE_STATIC_ACCESS(_addr, _size, _global) \
DVALIDATE_SHADOW_LAYOUT; \
- DVASSERT(IS_ON_STATIC((uintptr_t)_addr, _global), \
+ DVASSERT(IS_ON_STATIC(_addr, _global), \
"Expected %s location: %a\n ", segstr(_global), _addr); \
DVASSERT(static_allocated((uintptr_t)_addr, _size, _global), \
"Operation on unallocated %s block [%a + %lu]\n ", \
@@ -241,7 +241,7 @@ static int freeable(void *ptr);
# define DVALIDATE_STATIC_LOCATION(_addr, _global) \
DVALIDATE_SHADOW_LAYOUT; \
- DVASSERT(IS_ON_STATIC((uintptr_t)_addr, _global), \
+ DVASSERT(IS_ON_STATIC(_addr, _global), \
"Expected %s location: %a\n ", segstr(_global), _addr); \
DVASSERT(static_allocated_one((uintptr_t)_addr, _global), \
"Operation on unallocated %s block [%a]\n ", segstr(_global), _addr)
@@ -306,11 +306,11 @@ static uintptr_t predicate(uintptr_t addr, char p) {
#define block_length(_addr) predicate((uintptr_t)_addr, 'L')
/*! \brief Return a base address of a memory block address `_addr` belongs to
* \param uintptr_t _addr - a memory address */
-#define base_addr(_addr) predicate((uintptr_t)_addr, 'B')
+#define base_addr(_addr) predicate((uintptr_t)_addr, 'B')
/*! \brief Return a byte offset of a memory address given by `_addr` within
* its block
* \param uintptr_t _addr - a memory address */
-#define offset(_addr) predicate((uintptr_t)_addr, 'O')
+#define offset(_addr) predicate((uintptr_t)_addr, 'O')
/* }}} */
/* Static allocation {{{ */
@@ -336,39 +336,39 @@ static const char short_offsets_base [] = { 0, 1, 2, 4, 7, 11, 16, 22, 29 };
static void shadow_alloca(void *ptr, size_t size, int global) {
DVALIDATE_SHADOW_LAYOUT;
- unsigned char *short_shadowed =
+ unsigned char *prim_shadow =
(unsigned char*)PRIMARY_SHADOW(ptr, global);
- uint64_t *short_shadowed_alt =
+ uint64_t *prim_shadow_alt =
(uint64_t *)PRIMARY_SHADOW(ptr, global);
- unsigned int *long_shadowed =
+ unsigned int *sec_shadow =
(unsigned int*)SECONDARY_SHADOW(ptr, global);
/* Flip read-only bit for zero-size blocks. That is, physically it exists
* but one cannot write to it. Further, the flipped read-only bit will also
* identify such block as allocated */
if (!size)
- setbit(READONLY_BIT, short_shadowed[0]);
+ setbit(READONLY_BIT, prim_shadow[0]);
unsigned int i, j = 0, k = 0;
if (IS_LONG_BLOCK(size)) { /* Long blocks */
int boundary = LONG_BLOCK_BOUNDARY(size);
for (i = 0; i < boundary; i += LONG_BLOCK) {
- /* Set values for a long shadow */
- long_shadowed[j++] = size;
- long_shadowed[j++] = i;
- /* Set offsets in the short shadow */
- short_shadowed_alt[k++] = LONG_BLOCK_MASK;
+ /* Set-up a secondary shadow segment */
+ sec_shadow[j++] = size;
+ sec_shadow[j++] = i;
+ /* Set primary shadow offsets */
+ prim_shadow_alt[k++] = LONG_BLOCK_MASK;
}
/* Write out the remainder */
for (i = boundary; i < size; i++) {
unsigned char offset = i%LONG_BLOCK + LONG_BLOCK_INDEX_START + LONG_BLOCK;
- short_shadowed[i] = (offset << 2);
+ prim_shadow[i] = (offset << 2);
}
} else { /* Short blocks */
for (i = 0; i < size; i++) {
unsigned char code = short_offsets_base[size] + i;
- short_shadowed[i] = (code << 2);
+ prim_shadow[i] = (code << 2);
}
}
}
@@ -409,18 +409,18 @@ static void static_shadow_freea(void *ptr, int global) {
* applied to a stack or global address. */
static int static_allocated(uintptr_t addr, long size, int global) {
DVALIDATE_SHADOW_LAYOUT;
- unsigned char *short_shadowed = (unsigned char*)PRIMARY_SHADOW(addr, global);
+ unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(addr, global);
/* Unless the address belongs to tracked allocation 0 is returned */
- if (short_shadowed[0]) {
- unsigned int code = (short_shadowed[0] >> 2);
+ if (prim_shadow[0]) {
+ unsigned int code = (prim_shadow[0] >> 2);
unsigned int long_block = (code >= LONG_BLOCK_INDEX_START);
size_t length, offset;
if (long_block) {
offset = code - LONG_BLOCK_INDEX_START;
- unsigned int *long_shadowed =
+ unsigned int *sec_shadow =
(unsigned int*)SECONDARY_SHADOW(addr - offset, global) ;
- length = long_shadowed[0];
- offset = long_shadowed[1] + offset;
+ length = sec_shadow[0];
+ offset = sec_shadow[1] + offset;
} else {
offset = short_offsets[code];
length = short_lengths[code];
@@ -490,23 +490,23 @@ static int static_initialized(uintptr_t addr, long size, int global) {
* unspecified. */
static uintptr_t static_info(uintptr_t addr, char type, int global) {
DVALIDATE_STATIC_LOCATION(addr, global);
- unsigned char *short_shadowed = (unsigned char*)PRIMARY_SHADOW(addr, global);
+ unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(addr, global);
/* Unless the address belongs to tracked allocation 0 is returned */
- if (short_shadowed[0]) {
- unsigned int code = (short_shadowed[0] >> 2);
+ if (prim_shadow[0]) {
+ unsigned int code = (prim_shadow[0] >> 2);
unsigned int long_block = (code >= LONG_BLOCK_INDEX_START);
if (long_block) {
unsigned int offset = code - LONG_BLOCK_INDEX_START;
- unsigned int *long_shadowed =
+ unsigned int *sec_shadow =
(unsigned int*)SECONDARY_SHADOW(addr - offset, global) ;
switch(type) {
case 'B': /* Base address */
- return addr - offset - long_shadowed[1];
+ return addr - offset - sec_shadow[1];
case 'O': /* Offset */
- return long_shadowed[1] + offset;
+ return sec_shadow[1] + offset;
case 'L': /* Length */
- return long_shadowed[0];
+ return sec_shadow[0];
default:
DASSERT(0 && "Unknown static query type");
}
@@ -1084,11 +1084,11 @@ static void initialize(void *ptr, size_t n) {
* shadow */
static void printbyte(unsigned char c, char buf[]) {
if (c >> 2 < LONG_BLOCK_INDEX_START) {
- sprintf(buf, "SHORT: I{%u} RO{%u} OF{%2u} => %u[%u]",
+ 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]);
} else {
- sprintf(buf, "LONG: I{%u} RO{%u} OF{%u} => %4u",
+ 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);
}
@@ -1097,27 +1097,27 @@ static void printbyte(unsigned char c, char buf[]) {
/*! \brief Print human-readable (well, ish) representation of a memory block
* using primary and secondary shadows. */
static void print_static_shadows(uintptr_t addr, size_t size, int global) {
- char short_buf[256];
- char long_buf[256];
+ char prim_buf[256];
+ char sec_buf[256];
- unsigned char *short_shadowed = (unsigned char*)PRIMARY_SHADOW(addr, global);
- unsigned int *long_shadowed = (unsigned int*)SECONDARY_SHADOW(addr, global);
+ unsigned char *prim_shadow = (unsigned char*)PRIMARY_SHADOW(addr, global);
+ unsigned int *sec_shadow = (unsigned int*)SECONDARY_SHADOW(addr, global);
int i, j = 0;
for (i = 0; i < size; i++) {
- long_buf[0] = '\0';
- printbyte(short_shadowed[i], short_buf);
+ sec_buf[0] = '\0';
+ printbyte(prim_shadow[i], prim_buf);
if (IS_LONG_BLOCK(size) && (i%LONG_BLOCK) == 0) {
j += 2;
if (i < LONG_BLOCK_BOUNDARY(size)) {
- sprintf(long_buf, " %a SZ{%u} OF{%u}",
- &long_shadowed[j], long_shadowed[j-2], long_shadowed[j-1]);
+ sprintf(sec_buf, " %a SZ{%u} OF{%u}",
+ &sec_shadow[j], sec_shadow[j-2], sec_shadow[j-1]);
}
if (i) {
DLOG("---------------------------------------------\n");
}
}
- DLOG("| [%2d] %a | %s || %s\n", i, &short_shadowed[i], short_buf, long_buf);
+ DLOG("| [%2d] %a | %s || %s\n", i, &prim_shadow[i], prim_buf, sec_buf);
}
}
@@ -1184,6 +1184,8 @@ static void which_segment(uintptr_t addr) {
loc = "heap";
else if (IS_ON_GLOBAL(addr))
loc = "global";
+ else if (IS_ON_TLS(addr))
+ loc = "TLS";
else
loc = "untracked";
DLOG("Address: %a -> %s\n", addr, loc);
--
GitLab