From 9a36fe677e603aed42a3f2d012a06a63ee0de7b2 Mon Sep 17 00:00:00 2001 From: Bart Van Assche Date: Sun, 15 May 2011 07:04:03 +0000 Subject: [PATCH] Get rid of the remaining "set but not used" warnings reported by gcc 4.6 by swapping the roles of the VALGRIND_DO_CLIENT_REQUEST() and VALGRIND_DO_CLIENT_REQUEST_EXPR() macros. Also, many __attribute__((unused)) declarations on variables have been eliminated. Closes #269778. Note: so far this patch has been tested on x86/Linux, amd64/Linux and ppc64/Linux but not yet on any other supported CPU/OS combination. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@11755 --- callgrind/callgrind.h | 48 +-- coregrind/m_replacemalloc/vg_replace_malloc.c | 6 +- coregrind/vg_preloaded.c | 13 +- drd/drd.h | 10 +- drd/drd_pthread_intercepts.c | 374 +++++++--------- drd/drd_qtcore_intercepts.c | 74 ++-- drd/tests/rwlock_race.c | 6 +- helgrind/helgrind.h | 19 +- helgrind/hg_intercepts.c | 14 +- include/valgrind.h | 402 ++++++++---------- memcheck/mc_replace_strmem.c | 11 +- memcheck/memcheck.h | 26 +- memcheck/tests/linux/stack_changes.c | 4 +- memcheck/tests/sh-mem-random.c | 6 +- memcheck/tests/sh-mem.c | 6 +- none/tests/discard.c | 2 +- 16 files changed, 430 insertions(+), 591 deletions(-) diff --git a/callgrind/callgrind.h b/callgrind/callgrind.h index 3879a16542..ff50911dfa 100644 --- a/callgrind/callgrind.h +++ b/callgrind/callgrind.h @@ -82,53 +82,38 @@ typedef } Vg_CallgrindClientRequest; /* Dump current state of cost centers, and zero them afterwards */ -#define CALLGRIND_DUMP_STATS \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ - VG_USERREQ__DUMP_STATS, \ - 0, 0, 0, 0, 0); \ - } +#define CALLGRIND_DUMP_STATS \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DUMP_STATS, \ + 0, 0, 0, 0, 0) /* Dump current state of cost centers, and zero them afterwards. The argument is appended to a string stating the reason which triggered the dump. This string is written as a description field into the profile data dump. */ -#define CALLGRIND_DUMP_STATS_AT(pos_str) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ - VG_USERREQ__DUMP_STATS_AT, \ - pos_str, 0, 0, 0, 0); \ - } +#define CALLGRIND_DUMP_STATS_AT(pos_str) \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DUMP_STATS_AT, \ + pos_str, 0, 0, 0, 0) /* Zero cost centers */ -#define CALLGRIND_ZERO_STATS \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ - VG_USERREQ__ZERO_STATS, \ - 0, 0, 0, 0, 0); \ - } +#define CALLGRIND_ZERO_STATS \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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 \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ - VG_USERREQ__TOGGLE_COLLECT, \ - 0, 0, 0, 0, 0); \ - } + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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 \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ - VG_USERREQ__START_INSTRUMENTATION, \ - 0, 0, 0, 0, 0); \ - } + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__START_INSTRUMENTATION, \ + 0, 0, 0, 0, 0) /* Stop full callgrind instrumentation if not already switched off. This flushes Valgrinds translation cache, and does no additional @@ -138,10 +123,7 @@ typedef To start Callgrind in this mode to ignore the setup phase, use the option "--instr-atstart=no". */ #define CALLGRIND_STOP_INSTRUMENTATION \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ - VG_USERREQ__STOP_INSTRUMENTATION, \ - 0, 0, 0, 0, 0); \ - } + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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 9d2cb44fbb..612bf417d6 100644 --- a/coregrind/m_replacemalloc/vg_replace_malloc.c +++ b/coregrind/m_replacemalloc/vg_replace_malloc.c @@ -850,8 +850,6 @@ ZONE_CHECK(VG_Z_LIBC_SONAME, malloc_zone_check); __attribute__((constructor)) static void init(void) { - int res __attribute__((unused)); - // This doesn't look thread-safe, but it should be ok... Bart says: // // Every program I know of calls malloc() at least once before calling @@ -873,8 +871,8 @@ static void init(void) init_done = 1; - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__GET_MALLOCFUNCS, &info, - 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__GET_MALLOCFUNCS, &info, + 0, 0, 0, 0); } /*--------------------------------------------------------------------*/ diff --git a/coregrind/vg_preloaded.c b/coregrind/vg_preloaded.c index 863c7743fa..0943b9ac03 100644 --- a/coregrind/vg_preloaded.c +++ b/coregrind/vg_preloaded.c @@ -56,14 +56,13 @@ void VG_NOTIFY_ON_LOAD(freeres)( void ); void VG_NOTIFY_ON_LOAD(freeres)( void ) { - int res __attribute__((unused)); #if !defined(__UCLIBC__) && !defined(VGO_aix5) extern void __libc_freeres(void); __libc_freeres(); #endif - VALGRIND_DO_CLIENT_REQUEST(res, 0 /* default */, - VG_USERREQ__LIBC_FREERES_DONE, - 0, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default */, + VG_USERREQ__LIBC_FREERES_DONE, + 0, 0, 0, 0, 0); /*NOTREACHED*/ *(volatile int *)0 = 'x'; } @@ -77,7 +76,6 @@ void * VG_NOTIFY_ON_LOAD(ifunc_wrapper) (void) { OrigFn fn; Addr result = 0; - int res __attribute__((unused)); /* Call the original indirect function and get it's result */ VALGRIND_GET_ORIG_FN(fn); @@ -87,9 +85,8 @@ 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(res, 0, - VG_USERREQ__ADD_IFUNC_TARGET, - fn.nraddr, result, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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 3f4ffc5c46..55f72279a3 100644 --- a/drd/drd.h +++ b/drd/drd.h @@ -66,13 +66,15 @@ /** Obtain the thread ID assigned by Valgrind's core. */ -#define DRD_GET_VALGRIND_THREADID \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID, \ +#define DRD_GET_VALGRIND_THREADID \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID, \ 0, 0, 0, 0, 0) /** Obtain the thread ID assigned by DRD. */ -#define DRD_GET_DRD_THREADID \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_GET_DRD_THREAD_ID, \ +#define DRD_GET_DRD_THREADID \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + VG_USERREQ__DRD_GET_DRD_THREAD_ID, \ 0, 0, 0, 0, 0) diff --git a/drd/drd_pthread_intercepts.c b/drd/drd_pthread_intercepts.c index 3c9f039c1e..ac648e9988 100644 --- a/drd/drd_pthread_intercepts.c +++ b/drd/drd_pthread_intercepts.c @@ -235,26 +235,23 @@ static __always_inline MutexT DRD_(mutex_type)(pthread_mutex_t* mutex) */ static void DRD_(set_joinable)(const pthread_t tid, const int joinable) { - int res __attribute__((unused)); assert(joinable == 0 || joinable == 1); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__SET_JOINABLE, - tid, joinable, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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) { - int res __attribute__((unused)); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__ENTERING_PTHREAD_CREATE, - 0, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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) { - int res __attribute__((unused)); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__LEFT_PTHREAD_CREATE, - 0, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__LEFT_PTHREAD_CREATE, + 0, 0, 0, 0, 0); } /** @@ -263,15 +260,14 @@ static __always_inline void DRD_(left_pthread_create)(void) */ static void* DRD_(thread_wrapper)(void* arg) { - int res __attribute__((unused)); DrdPosixThreadArgs* arg_ptr; DrdPosixThreadArgs arg_copy; arg_ptr = (DrdPosixThreadArgs*)arg; arg_copy = *arg_ptr; - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__SET_PTHREADID, - pthread_self(), 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__SET_PTHREADID, + pthread_self(), 0, 0, 0, 0); DRD_(set_joinable)(pthread_self(), arg_copy.detachstate == PTHREAD_CREATE_JOINABLE); @@ -348,11 +344,9 @@ static void DRD_(check_threading_library)(void) */ static void DRD_(set_main_thread_state)(void) { - int res __attribute__((unused)); - // Make sure that DRD knows about the main thread's POSIX thread ID. - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__SET_PTHREADID, - pthread_self(), 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__SET_PTHREADID, + pthread_self(), 0, 0, 0, 0); } /* @@ -377,7 +371,6 @@ static __always_inline int pthread_create_intercept(pthread_t* thread, const pthread_attr_t* attr, void* (*start)(void*), void* arg) { - int res __attribute__((unused)); int ret; OrigFn fn; DrdPosixThreadArgs thread_args; @@ -413,8 +406,8 @@ int pthread_create_intercept(pthread_t* thread, const pthread_attr_t* attr, sched_yield(); } - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__DRD_START_NEW_SEGMENT, - pthread_self(), 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__DRD_START_NEW_SEGMENT, + pthread_self(), 0, 0, 0, 0); return ret; } @@ -428,15 +421,14 @@ static __always_inline int pthread_join_intercept(pthread_t pt_joinee, void **thread_return) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); CALL_FN_W_WW(ret, fn, pt_joinee, thread_return); if (ret == 0) { - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_THREAD_JOIN, - pt_joinee, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_THREAD_JOIN, + pt_joinee, 0, 0, 0, 0); } return ret; } @@ -467,15 +459,14 @@ PTH_FUNCS(int, pthreadZudetach, pthread_detach_intercept, static __always_inline int pthread_cancel_intercept(pthread_t pt_thread) { - int res __attribute__((unused)); int ret; OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_THREAD_CANCEL, - pt_thread, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_THREAD_CANCEL, + pt_thread, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, pt_thread); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_THREAD_CANCEL, - pt_thread, ret==0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_THREAD_CANCEL, + pt_thread, ret==0, 0, 0, 0); return ret; } @@ -509,19 +500,18 @@ int pthread_mutex_init_intercept(pthread_mutex_t *mutex, const pthread_mutexattr_t* attr) { int ret; - int res __attribute__((unused)); OrigFn fn; int mt; VALGRIND_GET_ORIG_FN(fn); mt = PTHREAD_MUTEX_DEFAULT; if (attr) pthread_mutexattr_gettype(attr, &mt); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_INIT, - mutex, DRD_(pthread_to_drd_mutex_type)(mt), - 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, 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(res, -1, VG_USERREQ__POST_MUTEX_INIT, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_INIT, + mutex, 0, 0, 0, 0); return ret; } @@ -533,14 +523,13 @@ static __always_inline int pthread_mutex_destroy_intercept(pthread_mutex_t* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_DESTROY, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_DESTROY, + mutex, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_DESTROY, - mutex, DRD_(mutex_type)(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_DESTROY, + mutex, DRD_(mutex_type)(mutex), 0, 0, 0); return ret; } @@ -551,14 +540,13 @@ static __always_inline int pthread_mutex_lock_intercept(pthread_mutex_t* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - mutex, DRD_(mutex_type)(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + mutex, DRD_(mutex_type)(mutex), 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__POST_MUTEX_LOCK, - mutex, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__POST_MUTEX_LOCK, + mutex, ret == 0, 0, 0, 0); return ret; } @@ -569,14 +557,13 @@ static __always_inline int pthread_mutex_trylock_intercept(pthread_mutex_t* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - mutex, DRD_(mutex_type)(mutex), 1, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + mutex, DRD_(mutex_type)(mutex), 1, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, - mutex, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + mutex, ret == 0, 0, 0, 0); return ret; } @@ -588,14 +575,13 @@ int pthread_mutex_timedlock_intercept(pthread_mutex_t *mutex, const struct timespec *abs_timeout) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - mutex, DRD_(mutex_type)(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, 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(res, -1, VG_USERREQ__POST_MUTEX_LOCK, - mutex, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + mutex, ret == 0, 0, 0, 0); return ret; } @@ -607,16 +593,13 @@ static __always_inline int pthread_mutex_unlock_intercept(pthread_mutex_t *mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, - VG_USERREQ__PRE_MUTEX_UNLOCK, - mutex, DRD_(mutex_type)(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_UNLOCK, + mutex, DRD_(mutex_type)(mutex), 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, - VG_USERREQ__POST_MUTEX_UNLOCK, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_UNLOCK, + mutex, 0, 0, 0, 0); return ret; } @@ -628,14 +611,13 @@ int pthread_cond_init_intercept(pthread_cond_t* cond, const pthread_condattr_t* attr) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_INIT, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_INIT, + cond, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, cond, attr); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_INIT, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_INIT, + cond, 0, 0, 0, 0); return ret; } @@ -647,14 +629,13 @@ static __always_inline int pthread_cond_destroy_intercept(pthread_cond_t* cond) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_DESTROY, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_DESTROY, + cond, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, cond); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_DESTROY, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_DESTROY, + cond, 0, 0, 0, 0); return ret; } @@ -665,14 +646,13 @@ static __always_inline int pthread_cond_wait_intercept(pthread_cond_t *cond, pthread_mutex_t *mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_WAIT, - cond, mutex, DRD_(mutex_type)(mutex), 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, 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(res, -1, VG_USERREQ__POST_COND_WAIT, - cond, mutex, 1, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_WAIT, + cond, mutex, 1, 0, 0); return ret; } @@ -686,14 +666,13 @@ int pthread_cond_timedwait_intercept(pthread_cond_t *cond, const struct timespec* abstime) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_WAIT, - cond, mutex, DRD_(mutex_type)(mutex), 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, 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(res, -1, VG_USERREQ__POST_COND_WAIT, - cond, mutex, 1, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_WAIT, + cond, mutex, 1, 0, 0); return ret; } @@ -712,14 +691,13 @@ static __always_inline int pthread_cond_signal_intercept(pthread_cond_t* cond) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_SIGNAL, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_SIGNAL, + cond, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, cond); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_SIGNAL, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_SIGNAL, + cond, 0, 0, 0, 0); return ret; } @@ -730,14 +708,13 @@ static __always_inline int pthread_cond_broadcast_intercept(pthread_cond_t* cond) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_BROADCAST, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_COND_BROADCAST, + cond, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, cond); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_BROADCAST, - cond, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_COND_BROADCAST, + cond, 0, 0, 0, 0); return ret; } @@ -749,14 +726,13 @@ static __always_inline int pthread_spin_init_intercept(pthread_spinlock_t *spinlock, int pshared) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, - spinlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, + spinlock, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, spinlock, pshared); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, - spinlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, + spinlock, 0, 0, 0, 0); return ret; } @@ -767,14 +743,13 @@ static __always_inline int pthread_spin_destroy_intercept(pthread_spinlock_t *spinlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_DESTROY, - spinlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_DESTROY, + spinlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_DESTROY, - spinlock, mutex_type_spinlock, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_DESTROY, + spinlock, mutex_type_spinlock, 0, 0, 0); return ret; } @@ -785,14 +760,13 @@ static __always_inline int pthread_spin_lock_intercept(pthread_spinlock_t *spinlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - spinlock, mutex_type_spinlock, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + spinlock, mutex_type_spinlock, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, - spinlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + spinlock, ret == 0, 0, 0, 0); return ret; } @@ -803,14 +777,13 @@ static __always_inline int pthread_spin_trylock_intercept(pthread_spinlock_t *spinlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - spinlock, mutex_type_spinlock, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + spinlock, mutex_type_spinlock, 0, 0, 0); CALL_FN_W_W(ret, fn, spinlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, - spinlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + spinlock, ret == 0, 0, 0, 0); return ret; } @@ -821,14 +794,13 @@ static __always_inline int pthread_spin_unlock_intercept(pthread_spinlock_t *spinlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, - spinlock, mutex_type_spinlock, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, 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(res, -1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, - spinlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, + spinlock, 0, 0, 0, 0); return ret; } @@ -844,14 +816,13 @@ int pthread_barrier_init_intercept(pthread_barrier_t* barrier, unsigned count) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_INIT, - barrier, pthread_barrier, count, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_BARRIER_INIT, + barrier, pthread_barrier, count, 0, 0); CALL_FN_W_WWW(ret, fn, barrier, attr, count); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_INIT, - barrier, pthread_barrier, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_BARRIER_INIT, + barrier, pthread_barrier, 0, 0, 0); return ret; } @@ -863,14 +834,13 @@ static __always_inline int pthread_barrier_destroy_intercept(pthread_barrier_t* barrier) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_DESTROY, - barrier, pthread_barrier, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_BARRIER_DESTROY, + barrier, pthread_barrier, 0, 0, 0); CALL_FN_W_W(ret, fn, barrier); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_DESTROY, - barrier, pthread_barrier, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_BARRIER_DESTROY, + barrier, pthread_barrier, 0, 0, 0); return ret; } @@ -881,13 +851,12 @@ static __always_inline int pthread_barrier_wait_intercept(pthread_barrier_t* barrier) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_WAIT, - barrier, pthread_barrier, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_BARRIER_WAIT, + barrier, pthread_barrier, 0, 0, 0); CALL_FN_W_W(ret, fn, barrier); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_WAIT, + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_BARRIER_WAIT, barrier, pthread_barrier, ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD, ret == PTHREAD_BARRIER_SERIAL_THREAD, 0); @@ -903,14 +872,13 @@ static __always_inline int sem_init_intercept(sem_t *sem, int pshared, unsigned int value) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_INIT, - sem, pshared, value, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_INIT, + sem, pshared, value, 0, 0); CALL_FN_W_WWW(ret, fn, sem, pshared, value); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_INIT, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_INIT, + sem, 0, 0, 0, 0); return ret; } @@ -921,14 +889,13 @@ static __always_inline int sem_destroy_intercept(sem_t *sem) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_DESTROY, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_DESTROY, + sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_DESTROY, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_DESTROY, + sem, 0, 0, 0, 0); return ret; } @@ -939,15 +906,14 @@ sem_t* sem_open_intercept(const char *name, int oflag, mode_t mode, unsigned int value) { sem_t *ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_OPEN, - name, oflag, mode, value, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_OPEN, + name, oflag, mode, value, 0); CALL_FN_W_WWWW(ret, fn, name, oflag, mode, value); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_OPEN, - ret != SEM_FAILED ? ret : 0, - name, oflag, mode, value); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_OPEN, + ret != SEM_FAILED ? ret : 0, + name, oflag, mode, value); return ret; } @@ -958,14 +924,13 @@ PTH_FUNCS(sem_t *, semZuopen, sem_open_intercept, static __always_inline int sem_close_intercept(sem_t *sem) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_CLOSE, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_CLOSE, + sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_CLOSE, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_CLOSE, + sem, 0, 0, 0, 0); return ret; } @@ -974,14 +939,13 @@ PTH_FUNCS(int, semZuclose, sem_close_intercept, (sem_t *sem), (sem)); static __always_inline int sem_wait_intercept(sem_t *sem) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_WAIT, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_WAIT, + sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_WAIT, - sem, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_WAIT, + sem, ret == 0, 0, 0, 0); return ret; } @@ -990,14 +954,13 @@ PTH_FUNCS(int, semZuwait, sem_wait_intercept, (sem_t *sem), (sem)); static __always_inline int sem_trywait_intercept(sem_t *sem) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_WAIT, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_WAIT, + sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_WAIT, - sem, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_WAIT, + sem, ret == 0, 0, 0, 0); return ret; } @@ -1007,14 +970,13 @@ static __always_inline int sem_timedwait_intercept(sem_t *sem, const struct timespec *abs_timeout) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_WAIT, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_WAIT, + sem, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, sem, abs_timeout); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_WAIT, - sem, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_WAIT, + sem, ret == 0, 0, 0, 0); return ret; } @@ -1025,14 +987,13 @@ PTH_FUNCS(int, semZutimedwait, sem_timedwait_intercept, static __always_inline int sem_post_intercept(sem_t *sem) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_POST, - sem, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_SEM_POST, + sem, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, sem); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_POST, - sem, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_SEM_POST, + sem, ret == 0, 0, 0, 0); return ret; } @@ -1043,11 +1004,10 @@ int pthread_rwlock_init_intercept(pthread_rwlock_t* rwlock, const pthread_rwlockattr_t* attr) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_INIT, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_INIT, + rwlock, 0, 0, 0, 0); CALL_FN_W_WW(ret, fn, rwlock, attr); return ret; } @@ -1061,12 +1021,11 @@ static __always_inline int pthread_rwlock_destroy_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_DESTROY, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_DESTROY, + rwlock, 0, 0, 0, 0); return ret; } @@ -1078,14 +1037,13 @@ static __always_inline int pthread_rwlock_rdlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_RDLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_RDLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_RDLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_RDLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1097,14 +1055,13 @@ static __always_inline int pthread_rwlock_wrlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_WRLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_WRLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_WRLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_WRLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1116,14 +1073,13 @@ static __always_inline int pthread_rwlock_timedrdlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_RDLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_RDLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_RDLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_RDLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1135,14 +1091,13 @@ static __always_inline int pthread_rwlock_timedwrlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_WRLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_WRLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_WRLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_WRLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1154,14 +1109,13 @@ static __always_inline int pthread_rwlock_tryrdlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_RDLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_RDLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_RDLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_RDLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1173,14 +1127,13 @@ static __always_inline int pthread_rwlock_trywrlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_WRLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_WRLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_WRLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_WRLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } @@ -1192,14 +1145,13 @@ static __always_inline int pthread_rwlock_unlock_intercept(pthread_rwlock_t* rwlock) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_UNLOCK, - rwlock, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_RWLOCK_UNLOCK, + rwlock, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, rwlock); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_UNLOCK, - rwlock, ret == 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_RWLOCK_UNLOCK, + rwlock, ret == 0, 0, 0, 0); return ret; } diff --git a/drd/drd_qtcore_intercepts.c b/drd/drd_qtcore_intercepts.c index be1c5c9a9d..bd55fa44b3 100644 --- a/drd/drd_qtcore_intercepts.c +++ b/drd/drd_qtcore_intercepts.c @@ -90,14 +90,13 @@ QT4CORE_FUNC(void, _ZN6QMutexC1ENS_13RecursionModeE, qt_mutex_mode mode) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_INIT, - mutex, qt_to_drd_mutex_type(mode), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_INIT, + mutex, qt_to_drd_mutex_type(mode), 0, 0, 0); CALL_FN_W_WW(ret, fn, mutex, mode); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_INIT, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_INIT, + mutex, 0, 0, 0, 0); } // QMutex::QMutex(RecursionMode) -- _ZN6QMutexC2ENS_13RecursionModeE @@ -106,14 +105,13 @@ QT4CORE_FUNC(void, _ZN6QMutexC2ENS_13RecursionModeE, qt_mutex_mode mode) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_INIT, - mutex, qt_to_drd_mutex_type(mode), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_INIT, + mutex, qt_to_drd_mutex_type(mode), 0, 0, 0); CALL_FN_W_WW(ret, fn, mutex, mode); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_INIT, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_INIT, + mutex, 0, 0, 0, 0); } // QMutex::~QMutex() -- _ZN6QMutexD1Ev @@ -121,14 +119,13 @@ QT4CORE_FUNC(void, _ZN6QMutexD1Ev, void* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_DESTROY, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_DESTROY, + mutex, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_DESTROY, - mutex, mutex_type(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_DESTROY, + mutex, mutex_type(mutex), 0, 0, 0); } // QMutex::~QMutex() -- _ZN6QMutexD2Ev @@ -136,14 +133,13 @@ QT4CORE_FUNC(void, _ZN6QMutexD2Ev, void** mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_DESTROY, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_DESTROY, + mutex, 0, 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_DESTROY, - mutex, mutex_type(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_DESTROY, + mutex, mutex_type(mutex), 0, 0, 0); } // QMutex::lock() -- _ZN6QMutex4lockEv @@ -151,14 +147,13 @@ QT4CORE_FUNC(void, _ZN6QMutex4lockEv, void* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - mutex, mutex_type(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + mutex, mutex_type(mutex), 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__POST_MUTEX_LOCK, - mutex, 1, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__POST_MUTEX_LOCK, + mutex, 1, 0, 0, 0); } // QMutex::tryLock() -- _ZN6QMutex7tryLockEv @@ -166,14 +161,13 @@ QT4CORE_FUNC(int, _ZN6QMutex7tryLockEv, void* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - mutex, mutex_type(mutex), 1, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + mutex, mutex_type(mutex), 1, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, - mutex, ret, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + mutex, ret, 0, 0, 0); return ret; } @@ -183,14 +177,13 @@ QT4CORE_FUNC(int, _ZN6QMutex7tryLockEi, int timeout_ms) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, - mutex, mutex_type(mutex), 1, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRE_MUTEX_LOCK, + mutex, mutex_type(mutex), 1, 0, 0); CALL_FN_W_WW(ret, fn, mutex, timeout_ms); - VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, - mutex, ret, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_LOCK, + mutex, ret, 0, 0, 0); return ret; } @@ -199,14 +192,11 @@ QT4CORE_FUNC(void, _ZN6QMutex6unlockEv, void* mutex) { int ret; - int res __attribute__((unused)); OrigFn fn; VALGRIND_GET_ORIG_FN(fn); - VALGRIND_DO_CLIENT_REQUEST(res, -1, - VG_USERREQ__PRE_MUTEX_UNLOCK, - mutex, mutex_type(mutex), 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__PRE_MUTEX_UNLOCK, + mutex, mutex_type(mutex), 0, 0, 0); CALL_FN_W_W(ret, fn, mutex); - VALGRIND_DO_CLIENT_REQUEST(res, -1, - VG_USERREQ__POST_MUTEX_UNLOCK, - mutex, 0, 0, 0, 0); + VALGRIND_DO_CLIENT_REQUEST_EXPR(-1, VG_USERREQ__POST_MUTEX_UNLOCK, + mutex, 0, 0, 0, 0); } diff --git a/drd/tests/rwlock_race.c b/drd/tests/rwlock_race.c index e07524f090..6650c81b98 100644 --- a/drd/tests/rwlock_race.c +++ b/drd/tests/rwlock_race.c @@ -38,9 +38,9 @@ int main(int argc, char** argv) pthread_t thread2; #if 0 - int res; - VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__DRD_TRACE_ADDR, - &s_racy, 0, 0, 0, 0); + + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__DRD_TRACE_ADDR, + &s_racy, 0, 0, 0, 0); #endif pthread_rwlock_init(&s_rwlock, 0); diff --git a/helgrind/helgrind.h b/helgrind/helgrind.h index 64271eddbb..1480877080 100644 --- a/helgrind/helgrind.h +++ b/helgrind/helgrind.h @@ -144,20 +144,21 @@ typedef #define DO_CREQ_v_W(_creqF, _ty1F,_arg1F) \ do { \ - long _unused_res __attribute__((unused)), _arg1; \ + long int _arg1; \ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \ _arg1 = (long int)(_arg1F); \ - VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ (_creqF), \ _arg1, 0,0,0,0); \ } while (0) #define DO_CREQ_W_W(_resF, _dfltF, _creqF, _ty1F,_arg1F) \ do { \ - long int _qzz_res, _arg1; \ + long int arg1; \ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \ _arg1 = (long int)(_arg1F); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, (_dfltF), \ + _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + (_dfltF), \ (_creqF), \ _arg1, 0,0,0,0); \ _resF = _qzz_res; \ @@ -165,13 +166,12 @@ typedef #define DO_CREQ_v_WW(_creqF, _ty1F,_arg1F, _ty2F,_arg2F) \ do { \ - long _unused_res __attribute__((unused)); \ - long _arg1, _arg2; \ + long int _arg1, _arg2; \ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \ /* assert(sizeof(_ty2F) == sizeof(long int)); */ \ _arg1 = (long int)(_arg1F); \ _arg2 = (long int)(_arg2F); \ - VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ (_creqF), \ _arg1,_arg2,0,0,0); \ } while (0) @@ -179,15 +179,14 @@ typedef #define DO_CREQ_v_WWW(_creqF, _ty1F,_arg1F, \ _ty2F,_arg2F, _ty3F, _arg3F) \ do { \ - long _unused_res __attribute__((unused)); \ - long _arg1, _arg2, _arg3; \ + long int _arg1, _arg2, _arg3; \ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \ /* assert(sizeof(_ty2F) == sizeof(long int)); */ \ /* assert(sizeof(_ty3F) == sizeof(long int)); */ \ _arg1 = (long int)(_arg1F); \ _arg2 = (long int)(_arg2F); \ _arg3 = (long int)(_arg3F); \ - VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ (_creqF), \ _arg1,_arg2,_arg3,0,0); \ } while (0) diff --git a/helgrind/hg_intercepts.c b/helgrind/hg_intercepts.c index a31dc0da44..798ee6cd81 100644 --- a/helgrind/hg_intercepts.c +++ b/helgrind/hg_intercepts.c @@ -86,25 +86,21 @@ #define DO_CREQ_v_W(_creqF, _ty1F,_arg1F) \ do { \ - Word _unused_res __attribute__((unused)); \ Word _arg1; \ assert(sizeof(_ty1F) == sizeof(Word)); \ _arg1 = (Word)(_arg1F); \ - VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \ - (_creqF), \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, (_creqF), \ _arg1, 0,0,0,0); \ } while (0) #define DO_CREQ_v_WW(_creqF, _ty1F,_arg1F, _ty2F,_arg2F) \ do { \ - Word _unused_res __attribute__((unused)); \ Word _arg1, _arg2; \ assert(sizeof(_ty1F) == sizeof(Word)); \ assert(sizeof(_ty2F) == sizeof(Word)); \ _arg1 = (Word)(_arg1F); \ _arg2 = (Word)(_arg2F); \ - VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \ - (_creqF), \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, (_creqF), \ _arg1,_arg2,0,0,0); \ } while (0) @@ -116,7 +112,7 @@ assert(sizeof(_ty2F) == sizeof(Word)); \ _arg1 = (Word)(_arg1F); \ _arg2 = (Word)(_arg2F); \ - VALGRIND_DO_CLIENT_REQUEST(_res, 2, \ + _res = VALGRIND_DO_CLIENT_REQUEST_EXPR(2, \ (_creqF), \ _arg1,_arg2,0,0,0); \ _resF = _res; \ @@ -125,7 +121,6 @@ #define DO_CREQ_v_WWW(_creqF, _ty1F,_arg1F, \ _ty2F,_arg2F, _ty3F, _arg3F) \ do { \ - Word _unused_res __attribute__((unused)); \ Word _arg1, _arg2, _arg3; \ assert(sizeof(_ty1F) == sizeof(Word)); \ assert(sizeof(_ty2F) == sizeof(Word)); \ @@ -133,8 +128,7 @@ _arg1 = (Word)(_arg1F); \ _arg2 = (Word)(_arg2F); \ _arg3 = (Word)(_arg3F); \ - VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \ - (_creqF), \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, (_creqF), \ _arg1,_arg2,_arg3,0,0); \ } while (0) diff --git a/include/valgrind.h b/include/valgrind.h index 10f3d9bc88..631dafdc5d 100644 --- a/include/valgrind.h +++ b/include/valgrind.h @@ -157,17 +157,31 @@ /* in here of use to end-users -- skip to the next section. */ /* ------------------------------------------------------------------ */ +/* + * VALGRIND_DO_CLIENT_REQUEST(): a statement that invokes a Valgrind client + * request. Accepts both pointers and integers as arguments. + * + * 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. + */ + +#define VALGRIND_DO_CLIENT_REQUEST(_zzq_rlval, _zzq_default, \ + _zzq_request, _zzq_arg1, _zzq_arg2, \ + _zzq_arg3, _zzq_arg4, _zzq_arg5) \ + { (_zzq_rlval) = VALGRIND_DO_CLIENT_REQUEST_EXPR((_zzq_default), \ + (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ + (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } + #if defined(NVALGRIND) /* Define NVALGRIND to completely remove the Valgrind magic sequence from the compiled code (analogous to NDEBUG's effects on assert()) */ -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - { \ - (_zzq_rlval) = (_zzq_default); \ - } + (_zzq_default) #else /* ! NVALGRIND */ @@ -221,10 +235,11 @@ typedef "roll $3, %%edi ; roll $13, %%edi\n\t" \ "roll $29, %%edi ; roll $19, %%edi\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - { volatile unsigned int _zzq_args[6]; \ + __extension__ \ + ({volatile unsigned int _zzq_args[6]; \ volatile unsigned int _zzq_result; \ _zzq_args[0] = (unsigned int)(_zzq_request); \ _zzq_args[1] = (unsigned int)(_zzq_arg1); \ @@ -239,8 +254,8 @@ typedef : "a" (&_zzq_args[0]), "0" (_zzq_default) \ : "cc", "memory" \ ); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -277,25 +292,36 @@ typedef __asm rol edi, 3 __asm rol edi, 13 \ __asm rol edi, 29 __asm rol edi, 19 -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - { volatile uintptr_t _zzq_args[6]; \ - volatile unsigned int _zzq_result; \ - _zzq_args[0] = (uintptr_t)(_zzq_request); \ - _zzq_args[1] = (uintptr_t)(_zzq_arg1); \ - _zzq_args[2] = (uintptr_t)(_zzq_arg2); \ - _zzq_args[3] = (uintptr_t)(_zzq_arg3); \ - _zzq_args[4] = (uintptr_t)(_zzq_arg4); \ - _zzq_args[5] = (uintptr_t)(_zzq_arg5); \ - __asm { __asm lea eax, _zzq_args __asm mov edx, _zzq_default \ - __SPECIAL_INSTRUCTION_PREAMBLE \ - /* %EDX = client_request ( %EAX ) */ \ - __asm xchg ebx,ebx \ - __asm mov _zzq_result, edx \ - } \ - _zzq_rlval = _zzq_result; \ - } + valgrind_do_client_request_expr((uintptr_t)(_zzq_default), \ + (uintptr_t)(_zzq_request), (uintptr_t)(_zzq_arg1), \ + (uintptr_t)(_zzq_arg2), (uintptr_t)(_zzq_arg3), \ + (uintptr_t)(_zzq_arg4), (uintptr_t)(_zzq_arg5)) + +static __inline uintptr_t +valgrind_do_client_request_expr(uintptr_t _zzq_default, uintptr_t _zzq_request, + uintptr_t _zzq_arg1, uintptr_t _zzq_arg2, + uintptr_t _zzq_arg3, uintptr_t _zzq_arg4, + uintptr_t _zzq_arg5) +{ + volatile uintptr_t _zzq_args[6]; + volatile unsigned int _zzq_result; + _zzq_args[0] = (uintptr_t)(_zzq_request); + _zzq_args[1] = (uintptr_t)(_zzq_arg1); + _zzq_args[2] = (uintptr_t)(_zzq_arg2); + _zzq_args[3] = (uintptr_t)(_zzq_arg3); + _zzq_args[4] = (uintptr_t)(_zzq_arg4); + _zzq_args[5] = (uintptr_t)(_zzq_arg5); + __asm { __asm lea eax, _zzq_args __asm mov edx, _zzq_default + __SPECIAL_INSTRUCTION_PREAMBLE + /* %EDX = client_request ( %EAX ) */ + __asm xchg ebx,ebx + __asm mov _zzq_result, edx + } + return _zzq_result; +} #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -330,10 +356,11 @@ typedef "rolq $3, %%rdi ; rolq $13, %%rdi\n\t" \ "rolq $61, %%rdi ; rolq $51, %%rdi\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - { volatile unsigned long long int _zzq_args[6]; \ + __extension__ \ + ({ volatile unsigned long long int _zzq_args[6]; \ volatile unsigned long long int _zzq_result; \ _zzq_args[0] = (unsigned long long int)(_zzq_request); \ _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \ @@ -348,8 +375,8 @@ typedef : "a" (&_zzq_args[0]), "0" (_zzq_default) \ : "cc", "memory" \ ); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -384,11 +411,12 @@ typedef "rlwinm 0,0,3,0,0 ; rlwinm 0,0,13,0,0\n\t" \ "rlwinm 0,0,29,0,0 ; rlwinm 0,0,19,0,0\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ \ - { unsigned int _zzq_args[6]; \ + __extension__ \ + ({ unsigned int _zzq_args[6]; \ unsigned int _zzq_result; \ unsigned int* _zzq_ptr; \ _zzq_args[0] = (unsigned int)(_zzq_request); \ @@ -407,8 +435,8 @@ typedef : "=b" (_zzq_result) \ : "b" (_zzq_default), "b" (_zzq_ptr) \ : "cc", "memory", "r3", "r4"); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -445,11 +473,12 @@ typedef "rotldi 0,0,3 ; rotldi 0,0,13\n\t" \ "rotldi 0,0,61 ; rotldi 0,0,51\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ \ - { unsigned long long int _zzq_args[6]; \ + __extension__ \ + ({ unsigned long long int _zzq_args[6]; \ register unsigned long long int _zzq_result __asm__("r3"); \ register unsigned long long int* _zzq_ptr __asm__("r4"); \ _zzq_args[0] = (unsigned long long int)(_zzq_request); \ @@ -465,8 +494,8 @@ typedef : "=r" (_zzq_result) \ : "0" (_zzq_default), "r" (_zzq_ptr) \ : "cc", "memory"); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -510,11 +539,12 @@ typedef "mov r12, r12, ror #3 ; mov r12, r12, ror #13 \n\t" \ "mov r12, r12, ror #29 ; mov r12, r12, ror #19 \n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ \ - { volatile unsigned int _zzq_args[6]; \ + __extension__ \ + ({volatile unsigned int _zzq_args[6]; \ volatile unsigned int _zzq_result; \ _zzq_args[0] = (unsigned int)(_zzq_request); \ _zzq_args[1] = (unsigned int)(_zzq_arg1); \ @@ -531,8 +561,8 @@ typedef : "=r" (_zzq_result) \ : "r" (_zzq_default), "r" (&_zzq_args[0]) \ : "cc","memory", "r3", "r4"); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -570,11 +600,12 @@ typedef "rlwinm 0,0,3,0,0 ; rlwinm 0,0,13,0,0\n\t" \ "rlwinm 0,0,29,0,0 ; rlwinm 0,0,19,0,0\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ \ - { unsigned int _zzq_args[7]; \ + __extension__ \ + ({ unsigned int _zzq_args[7]; \ register unsigned int _zzq_result; \ register unsigned int* _zzq_ptr; \ _zzq_args[0] = (unsigned int)(_zzq_request); \ @@ -594,8 +625,8 @@ typedef : "=b" (_zzq_result) \ : "b" (_zzq_ptr) \ : "r3", "r4", "cc", "memory"); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -642,11 +673,12 @@ typedef "rotldi 0,0,3 ; rotldi 0,0,13\n\t" \ "rotldi 0,0,61 ; rotldi 0,0,51\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ \ - { unsigned long long int _zzq_args[7]; \ + __extension__ \ + ({ unsigned long long int _zzq_args[7]; \ register unsigned long long int _zzq_result; \ register unsigned long long int* _zzq_ptr; \ _zzq_args[0] = (unsigned int long long)(_zzq_request); \ @@ -666,8 +698,8 @@ typedef : "=b" (_zzq_result) \ : "b" (_zzq_ptr) \ : "r3", "r4", "cc", "memory"); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -723,10 +755,11 @@ typedef #define __GET_NR_CONTEXT_CODE "lr 3,3\n\t" #define __CALL_NO_REDIR_CODE "lr 4,4\n\t" -#define VALGRIND_DO_CLIENT_REQUEST( \ - _zzq_rlval, _zzq_default, _zzq_request, \ +#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + _zzq_default, _zzq_request, \ _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - { volatile unsigned long long int _zzq_args[6]; \ + __extension__ \ + ({volatile unsigned long long int _zzq_args[6]; \ volatile unsigned long long int _zzq_result; \ _zzq_args[0] = (unsigned long long int)(_zzq_request); \ _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \ @@ -746,8 +779,8 @@ typedef : "a" (&_zzq_args[0]), "0" (_zzq_default) \ : "cc", "2", "3", "memory" \ ); \ - _zzq_rlval = _zzq_result; \ - } + _zzq_result; \ + }) #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \ { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \ @@ -4892,64 +4925,12 @@ typedef #endif -/* - * VALGRIND_DO_CLIENT_REQUEST_EXPR(): a C expression that invokes a Valgrind - * client request and whose value equals the client request result. - */ - -#if defined(NVALGRIND) - -#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ - _zzq_default, _zzq_request, \ - _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - (_zzq_default) - -#else /*defined(NVALGRIND)*/ - -#if defined(_MSC_VER) - -#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ - _zzq_default, _zzq_request, \ - _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - (vg_VALGRIND_DO_CLIENT_REQUEST_EXPR((uintptr_t)(_zzq_default), \ - (_zzq_request), (uintptr_t)(_zzq_arg1), (uintptr_t)(_zzq_arg2), \ - (uintptr_t)(_zzq_arg3), (uintptr_t)(_zzq_arg4), \ - (uintptr_t)(_zzq_arg5))) - -static __inline unsigned -vg_VALGRIND_DO_CLIENT_REQUEST_EXPR(uintptr_t _zzq_default, - unsigned _zzq_request, uintptr_t _zzq_arg1, - uintptr_t _zzq_arg2, uintptr_t _zzq_arg3, - uintptr_t _zzq_arg4, uintptr_t _zzq_arg5) -{ - unsigned _zzq_rlval; - VALGRIND_DO_CLIENT_REQUEST(_zzq_rlval, _zzq_default, _zzq_request, - _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5); - return _zzq_rlval; -} - -#else /*defined(_MSC_VER)*/ - -#define VALGRIND_DO_CLIENT_REQUEST_EXPR( \ - _zzq_default, _zzq_request, \ - _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - (__extension__({unsigned int _zzq_rlval; \ - VALGRIND_DO_CLIENT_REQUEST(_zzq_rlval, _zzq_default, _zzq_request, \ - _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \ - _zzq_rlval; \ - })) - -#endif /*defined(_MSC_VER)*/ - -#endif /*defined(NVALGRIND)*/ - - /* Returns the number of Valgrinds this code is running under. That is, 0 if running natively, 1 if running under Valgrind, 2 if running under Valgrind which is running under another Valgrind, etc. */ #define RUNNING_ON_VALGRIND \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ VG_USERREQ__RUNNING_ON_VALGRIND, \ 0, 0, 0, 0, 0) \ @@ -4959,11 +4940,9 @@ vg_VALGRIND_DO_CLIENT_REQUEST_EXPR(uintptr_t _zzq_default, 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 int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__DISCARD_TRANSLATIONS, \ - _qzz_addr, _qzz_len, 0, 0, 0); \ - } + _qzz_addr, _qzz_len, 0, 0, 0) /* These requests are for getting Valgrind itself to print something. @@ -4986,17 +4965,21 @@ VALGRIND_PRINTF(const char *format, ...) #if defined(NVALGRIND) return 0; #else /* NVALGRIND */ +#if defined(_MSC_VER) + uintptr_t _qzz_res; +#else unsigned long _qzz_res; +#endif va_list vargs; va_start(vargs, format); #if defined(_MSC_VER) - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, + _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRINTF_VALIST_BY_REF, (uintptr_t)format, (uintptr_t)&vargs, 0, 0, 0); #else - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, + _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRINTF_VALIST_BY_REF, (unsigned long)format, (unsigned long)&vargs, @@ -5020,17 +5003,21 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...) #if defined(NVALGRIND) return 0; #else /* NVALGRIND */ +#if defined(_MSC_VER) + uintptr_t _qzz_res; +#else unsigned long _qzz_res; +#endif va_list vargs; va_start(vargs, format); #if defined(_MSC_VER) - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, + _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRINTF_BACKTRACE_VALIST_BY_REF, (uintptr_t)format, (uintptr_t)&vargs, 0, 0, 0); #else - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, + _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__PRINTF_BACKTRACE_VALIST_BY_REF, (unsigned long)format, (unsigned long)&vargs, @@ -5066,58 +5053,39 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...) with a lot in the past. */ #define VALGRIND_NON_SIMD_CALL0(_qyy_fn) \ - __extension__ \ - ({unsigned long _qyy_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \ - VG_USERREQ__CLIENT_CALL0, \ - _qyy_fn, \ - 0, 0, 0, 0); \ - _qyy_res; \ - }) - -#define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \ - __extension__ \ - ({unsigned long _qyy_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \ - VG_USERREQ__CLIENT_CALL1, \ - _qyy_fn, \ - _qyy_arg1, 0, 0, 0); \ - _qyy_res; \ - }) - -#define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \ - __extension__ \ - ({unsigned long _qyy_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \ - VG_USERREQ__CLIENT_CALL2, \ - _qyy_fn, \ - _qyy_arg1, _qyy_arg2, 0, 0); \ - _qyy_res; \ - }) + VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \ + VG_USERREQ__CLIENT_CALL0, \ + _qyy_fn, \ + 0, 0, 0, 0) + +#define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \ + VG_USERREQ__CLIENT_CALL1, \ + _qyy_fn, \ + _qyy_arg1, 0, 0, 0) + +#define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \ + VG_USERREQ__CLIENT_CALL2, \ + _qyy_fn, \ + _qyy_arg1, _qyy_arg2, 0, 0) #define VALGRIND_NON_SIMD_CALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3) \ - __extension__ \ - ({unsigned long _qyy_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \ - VG_USERREQ__CLIENT_CALL3, \ - _qyy_fn, \ - _qyy_arg1, _qyy_arg2, \ - _qyy_arg3, 0); \ - _qyy_res; \ - }) + VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \ + VG_USERREQ__CLIENT_CALL3, \ + _qyy_fn, \ + _qyy_arg1, _qyy_arg2, \ + _qyy_arg3, 0) /* Counts the number of errors that have been recorded by a tool. Nb: the tool must record the errors with VG_(maybe_record_error)() or VG_(unique_error)() for them to be counted. */ #define VALGRIND_COUNT_ERRORS \ - __extension__ \ - ({unsigned int _qyy_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR( \ + 0 /* default return */, \ VG_USERREQ__COUNT_ERRORS, \ - 0, 0, 0, 0, 0); \ - _qyy_res; \ - }) + 0, 0, 0, 0, 0) /* Several Valgrind tools (Memcheck, Massif, Helgrind, DRD) rely on knowing when heap blocks are allocated in order to give accurate results. This @@ -5221,143 +5189,107 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...) Ignored if addr == 0. */ #define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MALLOCLIKE_BLOCK, \ - addr, sizeB, rzB, is_zeroed, 0); \ - } + 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) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__RESIZEINPLACE_BLOCK, \ - addr, oldSizeB, newSizeB, rzB, 0); \ - } + addr, oldSizeB, newSizeB, rzB, 0) /* See the comment for VALGRIND_MALLOCLIKE_BLOCK for details. Ignored if addr == 0. */ #define VALGRIND_FREELIKE_BLOCK(addr, rzB) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__FREELIKE_BLOCK, \ - addr, rzB, 0, 0, 0); \ - } + addr, rzB, 0, 0, 0) /* Create a memory pool. */ #define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__CREATE_MEMPOOL, \ - pool, rzB, is_zeroed, 0, 0); \ - } + pool, rzB, is_zeroed, 0, 0) /* Destroy a memory pool. */ #define VALGRIND_DESTROY_MEMPOOL(pool) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__DESTROY_MEMPOOL, \ - pool, 0, 0, 0, 0); \ - } + pool, 0, 0, 0, 0) /* Associate a piece of memory with a memory pool. */ #define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MEMPOOL_ALLOC, \ - pool, addr, size, 0, 0); \ - } + pool, addr, size, 0, 0) /* Disassociate a piece of memory from a memory pool. */ #define VALGRIND_MEMPOOL_FREE(pool, addr) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MEMPOOL_FREE, \ - pool, addr, 0, 0, 0); \ - } + pool, addr, 0, 0, 0) /* Disassociate any pieces outside a particular range. */ #define VALGRIND_MEMPOOL_TRIM(pool, addr, size) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MEMPOOL_TRIM, \ - pool, addr, size, 0, 0); \ - } + pool, addr, size, 0, 0) /* Resize and/or move a piece associated with a memory pool. */ #define VALGRIND_MOVE_MEMPOOL(poolA, poolB) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MOVE_MEMPOOL, \ - poolA, poolB, 0, 0, 0); \ - } + poolA, poolB, 0, 0, 0) /* Resize and/or move a piece associated with a memory pool. */ #define VALGRIND_MEMPOOL_CHANGE(pool, addrA, addrB, size) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MEMPOOL_CHANGE, \ - pool, addrA, addrB, size, 0); \ - } + pool, addrA, addrB, size, 0) /* Return 1 if a mempool exists, else 0. */ #define VALGRIND_MEMPOOL_EXISTS(pool) \ - __extension__ \ - ({unsigned int _qzz_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MEMPOOL_EXISTS, \ - pool, 0, 0, 0, 0); \ - _qzz_res; \ - }) + pool, 0, 0, 0, 0) /* Mark a piece of memory as being a stack. Returns a stack id. */ #define VALGRIND_STACK_REGISTER(start, end) \ - __extension__ \ - ({unsigned int _qzz_res; \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__STACK_REGISTER, \ - start, end, 0, 0, 0); \ - _qzz_res; \ - }) + start, end, 0, 0, 0) /* Unmark the piece of memory associated with a stack id as being a stack. */ #define VALGRIND_STACK_DEREGISTER(id) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__STACK_DEREGISTER, \ - id, 0, 0, 0, 0); \ - } + id, 0, 0, 0, 0) /* Change the start and end address of the stack id. */ #define VALGRIND_STACK_CHANGE(id, start, end) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__STACK_CHANGE, \ - id, start, end, 0, 0); \ - } + id, start, end, 0, 0) /* Load PDB debug info for Wine PE image_map. */ #define VALGRIND_LOAD_PDB_DEBUGINFO(fd, ptr, total_size, delta) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__LOAD_PDB_DEBUGINFO, \ - fd, ptr, total_size, delta, 0); \ - } + 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 result will be dumped in there and is guaranteed to be zero terminated. If no info is found, the first byte is set to zero. */ #define VALGRIND_MAP_IP_TO_SRCLOC(addr, buf64) \ - {unsigned int _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__MAP_IP_TO_SRCLOC, \ - addr, buf64, 0, 0, 0); \ - } + addr, buf64, 0, 0, 0) #undef PLAT_x86_linux diff --git a/memcheck/mc_replace_strmem.c b/memcheck/mc_replace_strmem.c index a06dea7a62..c45d270b04 100644 --- a/memcheck/mc_replace_strmem.c +++ b/memcheck/mc_replace_strmem.c @@ -89,13 +89,10 @@ Bool is_overlap ( void* dst, const void* src, SizeT dstlen, SizeT srclen ) // 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) \ -{ \ - Word unused_res __attribute__((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(unused_res, 0, \ - _VG_USERREQ__MEMCHECK_RECORD_OVERLAP_ERROR, \ - s, src, dst, len, 0); \ -} +#define RECORD_OVERLAP_ERROR(s, src, dst, len) \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + _VG_USERREQ__MEMCHECK_RECORD_OVERLAP_ERROR, \ + s, src, dst, len, 0) #define STRRCHR(soname, fnname) \ diff --git a/memcheck/memcheck.h b/memcheck/memcheck.h index 77629705a4..628511be0e 100644 --- a/memcheck/memcheck.h +++ b/memcheck/memcheck.h @@ -184,19 +184,15 @@ typedef /* Do a full memory leak check (like --leak-check=full) mid-execution. */ #define VALGRIND_DO_LEAK_CHECK \ - {unsigned long _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__DO_LEAK_CHECK, \ - 0, 0, 0, 0, 0); \ - } + 0, 0, 0, 0, 0) /* Do a summary memory leak check (like --leak-check=summary) mid-execution. */ -#define VALGRIND_DO_QUICK_LEAK_CHECK \ - {unsigned long _qzz_res __attribute((unused)); \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ +#define VALGRIND_DO_QUICK_LEAK_CHECK \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__DO_LEAK_CHECK, \ - 1, 0, 0, 0, 0); \ - } + 1, 0, 0, 0, 0) /* Return number of leaked, dubious, reachable and suppressed bytes found by all previous leak checks. They must be lvalues. */ @@ -207,10 +203,10 @@ typedef are. We also initialise '_qzz_leaked', etc because VG_USERREQ__COUNT_LEAKS doesn't mark the values returned as defined. */ \ - {unsigned long _qzz_res __attribute((unused)); \ + { \ unsigned long _qzz_leaked = 0, _qzz_dubious = 0; \ unsigned long _qzz_reachable = 0, _qzz_suppressed = 0; \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__COUNT_LEAKS, \ &_qzz_leaked, &_qzz_dubious, \ &_qzz_reachable, &_qzz_suppressed, 0); \ @@ -229,10 +225,10 @@ typedef are. We also initialise '_qzz_leaked', etc because VG_USERREQ__COUNT_LEAKS doesn't mark the values returned as defined. */ \ - {unsigned long _qzz_res __attribute((unused)); \ + { \ unsigned long _qzz_leaked = 0, _qzz_dubious = 0; \ unsigned long _qzz_reachable = 0, _qzz_suppressed = 0; \ - VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \ + VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__COUNT_LEAK_BLOCKS, \ &_qzz_leaked, &_qzz_dubious, \ &_qzz_reachable, &_qzz_suppressed, 0); \ @@ -253,7 +249,7 @@ typedef impossible to segfault your system by using this call. */ #define VALGRIND_GET_VBITS(zza,zzvbits,zznbytes) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__GET_VBITS, \ (const char*)(zza), \ (char*)(zzvbits), \ @@ -269,7 +265,7 @@ typedef impossible to segfault your system by using this call. */ #define VALGRIND_SET_VBITS(zza,zzvbits,zznbytes) \ - VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ + (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ VG_USERREQ__SET_VBITS, \ (const char*)(zza), \ (const char*)(zzvbits), \ diff --git a/memcheck/tests/linux/stack_changes.c b/memcheck/tests/linux/stack_changes.c index a978fc2b0f..de39cd7545 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); - VALGRIND_STACK_DEREGISTER(c1); + (void)VALGRIND_STACK_DEREGISTER(c1); //free(ctx1.uc_stack.ss_sp); - VALGRIND_STACK_DEREGISTER(c2); + (void)VALGRIND_STACK_DEREGISTER(c2); //free(ctx2.uc_stack.ss_sp); return 0; diff --git a/memcheck/tests/sh-mem-random.c b/memcheck/tests/sh-mem-random.c index bcf1fb1984..5564858394 100644 --- a/memcheck/tests/sh-mem-random.c +++ b/memcheck/tests/sh-mem-random.c @@ -53,9 +53,9 @@ U8 build(int size, U1 byte) // res is now considered partially defined, but we know exactly what its // value is (it happens to be the same as its metavalue). - VALGRIND_GET_VBITS(&res, &shres, 8); + (void)VALGRIND_GET_VBITS(&res, &shres, 8); res2 = res; - VALGRIND_MAKE_MEM_DEFINED(&res2, 8); // avoid the 'undefined' warning + (void)VALGRIND_MAKE_MEM_DEFINED(&res2, 8); // avoid the 'undefined' warning assert(res2 == shres); return res; } @@ -73,7 +73,7 @@ void check(U1* arr, int n, char* who) U1* shadow = malloc(n); U1 arr_i; U8 sum = 0; - VALGRIND_GET_VBITS(arr, shadow, n); + (void)VALGRIND_GET_VBITS(arr, shadow, n); for (i = 0; i < n; i++) { arr_i = make_defined(arr[i]); if (arr_i != shadow[i]) { diff --git a/memcheck/tests/sh-mem.c b/memcheck/tests/sh-mem.c index a0f018441a..f168c76020 100644 --- a/memcheck/tests/sh-mem.c +++ b/memcheck/tests/sh-mem.c @@ -54,9 +54,9 @@ U8 build(int size, U1 byte) // res is now considered partially defined, but we know exactly what its // value is (it happens to be the same as its metavalue). - VALGRIND_GET_VBITS(&res, &shres, 8); + (void)VALGRIND_GET_VBITS(&res, &shres, 8); res2 = res; - VALGRIND_MAKE_MEM_DEFINED(&res2, 8); // avoid the 'undefined' warning + (void)VALGRIND_MAKE_MEM_DEFINED(&res2, 8); // avoid the 'undefined' warning assert(res2 == shres); return res; } @@ -71,7 +71,7 @@ void check_all(U4 x, U4 y, U1 expected_byte, U1 expected_byte_alt, U1 sh[SZB_OF_a]; // Used for getting a[]'s V bits int i; - VALGRIND_GET_VBITS(a, sh, sizeof(a)); + (void)VALGRIND_GET_VBITS(a, sh, sizeof(a)); for (i = x; i < y; i++) { if ( expected_byte != sh[i] && expected_byte_alt != sh[i] ) { fprintf(stderr, "\n\nFAILURE: %s, offset %d, byte %d -- " diff --git a/none/tests/discard.c b/none/tests/discard.c index 3a1fc653dc..a5e6b5210a 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() ); - VALGRIND_DISCARD_TRANSLATIONS( (char*)(&fooble), + (void)VALGRIND_DISCARD_TRANSLATIONS( (char*)(&fooble), ((char*)(&someother)) - ((char*)(&fooble)) ); printf("fooble-2() = %d\n", fooble() ); return 0; -- 2.47.2