|
From: <sv...@va...> - 2009-05-03 23:15:04
|
Author: njn
Date: 2009-05-04 00:14:55 +0100 (Mon, 04 May 2009)
New Revision: 9738
Log:
Merged a number of commits between r9708..r9733 (DRD changes, mostly) from
the trunk.
Added:
branches/DARWIN/drd/tests/custom_alloc.stderr.exp
branches/DARWIN/drd/tests/custom_alloc.vgtest
branches/DARWIN/drd/tests/sem_as_mutex3.stderr.exp
branches/DARWIN/drd/tests/sem_as_mutex3.vgtest
Modified:
branches/DARWIN/drd/drd_clientreq.c
branches/DARWIN/drd/drd_load_store.c
branches/DARWIN/drd/drd_load_store.h
branches/DARWIN/drd/drd_main.c
branches/DARWIN/drd/drd_malloc_wrappers.c
branches/DARWIN/drd/drd_malloc_wrappers.h
branches/DARWIN/drd/drd_segment.c
branches/DARWIN/drd/drd_segment.h
branches/DARWIN/drd/tests/Makefile.am
branches/DARWIN/drd/tests/drd_bitmap_test.c
branches/DARWIN/drd/tests/sem_as_mutex.vgtest
branches/DARWIN/drd/tests/sem_as_mutex2.vgtest
branches/DARWIN/memcheck/tests/linux/timerfd-syscall.c
Modified: branches/DARWIN/drd/drd_clientreq.c
===================================================================
--- branches/DARWIN/drd/drd_clientreq.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_clientreq.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -26,7 +26,9 @@
#include "drd_barrier.h"
#include "drd_clientreq.h"
#include "drd_cond.h"
+#include "drd_error.h"
#include "drd_load_store.h"
+#include "drd_malloc_wrappers.h"
#include "drd_mutex.h"
#include "drd_rwlock.h"
#include "drd_semaphore.h"
@@ -44,9 +46,8 @@
/* Local function declarations. */
-static
-Bool DRD_(handle_client_request)(ThreadId vg_tid, UWord* arg, UWord* ret);
-static Addr DRD_(highest_used_stack_address)(const ThreadId vg_tid);
+static Bool handle_client_request(ThreadId vg_tid, UWord* arg, UWord* ret);
+static Addr highest_used_stack_address(const ThreadId vg_tid);
/* Function definitions. */
@@ -57,15 +58,14 @@
*/
void DRD_(clientreq_init)(void)
{
- VG_(needs_client_requests)(DRD_(handle_client_request));
+ VG_(needs_client_requests)(handle_client_request);
}
/**
* DRD's handler for Valgrind client requests. The code below handles both
* DRD's public and tool-internal client requests.
*/
-static
-Bool DRD_(handle_client_request)(ThreadId vg_tid, UWord* arg, UWord* ret)
+static Bool handle_client_request(ThreadId vg_tid, UWord* arg, UWord* ret)
{
UWord result = 0;
const DrdThreadId drd_tid = DRD_(thread_get_running_tid)();
@@ -75,6 +75,22 @@
switch (arg[0])
{
+ case VG_USERREQ__MALLOCLIKE_BLOCK:
+ if (arg[1])
+ DRD_(malloclike_block)(vg_tid, arg[1]/*addr*/, arg[2]/*size*/);
+ break;
+
+ case VG_USERREQ__FREELIKE_BLOCK:
+ if (arg[1] && ! DRD_(freelike_block)(vg_tid, arg[1]/*addr*/))
+ {
+ VG_(maybe_record_error)(vg_tid,
+ GenericErr,
+ VG_(get_IP)(vg_tid),
+ "Invalid VG_USERREQ__FREELIKE_BLOCK request",
+ NULL);
+ }
+ break;
+
case VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID:
result = vg_tid;
break;
@@ -93,7 +109,7 @@
case VG_USERREQ__DRD_SUPPRESS_CURRENT_STACK:
{
- const Addr topmost_sp = DRD_(highest_used_stack_address)(vg_tid);
+ const Addr topmost_sp = highest_used_stack_address(vg_tid);
#if 0
UInt nframes;
const UInt n_ips = 20;
@@ -375,9 +391,11 @@
break;
default:
+#if 0
VG_(message)(Vg_DebugMsg, "Unrecognized client request 0x%lx 0x%lx",
arg[0], arg[1]);
tl_assert(0);
+#endif
return False;
}
@@ -393,7 +411,7 @@
* in vgpreload_exp-drd-*.so or from the thread wrapper for a newly created
* thread. See also drd_pthread_intercepts.c.
*/
-static Addr DRD_(highest_used_stack_address)(const ThreadId vg_tid)
+static Addr highest_used_stack_address(const ThreadId vg_tid)
{
UInt nframes;
const UInt n_ips = 10;
Modified: branches/DARWIN/drd/drd_load_store.c
===================================================================
--- branches/DARWIN/drd/drd_load_store.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_load_store.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -53,22 +53,34 @@
/* Local variables. */
-static Bool DRD_(s_check_stack_accesses) = False;
+static Bool s_check_stack_accesses = False;
+static Bool s_first_race_only = False;
/* Function definitions. */
Bool DRD_(get_check_stack_accesses)()
{
- return DRD_(s_check_stack_accesses);
+ return s_check_stack_accesses;
}
void DRD_(set_check_stack_accesses)(const Bool c)
{
tl_assert(c == False || c == True);
- DRD_(s_check_stack_accesses) = c;
+ s_check_stack_accesses = c;
}
+Bool DRD_(get_first_race_only)()
+{
+ return s_first_race_only;
+}
+
+void DRD_(set_first_race_only)(const Bool fro)
+{
+ tl_assert(fro == False || fro == True);
+ s_first_race_only = fro;
+}
+
void DRD_(trace_mem_access)(const Addr addr, const SizeT size,
const BmAccessTypeT access_type)
{
@@ -124,6 +136,11 @@
VG_(get_IP)(VG_(get_running_tid)()),
"Conflicting accesses",
&drei);
+
+ if (s_first_race_only)
+ {
+ DRD_(start_suppression)(addr, addr + size, "first race only");
+ }
}
VG_REGPARM(2) void DRD_(trace_load)(Addr addr, SizeT size)
@@ -135,7 +152,7 @@
#endif
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_load_triggers_conflict(addr, addr + size)
&& ! DRD_(is_suppressed)(addr, addr + size))
@@ -147,7 +164,7 @@
static VG_REGPARM(1) void drd_trace_load_1(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_load_1_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 1))
@@ -159,7 +176,7 @@
static VG_REGPARM(1) void drd_trace_load_2(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_load_2_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 2))
@@ -171,7 +188,7 @@
static VG_REGPARM(1) void drd_trace_load_4(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_load_4_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 4))
@@ -183,7 +200,7 @@
static VG_REGPARM(1) void drd_trace_load_8(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_load_8_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 8))
@@ -201,7 +218,7 @@
#endif
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_store_triggers_conflict(addr, addr + size)
&& ! DRD_(is_suppressed)(addr, addr + size))
@@ -213,7 +230,7 @@
static VG_REGPARM(1) void drd_trace_store_1(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_store_1_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 1))
@@ -225,7 +242,7 @@
static VG_REGPARM(1) void drd_trace_store_2(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_store_2_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 2))
@@ -237,7 +254,7 @@
static VG_REGPARM(1) void drd_trace_store_4(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_store_4_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 4))
@@ -249,7 +266,7 @@
static VG_REGPARM(1) void drd_trace_store_8(Addr addr)
{
if (DRD_(running_thread_is_recording)()
- && (DRD_(s_check_stack_accesses)
+ && (s_check_stack_accesses
|| ! DRD_(thread_address_on_stack)(addr))
&& bm_access_store_8_triggers_conflict(addr)
&& ! DRD_(is_suppressed)(addr, addr + 8))
@@ -310,7 +327,7 @@
mkIRExpr_HWord(size)))));
}
- if (! DRD_(s_check_stack_accesses) && is_stack_access(bb, addr_expr))
+ if (! s_check_stack_accesses && is_stack_access(bb, addr_expr))
return;
switch (size)
@@ -375,7 +392,7 @@
mkIRExpr_HWord(size)))));
}
- if (! DRD_(s_check_stack_accesses) && is_stack_access(bb, addr_expr))
+ if (! s_check_stack_accesses && is_stack_access(bb, addr_expr))
return;
switch (size)
Modified: branches/DARWIN/drd/drd_load_store.h
===================================================================
--- branches/DARWIN/drd/drd_load_store.h 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_load_store.h 2009-05-03 23:14:55 UTC (rev 9738)
@@ -38,6 +38,8 @@
Bool DRD_(get_check_stack_accesses)(void);
void DRD_(set_check_stack_accesses)(const Bool c);
+Bool DRD_(get_first_race_only)(void);
+void DRD_(set_first_race_only)(const Bool fro);
IRSB* DRD_(instrument)(VgCallbackClosure* const closure,
IRSB* const bb_in,
VexGuestLayout* const layout,
Modified: branches/DARWIN/drd/drd_main.c
===================================================================
--- branches/DARWIN/drd/drd_main.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_main.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -67,6 +67,7 @@
{
int check_stack_accesses = -1;
int exclusive_threshold_ms = -1;
+ int first_race_only = -1;
int report_signal_unlocked = -1;
int segment_merging = -1;
int shared_threshold_ms = -1;
@@ -86,6 +87,7 @@
if VG_BOOL_CLO(arg, "--check-stack-var", check_stack_accesses) {}
else if VG_BOOL_CLO(arg, "--drd-stats", DRD_(s_print_stats)) {}
+ else if VG_BOOL_CLO(arg, "--first-race-only", first_race_only) {}
else if VG_BOOL_CLO(arg,"--report-signal-unlocked",report_signal_unlocked) {}
else if VG_BOOL_CLO(arg, "--segment-merging", segment_merging) {}
else if VG_BOOL_CLO(arg, "--show-confl-seg", show_confl_seg) {}
@@ -116,6 +118,10 @@
DRD_(mutex_set_lock_threshold)(exclusive_threshold_ms);
DRD_(rwlock_set_exclusive_threshold)(exclusive_threshold_ms);
}
+ if (first_race_only != -1)
+ {
+ DRD_(set_first_race_only)(first_race_only);
+ }
if (report_signal_unlocked != -1)
{
DRD_(cond_set_report_signal_unlocked)(report_signal_unlocked);
@@ -166,6 +172,8 @@
" stack variables [no].\n"
" --exclusive-threshold=<n> Print an error message if any mutex or\n"
" writer lock is held longer than the specified time (in milliseconds).\n"
+" --first-race-only=yes|no Only report the first data race that occurs on\n"
+" a memory location instead of all races [no].\n"
" --report-signal-unlocked=yes|no Whether to report calls to\n"
" pthread_cond_signal() where the mutex associated\n"
" with the signal via pthread_cond_wait() is not\n"
@@ -574,6 +582,9 @@
DRD_(sg_get_max_segments_alive_count)(),
DRD_(thread_get_discard_ordered_segments_count)());
VG_(message)(Vg_UserMsg,
+ " %lld merges.",
+ DRD_(sg_get_segment_merge_count)());
+ VG_(message)(Vg_UserMsg,
" (%lld m, %lld rw, %lld s, %lld b)",
DRD_(get_mutex_segment_creation_count)(),
DRD_(get_rwlock_segment_creation_count)(),
Modified: branches/DARWIN/drd/drd_malloc_wrappers.c
===================================================================
--- branches/DARWIN/drd/drd_malloc_wrappers.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_malloc_wrappers.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -50,14 +50,14 @@
/* Local variables. */
-static StartUsingMem DRD_(s_start_using_mem_callback);
-static StopUsingMem DRD_(s_stop_using_mem_callback);
+static StartUsingMem s_start_using_mem_callback;
+static StopUsingMem s_stop_using_mem_callback;
/* Stats ... */
-static SizeT DRD_(s_cmalloc_n_mallocs) = 0;
-static SizeT DRD_(s_cmalloc_n_frees) = 0;
-static SizeT DRD_(s_cmalloc_bs_mallocd) = 0;
+static SizeT s_cmalloc_n_mallocs = 0;
+static SizeT s_cmalloc_n_frees = 0;
+static SizeT s_cmalloc_bs_mallocd = 0;
/* Record malloc'd blocks. */
-static VgHashTable DRD_(s_malloc_list) = NULL;
+static VgHashTable s_malloc_list = NULL;
/*------------------------------------------------------------*/
@@ -65,7 +65,7 @@
/*------------------------------------------------------------*/
/** Allocate its shadow chunk, put it on the appropriate list. */
-static DRD_Chunk* DRD_(create_chunk)(ThreadId tid, Addr p, SizeT size)
+static DRD_Chunk* create_chunk(ThreadId tid, Addr p, SizeT size)
{
DRD_Chunk* mc = VG_(malloc)("drd.malloc_wrappers.cDC.1",
sizeof(DRD_Chunk));
@@ -81,15 +81,11 @@
/*------------------------------------------------------------*/
/* Allocate memory and note change in memory available */
-static
-__inline__
-void* DRD_(new_block)(ThreadId tid,
- SizeT size, SizeT align,
- Bool is_zeroed)
+static void* new_block(ThreadId tid, SizeT size, SizeT align, Bool is_zeroed)
{
Addr p;
- DRD_(s_cmalloc_n_mallocs) ++;
+ s_cmalloc_n_mallocs ++;
// Allocate and zero
p = (Addr)VG_(cli_malloc)(align, size);
@@ -97,56 +93,79 @@
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;
+ DRD_(malloclike_block)(tid, p, size);
- VG_(HT_add_node)(DRD_(s_malloc_list), DRD_(create_chunk)(tid, p, size));
-
return (void*)p;
}
+/**
+ * Store information about a memory block that has been allocated by
+ * malloc() or a malloc() replacement.
+ */
+void DRD_(malloclike_block)(const ThreadId tid, const Addr p, const SizeT size)
+{
+ tl_assert(p);
+
+ s_start_using_mem_callback(p, p + size, 0/*ec_uniq*/);
+
+ // Only update this stat if allocation succeeded.
+ s_cmalloc_bs_mallocd += size;
+
+ VG_(HT_add_node)(s_malloc_list, create_chunk(tid, p, size));
+}
+
static void* DRD_(malloc)(ThreadId tid, SizeT n)
{
- return DRD_(new_block)(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
+ return 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 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),
+ return new_block(tid, nmemb*size1, VG_(clo_alignment),
/*is_zeroed*/True);
}
-static __inline__ void DRD_(handle_free)(ThreadId tid, Addr p)
+/**
+ * Remove the information that was stored by DRD_(malloclike_block)() about
+ * a memory block.
+ */
+Bool DRD_(freelike_block)(const ThreadId tid, const Addr p)
{
DRD_Chunk* mc;
- DRD_(s_cmalloc_n_frees)++;
+ tl_assert(p);
- mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p);
- if (mc == NULL)
+ s_cmalloc_n_frees++;
+
+ mc = VG_(HT_remove)(s_malloc_list, (UWord)p);
+ if (mc)
{
- 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);
+ s_stop_using_mem_callback(mc->data, mc->size);
VG_(free)(mc);
+ return True;
}
+ return False;
}
+static void handle_free(ThreadId tid, Addr p)
+{
+ if (DRD_(freelike_block)(tid, p))
+ VG_(cli_free)((void*)p);
+ else
+ tl_assert(False);
+}
+
static void DRD_(free)(ThreadId tid, void* p)
{
- DRD_(handle_free)(tid, (Addr)p);
+ handle_free(tid, (Addr)p);
}
static void* DRD_(realloc)(ThreadId tid, void* p_old, SizeT new_size)
@@ -155,12 +174,12 @@
void* p_new;
SizeT old_size;
- DRD_(s_cmalloc_n_frees) ++;
- DRD_(s_cmalloc_n_mallocs) ++;
- DRD_(s_cmalloc_bs_mallocd) += new_size;
+ s_cmalloc_n_frees ++;
+ s_cmalloc_n_mallocs ++;
+ s_cmalloc_bs_mallocd += new_size;
/* Remove the old block */
- mc = VG_(HT_remove)(DRD_(s_malloc_list), (UWord)p_old);
+ mc = VG_(HT_remove)(s_malloc_list, (UWord)p_old);
if (mc == NULL) {
tl_assert(0);
return NULL;
@@ -178,7 +197,7 @@
else if (old_size > new_size)
{
/* new size is smaller */
- DRD_(s_stop_using_mem_callback)(mc->data + new_size, old_size);
+ 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;
@@ -196,12 +215,12 @@
VG_(memcpy)((void*)a_new, p_old, mc->size);
/* Free old memory */
- DRD_(s_stop_using_mem_callback)(mc->data, mc->size);
+ 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,
+ mc = create_chunk(tid, a_new, new_size);
+ s_start_using_mem_callback(a_new, a_new + new_size,
0/*ec_uniq*/);
}
else
@@ -217,14 +236,14 @@
// 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);
+ VG_(HT_add_node)(s_malloc_list, mc);
return p_new;
}
static void* DRD_(__builtin_new)(ThreadId tid, SizeT n)
{
- void* const result = DRD_(new_block)(tid, n, VG_(clo_alignment),
+ void* const result = new_block(tid, n, VG_(clo_alignment),
/*is_zeroed*/False);
//VG_(message)(Vg_DebugMsg, "__builtin_new(%d, %d) = %p", tid, n, result);
return result;
@@ -233,22 +252,22 @@
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);
+ 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 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);
+ handle_free(tid, (Addr)p);
}
static SizeT DRD_(malloc_usable_size) ( ThreadId tid, void* p )
{
- DRD_Chunk *mc = VG_(HT_lookup)( DRD_(s_malloc_list), (UWord)p );
+ DRD_Chunk *mc = VG_(HT_lookup)( s_malloc_list, (UWord)p );
// There may be slop, but pretend there isn't because only the asked-for
// area will have been shadowed properly.
@@ -258,14 +277,14 @@
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(s_malloc_list == 0);
+ s_malloc_list = VG_(HT_construct)("drd_malloc_list"); // a big prime
+ tl_assert(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;
+ s_start_using_mem_callback = start_callback;
+ s_stop_using_mem_callback = stop_callback;
VG_(needs_malloc_replacement)(DRD_(malloc),
DRD_(__builtin_new),
@@ -291,8 +310,8 @@
tl_assert(size);
tl_assert(where);
- VG_(HT_ResetIter)(DRD_(s_malloc_list));
- while ((mc = VG_(HT_Next)(DRD_(s_malloc_list))))
+ VG_(HT_ResetIter)(s_malloc_list);
+ while ((mc = VG_(HT_Next)(s_malloc_list)))
{
if (mc->data <= a && a < mc->data + mc->size)
{
@@ -321,8 +340,8 @@
return;
/* Count memory still in use. */
- VG_(HT_ResetIter)(DRD_(s_malloc_list));
- while ((mc = VG_(HT_Next)(DRD_(s_malloc_list))))
+ VG_(HT_ResetIter)(s_malloc_list);
+ while ((mc = VG_(HT_Next)(s_malloc_list)))
{
nblocks++;
nbytes += mc->size;
@@ -333,8 +352,8 @@
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));
+ s_cmalloc_n_mallocs,
+ s_cmalloc_n_frees, s_cmalloc_bs_mallocd);
if (VG_(clo_verbosity) > 1)
VG_(message)(Vg_DebugMsg, " ");
}
Modified: branches/DARWIN/drd/drd_malloc_wrappers.h
===================================================================
--- branches/DARWIN/drd/drd_malloc_wrappers.h 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_malloc_wrappers.h 2009-05-03 23:14:55 UTC (rev 9738)
@@ -37,6 +37,8 @@
void DRD_(register_malloc_wrappers)(const StartUsingMem start_callback,
const StopUsingMem stop_callback);
+void DRD_(malloclike_block)(const ThreadId tid, const Addr p, const SizeT size);
+Bool DRD_(freelike_block)(const ThreadId tid, const Addr p);
Bool DRD_(heap_addrinfo)(Addr const a,
Addr* const data,
SizeT* const size,
Modified: branches/DARWIN/drd/drd_segment.c
===================================================================
--- branches/DARWIN/drd/drd_segment.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_segment.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -38,6 +38,7 @@
/* Local variables. */
+static ULong s_segment_merge_count;
static ULong s_segments_created_count;
static ULong s_segments_alive_count;
static ULong s_max_segments_alive_count;
@@ -215,6 +216,8 @@
VG_(message)(Vg_UserMsg, "%s", msg);
}
+ s_segment_merge_count++;
+
// Keep sg1->stacktrace.
// Keep sg1->vc.
// Merge sg2->bm into sg1->bm.
@@ -258,3 +261,8 @@
{
return s_max_segments_alive_count;
}
+
+ULong DRD_(sg_get_segment_merge_count)(void)
+{
+ return s_segment_merge_count;
+}
Modified: branches/DARWIN/drd/drd_segment.h
===================================================================
--- branches/DARWIN/drd/drd_segment.h 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/drd_segment.h 2009-05-03 23:14:55 UTC (rev 9738)
@@ -70,6 +70,7 @@
ULong DRD_(sg_get_segments_created_count)(void);
ULong DRD_(sg_get_segments_alive_count)(void);
ULong DRD_(sg_get_max_segments_alive_count)(void);
+ULong DRD_(sg_get_segment_merge_count)(void);
#endif // __SEGMENT_H
Modified: branches/DARWIN/drd/tests/Makefile.am
===================================================================
--- branches/DARWIN/drd/tests/Makefile.am 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/tests/Makefile.am 2009-05-03 23:14:55 UTC (rev 9738)
@@ -27,6 +27,8 @@
circular_buffer.stderr.exp-with-atomic-builtins \
circular_buffer.stderr.exp-without-atomic-builtins \
circular_buffer.vgtest \
+ custom_alloc.vgtest \
+ custom_alloc.stderr.exp \
drd_bitmap_test.stderr.exp \
drd_bitmap_test.stdout.exp \
drd_bitmap_test.vgtest \
@@ -134,6 +136,8 @@
sem_as_mutex.vgtest \
sem_as_mutex2.stderr.exp \
sem_as_mutex2.vgtest \
+ sem_as_mutex3.stderr.exp \
+ sem_as_mutex3.vgtest \
sigalrm.stderr.exp \
sigalrm.vgtest \
tc01_simple_race.stderr.exp \
@@ -173,7 +177,8 @@
tc17_sembar.vgtest \
tc18_semabuse.stderr.exp \
tc18_semabuse.vgtest \
- tc19_shadowmem.stderr.exp \
+ tc19_shadowmem.stderr.exp-32bit \
+ tc19_shadowmem.stderr.exp-64bit \
tc19_shadowmem.vgtest \
tc20_verifywrap.stderr.exp-glibc2.3 \
tc20_verifywrap.stderr.exp-glibc2.5 \
Copied: branches/DARWIN/drd/tests/custom_alloc.stderr.exp (from rev 9733, trunk/drd/tests/custom_alloc.stderr.exp)
===================================================================
--- branches/DARWIN/drd/tests/custom_alloc.stderr.exp (rev 0)
+++ branches/DARWIN/drd/tests/custom_alloc.stderr.exp 2009-05-03 23:14:55 UTC (rev 9738)
@@ -0,0 +1,3 @@
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Copied: branches/DARWIN/drd/tests/custom_alloc.vgtest (from rev 9733, trunk/drd/tests/custom_alloc.vgtest)
===================================================================
--- branches/DARWIN/drd/tests/custom_alloc.vgtest (rev 0)
+++ branches/DARWIN/drd/tests/custom_alloc.vgtest 2009-05-03 23:14:55 UTC (rev 9738)
@@ -0,0 +1 @@
+prog: ../../memcheck/tests/custom_alloc
Modified: branches/DARWIN/drd/tests/drd_bitmap_test.c
===================================================================
--- branches/DARWIN/drd/tests/drd_bitmap_test.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/tests/drd_bitmap_test.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -74,7 +74,7 @@
int equal;
equal = DRD_(bm_equal)(bm1, bm2);
- if (! equal)
+ if (s_verbose && ! equal)
{
VG_(printf)("Bitmaps are different.\n");
VG_(printf)("Bitmap 1:\n");
@@ -167,16 +167,17 @@
struct bitmap* bm1;
struct bitmap* bm2;
+ const Addr lb = ADDR0_COUNT - 2 * BITS_PER_UWORD;
+ const Addr ub = ADDR0_COUNT + 2 * BITS_PER_UWORD;
+
assert(outer_loop_step >= 1);
assert(inner_loop_step >= 1);
bm1 = DRD_(bm_new)();
bm2 = DRD_(bm_new)();
- for (i = ADDR0_COUNT - 2 * BITS_PER_UWORD;
- i < ADDR0_COUNT + 2 * BITS_PER_UWORD;
- i += outer_loop_step)
+ for (i = lb; i < ub; i += outer_loop_step)
{
- for (j = i + 1; j < ADDR0_COUNT + 2 * BITS_PER_UWORD; j += inner_loop_step)
+ for (j = i + 1; j < ub; j += inner_loop_step)
{
DRD_(bm_access_range_load)(bm1, i, j);
DRD_(bm_clear_load)(bm1, i, j);
@@ -240,7 +241,7 @@
i < ADDR0_COUNT + 2 * BITS_PER_UWORD;
i += outer_loop_step)
{
- for (j = i + 1; j < ADDR0_COUNT + 2 * BITS_PER_UWORD; j += inner_loop_step)
+ for (j = i + 1; j < ub; j += inner_loop_step)
{
DRD_(bm_clear_load)(bm1, i, j);
DRD_(bm_access_range_load)(bm1, i, j);
@@ -257,6 +258,7 @@
DRD_(bm_clear_load)(bm1, i, i+8);
DRD_(bm_access_load_8)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
+
DRD_(bm_clear_store)(bm1, i, j);
DRD_(bm_access_range_store)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
@@ -272,6 +274,11 @@
DRD_(bm_clear_store)(bm1, i, i+8);
DRD_(bm_access_store_8)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
+
+ DRD_(bm_clear)(bm1, i, j);
+ DRD_(bm_access_range_load)(bm1, i, j);
+ DRD_(bm_access_range_store)(bm1, i, j);
+ assert(bm_equal_print_diffs(bm1, bm2));
}
}
DRD_(bm_delete)(bm2);
Modified: branches/DARWIN/drd/tests/sem_as_mutex.vgtest
===================================================================
--- branches/DARWIN/drd/tests/sem_as_mutex.vgtest 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/tests/sem_as_mutex.vgtest 2009-05-03 23:14:55 UTC (rev 9738)
@@ -1,3 +1,3 @@
prereq: ./supported_libpthread
-vgopts: --var-info=yes
+vgopts: --check-stack-var=yes --var-info=yes
prog: sem_as_mutex
Modified: branches/DARWIN/drd/tests/sem_as_mutex2.vgtest
===================================================================
--- branches/DARWIN/drd/tests/sem_as_mutex2.vgtest 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/drd/tests/sem_as_mutex2.vgtest 2009-05-03 23:14:55 UTC (rev 9738)
@@ -1,3 +1,4 @@
prereq: ./supported_libpthread
+vgopts: --check-stack-var=yes --var-info=yes
prog: sem_as_mutex
args: -m
Copied: branches/DARWIN/drd/tests/sem_as_mutex3.stderr.exp (from rev 9733, trunk/drd/tests/sem_as_mutex3.stderr.exp)
===================================================================
--- branches/DARWIN/drd/tests/sem_as_mutex3.stderr.exp (rev 0)
+++ branches/DARWIN/drd/tests/sem_as_mutex3.stderr.exp 2009-05-03 23:14:55 UTC (rev 9738)
@@ -0,0 +1,11 @@
+
+Conflicting load by thread 1/1 at 0x........ size 8
+ at 0x........: main (sem_as_mutex.c:?)
+Location 0x........ is 0 bytes inside local var "s_d3"
+declared at sem_as_mutex.c:25, in frame #? of thread 1
+Other segment start (thread 0/2)
+ (thread finished, call stack no longer available)
+Other segment end (thread 0/2)
+ (thread finished, call stack no longer available)
+
+ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
Copied: branches/DARWIN/drd/tests/sem_as_mutex3.vgtest (from rev 9733, trunk/drd/tests/sem_as_mutex3.vgtest)
===================================================================
--- branches/DARWIN/drd/tests/sem_as_mutex3.vgtest (rev 0)
+++ branches/DARWIN/drd/tests/sem_as_mutex3.vgtest 2009-05-03 23:14:55 UTC (rev 9738)
@@ -0,0 +1,3 @@
+prereq: ./supported_libpthread
+vgopts: --check-stack-var=yes --first-race-only=yes --var-info=yes
+prog: sem_as_mutex
Modified: branches/DARWIN/memcheck/tests/linux/timerfd-syscall.c
===================================================================
--- branches/DARWIN/memcheck/tests/linux/timerfd-syscall.c 2009-05-03 22:53:19 UTC (rev 9737)
+++ branches/DARWIN/memcheck/tests/linux/timerfd-syscall.c 2009-05-03 23:14:55 UTC (rev 9738)
@@ -57,14 +57,23 @@
#ifndef __NR_timerfd_create
#if defined(__x86_64__)
#define __NR_timerfd_create 283
+#elif defined(__i386__)
+#define __NR_timerfd_create 322
+#elif defined(__powerpc__)
+#define __NR_timerfd_create 306
+#else
+#error Cannot detect your architecture!
+#endif
+#endif
+
+#ifndef __NR_timerfd_settime
+#if defined(__x86_64__)
#define __NR_timerfd_settime 286
#define __NR_timerfd_gettime 287
#elif defined(__i386__)
-#define __NR_timerfd_create 322
#define __NR_timerfd_settime 325
#define __NR_timerfd_gettime 326
#elif defined(__powerpc__)
-#define __NR_timerfd_create 306
#define __NR_timerfd_settime 311
#define __NR_timerfd_gettime 312
#else
|