From c13f1a4f749b41e2cb0c87451ee951e893d219dc Mon Sep 17 00:00:00 2001 From: Bart Van Assche Date: Sun, 15 Feb 2009 14:46:17 +0000 Subject: [PATCH] Wrapped DRD_() macro around even more function and variable names. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@9171 --- drd/drd_error.c | 98 ++++++++++----------- drd/drd_error.h | 2 +- drd/drd_main.c | 8 +- drd/drd_malloc_wrappers.c | 177 ++++++++++++++++++-------------------- drd/drd_malloc_wrappers.h | 19 ++-- 5 files changed, 146 insertions(+), 158 deletions(-) diff --git a/drd/drd_error.c b/drd/drd_error.c index 5c87812326..801b9c8fe1 100644 --- a/drd/drd_error.c +++ b/drd/drd_error.c @@ -43,23 +43,25 @@ /* Local variables. */ -static Bool s_drd_show_conflicting_segments = True; +static Bool DRD_(s_show_conflicting_segments) = True; -void set_show_conflicting_segments(const Bool scs) +void DRD_(set_show_conflicting_segments)(const Bool scs) { - s_drd_show_conflicting_segments = scs; + DRD_(s_show_conflicting_segments) = scs; } -/** Describe a data address range [a,a+len[ as good as possible, for error - * messages, putting the result in ai. +/** + * Describe a data address range [a,a+len[ as good as possible, for error + * messages, putting the result in ai. */ static -void describe_malloced_addr(Addr const a, SizeT const len, AddrInfo* const ai) +void DRD_(describe_malloced_addr)(Addr const a, SizeT const len, + AddrInfo* const ai) { Addr data; - if (drd_heap_addrinfo(a, &data, &ai->size, &ai->lastchange)) + if (DRD_(heap_addrinfo)(a, &data, &ai->size, &ai->lastchange)) { ai->akind = eMallocd; ai->rwoffset = a - data; @@ -70,11 +72,12 @@ void describe_malloced_addr(Addr const a, SizeT const len, AddrInfo* const ai) } } -/** Report where an object has been observed for the first time. The printed - * call stack will either refer to a pthread_*_init() or a pthread_*lock() - * call. +/** + * Report where an object has been observed for the first time. The printed + * call stack will either refer to a pthread_*_init() or a pthread_*lock() + * call. */ -static void first_observed(const Addr obj) +static void DRD_(first_observed)(const Addr obj) { DrdClientobj* cl; @@ -91,7 +94,8 @@ static void first_observed(const Addr obj) } static -void drd_report_data_race2(Error* const err, const DataRaceErrInfo* const dri) +void DRD_(drd_report_data_race)(Error* const err, + const DataRaceErrInfo* const dri) { AddrInfo ai; const unsigned descr_size = 256; @@ -109,7 +113,7 @@ void drd_report_data_race2(Error* const err, const DataRaceErrInfo* const dri) VG_(get_data_description)(descr1, descr2, descr_size, dri->addr); if (descr1[0] == 0) { - describe_malloced_addr(dri->addr, dri->size, &ai); + DRD_(describe_malloced_addr)(dri->addr, dri->size, &ai); } VG_(message)(Vg_UserMsg, "Conflicting %s by thread %d/%d at 0x%08lx size %ld", @@ -150,7 +154,7 @@ void drd_report_data_race2(Error* const err, const DataRaceErrInfo* const dri) VG_(message)(Vg_UserMsg, "Allocation context: unknown."); } } - if (s_drd_show_conflicting_segments) + if (DRD_(s_show_conflicting_segments)) { DRD_(thread_report_conflicting_segments)(dri->tid, dri->addr, dri->size, @@ -161,17 +165,17 @@ void drd_report_data_race2(Error* const err, const DataRaceErrInfo* const dri) VG_(free)(descr1); } -static Bool drd_tool_error_eq(VgRes res, Error* e1, Error* e2) +static Bool DRD_(drd_tool_error_eq)(VgRes res, Error* e1, Error* e2) { return False; } -static void drd_tool_error_pp(Error* const e) +static void DRD_(drd_tool_error_pp)(Error* const e) { switch (VG_(get_error_kind)(e)) { case DataRaceErr: { - drd_report_data_race2(e, VG_(get_error_extra)(e)); + DRD_(drd_report_data_race)(e, VG_(get_error_extra)(e)); break; } case MutexErr: { @@ -193,7 +197,7 @@ static void drd_tool_error_pp(Error* const e) p->mutex); } VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(p->mutex); + DRD_(first_observed)(p->mutex); break; } case CondErr: { @@ -203,7 +207,7 @@ static void drd_tool_error_pp(Error* const e) VG_(get_error_string)(e), cdei->cond); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(cdei->cond); + DRD_(first_observed)(cdei->cond); break; } case CondDestrErr: { @@ -214,7 +218,7 @@ static void drd_tool_error_pp(Error* const e) cdi->cond, cdi->mutex, DRD_(DrdThreadIdToVgThreadId)(cdi->tid), cdi->tid); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(cdi->mutex); + DRD_(first_observed)(cdi->mutex); break; } case CondRaceErr: { @@ -225,8 +229,8 @@ static void drd_tool_error_pp(Error* const e) " by the signalling thread.", cei->cond, cei->mutex); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(cei->cond); - first_observed(cei->mutex); + DRD_(first_observed)(cei->cond); + DRD_(first_observed)(cei->mutex); break; } case CondWaitErr: { @@ -238,9 +242,9 @@ static void drd_tool_error_pp(Error* const e) cwei->mutex1, cwei->mutex2); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(cwei->cond); - first_observed(cwei->mutex1); - first_observed(cwei->mutex2); + DRD_(first_observed)(cwei->cond); + DRD_(first_observed)(cwei->mutex1); + DRD_(first_observed)(cwei->mutex2); break; } case SemaphoreErr: { @@ -251,7 +255,7 @@ static void drd_tool_error_pp(Error* const e) VG_(get_error_string)(e), sei->semaphore); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(sei->semaphore); + DRD_(first_observed)(sei->semaphore); break; } case BarrierErr: { @@ -262,7 +266,7 @@ static void drd_tool_error_pp(Error* const e) VG_(get_error_string)(e), bei->barrier); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(bei->barrier); + DRD_(first_observed)(bei->barrier); break; } case RwlockErr: { @@ -273,7 +277,7 @@ static void drd_tool_error_pp(Error* const e) VG_(get_error_string)(e), p->rwlock); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(p->rwlock); + DRD_(first_observed)(p->rwlock); break; } case HoldtimeErr: { @@ -289,7 +293,7 @@ static void drd_tool_error_pp(Error* const e) p->hold_time_ms, p->threshold_ms); VG_(pp_ExeContext)(VG_(get_error_where)(e)); - first_observed(p->synchronization_object); + DRD_(first_observed)(p->synchronization_object); break; } case GenericErr: { @@ -307,7 +311,7 @@ static void drd_tool_error_pp(Error* const e) } } -static UInt drd_tool_error_update_extra(Error* e) +static UInt DRD_(drd_tool_error_update_extra)(Error* e) { switch (VG_(get_error_kind)(e)) { @@ -339,7 +343,7 @@ static UInt drd_tool_error_update_extra(Error* e) } } -static Bool drd_tool_error_recog(Char* const name, Supp* const supp) +static Bool DRD_(drd_tool_error_recog)(Char* const name, Supp* const supp) { SuppKind skind = 0; @@ -372,12 +376,13 @@ static Bool drd_tool_error_recog(Char* const name, Supp* const supp) return True; } -static Bool drd_tool_error_read_extra(Int fd, Char* buf, Int nBuf, Supp* supp) +static +Bool DRD_(drd_tool_error_read_extra)(Int fd, Char* buf, Int nBuf, Supp* supp) { return True; } -static Bool drd_tool_error_matches(Error* const e, Supp* const supp) +static Bool DRD_(drd_tool_error_matches)(Error* const e, Supp* const supp) { switch (VG_(get_supp_kind)(supp)) { @@ -385,7 +390,7 @@ static Bool drd_tool_error_matches(Error* const e, Supp* const supp) return True; } -static Char* drd_tool_error_name(Error* e) +static Char* DRD_(drd_tool_error_name)(Error* e) { switch (VG_(get_error_kind)(e)) { @@ -406,24 +411,19 @@ static Char* drd_tool_error_name(Error* e) return 0; } -static void drd_tool_error_print_extra(Error* e) -{ - switch (VG_(get_error_kind)(e)) - { - // VG_(printf)(" %s\n", VG_(get_error_string)(err)); - } -} +static void DRD_(drd_tool_error_print_extra)(Error* e) +{ } void DRD_(register_error_handlers)(void) { // Tool error reporting. - VG_(needs_tool_errors)(drd_tool_error_eq, - drd_tool_error_pp, + VG_(needs_tool_errors)(DRD_(drd_tool_error_eq), + DRD_(drd_tool_error_pp), True, - drd_tool_error_update_extra, - drd_tool_error_recog, - drd_tool_error_read_extra, - drd_tool_error_matches, - drd_tool_error_name, - drd_tool_error_print_extra); + DRD_(drd_tool_error_update_extra), + DRD_(drd_tool_error_recog), + DRD_(drd_tool_error_read_extra), + DRD_(drd_tool_error_matches), + DRD_(drd_tool_error_name), + DRD_(drd_tool_error_print_extra)); } diff --git a/drd/drd_error.h b/drd/drd_error.h index 4035122940..e49ac0775d 100644 --- a/drd/drd_error.h +++ b/drd/drd_error.h @@ -147,7 +147,7 @@ typedef struct { } GenericErrInfo; -void set_show_conflicting_segments(const Bool scs); +void DRD_(set_show_conflicting_segments)(const Bool scs); void DRD_(register_error_handlers)(void); diff --git a/drd/drd_main.c b/drd/drd_main.c index 44f64a32a3..2424fdb34c 100644 --- a/drd/drd_main.c +++ b/drd/drd_main.c @@ -125,7 +125,7 @@ static Bool DRD_(process_cmd_line_option)(Char* arg) if (segment_merging != -1) DRD_(thread_set_segment_merging)(segment_merging); if (show_confl_seg != -1) - set_show_conflicting_segments(show_confl_seg); + DRD_(set_show_conflicting_segments)(show_confl_seg); if (trace_address) { const Addr addr = VG_(strtoll16)(trace_address, 0); @@ -568,7 +568,7 @@ static void DRD_(fini)(Int exitcode) VG_(message)(Vg_UserMsg, " mutex: %lld non-recursive lock/unlock events.", DRD_(get_mutex_lock_count)()); - drd_print_malloc_stats(); + DRD_(print_malloc_stats)(); } } @@ -615,8 +615,8 @@ void drd_pre_clo_init(void) VG_(track_pre_thread_ll_exit) (drd_thread_finished); // Other stuff. - drd_register_malloc_wrappers(drd_start_using_mem_w_ecu, - drd_stop_using_nonstack_mem); + DRD_(register_malloc_wrappers)(drd_start_using_mem_w_ecu, + drd_stop_using_nonstack_mem); DRD_(clientreq_init)(); diff --git a/drd/drd_malloc_wrappers.c b/drd/drd_malloc_wrappers.c index 5a47ed7cfb..bf8da849fb 100644 --- a/drd/drd_malloc_wrappers.c +++ b/drd/drd_malloc_wrappers.c @@ -38,10 +38,7 @@ #include "pub_tool_tooliface.h" -/*------------------------------------------------------------*/ -/*--- Definitions ---*/ -/*------------------------------------------------------------*/ - +/* Local type definitions. */ typedef struct _DRD_Chunk { struct _DRD_Chunk* next; @@ -50,25 +47,25 @@ typedef struct _DRD_Chunk { ExeContext* where; // where it was allocated } DRD_Chunk; -static StartUsingMem s_start_using_mem_callback; -static StopUsingMem s_stop_using_mem_callback; + +/* Local variables. */ + +static StartUsingMem DRD_(s_start_using_mem_callback); +static StopUsingMem DRD_(s_stop_using_mem_callback); /* Stats ... */ -static SizeT cmalloc_n_mallocs = 0; -static SizeT cmalloc_n_frees = 0; -static SizeT cmalloc_bs_mallocd = 0; +static SizeT DRD_(s_cmalloc_n_mallocs) = 0; +static SizeT DRD_(s_cmalloc_n_frees) = 0; +static SizeT DRD_(s_cmalloc_bs_mallocd) = 0; +/* Record malloc'd blocks. */ +static VgHashTable DRD_(s_malloc_list) = NULL; /*------------------------------------------------------------*/ /*--- Tracking malloc'd and free'd blocks ---*/ /*------------------------------------------------------------*/ -/* Record malloc'd blocks. */ -static VgHashTable drd_malloc_list = NULL; - - -/* Allocate its shadow chunk, put it on the appropriate list. */ -static -DRD_Chunk* create_DRD_Chunk(ThreadId tid, Addr p, SizeT size) +/** 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)); @@ -86,13 +83,13 @@ DRD_Chunk* create_DRD_Chunk(ThreadId tid, Addr p, SizeT size) /* Allocate memory and note change in memory available */ static __inline__ -void* drd_new_block(ThreadId tid, - SizeT size, SizeT align, - Bool is_zeroed) +void* DRD_(new_block)(ThreadId tid, + SizeT size, SizeT align, + Bool is_zeroed) { Addr p; - cmalloc_n_mallocs ++; + DRD_(s_cmalloc_n_mallocs) ++; // Allocate and zero p = (Addr)VG_(cli_malloc)(align, size); @@ -100,44 +97,39 @@ void* drd_new_block(ThreadId tid, return NULL; } if (is_zeroed) VG_(memset)((void*)p, 0, size); - s_start_using_mem_callback(p, p + size, 0/*ec_uniq*/); + DRD_(s_start_using_mem_callback)(p, p + size, 0/*ec_uniq*/); // Only update this stat if allocation succeeded. - cmalloc_bs_mallocd += size; + DRD_(s_cmalloc_bs_mallocd) += size; - VG_(HT_add_node)(drd_malloc_list, create_DRD_Chunk(tid, p, size)); + VG_(HT_add_node)(DRD_(s_malloc_list), DRD_(create_chunk)(tid, p, size)); return (void*)p; } -static -void* drd_malloc(ThreadId tid, SizeT n) +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) +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) +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) +static __inline__ void DRD_(handle_free)(ThreadId tid, Addr p) { DRD_Chunk* mc; - cmalloc_n_frees++; + DRD_(s_cmalloc_n_frees)++; - mc = VG_(HT_remove)(drd_malloc_list, (UWord)p); + mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p); if (mc == NULL) { tl_assert(0); @@ -146,31 +138,29 @@ void drd_handle_free(ThreadId tid, Addr p) { tl_assert(p == mc->data); if (mc->size > 0) - s_stop_using_mem_callback(mc->data, mc->size); + 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) +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) +static void* DRD_(realloc)(ThreadId tid, void* p_old, SizeT new_size) { DRD_Chunk* mc; void* p_new; SizeT old_size; - cmalloc_n_frees ++; - cmalloc_n_mallocs ++; - 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_malloc_list, (UWord)p_old); + mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p_old); if (mc == NULL) { tl_assert(0); return NULL; @@ -188,7 +178,7 @@ void* drd_realloc(ThreadId tid, void* p_old, SizeT new_size) else if (old_size > new_size) { /* new size is smaller */ - s_stop_using_mem_callback(mc->data + new_size, old_size); + 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; @@ -206,12 +196,12 @@ void* drd_realloc(ThreadId tid, void* p_old, SizeT new_size) VG_(memcpy)((void*)a_new, p_old, mc->size); /* Free old memory */ - s_stop_using_mem_callback(mc->data, mc->size); + DRD_(s_stop_using_mem_callback)(mc->data, mc->size); VG_(free)(mc); // Allocate a new chunk. - mc = create_DRD_Chunk(tid, a_new, new_size); - s_start_using_mem_callback(a_new, a_new + new_size, 0/*ec_uniq*/); + 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 { @@ -226,65 +216,62 @@ void* drd_realloc(ThreadId tid, void* p_old, SizeT new_size) // 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_malloc_list, mc); + VG_(HT_add_node)(DRD_(s_malloc_list), mc); return p_new; } -static -void* drd___builtin_new(ThreadId tid, SizeT n) +static void* DRD_(__builtin_new)(ThreadId tid, SizeT n) { - void* const result = drd_new_block(tid, n, VG_(clo_alignment), /*is_zeroed*/False); + 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) +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); + DRD_(handle_free)(tid, (Addr)p); } -static -void* drd___builtin_vec_new(ThreadId tid, SizeT n) +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) +static void DRD_(__builtin_vec_delete)(ThreadId tid, void* p) { - drd_handle_free(tid, (Addr)p); + DRD_(handle_free)(tid, (Addr)p); } -void drd_register_malloc_wrappers(const StartUsingMem start_using_mem_callback, - const StopUsingMem stop_using_mem_callback) +void DRD_(register_malloc_wrappers)(const StartUsingMem start_callback, + const StopUsingMem stop_callback) { - tl_assert(drd_malloc_list == 0); - drd_malloc_list = VG_(HT_construct)("drd_malloc_list"); // a big prime - tl_assert(drd_malloc_list != 0); - tl_assert(stop_using_mem_callback); - - s_start_using_mem_callback = start_using_mem_callback; - s_stop_using_mem_callback = stop_using_mem_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, + 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; + + 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), 0); } -Bool drd_heap_addrinfo(Addr const a, - Addr* const data, - SizeT* const size, - ExeContext** const where) +Bool DRD_(heap_addrinfo)(Addr const a, + Addr* const data, + SizeT* const size, + ExeContext** const where) { DRD_Chunk* mc; @@ -292,8 +279,8 @@ Bool drd_heap_addrinfo(Addr const a, tl_assert(size); tl_assert(where); - VG_(HT_ResetIter)(drd_malloc_list); - while ((mc = VG_(HT_Next)(drd_malloc_list))) + 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) { @@ -310,7 +297,7 @@ Bool drd_heap_addrinfo(Addr const a, /*--- Statistics printing ---*/ /*------------------------------------------------------------*/ -void drd_print_malloc_stats(void) +void DRD_(print_malloc_stats)(void) { DRD_Chunk* mc; SizeT nblocks = 0; @@ -322,8 +309,8 @@ void drd_print_malloc_stats(void) return; /* Count memory still in use. */ - VG_(HT_ResetIter)(drd_malloc_list); - while ((mc = VG_(HT_Next)(drd_malloc_list))) + VG_(HT_ResetIter)(DRD_(s_malloc_list)); + while ((mc = VG_(HT_Next)(DRD_(s_malloc_list)))) { nblocks++; nbytes += mc->size; @@ -334,8 +321,8 @@ void drd_print_malloc_stats(void) nbytes, nblocks); VG_(message)(Vg_DebugMsg, "malloc/free: %lu allocs, %lu frees, %lu bytes allocated.", - cmalloc_n_mallocs, - cmalloc_n_frees, cmalloc_bs_mallocd); + DRD_(s_cmalloc_n_mallocs), + DRD_(s_cmalloc_n_frees), DRD_(s_cmalloc_bs_mallocd)); if (VG_(clo_verbosity) > 1) VG_(message)(Vg_DebugMsg, " "); } diff --git a/drd/drd_malloc_wrappers.h b/drd/drd_malloc_wrappers.h index 89d3b8553b..e00fcb993f 100644 --- a/drd/drd_malloc_wrappers.h +++ b/drd/drd_malloc_wrappers.h @@ -26,21 +26,22 @@ #define __MALLOC_WRAPPERS_H -#include "pub_tool_basics.h" // Bool -#include "pub_tool_execontext.h" // ExeContext +#include "drd_basics.h" /* DRD_() */ +#include "pub_tool_basics.h" /* Bool */ +#include "pub_tool_execontext.h" /* ExeContext */ typedef void (*StartUsingMem)(const Addr a1, const Addr a2, UInt ec_uniq); typedef void (*StopUsingMem)(const Addr a1, const Addr a2); -void drd_register_malloc_wrappers(const StartUsingMem start_using_mem_callback, - const StopUsingMem stop_using_mem_callback); -Bool drd_heap_addrinfo(Addr const a, - Addr* const data, - SizeT* const size, - ExeContext** const where); -void drd_print_malloc_stats(void); +void DRD_(register_malloc_wrappers)(const StartUsingMem start_callback, + const StopUsingMem stop_callback); +Bool DRD_(heap_addrinfo)(Addr const a, + Addr* const data, + SizeT* const size, + ExeContext** const where); +void DRD_(print_malloc_stats)(void); #endif // __MALLOC_WRAPPERS_H -- 2.47.3