From: Julian Seward Date: Mon, 24 Oct 2011 13:21:57 +0000 (+0000) Subject: Fix #284384 (clang 3.1 -Wunused-value warnings in valgrind.h, X-Git-Tag: svn/VALGRIND_3_7_0~13 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=084b7cb10bb2af6b3bd148b02ed41c5d8f30fe78;p=thirdparty%2Fvalgrind.git Fix #284384 (clang 3.1 -Wunused-value warnings in valgrind.h, memcheck.h) by changing a bunch of VALGRIND_DO_CLIENT_REQUEST_EXPR into VALGRIND_DO_CLIENT_REQUEST_STMT for cases where the return value of the former would be unused. (Bart Van Assche, bart.vanassche@gmail.com) git-svn-id: svn://svn.valgrind.org/valgrind/trunk@12226 --- diff --git a/callgrind/callgrind.h b/callgrind/callgrind.h index 476db9799d..752d0af61d 100644 --- a/callgrind/callgrind.h +++ b/callgrind/callgrind.h @@ -83,7 +83,7 @@ typedef /* Dump current state of cost centers, and zero them afterwards */ #define CALLGRIND_DUMP_STATS \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DUMP_STATS, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DUMP_STATS, \ 0, 0, 0, 0, 0) /* Dump current state of cost centers, and zero them afterwards. @@ -91,28 +91,28 @@ typedef the dump. This string is written as a description field into the profile data dump. */ #define CALLGRIND_DUMP_STATS_AT(pos_str) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DUMP_STATS_AT, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DUMP_STATS_AT, \ pos_str, 0, 0, 0, 0) /* Zero cost centers */ #define CALLGRIND_ZERO_STATS \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__ZERO_STATS, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__ZERO_STATS, \ 0, 0, 0, 0, 0) /* Toggles collection state. The collection state specifies whether the happening of events should be noted or if they are to be ignored. Events are noted by increment of counters in a cost center */ -#define CALLGRIND_TOGGLE_COLLECT \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__TOGGLE_COLLECT, \ +#define CALLGRIND_TOGGLE_COLLECT \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__TOGGLE_COLLECT, \ 0, 0, 0, 0, 0) /* Start full callgrind instrumentation if not already switched on. When cache simulation is done, it will flush the simulated cache; this will lead to an artifical cache warmup phase afterwards with cache misses which would not have happened in reality. */ -#define CALLGRIND_START_INSTRUMENTATION \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__START_INSTRUMENTATION, \ +#define CALLGRIND_START_INSTRUMENTATION \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__START_INSTRUMENTATION, \ 0, 0, 0, 0, 0) /* Stop full callgrind instrumentation if not already switched off. @@ -122,8 +122,8 @@ typedef Use this to bypass Callgrind aggregation for uninteresting code parts. To start Callgrind in this mode to ignore the setup phase, use the option "--instr-atstart=no". */ -#define CALLGRIND_STOP_INSTRUMENTATION \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__STOP_INSTRUMENTATION, \ +#define CALLGRIND_STOP_INSTRUMENTATION \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__STOP_INSTRUMENTATION, \ 0, 0, 0, 0, 0) #endif /* __CALLGRIND_H */ diff --git a/coregrind/m_replacemalloc/vg_replace_malloc.c b/coregrind/m_replacemalloc/vg_replace_malloc.c index 725b13ef08..06cb2f6897 100644 --- a/coregrind/m_replacemalloc/vg_replace_malloc.c +++ b/coregrind/m_replacemalloc/vg_replace_malloc.c @@ -1035,7 +1035,7 @@ static void init(void) init_done = 1; - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__GET_MALLOCFUNCS, &info, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__GET_MALLOCFUNCS, &info, 0, 0, 0, 0); } diff --git a/coregrind/vg_preloaded.c b/coregrind/vg_preloaded.c index a16b3c82ed..24a8f71674 100644 --- a/coregrind/vg_preloaded.c +++ b/coregrind/vg_preloaded.c @@ -60,8 +60,7 @@ void VG_NOTIFY_ON_LOAD(freeres)( void ) extern void __libc_freeres(void); __libc_freeres(); # endif - VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default */, - VG_USERREQ__LIBC_FREERES_DONE, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__LIBC_FREERES_DONE, 0, 0, 0, 0, 0); /*NOTREACHED*/ *(volatile int *)0 = 'x'; @@ -85,7 +84,7 @@ void * VG_NOTIFY_ON_LOAD(ifunc_wrapper) (void) code which runs on the emulated CPU) to update the redirection that led to this function. This client request eventually gives control to the function VG_(redir_add_ifunc_target) in m_redir.c */ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__ADD_IFUNC_TARGET, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__ADD_IFUNC_TARGET, fn.nraddr, result, 0, 0, 0); return (void*)result; } diff --git a/drd/drd.h b/drd/drd.h index 55f72279a3..5f21aabcb7 100644 --- a/drd/drd.h +++ b/drd/drd.h @@ -82,16 +82,16 @@ #define DRD_IGNORE_VAR(x) ANNOTATE_BENIGN_RACE_SIZED(&(x), sizeof(x), "") /** Tell DRD to no longer ignore data races for the specified variable. */ -#define DRD_STOP_IGNORING_VAR(x) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_FINISH_SUPPRESSION, \ +#define DRD_STOP_IGNORING_VAR(x) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_FINISH_SUPPRESSION, \ &(x), sizeof(x), 0, 0, 0) /** * Tell DRD to trace all memory accesses on the specified variable. * until the memory that was allocated for the variable is freed. */ -#define DRD_TRACE_VAR(x) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_START_TRACE_ADDR, \ +#define DRD_TRACE_VAR(x) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_START_TRACE_ADDR, \ &(x), sizeof(x), 0, 0, 0) /** @@ -107,9 +107,8 @@ * Tell DRD to insert a happens-before mark. addr is the address of an object * that is not a pthread synchronization object. */ -#define ANNOTATE_HAPPENS_BEFORE(addr) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DRD_ANNOTATE_HAPPENS_BEFORE, \ +#define ANNOTATE_HAPPENS_BEFORE(addr) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_HAPPENS_BEFORE, \ addr, 0, 0, 0, 0) /** @@ -120,9 +119,8 @@ * before any other thread has passed by a happens-before annotation for the * same address is an error. */ -#define ANNOTATE_HAPPENS_AFTER(addr) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DRD_ANNOTATE_HAPPENS_AFTER, \ +#define ANNOTATE_HAPPENS_AFTER(addr) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_HAPPENS_AFTER, \ addr, 0, 0, 0, 0) /** @@ -179,15 +177,13 @@ #define ANNOTATE_SWAP_MEMORY_RANGE(addr, size) do { } while(0) /** Tell DRD that a reader-writer lock object has been initialized. */ -#define ANNOTATE_RWLOCK_CREATE(rwlock) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DRD_ANNOTATE_RWLOCK_CREATE, \ +#define ANNOTATE_RWLOCK_CREATE(rwlock) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_CREATE, \ rwlock, 0, 0, 0, 0); /** Tell DRD that a reader-writer lock object has been destroyed. */ -#define ANNOTATE_RWLOCK_DESTROY(rwlock) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DRD_ANNOTATE_RWLOCK_DESTROY, \ +#define ANNOTATE_RWLOCK_DESTROY(rwlock) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_DESTROY, \ rwlock, 0, 0, 0, 0); /** @@ -195,9 +191,8 @@ * a write lock has been obtained, is_w == 0 means that a read lock has been * obtained. */ -#define ANNOTATE_RWLOCK_ACQUIRED(rwlock, is_w) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DRD_ANNOTATE_RWLOCK_ACQUIRED, \ +#define ANNOTATE_RWLOCK_ACQUIRED(rwlock, is_w) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_ACQUIRED, \ rwlock, is_w, 0, 0, 0) /** @@ -218,8 +213,7 @@ * is about to be released. */ #define ANNOTATE_RWLOCK_RELEASED(rwlock, is_w) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DRD_ANNOTATE_RWLOCK_RELEASED, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_RELEASED, \ rwlock, is_w, 0, 0, 0); /** @@ -238,27 +232,27 @@ * is, whether or not it is allowed to call barrier_init() several times * without calling barrier_destroy(). */ -#define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_ANNOTATION_UNIMP, \ - "ANNOTATE_BARRIER_INIT", barrier, \ +#define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP, \ + "ANNOTATE_BARRIER_INIT", barrier, \ count, reinitialization_allowed, 0) /* Report that a barrier has been destroyed. */ -#define ANNOTATE_BARRIER_DESTROY(barrier) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_ANNOTATION_UNIMP, \ - "ANNOTATE_BARRIER_DESTROY", \ +#define ANNOTATE_BARRIER_DESTROY(barrier) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP, \ + "ANNOTATE_BARRIER_DESTROY", \ barrier, 0, 0, 0) /* Report that the calling thread is about to start waiting for a barrier. */ -#define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_ANNOTATION_UNIMP, \ - "ANNOTATE_BARRIER_WAIT_BEFORE", \ +#define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP, \ + "ANNOTATE_BARRIER_WAIT_BEFORE", \ barrier, 0, 0, 0) /* Report that the calling thread has just finished waiting for a barrier. */ -#define ANNOTATE_BARRIER_WAIT_AFTER(barrier) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_ANNOTATION_UNIMP, \ - "ANNOTATE_BARRIER_WAIT_AFTER", \ +#define ANNOTATE_BARRIER_WAIT_AFTER(barrier) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP, \ + "ANNOTATE_BARRIER_WAIT_AFTER", \ barrier, 0, 0, 0) /** @@ -295,29 +289,29 @@ /* Same as ANNOTATE_BENIGN_RACE(addr, descr), but applies to the memory range [addr, addr + size). */ -#define ANNOTATE_BENIGN_RACE_SIZED(addr, size, descr) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_START_SUPPRESSION, \ +#define ANNOTATE_BENIGN_RACE_SIZED(addr, size, descr) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_START_SUPPRESSION, \ addr, size, 0, 0, 0) /** Tell DRD to ignore all reads performed by the current thread. */ #define ANNOTATE_IGNORE_READS_BEGIN() \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_RECORD_LOADS, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_LOADS, \ 0, 0, 0, 0, 0); /** Tell DRD to no longer ignore the reads performed by the current thread. */ #define ANNOTATE_IGNORE_READS_END() \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_RECORD_LOADS, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_LOADS, \ 1, 0, 0, 0, 0); /** Tell DRD to ignore all writes performed by the current thread. */ #define ANNOTATE_IGNORE_WRITES_BEGIN() \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_RECORD_STORES, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_STORES, \ 0, 0, 0, 0, 0) /** Tell DRD to no longer ignore the writes performed by the current thread. */ #define ANNOTATE_IGNORE_WRITES_END() \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_RECORD_STORES, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_STORES, \ 1, 0, 0, 0, 0) /** Tell DRD to ignore all memory accesses performed by the current thread. */ @@ -335,8 +329,8 @@ * Tell DRD that size bytes starting at addr has been allocated by a custom * memory allocator. */ -#define ANNOTATE_NEW_MEMORY(addr, size) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_CLEAN_MEMORY, \ +#define ANNOTATE_NEW_MEMORY(addr, size) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_CLEAN_MEMORY, \ addr, size, 0, 0, 0) /** Ask DRD to report every access to the specified address. */ @@ -347,7 +341,7 @@ * be used in error messages printed by DRD. */ #define ANNOTATE_THREAD_NAME(name) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_SET_THREAD_NAME, \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_SET_THREAD_NAME, \ name, 0, 0, 0, 0) /*@}*/ diff --git a/drd/drd_pthread_intercepts.c b/drd/drd_pthread_intercepts.c index 4dc631c693..f34540f402 100644 --- a/drd/drd_pthread_intercepts.c +++ b/drd/drd_pthread_intercepts.c @@ -295,21 +295,21 @@ static __always_inline MutexT DRD_(mutex_type)(pthread_mutex_t* mutex) static void DRD_(set_joinable)(const pthread_t tid, const int joinable) { assert(joinable == 0 || joinable == 1); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__SET_JOINABLE, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__SET_JOINABLE, tid, joinable, 0, 0, 0); } /** Tell DRD that the calling thread is about to enter pthread_create(). */ static __always_inline void DRD_(entering_pthread_create)(void) { - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__ENTERING_PTHREAD_CREATE, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__ENTERING_PTHREAD_CREATE, 0, 0, 0, 0, 0); } /** Tell DRD that the calling thread has left pthread_create(). */ static __always_inline void DRD_(left_pthread_create)(void) { - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__LEFT_PTHREAD_CREATE, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__LEFT_PTHREAD_CREATE, 0, 0, 0, 0, 0); } @@ -325,7 +325,7 @@ static void* DRD_(thread_wrapper)(void* arg) arg_ptr = (DrdPosixThreadArgs*)arg; arg_copy = *arg_ptr; - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__SET_PTHREADID, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__SET_PTHREADID, pthread_self(), 0, 0, 0, 0); DRD_(set_joinable)(pthread_self(), @@ -404,7 +404,7 @@ static void DRD_(check_threading_library)(void) static void DRD_(set_main_thread_state)(void) { // Make sure that DRD knows about the main thread's POSIX thread ID. - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__SET_PTHREADID, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__SET_PTHREADID, pthread_self(), 0, 0, 0, 0); } @@ -465,7 +465,7 @@ int pthread_create_intercept(pthread_t* thread, const pthread_attr_t* attr, DRD_(sema_destroy)(&thread_args.wrapper_started); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__DRD_START_NEW_SEGMENT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_START_NEW_SEGMENT, pthread_self(), 0, 0, 0, 0); return ret; @@ -491,7 +491,7 @@ int pthread_join_intercept(pthread_t pt_joinee, void **thread_return) CALL_FN_W_WW(ret, fn, pt_joinee, thread_return); if (ret == 0) { - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_THREAD_JOIN, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_THREAD_JOIN, pt_joinee, 0, 0, 0, 0); } ANNOTATE_IGNORE_READS_AND_WRITES_END(); @@ -527,10 +527,10 @@ int pthread_cancel_intercept(pthread_t pt_thread) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_THREAD_CANCEL, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_THREAD_CANCEL, pt_thread, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, pt_thread); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_THREAD_CANCEL, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_THREAD_CANCEL, pt_thread, ret==0, 0, 0, 0); return ret; } @@ -573,11 +573,11 @@ int pthread_mutex_init_intercept(pthread_mutex_t *mutex, mt = PTHREAD_MUTEX_DEFAULT; if (attr) pthread_mutexattr_gettype(attr, &mt); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_INIT, mutex, DRD_(pthread_to_drd_mutex_type)(mt), 0, 0, 0); CALL_FN_W_WW(ret, fn, mutex, attr); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_INIT, mutex, 0, 0, 0, 0); return ret; } @@ -592,10 +592,10 @@ int pthread_mutex_destroy_intercept(pthread_mutex_t* mutex) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY, mutex, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY, mutex, DRD_(mutex_type)(mutex), 0, 0, 0); return ret; } @@ -609,10 +609,10 @@ int pthread_mutex_lock_intercept(pthread_mutex_t* mutex) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK, mutex, DRD_(mutex_type)(mutex), 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__POST_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK, mutex, ret == 0, 0, 0, 0); return ret; } @@ -626,10 +626,10 @@ int pthread_mutex_trylock_intercept(pthread_mutex_t* mutex) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK, mutex, DRD_(mutex_type)(mutex), 1, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK, mutex, ret == 0, 0, 0, 0); return ret; } @@ -644,10 +644,10 @@ int pthread_mutex_timedlock_intercept(pthread_mutex_t *mutex, int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK, mutex, DRD_(mutex_type)(mutex), 0, 0, 0); CALL_FN_W_WW(ret, fn, mutex, abs_timeout); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK, mutex, ret == 0, 0, 0, 0); return ret; } @@ -662,10 +662,10 @@ int pthread_mutex_unlock_intercept(pthread_mutex_t *mutex) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK, mutex, DRD_(mutex_type)(mutex), 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK, mutex, 0, 0, 0, 0); return ret; } @@ -680,10 +680,10 @@ int pthread_cond_init_intercept(pthread_cond_t* cond, int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_INIT, cond, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, cond, attr); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_INIT, cond, 0, 0, 0, 0); return ret; } @@ -698,10 +698,10 @@ int pthread_cond_destroy_intercept(pthread_cond_t* cond) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_DESTROY, cond, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, cond); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_DESTROY, cond, 0, 0, 0, 0); return ret; } @@ -715,10 +715,10 @@ int pthread_cond_wait_intercept(pthread_cond_t *cond, pthread_mutex_t *mutex) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_WAIT, cond, mutex, DRD_(mutex_type)(mutex), 0, 0); CALL_FN_W_WW(ret, fn, cond, mutex); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_WAIT, cond, mutex, 1, 0, 0); return ret; } @@ -735,10 +735,10 @@ int pthread_cond_timedwait_intercept(pthread_cond_t *cond, int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_WAIT, cond, mutex, DRD_(mutex_type)(mutex), 0, 0); CALL_FN_W_WWW(ret, fn, cond, mutex, abstime); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_WAIT, cond, mutex, 1, 0, 0); return ret; } @@ -760,10 +760,10 @@ int pthread_cond_signal_intercept(pthread_cond_t* cond) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_SIGNAL, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_SIGNAL, cond, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, cond); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_SIGNAL, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_SIGNAL, cond, 0, 0, 0, 0); return ret; } @@ -777,10 +777,10 @@ int pthread_cond_broadcast_intercept(pthread_cond_t* cond) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_BROADCAST, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_BROADCAST, cond, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, cond); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_BROADCAST, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_BROADCAST, cond, 0, 0, 0, 0); return ret; } @@ -795,10 +795,10 @@ int pthread_spin_init_intercept(pthread_spinlock_t *spinlock, int pshared) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, spinlock, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, spinlock, pshared); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, spinlock, 0, 0, 0, 0); return ret; } @@ -812,10 +812,10 @@ int pthread_spin_destroy_intercept(pthread_spinlock_t *spinlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY, spinlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY, spinlock, mutex_type_spinlock, 0, 0, 0); return ret; } @@ -829,10 +829,10 @@ int pthread_spin_lock_intercept(pthread_spinlock_t *spinlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK, spinlock, mutex_type_spinlock, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK, spinlock, ret == 0, 0, 0, 0); return ret; } @@ -846,10 +846,10 @@ int pthread_spin_trylock_intercept(pthread_spinlock_t *spinlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK, spinlock, mutex_type_spinlock, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK, spinlock, ret == 0, 0, 0, 0); return ret; } @@ -863,10 +863,10 @@ int pthread_spin_unlock_intercept(pthread_spinlock_t *spinlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, spinlock, mutex_type_spinlock, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, spinlock, 0, 0, 0, 0); return ret; } @@ -885,10 +885,10 @@ int pthread_barrier_init_intercept(pthread_barrier_t* barrier, int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_BARRIER_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_INIT, barrier, pthread_barrier, count, 0, 0); CALL_FN_W_WWW(ret, fn, barrier, attr, count); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_BARRIER_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_INIT, barrier, pthread_barrier, 0, 0, 0); return ret; } @@ -903,10 +903,10 @@ int pthread_barrier_destroy_intercept(pthread_barrier_t* barrier) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_BARRIER_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_DESTROY, barrier, pthread_barrier, 0, 0, 0); CALL_FN_W_W(ret, fn, barrier); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_BARRIER_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_DESTROY, barrier, pthread_barrier, 0, 0, 0); return ret; } @@ -920,10 +920,10 @@ int pthread_barrier_wait_intercept(pthread_barrier_t* barrier) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_BARRIER_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_WAIT, barrier, pthread_barrier, 0, 0, 0); CALL_FN_W_W(ret, fn, barrier); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_BARRIER_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_WAIT, barrier, pthread_barrier, ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD, ret == PTHREAD_BARRIER_SERIAL_THREAD, 0); @@ -941,10 +941,10 @@ int sem_init_intercept(sem_t *sem, int pshared, unsigned int value) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_INIT, sem, pshared, value, 0, 0); CALL_FN_W_WWW(ret, fn, sem, pshared, value); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_INIT, sem, 0, 0, 0, 0); return ret; } @@ -958,10 +958,10 @@ int sem_destroy_intercept(sem_t *sem) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_DESTROY, sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_DESTROY, sem, 0, 0, 0, 0); return ret; } @@ -975,10 +975,10 @@ sem_t* sem_open_intercept(const char *name, int oflag, mode_t mode, sem_t *ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_OPEN, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_OPEN, name, oflag, mode, value, 0); CALL_FN_W_WWWW(ret, fn, name, oflag, mode, value); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_OPEN, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_OPEN, ret != SEM_FAILED ? ret : 0, name, oflag, mode, value); return ret; @@ -993,10 +993,10 @@ static __always_inline int sem_close_intercept(sem_t *sem) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_CLOSE, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_CLOSE, sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_CLOSE, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_CLOSE, sem, 0, 0, 0, 0); return ret; } @@ -1008,10 +1008,10 @@ static __always_inline int sem_wait_intercept(sem_t *sem) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_WAIT, sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_WAIT, sem, ret == 0, 0, 0, 0); return ret; } @@ -1023,10 +1023,10 @@ static __always_inline int sem_trywait_intercept(sem_t *sem) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_WAIT, sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_WAIT, sem, ret == 0, 0, 0, 0); return ret; } @@ -1039,10 +1039,10 @@ int sem_timedwait_intercept(sem_t *sem, const struct timespec *abs_timeout) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_WAIT, sem, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, sem, abs_timeout); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_WAIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_WAIT, sem, ret == 0, 0, 0, 0); return ret; } @@ -1056,10 +1056,10 @@ static __always_inline int sem_post_intercept(sem_t *sem) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_POST, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_POST, sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_POST, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_POST, sem, ret == 0, 0, 0, 0); return ret; } @@ -1077,7 +1077,7 @@ int pthread_rwlock_init_intercept(pthread_rwlock_t* rwlock, int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_INIT, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_INIT, rwlock, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, rwlock, attr); return ret; @@ -1095,7 +1095,7 @@ int pthread_rwlock_destroy_intercept(pthread_rwlock_t* rwlock) OrigFn fn; VALGRIND_GET_ORIG_FN(fn); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_DESTROY, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_DESTROY, rwlock, 0, 0, 0, 0); return ret; } @@ -1110,10 +1110,10 @@ int pthread_rwlock_rdlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_RDLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_RDLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1128,10 +1128,10 @@ int pthread_rwlock_wrlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_WRLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_WRLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1146,10 +1146,10 @@ int pthread_rwlock_timedrdlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_RDLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_RDLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1164,10 +1164,10 @@ int pthread_rwlock_timedwrlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_WRLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_WRLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1182,10 +1182,10 @@ int pthread_rwlock_tryrdlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_RDLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_RDLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1200,10 +1200,10 @@ int pthread_rwlock_trywrlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_WRLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_WRLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1218,10 +1218,10 @@ int pthread_rwlock_unlock_intercept(pthread_rwlock_t* rwlock) int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_UNLOCK, rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_UNLOCK, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_UNLOCK, rwlock, ret == 0, 0, 0, 0); return ret; } diff --git a/drd/tests/rwlock_race.c b/drd/tests/rwlock_race.c index 6650c81b98..4a73bfc54e 100644 --- a/drd/tests/rwlock_race.c +++ b/drd/tests/rwlock_race.c @@ -39,7 +39,7 @@ int main(int argc, char** argv) #if 0 - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_TRACE_ADDR, + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_TRACE_ADDR, &s_racy, 0, 0, 0, 0); #endif diff --git a/helgrind/helgrind.h b/helgrind/helgrind.h index d59734ef47..8645866049 100644 --- a/helgrind/helgrind.h +++ b/helgrind/helgrind.h @@ -147,7 +147,7 @@ typedef long int _arg1; \ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \ _arg1 = (long int)(_arg1F); \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VALGRIND_DO_CLIENT_REQUEST_STMT( \ (_creqF), \ _arg1, 0,0,0,0); \ } while (0) @@ -171,7 +171,7 @@ typedef /* assert(sizeof(_ty2F) == sizeof(long int)); */ \ _arg1 = (long int)(_arg1F); \ _arg2 = (long int)(_arg2F); \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VALGRIND_DO_CLIENT_REQUEST_STMT( \ (_creqF), \ _arg1,_arg2,0,0,0); \ } while (0) @@ -186,7 +186,7 @@ typedef _arg1 = (long int)(_arg1F); \ _arg2 = (long int)(_arg2F); \ _arg3 = (long int)(_arg3F); \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VALGRIND_DO_CLIENT_REQUEST_STMT( \ (_creqF), \ _arg1,_arg2,_arg3,0,0); \ } while (0) diff --git a/helgrind/hg_intercepts.c b/helgrind/hg_intercepts.c index a30edfd169..206221e214 100644 --- a/helgrind/hg_intercepts.c +++ b/helgrind/hg_intercepts.c @@ -89,7 +89,7 @@ Word _arg1; \ assert(sizeof(_ty1F) == sizeof(Word)); \ _arg1 = (Word)(_arg1F); \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, (_creqF), \ + VALGRIND_DO_CLIENT_REQUEST_STMT((_creqF), \ _arg1, 0,0,0,0); \ } while (0) @@ -100,7 +100,7 @@ assert(sizeof(_ty2F) == sizeof(Word)); \ _arg1 = (Word)(_arg1F); \ _arg2 = (Word)(_arg2F); \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, (_creqF), \ + VALGRIND_DO_CLIENT_REQUEST_STMT((_creqF), \ _arg1,_arg2,0,0,0); \ } while (0) @@ -128,7 +128,7 @@ _arg1 = (Word)(_arg1F); \ _arg2 = (Word)(_arg2F); \ _arg3 = (Word)(_arg3F); \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, (_creqF), \ + VALGRIND_DO_CLIENT_REQUEST_STMT((_creqF), \ _arg1,_arg2,_arg3,0,0); \ } while (0) diff --git a/include/valgrind.h b/include/valgrind.h index 9d20fc945a..222a58e156 100644 --- a/include/valgrind.h +++ b/include/valgrind.h @@ -156,9 +156,13 @@ * VALGRIND_DO_CLIENT_REQUEST(): a statement that invokes a Valgrind client * request. Accepts both pointers and integers as arguments. * + * VALGRIND_DO_CLIENT_REQUEST_STMT(): a statement that invokes a Valgrind + * client request that does not return a value. + * VALGRIND_DO_CLIENT_REQUEST_EXPR(): a C expression that invokes a Valgrind - * client request and whose value equals the client request result. Accepts - * both pointers and integers as arguments. + * client request and whose value equals the client request result. Accepts + * both pointers and integers as arguments. Note that such calls are not + * necessarily pure functions -- they may have side effects. */ #define VALGRIND_DO_CLIENT_REQUEST(_zzq_rlval, _zzq_default, \ @@ -168,6 +172,12 @@ (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) +#define VALGRIND_DO_CLIENT_REQUEST_STMT(_zzq_request, _zzq_arg1, \ + _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ + do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ + (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) + #if defined(NVALGRIND) /* Define NVALGRIND to completely remove the Valgrind magic sequence @@ -3681,10 +3691,9 @@ typedef _qzz_len - 1]. Useful if you are debugging a JITter or some such, since it provides a way to make sure valgrind will retranslate the invalidated area. Returns no value. */ -#define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \ - (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DISCARD_TRANSLATIONS, \ - _qzz_addr, _qzz_len, 0, 0, 0) +#define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DISCARD_TRANSLATIONS, \ + _qzz_addr, _qzz_len, 0, 0, 0) /* These requests are for getting Valgrind itself to print something. @@ -3930,68 +3939,58 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...) Ignored if addr == 0. */ -#define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__MALLOCLIKE_BLOCK, \ - addr, sizeB, rzB, is_zeroed, 0) +#define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ + addr, sizeB, rzB, is_zeroed, 0) /* See the comment for VALGRIND_MALLOCLIKE_BLOCK for details. Ignored if addr == 0. */ -#define VALGRIND_RESIZEINPLACE_BLOCK(addr, oldSizeB, newSizeB, rzB) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__RESIZEINPLACE_BLOCK, \ - addr, oldSizeB, newSizeB, rzB, 0) +#define VALGRIND_RESIZEINPLACE_BLOCK(addr, oldSizeB, newSizeB, rzB) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__RESIZEINPLACE_BLOCK, \ + addr, oldSizeB, newSizeB, rzB, 0) /* See the comment for VALGRIND_MALLOCLIKE_BLOCK for details. Ignored if addr == 0. */ -#define VALGRIND_FREELIKE_BLOCK(addr, rzB) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__FREELIKE_BLOCK, \ - addr, rzB, 0, 0, 0) +#define VALGRIND_FREELIKE_BLOCK(addr, rzB) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREELIKE_BLOCK, \ + addr, rzB, 0, 0, 0) /* Create a memory pool. */ #define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__CREATE_MEMPOOL, \ - pool, rzB, is_zeroed, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__CREATE_MEMPOOL, \ + pool, rzB, is_zeroed, 0, 0) /* Destroy a memory pool. */ #define VALGRIND_DESTROY_MEMPOOL(pool) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DESTROY_MEMPOOL, \ - pool, 0, 0, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DESTROY_MEMPOOL, \ + pool, 0, 0, 0, 0) /* Associate a piece of memory with a memory pool. */ #define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__MEMPOOL_ALLOC, \ - pool, addr, size, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_ALLOC, \ + pool, addr, size, 0, 0) /* Disassociate a piece of memory from a memory pool. */ #define VALGRIND_MEMPOOL_FREE(pool, addr) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__MEMPOOL_FREE, \ - pool, addr, 0, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_FREE, \ + pool, addr, 0, 0, 0) /* Disassociate any pieces outside a particular range. */ #define VALGRIND_MEMPOOL_TRIM(pool, addr, size) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__MEMPOOL_TRIM, \ - pool, addr, size, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_TRIM, \ + pool, addr, size, 0, 0) /* Resize and/or move a piece associated with a memory pool. */ #define VALGRIND_MOVE_MEMPOOL(poolA, poolB) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__MOVE_MEMPOOL, \ - poolA, poolB, 0, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MOVE_MEMPOOL, \ + poolA, poolB, 0, 0, 0) /* Resize and/or move a piece associated with a memory pool. */ #define VALGRIND_MEMPOOL_CHANGE(pool, addrA, addrB, size) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__MEMPOOL_CHANGE, \ - pool, addrA, addrB, size, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_CHANGE, \ + pool, addrA, addrB, size, 0) /* Return 1 if a mempool exists, else 0. */ #define VALGRIND_MEMPOOL_EXISTS(pool) \ @@ -4008,21 +4007,18 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...) /* Unmark the piece of memory associated with a stack id as being a stack. */ #define VALGRIND_STACK_DEREGISTER(id) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__STACK_DEREGISTER, \ - id, 0, 0, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__STACK_DEREGISTER, \ + id, 0, 0, 0, 0) /* Change the start and end address of the stack id. */ #define VALGRIND_STACK_CHANGE(id, start, end) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__STACK_CHANGE, \ - id, start, end, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__STACK_CHANGE, \ + id, start, end, 0, 0) /* Load PDB debug info for Wine PE image_map. */ -#define VALGRIND_LOAD_PDB_DEBUGINFO(fd, ptr, total_size, delta) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__LOAD_PDB_DEBUGINFO, \ - fd, ptr, total_size, delta, 0) +#define VALGRIND_LOAD_PDB_DEBUGINFO(fd, ptr, total_size, delta) \ + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__LOAD_PDB_DEBUGINFO, \ + fd, ptr, total_size, delta, 0) /* Map a code address to a source file name and line number. buf64 must point to a 64-byte buffer in the caller's address space. The @@ -4042,20 +4038,14 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...) reporting. Child threads do not inherit this setting from their parents -- they are always created with reporting enabled. */ #define VALGRIND_DISABLE_ERROR_REPORTING \ - do { \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__CHANGE_ERR_DISABLEMENT, \ - 1, 0, 0, 0, 0); \ - } while (0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__CHANGE_ERR_DISABLEMENT, \ + 1, 0, 0, 0, 0) /* Re-enable error reporting, as per comments on VALGRIND_DISABLE_ERROR_REPORTING. */ #define VALGRIND_ENABLE_ERROR_REPORTING \ - do { \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__CHANGE_ERR_DISABLEMENT, \ - -1, 0, 0, 0, 0); \ - } while (0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__CHANGE_ERR_DISABLEMENT, \ + -1, 0, 0, 0, 0) #undef PLAT_x86_darwin #undef PLAT_amd64_darwin diff --git a/memcheck/mc_replace_strmem.c b/memcheck/mc_replace_strmem.c index 7661a96b98..d29dc59791 100644 --- a/memcheck/mc_replace_strmem.c +++ b/memcheck/mc_replace_strmem.c @@ -150,7 +150,7 @@ static inline void my_exit ( int x ) // This is a macro rather than a function because we don't want to have an // extra function in the stack trace. #define RECORD_OVERLAP_ERROR(s, src, dst, len) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VALGRIND_DO_CLIENT_REQUEST_STMT( \ _VG_USERREQ__MEMCHECK_RECORD_OVERLAP_ERROR, \ s, src, dst, len, 0) diff --git a/memcheck/memcheck.h b/memcheck/memcheck.h index 984be3162f..68474b4418 100644 --- a/memcheck/memcheck.h +++ b/memcheck/memcheck.h @@ -184,35 +184,27 @@ typedef /* Do a full memory leak check (like --leak-check=full) mid-execution. */ #define VALGRIND_DO_LEAK_CHECK \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DO_LEAK_CHECK, \ - 0, 0, 0, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DO_LEAK_CHECK, \ + 0, 0, 0, 0, 0) /* Same as VALGRIND_DO_LEAK_CHECK but only showing the entries for which there was an increase in leaked bytes or leaked nr of blocks since the previous leak search. */ #define VALGRIND_DO_ADDED_LEAK_CHECK \ - do { \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DO_LEAK_CHECK, \ - 0, 1, 0, 0, 0); \ - } while (0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DO_LEAK_CHECK, \ + 0, 1, 0, 0, 0) /* Same as VALGRIND_DO_ADDED_LEAK_CHECK but showing entries with increased or decreased leaked bytes/blocks since previous leak search. */ #define VALGRIND_DO_CHANGED_LEAK_CHECK \ - do { \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DO_LEAK_CHECK, \ - 0, 2, 0, 0, 0); \ - } while (0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DO_LEAK_CHECK, \ + 0, 2, 0, 0, 0) /* Do a summary memory leak check (like --leak-check=summary) mid-execution. */ #define VALGRIND_DO_QUICK_LEAK_CHECK \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ - VG_USERREQ__DO_LEAK_CHECK, \ - 1, 0, 0, 0, 0) + VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DO_LEAK_CHECK, \ + 1, 0, 0, 0, 0) /* Return number of leaked, dubious, reachable and suppressed bytes found by all previous leak checks. They must be lvalues. */ @@ -226,7 +218,7 @@ typedef { \ unsigned long _qzz_leaked = 0, _qzz_dubious = 0; \ unsigned long _qzz_reachable = 0, _qzz_suppressed = 0; \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VALGRIND_DO_CLIENT_REQUEST_STMT( \ VG_USERREQ__COUNT_LEAKS, \ &_qzz_leaked, &_qzz_dubious, \ &_qzz_reachable, &_qzz_suppressed, 0); \ @@ -248,7 +240,7 @@ typedef { \ unsigned long _qzz_leaked = 0, _qzz_dubious = 0; \ unsigned long _qzz_reachable = 0, _qzz_suppressed = 0; \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VALGRIND_DO_CLIENT_REQUEST_STMT( \ VG_USERREQ__COUNT_LEAK_BLOCKS, \ &_qzz_leaked, &_qzz_dubious, \ &_qzz_reachable, &_qzz_suppressed, 0); \ diff --git a/memcheck/tests/linux/stack_changes.c b/memcheck/tests/linux/stack_changes.c index de39cd7545..a978fc2b0f 100644 --- a/memcheck/tests/linux/stack_changes.c +++ b/memcheck/tests/linux/stack_changes.c @@ -62,9 +62,9 @@ int main(int argc, char **argv) swapcontext(&oldc, &ctx1); - (void)VALGRIND_STACK_DEREGISTER(c1); + VALGRIND_STACK_DEREGISTER(c1); //free(ctx1.uc_stack.ss_sp); - (void)VALGRIND_STACK_DEREGISTER(c2); + VALGRIND_STACK_DEREGISTER(c2); //free(ctx2.uc_stack.ss_sp); return 0; diff --git a/none/tests/discard.c b/none/tests/discard.c index a5e6b5210a..3a1fc653dc 100644 --- a/none/tests/discard.c +++ b/none/tests/discard.c @@ -22,7 +22,7 @@ void someother ( void ) int main ( void ) { printf("fooble-1() = %d\n", fooble() ); - (void)VALGRIND_DISCARD_TRANSLATIONS( (char*)(&fooble), + VALGRIND_DISCARD_TRANSLATIONS( (char*)(&fooble), ((char*)(&someother)) - ((char*)(&fooble)) ); printf("fooble-2() = %d\n", fooble() ); return 0;