- Reindented code such that it uses three spaces for indentation instead
of two. The indentation of the DRD source code is now consistent with
the other Valgrind source files.
- Added emacs mode line with indentation settings.
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@9496 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/drd/drd_malloc_wrappers.c b/drd/drd_malloc_wrappers.c
index 086f82f..62da58e 100644
--- a/drd/drd_malloc_wrappers.c
+++ b/drd/drd_malloc_wrappers.c
@@ -1,3 +1,4 @@
+/* -*- mode: C; c-basic-offset: 3; -*- */
/*
This file is part of drd, a thread error detector.
@@ -40,10 +41,10 @@
/* Local type definitions. */
typedef struct _DRD_Chunk {
- struct _DRD_Chunk* next;
- Addr data; // ptr to actual block
- SizeT size : (sizeof(UWord)*8)-2; //size requested; 30 or 62 bits
- ExeContext* where; // where it was allocated
+ struct _DRD_Chunk* next;
+ Addr data; // ptr to actual block
+ SizeT size : (sizeof(UWord)*8)-2; //size requested; 30 or 62 bits
+ ExeContext* where; // where it was allocated
} DRD_Chunk;
@@ -66,13 +67,13 @@
/** Allocate its shadow chunk, put it on the appropriate list. */
static DRD_Chunk* DRD_(create_chunk)(ThreadId tid, Addr p, SizeT size)
{
- DRD_Chunk* mc = VG_(malloc)("drd.malloc_wrappers.cDC.1",
- sizeof(DRD_Chunk));
- mc->data = p;
- mc->size = size;
- mc->where = VG_(record_ExeContext)(tid, 0);
+ DRD_Chunk* mc = VG_(malloc)("drd.malloc_wrappers.cDC.1",
+ sizeof(DRD_Chunk));
+ mc->data = p;
+ mc->size = size;
+ mc->where = VG_(record_ExeContext)(tid, 0);
- return mc;
+ return mc;
}
/*------------------------------------------------------------*/
@@ -86,161 +87,163 @@
SizeT size, SizeT align,
Bool is_zeroed)
{
- Addr p;
+ Addr p;
- DRD_(s_cmalloc_n_mallocs) ++;
+ DRD_(s_cmalloc_n_mallocs) ++;
- // Allocate and zero
- p = (Addr)VG_(cli_malloc)(align, size);
- if (!p) {
- return NULL;
- }
- if (is_zeroed) VG_(memset)((void*)p, 0, size);
- DRD_(s_start_using_mem_callback)(p, p + size, 0/*ec_uniq*/);
+ // Allocate and zero
+ p = (Addr)VG_(cli_malloc)(align, size);
+ if (!p) {
+ return NULL;
+ }
+ if (is_zeroed) VG_(memset)((void*)p, 0, size);
+ DRD_(s_start_using_mem_callback)(p, p + size, 0/*ec_uniq*/);
- // Only update this stat if allocation succeeded.
- DRD_(s_cmalloc_bs_mallocd) += size;
+ // Only update this stat if allocation succeeded.
+ DRD_(s_cmalloc_bs_mallocd) += size;
- VG_(HT_add_node)(DRD_(s_malloc_list), DRD_(create_chunk)(tid, p, size));
+ VG_(HT_add_node)(DRD_(s_malloc_list), DRD_(create_chunk)(tid, p, size));
- return (void*)p;
+ return (void*)p;
}
static void* DRD_(malloc)(ThreadId tid, SizeT n)
{
- return DRD_(new_block)(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
+ return DRD_(new_block)(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
}
static void* DRD_(memalign)(ThreadId tid, SizeT align, SizeT n)
{
- return DRD_(new_block)(tid, n, align, /*is_zeroed*/False);
+ return DRD_(new_block)(tid, n, align, /*is_zeroed*/False);
}
static void* DRD_(calloc)(ThreadId tid, SizeT nmemb, SizeT size1)
{
- return DRD_(new_block)(tid, nmemb*size1, VG_(clo_alignment),
- /*is_zeroed*/True);
+ return DRD_(new_block)(tid, nmemb*size1, VG_(clo_alignment),
+ /*is_zeroed*/True);
}
static __inline__ void DRD_(handle_free)(ThreadId tid, Addr p)
{
- DRD_Chunk* mc;
+ DRD_Chunk* mc;
- DRD_(s_cmalloc_n_frees)++;
+ DRD_(s_cmalloc_n_frees)++;
- mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p);
- if (mc == NULL)
- {
- tl_assert(0);
- }
- else
- {
- tl_assert(p == mc->data);
- if (mc->size > 0)
- DRD_(s_stop_using_mem_callback)(mc->data, mc->size);
- VG_(cli_free)((void*)p);
- VG_(free)(mc);
- }
+ mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p);
+ if (mc == NULL)
+ {
+ tl_assert(0);
+ }
+ else
+ {
+ tl_assert(p == mc->data);
+ if (mc->size > 0)
+ DRD_(s_stop_using_mem_callback)(mc->data, mc->size);
+ VG_(cli_free)((void*)p);
+ VG_(free)(mc);
+ }
}
static void DRD_(free)(ThreadId tid, void* p)
{
- DRD_(handle_free)(tid, (Addr)p);
+ DRD_(handle_free)(tid, (Addr)p);
}
static void* DRD_(realloc)(ThreadId tid, void* p_old, SizeT new_size)
{
- DRD_Chunk* mc;
- void* p_new;
- SizeT old_size;
+ DRD_Chunk* mc;
+ void* p_new;
+ SizeT old_size;
- DRD_(s_cmalloc_n_frees) ++;
- DRD_(s_cmalloc_n_mallocs) ++;
- DRD_(s_cmalloc_bs_mallocd) += new_size;
+ DRD_(s_cmalloc_n_frees) ++;
+ DRD_(s_cmalloc_n_mallocs) ++;
+ DRD_(s_cmalloc_bs_mallocd) += new_size;
- /* Remove the old block */
- mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p_old);
- if (mc == NULL) {
- tl_assert(0);
- return NULL;
- }
+ /* Remove the old block */
+ mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p_old);
+ if (mc == NULL) {
+ tl_assert(0);
+ return NULL;
+ }
- old_size = mc->size;
+ old_size = mc->size;
- if (old_size == new_size)
- {
- /* size unchanged */
- mc->where = VG_(record_ExeContext)(tid, 0);
- p_new = p_old;
+ if (old_size == new_size)
+ {
+ /* size unchanged */
+ mc->where = VG_(record_ExeContext)(tid, 0);
+ p_new = p_old;
- }
- else if (old_size > new_size)
- {
- /* new size is smaller */
- DRD_(s_stop_using_mem_callback)(mc->data + new_size, old_size);
- mc->size = new_size;
- mc->where = VG_(record_ExeContext)(tid, 0);
- p_new = p_old;
+ }
+ else if (old_size > new_size)
+ {
+ /* new size is smaller */
+ DRD_(s_stop_using_mem_callback)(mc->data + new_size, old_size);
+ mc->size = new_size;
+ mc->where = VG_(record_ExeContext)(tid, 0);
+ p_new = p_old;
- }
- else
- {
- /* new size is bigger */
- /* Get new memory */
- const Addr a_new = (Addr)VG_(cli_malloc)(VG_(clo_alignment), new_size);
+ }
+ else
+ {
+ /* new size is bigger */
+ /* Get new memory */
+ const Addr a_new = (Addr)VG_(cli_malloc)(VG_(clo_alignment), new_size);
- if (a_new)
- {
- /* Copy from old to new */
- VG_(memcpy)((void*)a_new, p_old, mc->size);
+ if (a_new)
+ {
+ /* Copy from old to new */
+ VG_(memcpy)((void*)a_new, p_old, mc->size);
- /* Free old memory */
- DRD_(s_stop_using_mem_callback)(mc->data, mc->size);
- VG_(free)(mc);
+ /* Free old memory */
+ DRD_(s_stop_using_mem_callback)(mc->data, mc->size);
+ VG_(free)(mc);
- // Allocate a new chunk.
- mc = DRD_(create_chunk)(tid, a_new, new_size);
- DRD_(s_start_using_mem_callback)(a_new, a_new + new_size, 0/*ec_uniq*/);
- }
- else
- {
- /* Allocation failed -- leave original block untouched. */
- }
+ // Allocate a new chunk.
+ mc = DRD_(create_chunk)(tid, a_new, new_size);
+ DRD_(s_start_using_mem_callback)(a_new, a_new + new_size,
+ 0/*ec_uniq*/);
+ }
+ else
+ {
+ /* Allocation failed -- leave original block untouched. */
+ }
- p_new = (void*)a_new;
- }
+ p_new = (void*)a_new;
+ }
- // Now insert the new mc (with a possibly new 'data' field) into
- // malloc_list. If this realloc() did not increase the memory size, we
- // will have removed and then re-added mc unnecessarily. But that's ok
- // because shrinking a block with realloc() is (presumably) much rarer
- // than growing it, and this way simplifies the growing case.
- VG_(HT_add_node)(DRD_(s_malloc_list), mc);
+ // Now insert the new mc (with a possibly new 'data' field) into
+ // malloc_list. If this realloc() did not increase the memory size, we
+ // will have removed and then re-added mc unnecessarily. But that's ok
+ // because shrinking a block with realloc() is (presumably) much rarer
+ // than growing it, and this way simplifies the growing case.
+ VG_(HT_add_node)(DRD_(s_malloc_list), mc);
- return p_new;
+ return p_new;
}
static void* DRD_(__builtin_new)(ThreadId tid, SizeT n)
{
- void* const result = DRD_(new_block)(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
- //VG_(message)(Vg_DebugMsg, "__builtin_new(%d, %d) = %p", tid, n, result);
- return result;
+ void* const result = DRD_(new_block)(tid, n, VG_(clo_alignment),
+ /*is_zeroed*/False);
+ //VG_(message)(Vg_DebugMsg, "__builtin_new(%d, %d) = %p", tid, n, result);
+ return result;
}
static void DRD_(__builtin_delete)(ThreadId tid, void* p)
{
- //VG_(message)(Vg_DebugMsg, "__builtin_delete(%d, %p)", tid, p);
- DRD_(handle_free)(tid, (Addr)p);
+ //VG_(message)(Vg_DebugMsg, "__builtin_delete(%d, %p)", tid, p);
+ DRD_(handle_free)(tid, (Addr)p);
}
static void* DRD_(__builtin_vec_new)(ThreadId tid, SizeT n)
{
- return DRD_(new_block)(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
+ return DRD_(new_block)(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
}
static void DRD_(__builtin_vec_delete)(ThreadId tid, void* p)
{
- DRD_(handle_free)(tid, (Addr)p);
+ DRD_(handle_free)(tid, (Addr)p);
}
static SizeT DRD_(malloc_usable_size) ( ThreadId tid, void* p )
@@ -255,26 +258,26 @@
void DRD_(register_malloc_wrappers)(const StartUsingMem start_callback,
const StopUsingMem stop_callback)
{
- tl_assert(DRD_(s_malloc_list) == 0);
- DRD_(s_malloc_list) = VG_(HT_construct)("drd_malloc_list"); // a big prime
- tl_assert(DRD_(s_malloc_list) != 0);
- tl_assert(start_callback);
- tl_assert(stop_callback);
+ tl_assert(DRD_(s_malloc_list) == 0);
+ DRD_(s_malloc_list) = VG_(HT_construct)("drd_malloc_list"); // a big prime
+ tl_assert(DRD_(s_malloc_list) != 0);
+ tl_assert(start_callback);
+ tl_assert(stop_callback);
- DRD_(s_start_using_mem_callback) = start_callback;
- DRD_(s_stop_using_mem_callback) = stop_callback;
+ DRD_(s_start_using_mem_callback) = start_callback;
+ DRD_(s_stop_using_mem_callback) = stop_callback;
- VG_(needs_malloc_replacement)(DRD_(malloc),
- DRD_(__builtin_new),
- DRD_(__builtin_vec_new),
- DRD_(memalign),
- DRD_(calloc),
- DRD_(free),
- DRD_(__builtin_delete),
- DRD_(__builtin_vec_delete),
- DRD_(realloc),
- DRD_(malloc_usable_size),
- 0);
+ VG_(needs_malloc_replacement)(DRD_(malloc),
+ DRD_(__builtin_new),
+ DRD_(__builtin_vec_new),
+ DRD_(memalign),
+ DRD_(calloc),
+ DRD_(free),
+ DRD_(__builtin_delete),
+ DRD_(__builtin_vec_delete),
+ DRD_(realloc),
+ DRD_(malloc_usable_size),
+ 0);
}
Bool DRD_(heap_addrinfo)(Addr const a,
@@ -282,24 +285,24 @@
SizeT* const size,
ExeContext** const where)
{
- DRD_Chunk* mc;
+ DRD_Chunk* mc;
- tl_assert(data);
- tl_assert(size);
- tl_assert(where);
+ tl_assert(data);
+ tl_assert(size);
+ tl_assert(where);
- VG_(HT_ResetIter)(DRD_(s_malloc_list));
- while ((mc = VG_(HT_Next)(DRD_(s_malloc_list))))
- {
- if (mc->data <= a && a < mc->data + mc->size)
- {
- *data = mc->data;
- *size = mc->size;
- *where = mc->where;
- return True;
- }
- }
- return False;
+ VG_(HT_ResetIter)(DRD_(s_malloc_list));
+ while ((mc = VG_(HT_Next)(DRD_(s_malloc_list))))
+ {
+ if (mc->data <= a && a < mc->data + mc->size)
+ {
+ *data = mc->data;
+ *size = mc->size;
+ *where = mc->where;
+ return True;
+ }
+ }
+ return False;
}
/*------------------------------------------------------------*/
@@ -308,32 +311,32 @@
void DRD_(print_malloc_stats)(void)
{
- DRD_Chunk* mc;
- SizeT nblocks = 0;
- SizeT nbytes = 0;
+ DRD_Chunk* mc;
+ SizeT nblocks = 0;
+ SizeT nbytes = 0;
- if (VG_(clo_verbosity) == 0)
- return;
- if (VG_(clo_xml))
- return;
+ if (VG_(clo_verbosity) == 0)
+ return;
+ if (VG_(clo_xml))
+ return;
- /* Count memory still in use. */
- VG_(HT_ResetIter)(DRD_(s_malloc_list));
- while ((mc = VG_(HT_Next)(DRD_(s_malloc_list))))
- {
- nblocks++;
- nbytes += mc->size;
- }
+ /* Count memory still in use. */
+ VG_(HT_ResetIter)(DRD_(s_malloc_list));
+ while ((mc = VG_(HT_Next)(DRD_(s_malloc_list))))
+ {
+ nblocks++;
+ nbytes += mc->size;
+ }
- VG_(message)(Vg_DebugMsg,
- "malloc/free: in use at exit: %lu bytes in %lu blocks.",
- nbytes, nblocks);
- VG_(message)(Vg_DebugMsg,
- "malloc/free: %lu allocs, %lu frees, %lu bytes allocated.",
- DRD_(s_cmalloc_n_mallocs),
- DRD_(s_cmalloc_n_frees), DRD_(s_cmalloc_bs_mallocd));
- if (VG_(clo_verbosity) > 1)
- VG_(message)(Vg_DebugMsg, " ");
+ VG_(message)(Vg_DebugMsg,
+ "malloc/free: in use at exit: %lu bytes in %lu blocks.",
+ nbytes, nblocks);
+ VG_(message)(Vg_DebugMsg,
+ "malloc/free: %lu allocs, %lu frees, %lu bytes allocated.",
+ DRD_(s_cmalloc_n_mallocs),
+ DRD_(s_cmalloc_n_frees), DRD_(s_cmalloc_bs_mallocd));
+ if (VG_(clo_verbosity) > 1)
+ VG_(message)(Vg_DebugMsg, " ");
}
/*--------------------------------------------------------------------*/