]> git.ipfire.org Git - thirdparty/valgrind.git/commitdiff
Fix #284384 (clang 3.1 -Wunused-value warnings in valgrind.h,
authorJulian Seward <jseward@acm.org>
Mon, 24 Oct 2011 13:21:57 +0000 (13:21 +0000)
committerJulian Seward <jseward@acm.org>
Mon, 24 Oct 2011 13:21:57 +0000 (13:21 +0000)
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

13 files changed:
callgrind/callgrind.h
coregrind/m_replacemalloc/vg_replace_malloc.c
coregrind/vg_preloaded.c
drd/drd.h
drd/drd_pthread_intercepts.c
drd/tests/rwlock_race.c
helgrind/helgrind.h
helgrind/hg_intercepts.c
include/valgrind.h
memcheck/mc_replace_strmem.c
memcheck/memcheck.h
memcheck/tests/linux/stack_changes.c
none/tests/discard.c

index 476db9799d2e31c358bf40466412295db2107218..752d0af61d8deacb8ed579723d27910d9b284bdd 100644 (file)
@@ -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 */
index 725b13ef088b739855f833c5693821305372fca9..06cb2f6897b3714fedab971d6a8b83550fa6a681 100644 (file)
@@ -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);
 }
 
index a16b3c82edc0256e0393a22b2ccd519515704659..24a8f71674fb6edd1314af78c5ec509f729f187c 100644 (file)
@@ -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;
 }
index 55f72279a385de2a7919442d776eb44f29635808..5f21aabcb7a23c34c940e84c7dd6dfef9aab23f4 100644 (file)
--- a/drd/drd.h
+++ b/drd/drd.h
 #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)
 
 /**
  * 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)
 
 /**
  * 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)
 
 /**
 #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);
 
 /**
  * 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)
 
 /**
  * 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);
 
 /**
  * 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)
 
 /**
 
 /* 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. */
  * 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. */
  * 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)
 
 /*@}*/
index 4dc631c6932f3212cb6d754961a1f4a9a2872bae..f34540f402afdc4e500f479b0c8bc3ab223fe5ce 100644 (file)
@@ -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;
 }
index 6650c81b987ca4a097078d2fea2bef9b481364f2..4a73bfc54e83e4f4bbed3e605bc66be3c3b2b73c 100644 (file)
@@ -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
 
index d59734ef47f3976d709beb5a29b87a1df69fc149..86458660496555bbc5a6f48fb969e321497188e0 100644 (file)
@@ -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)
index a30edfd169a6b0c90e456798c3ed1486ae0f8747..206221e2148944323a61adf93053412f350b94b0 100644 (file)
@@ -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)
 
       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)
 
       _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)
 
index 9d20fc945ac6062130c0ac8cbe8dc95218efc6d6..222a58e156323c6c183db5856690d6fea8d55a09 100644 (file)
  * 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,            \
                         (_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
index 7661a96b98669fdfafb78c149844f6d934caa9f3..d29dc5979169ff35941c3f673190f328a72ac310 100644 (file)
@@ -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)
 
index 984be3162f26834c3127d07236eb51fa71e6129f..68474b44186c68879716bf1d49715b8bade4ed4f 100644 (file)
@@ -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);    \
index de39cd7545749ac13dfd899865b630256d1554b2..a978fc2b0f3e1fe3b5348d3af44e6bd2b740e3fe 100644 (file)
@@ -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;
index a5e6b5210ab4d8258ebfd1d6adf51a24781f3dd0..3a1fc653dc209c24dbfb47976280a5a43c041da6 100644 (file)
@@ -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;