return True;
default:
+ VG_(message)(Vg_UserMsg,
+ "Warning: unknown cachegrind client request code %llx\n",
+ (ULong)args[0]);
return False;
}
}
return handled;
}
default:
+ VG_(message)(Vg_UserMsg,
+ "Warning: unknown callgrind client request code %llx\n",
+ (ULong)args[0]);
return False;
}
static Bool dh_handle_client_request(ThreadId tid, UWord* arg, UWord* ret)
{
+ if (!VG_IS_TOOL_USERREQ('D','H',arg[0]))
+ return False;
+
switch (arg[0]) {
case VG_USERREQ__DHAT_AD_HOC_EVENT: {
if (clo_mode != AdHoc) {
}
default:
- VG_(message)(
- Vg_UserMsg,
- "Warning: unknown DHAT client request code %llx\n",
- (ULong)arg[0]
+ VG_(message)(Vg_UserMsg,
+ "Warning: unknown DHAT client request code %llx\n",
+ (ULong)arg[0]
);
+
return False;
}
}
UWord result = 0;
const DrdThreadId drd_tid = DRD_(thread_get_running_tid)();
+ if (!VG_IS_TOOL_USERREQ('D','R',arg[0])
+ && !VG_IS_TOOL_USERREQ('D','r',arg[0])
+ && !VG_IS_TOOL_USERREQ('H','G',arg[0])
+ && VG_USERREQ__MALLOCLIKE_BLOCK != arg[0]
+ && VG_USERREQ__RESIZEINPLACE_BLOCK != arg[0]
+ && VG_USERREQ__FREELIKE_BLOCK != arg[0]
+#if defined(VGO_solaris)
+ && VG_USERREQ_DRD_RTLD_BIND_GUARD != arg[0]
+ && VG_USERREQ_DRD_RTLD_BIND_CLEAR != arg[0]
+#endif /* VGO_solaris */
+ && VG_USERREQ__GDB_MONITOR_COMMAND != arg[0]) {
+ return False;
+ }
+
tl_assert(vg_tid == VG_(get_running_tid)());
tl_assert(DRD_(VgThreadIdToDrdThreadId)(vg_tid) == drd_tid
|| (VG_USERREQ__GDB_MONITOR_COMMAND == arg[0]
DRD_(semaphore_pre_post)(drd_tid, arg[1]);
break;
- case VG_USERREQ__SET_PTHREAD_COND_INITIALIZER:
+ case VG_USERREQ_DRD_SET_PTHREAD_COND_INITIALIZER:
DRD_(pthread_cond_initializer) = (Addr)arg[1];
DRD_(pthread_cond_initializer_size) = arg[2];
break;
- case VG_USERREQ__DRD_START_NEW_SEGMENT:
+ case VG_USERREQ_DRD_START_NEW_SEGMENT:
DRD_(thread_new_segment)(DRD_(PtThreadIdToDrdThreadId)(arg[1]));
break;
DRD_(thread_set_record_stores)(drd_tid, arg[1]);
break;
- case VG_USERREQ__SET_PTHREADID:
+ case VG_USERREQ_DRD_SET_PTHREADID:
// pthread_self() returns 0 for programs not linked with libpthread.so.
if (arg[1] != INVALID_POSIX_THREADID)
DRD_(thread_set_pthreadid)(drd_tid, arg[1]);
break;
- case VG_USERREQ__SET_JOINABLE:
+ case VG_USERREQ_DRD_SET_JOINABLE:
{
const DrdThreadId drd_joinable = DRD_(PtThreadIdToDrdThreadId)(arg[1]);
if (drd_joinable != DRD_INVALID_THREADID)
break;
}
- case VG_USERREQ__ENTERING_PTHREAD_CREATE:
+ case VG_USERREQ_DRD_ENTERING_PTHREAD_CREATE:
DRD_(thread_entering_pthread_create)(drd_tid);
break;
- case VG_USERREQ__LEFT_PTHREAD_CREATE:
+ case VG_USERREQ_DRD_LEFT_PTHREAD_CREATE:
DRD_(thread_left_pthread_create)(drd_tid);
break;
- case VG_USERREQ__POST_THREAD_JOIN:
+ case VG_USERREQ_DRD_POST_THREAD_JOIN:
{
const DrdThreadId thread_to_join = DRD_(PtThreadIdToDrdThreadId)(arg[1]);
if (thread_to_join == DRD_INVALID_THREADID)
break;
}
- case VG_USERREQ__PRE_THREAD_CANCEL:
+ case VG_USERREQ_DRD_PRE_THREAD_CANCEL:
{
const DrdThreadId thread_to_cancel =DRD_(PtThreadIdToDrdThreadId)(arg[1]);
if (thread_to_cancel == DRD_INVALID_THREADID)
break;
}
- case VG_USERREQ__POST_THREAD_CANCEL:
+ case VG_USERREQ_DRD_POST_THREAD_CANCEL:
break;
- case VG_USERREQ__PRE_MUTEX_INIT:
+ case VG_USERREQ_DRD_PRE_MUTEX_INIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(mutex_init)(arg[1], arg[2]);
break;
- case VG_USERREQ__POST_MUTEX_INIT:
+ case VG_USERREQ_DRD_POST_MUTEX_INIT:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_MUTEX_DESTROY:
+ case VG_USERREQ_DRD_PRE_MUTEX_DESTROY:
DRD_(thread_enter_synchr)(drd_tid);
break;
- case VG_USERREQ__POST_MUTEX_DESTROY:
+ case VG_USERREQ_DRD_POST_MUTEX_DESTROY:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(mutex_post_destroy)(arg[1]);
break;
- case VG_USERREQ__PRE_MUTEX_LOCK:
+ case VG_USERREQ_DRD_PRE_MUTEX_LOCK:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(mutex_pre_lock)(arg[1], arg[2], arg[3]);
break;
- case VG_USERREQ__POST_MUTEX_LOCK:
+ case VG_USERREQ_DRD_POST_MUTEX_LOCK:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(mutex_post_lock)(arg[1], arg[2], False/*post_cond_wait*/);
break;
- case VG_USERREQ__PRE_MUTEX_UNLOCK:
+ case VG_USERREQ_DRD_PRE_MUTEX_UNLOCK:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(mutex_unlock)(arg[1], arg[2]);
break;
- case VG_USERREQ__POST_MUTEX_UNLOCK:
+ case VG_USERREQ_DRD_POST_MUTEX_UNLOCK:
DRD_(thread_leave_synchr)(drd_tid);
break;
DRD_(mutex_ignore_ordering)(arg[1]);
break;
- case VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK:
+ case VG_USERREQ_DRD_PRE_SPIN_INIT_OR_UNLOCK:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(spinlock_init_or_unlock)(arg[1]);
break;
- case VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK:
+ case VG_USERREQ_DRD_POST_SPIN_INIT_OR_UNLOCK:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_COND_INIT:
+ case VG_USERREQ_DRD_PRE_COND_INIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(cond_pre_init)(arg[1]);
break;
- case VG_USERREQ__POST_COND_INIT:
+ case VG_USERREQ_DRD_POST_COND_INIT:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_COND_DESTROY:
+ case VG_USERREQ_DRD_PRE_COND_DESTROY:
DRD_(thread_enter_synchr)(drd_tid);
break;
- case VG_USERREQ__POST_COND_DESTROY:
+ case VG_USERREQ_DRD_POST_COND_DESTROY:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(cond_post_destroy)(arg[1], arg[2]);
break;
- case VG_USERREQ__PRE_COND_WAIT:
+ case VG_USERREQ_DRD_PRE_COND_WAIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
{
const Addr cond = arg[1];
}
break;
- case VG_USERREQ__POST_COND_WAIT:
+ case VG_USERREQ_DRD_POST_COND_WAIT:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
{
const Addr cond = arg[1];
}
break;
- case VG_USERREQ__PRE_COND_SIGNAL:
+ case VG_USERREQ_DRD_PRE_COND_SIGNAL:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(cond_pre_signal)(arg[1]);
break;
- case VG_USERREQ__POST_COND_SIGNAL:
+ case VG_USERREQ_DRD_POST_COND_SIGNAL:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_COND_BROADCAST:
+ case VG_USERREQ_DRD_PRE_COND_BROADCAST:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(cond_pre_broadcast)(arg[1]);
break;
- case VG_USERREQ__POST_COND_BROADCAST:
+ case VG_USERREQ_DRD_POST_COND_BROADCAST:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_SEM_INIT:
+ case VG_USERREQ_DRD_PRE_SEM_INIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(semaphore_init)(arg[1], arg[2], arg[3]);
break;
- case VG_USERREQ__POST_SEM_INIT:
+ case VG_USERREQ_DRD_POST_SEM_INIT:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_SEM_DESTROY:
+ case VG_USERREQ_DRD_PRE_SEM_DESTROY:
DRD_(thread_enter_synchr)(drd_tid);
break;
- case VG_USERREQ__POST_SEM_DESTROY:
+ case VG_USERREQ_DRD_POST_SEM_DESTROY:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(semaphore_destroy)(arg[1]);
break;
- case VG_USERREQ__PRE_SEM_OPEN:
+ case VG_USERREQ_DRD_PRE_SEM_OPEN:
DRD_(thread_enter_synchr)(drd_tid);
break;
- case VG_USERREQ__POST_SEM_OPEN:
+ case VG_USERREQ_DRD_POST_SEM_OPEN:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(semaphore_open)(arg[1], (HChar*)arg[2], arg[3], arg[4], arg[5]);
break;
- case VG_USERREQ__PRE_SEM_CLOSE:
+ case VG_USERREQ_DRD_PRE_SEM_CLOSE:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(semaphore_close)(arg[1]);
break;
- case VG_USERREQ__POST_SEM_CLOSE:
+ case VG_USERREQ_DRD_POST_SEM_CLOSE:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_SEM_WAIT:
+ case VG_USERREQ_DRD_PRE_SEM_WAIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(semaphore_pre_wait)(arg[1]);
break;
- case VG_USERREQ__POST_SEM_WAIT:
+ case VG_USERREQ_DRD_POST_SEM_WAIT:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(semaphore_post_wait)(drd_tid, arg[1], arg[2]);
break;
- case VG_USERREQ__PRE_SEM_POST:
+ case VG_USERREQ_DRD_PRE_SEM_POST:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(semaphore_pre_post)(drd_tid, arg[1]);
break;
- case VG_USERREQ__POST_SEM_POST:
+ case VG_USERREQ_DRD_POST_SEM_POST:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(semaphore_post_post)(drd_tid, arg[1], arg[2]);
break;
- case VG_USERREQ__PRE_BARRIER_INIT:
+ case VG_USERREQ_DRD_PRE_BARRIER_INIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(barrier_init)(arg[1], arg[2], arg[3], arg[4]);
break;
- case VG_USERREQ__POST_BARRIER_INIT:
+ case VG_USERREQ_DRD_POST_BARRIER_INIT:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_BARRIER_DESTROY:
+ case VG_USERREQ_DRD_PRE_BARRIER_DESTROY:
DRD_(thread_enter_synchr)(drd_tid);
break;
- case VG_USERREQ__POST_BARRIER_DESTROY:
+ case VG_USERREQ_DRD_POST_BARRIER_DESTROY:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(barrier_destroy)(arg[1], arg[2]);
break;
- case VG_USERREQ__PRE_BARRIER_WAIT:
+ case VG_USERREQ_DRD_PRE_BARRIER_WAIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(barrier_pre_wait)(drd_tid, arg[1], arg[2]);
break;
- case VG_USERREQ__POST_BARRIER_WAIT:
+ case VG_USERREQ_DRD_POST_BARRIER_WAIT:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(barrier_post_wait)(drd_tid, arg[1], arg[2], arg[3], arg[4]);
break;
- case VG_USERREQ__PRE_RWLOCK_INIT:
+ case VG_USERREQ_DRD_PRE_RWLOCK_INIT:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(rwlock_pre_init)(arg[1], pthread_rwlock);
break;
- case VG_USERREQ__POST_RWLOCK_INIT:
+ case VG_USERREQ_DRD_POST_RWLOCK_INIT:
DRD_(thread_leave_synchr)(drd_tid);
break;
- case VG_USERREQ__PRE_RWLOCK_DESTROY:
+ case VG_USERREQ_DRD_PRE_RWLOCK_DESTROY:
DRD_(thread_enter_synchr)(drd_tid);
break;
- case VG_USERREQ__POST_RWLOCK_DESTROY:
+ case VG_USERREQ_DRD_POST_RWLOCK_DESTROY:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(rwlock_post_destroy)(arg[1], pthread_rwlock);
break;
- case VG_USERREQ__PRE_RWLOCK_RDLOCK:
+ case VG_USERREQ_DRD_PRE_RWLOCK_RDLOCK:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(rwlock_pre_rdlock)(arg[1], pthread_rwlock);
break;
- case VG_USERREQ__POST_RWLOCK_RDLOCK:
+ case VG_USERREQ_DRD_POST_RWLOCK_RDLOCK:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(rwlock_post_rdlock)(arg[1], pthread_rwlock, arg[2]);
break;
- case VG_USERREQ__PRE_RWLOCK_WRLOCK:
+ case VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(rwlock_pre_wrlock)(arg[1], pthread_rwlock);
break;
- case VG_USERREQ__POST_RWLOCK_WRLOCK:
+ case VG_USERREQ_DRD_POST_RWLOCK_WRLOCK:
if (DRD_(thread_leave_synchr)(drd_tid) == 0)
DRD_(rwlock_post_wrlock)(arg[1], pthread_rwlock, arg[2]);
break;
- case VG_USERREQ__PRE_RWLOCK_UNLOCK:
+ case VG_USERREQ_DRD_PRE_RWLOCK_UNLOCK:
if (DRD_(thread_enter_synchr)(drd_tid) == 0)
DRD_(rwlock_pre_unlock)(arg[1], pthread_rwlock);
break;
- case VG_USERREQ__POST_RWLOCK_UNLOCK:
+ case VG_USERREQ_DRD_POST_RWLOCK_UNLOCK:
DRD_(thread_leave_synchr)(drd_tid);
break;
#endif /* VGO_solaris */
default:
-#if 0
- VG_(message)(Vg_DebugMsg, "Unrecognized client request 0x%lx 0x%lx",
- arg[0], arg[1]);
- tl_assert(0);
-#endif
+ if (VG_IS_TOOL_USERREQ('D','R',arg[0]) ||
+ VG_IS_TOOL_USERREQ('D','r',arg[0])) {
+ /* don't warn about any unhandled HG client reqs */
+ VG_(message)(Vg_UserMsg,
+ "Warning: unknown DRD client request code %llx\n",
+ (ULong)arg[0]);
+ }
return False;
}
/* Declare the address and size of a variable with value
* PTHREAD_COND_INITIALIZER.
*/
- VG_USERREQ__SET_PTHREAD_COND_INITIALIZER = VG_USERREQ_TOOL_BASE('D', 'r'),
+ VG_USERREQ_DRD_SET_PTHREAD_COND_INITIALIZER = VG_USERREQ_TOOL_BASE('D', 'r'),
/* args: address, size. */
/* To ask the drd tool to start a new segment in the specified thread. */
- VG_USERREQ__DRD_START_NEW_SEGMENT,
+ VG_USERREQ_DRD_START_NEW_SEGMENT,
/* args: POSIX thread ID. */
/* Tell drd the pthread_t of the running thread. */
- VG_USERREQ__SET_PTHREADID,
+ VG_USERREQ_DRD_SET_PTHREADID,
/* args: pthread_t. */
/* Ask drd that a the thread's state transition from */
/* VgTs_Zombie to VgTs_Empty is delayed until */
/* VG_USERREQ__POST_THREAD_JOIN is performed. */
- VG_USERREQ__SET_JOINABLE,
+ VG_USERREQ_DRD_SET_JOINABLE,
/* args: pthread_t, Bool */
/* Tell DRD that the calling thread is about to enter pthread_create(). */
- VG_USERREQ__ENTERING_PTHREAD_CREATE,
+ VG_USERREQ_DRD_ENTERING_PTHREAD_CREATE,
/* args: (none) */
/* Tell DRD that the calling thread has left pthread_create(). */
- VG_USERREQ__LEFT_PTHREAD_CREATE,
+ VG_USERREQ_DRD_LEFT_PTHREAD_CREATE,
/* args: (none) */
/* To notify drd that a thread finished because */
/* pthread_thread_join() was called on it. */
- VG_USERREQ__POST_THREAD_JOIN,
+ VG_USERREQ_DRD_POST_THREAD_JOIN,
/* args: pthread_t (joinee) */
/* To notify drd before a pthread_cancel call. */
- VG_USERREQ__PRE_THREAD_CANCEL,
+ VG_USERREQ_DRD_PRE_THREAD_CANCEL,
/* args: pthread_t */
/* To notify drd after a pthread_cancel call. */
- VG_USERREQ__POST_THREAD_CANCEL,
+ VG_USERREQ_DRD_POST_THREAD_CANCEL,
/* args: pthread_t, Bool */
/* to notify the drd tool of a pthread_mutex_init call. */
- VG_USERREQ__PRE_MUTEX_INIT,
+ VG_USERREQ_DRD_PRE_MUTEX_INIT,
/* args: Addr, MutexT */
/* to notify the drd tool of a pthread_mutex_init call. */
- VG_USERREQ__POST_MUTEX_INIT,
+ VG_USERREQ_DRD_POST_MUTEX_INIT,
/* args: Addr */
/* to notify the drd tool of a pthread_mutex_destroy call. */
- VG_USERREQ__PRE_MUTEX_DESTROY,
+ VG_USERREQ_DRD_PRE_MUTEX_DESTROY,
/* args: Addr */
/* to notify the drd tool of a pthread_mutex_destroy call. */
- VG_USERREQ__POST_MUTEX_DESTROY,
+ VG_USERREQ_DRD_POST_MUTEX_DESTROY,
/* args: Addr, MutexT */
/* to notify the drd tool of pthread_mutex_lock calls */
- VG_USERREQ__PRE_MUTEX_LOCK,
+ VG_USERREQ_DRD_PRE_MUTEX_LOCK,
/* args: Addr, MutexT, Bool */
/* to notify the drd tool of pthread_mutex_lock calls */
- VG_USERREQ__POST_MUTEX_LOCK,
+ VG_USERREQ_DRD_POST_MUTEX_LOCK,
/* args: Addr, Bool */
/* to notify the drd tool of pthread_mutex_unlock calls */
- VG_USERREQ__PRE_MUTEX_UNLOCK,
+ VG_USERREQ_DRD_PRE_MUTEX_UNLOCK,
/* args: Addr */
/* to notify the drd tool of pthread_mutex_unlock calls */
- VG_USERREQ__POST_MUTEX_UNLOCK,
+ VG_USERREQ_DRD_POST_MUTEX_UNLOCK,
/* args: Addr */
/* to notify the drd tool of a pthread_spin_init/pthread_spin_unlock call */
- VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK,
+ VG_USERREQ_DRD_PRE_SPIN_INIT_OR_UNLOCK,
/* args: Addr */
/* to notify the drd tool of a pthread_spin_init/pthread_spin_unlock call */
- VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK,
+ VG_USERREQ_DRD_POST_SPIN_INIT_OR_UNLOCK,
/* args: Addr */
/* to notify the drd tool of a pthread_cond_init call. */
- VG_USERREQ__PRE_COND_INIT,
+ VG_USERREQ_DRD_PRE_COND_INIT,
/* args: Addr */
/* to notify the drd tool of a pthread_cond_init call. */
- VG_USERREQ__POST_COND_INIT,
+ VG_USERREQ_DRD_POST_COND_INIT,
/* args: Addr */
/* to notify the drd tool of a pthread_cond_destroy call. */
- VG_USERREQ__PRE_COND_DESTROY,
+ VG_USERREQ_DRD_PRE_COND_DESTROY,
/* args: Addr */
/* to notify the drd tool of a pthread_cond_destroy call. */
- VG_USERREQ__POST_COND_DESTROY,
+ VG_USERREQ_DRD_POST_COND_DESTROY,
/* args: Addr cond, Bool destroy_succeeded */
- VG_USERREQ__PRE_COND_WAIT,
+ VG_USERREQ_DRD_PRE_COND_WAIT,
/* args: Addr cond, Addr mutex, MutexT mt */
- VG_USERREQ__POST_COND_WAIT,
+ VG_USERREQ_DRD_POST_COND_WAIT,
/* args: Addr cond, Addr mutex, Bool took_lock*/
- VG_USERREQ__PRE_COND_SIGNAL,
+ VG_USERREQ_DRD_PRE_COND_SIGNAL,
/* args: Addr cond */
- VG_USERREQ__POST_COND_SIGNAL,
+ VG_USERREQ_DRD_POST_COND_SIGNAL,
/* args: Addr cond */
- VG_USERREQ__PRE_COND_BROADCAST,
+ VG_USERREQ_DRD_PRE_COND_BROADCAST,
/* args: Addr cond */
- VG_USERREQ__POST_COND_BROADCAST,
+ VG_USERREQ_DRD_POST_COND_BROADCAST,
/* args: Addr cond */
/* To notify the drd tool of a sem_init call. */
- VG_USERREQ__PRE_SEM_INIT,
+ VG_USERREQ_DRD_PRE_SEM_INIT,
/* args: Addr sem, Word pshared, Word value */
/* To notify the drd tool of a sem_init call. */
- VG_USERREQ__POST_SEM_INIT,
+ VG_USERREQ_DRD_POST_SEM_INIT,
/* args: Addr sem */
/* To notify the drd tool of a sem_destroy call. */
- VG_USERREQ__PRE_SEM_DESTROY,
+ VG_USERREQ_DRD_PRE_SEM_DESTROY,
/* args: Addr sem */
/* To notify the drd tool of a sem_destroy call. */
- VG_USERREQ__POST_SEM_DESTROY,
+ VG_USERREQ_DRD_POST_SEM_DESTROY,
/* args: Addr sem */
/* To notify the drd tool of a sem_open call. */
- VG_USERREQ__PRE_SEM_OPEN,
+ VG_USERREQ_DRD_PRE_SEM_OPEN,
/* args: Addr name, Word oflag, Word mode, Word value */
/* To notify the drd tool of a sem_open call. */
- VG_USERREQ__POST_SEM_OPEN,
+ VG_USERREQ_DRD_POST_SEM_OPEN,
/* args: Addr sem, Word oflag, Word mode, Word value */
/* To notify the drd tool of a sem_close call. */
- VG_USERREQ__PRE_SEM_CLOSE,
+ VG_USERREQ_DRD_PRE_SEM_CLOSE,
/* args: Addr sem */
/* To notify the drd tool of a sem_close call. */
- VG_USERREQ__POST_SEM_CLOSE,
+ VG_USERREQ_DRD_POST_SEM_CLOSE,
/* args: Addr sem */
/* To notify the drd tool of a sem_wait call. */
- VG_USERREQ__PRE_SEM_WAIT,
+ VG_USERREQ_DRD_PRE_SEM_WAIT,
/* args: Addr sem */
/* To notify the drd tool of a sem_wait call. */
- VG_USERREQ__POST_SEM_WAIT,
+ VG_USERREQ_DRD_POST_SEM_WAIT,
/* args: Addr sem, Bool waited */
/* To notify the drd tool before a sem_post call. */
- VG_USERREQ__PRE_SEM_POST,
+ VG_USERREQ_DRD_PRE_SEM_POST,
/* args: Addr sem */
/* To notify the drd tool after a sem_post call. */
- VG_USERREQ__POST_SEM_POST,
+ VG_USERREQ_DRD_POST_SEM_POST,
/* args: Addr sem, Bool waited */
/* To notify the drd tool of a pthread_barrier_init call. */
- VG_USERREQ__PRE_BARRIER_INIT,
+ VG_USERREQ_DRD_PRE_BARRIER_INIT,
/* args: Addr barrier, BarrierT type, Word count, Bool reinit */
/* To notify the drd tool of a pthread_barrier_init call. */
- VG_USERREQ__POST_BARRIER_INIT,
+ VG_USERREQ_DRD_POST_BARRIER_INIT,
/* args: Addr barrier, BarrierT type */
/* To notify the drd tool of a pthread_barrier_destroy call. */
- VG_USERREQ__PRE_BARRIER_DESTROY,
+ VG_USERREQ_DRD_PRE_BARRIER_DESTROY,
/* args: Addr barrier, BarrierT type. */
/* To notify the drd tool of a pthread_barrier_destroy call. */
- VG_USERREQ__POST_BARRIER_DESTROY,
+ VG_USERREQ_DRD_POST_BARRIER_DESTROY,
/* args: Addr barrier, BarrierT type. */
/* To notify the drd tool of a pthread_barrier_wait call. */
- VG_USERREQ__PRE_BARRIER_WAIT,
+ VG_USERREQ_DRD_PRE_BARRIER_WAIT,
/* args: Addr barrier, BarrierT type. */
/* To notify the drd tool of a pthread_barrier_wait call. */
- VG_USERREQ__POST_BARRIER_WAIT,
+ VG_USERREQ_DRD_POST_BARRIER_WAIT,
/* args: Addr barrier, BarrierT type, Word has_waited, Word serializing */
/* To notify the drd tool of a pthread_rwlock_init call. */
- VG_USERREQ__PRE_RWLOCK_INIT,
+ VG_USERREQ_DRD_PRE_RWLOCK_INIT,
/* args: Addr rwlock */
/* To notify the drd tool of a pthread_rwlock_init call. */
- VG_USERREQ__POST_RWLOCK_INIT,
+ VG_USERREQ_DRD_POST_RWLOCK_INIT,
/* args: Addr rwlock */
/* To notify the drd tool of a pthread_rwlock_destroy call. */
- VG_USERREQ__PRE_RWLOCK_DESTROY,
+ VG_USERREQ_DRD_PRE_RWLOCK_DESTROY,
/* args: Addr rwlock, RwLockT */
/* To notify the drd tool of a pthread_rwlock_destroy call. */
- VG_USERREQ__POST_RWLOCK_DESTROY,
+ VG_USERREQ_DRD_POST_RWLOCK_DESTROY,
/* args: Addr rwlock, RwLockT */
/* To notify the drd tool of a pthread_rwlock_rdlock call. */
- VG_USERREQ__PRE_RWLOCK_RDLOCK,
+ VG_USERREQ_DRD_PRE_RWLOCK_RDLOCK,
/* args: Addr rwlock, RwLockT */
/* To notify the drd tool of a pthread_rwlock_rdlock call. */
- VG_USERREQ__POST_RWLOCK_RDLOCK,
+ VG_USERREQ_DRD_POST_RWLOCK_RDLOCK,
/* args: Addr rwlock, RwLockT, Bool took_lock */
/* To notify the drd tool of a pthread_rwlock_wrlock call. */
- VG_USERREQ__PRE_RWLOCK_WRLOCK,
+ VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK,
/* args: Addr rwlock, RwLockT */
/* To notify the drd tool of a pthread_rwlock_wrlock call. */
- VG_USERREQ__POST_RWLOCK_WRLOCK,
+ VG_USERREQ_DRD_POST_RWLOCK_WRLOCK,
/* args: Addr rwlock, RwLockT, Bool took_lock */
/* To notify the drd tool of a pthread_rwlock_unlock call. */
- VG_USERREQ__PRE_RWLOCK_UNLOCK,
+ VG_USERREQ_DRD_PRE_RWLOCK_UNLOCK,
/* args: Addr rwlock, RwLockT */
/* To notify the drd tool of a pthread_rwlock_unlock call. */
- VG_USERREQ__POST_RWLOCK_UNLOCK
+ VG_USERREQ_DRD_POST_RWLOCK_UNLOCK
/* args: Addr rwlock, RwLockT, Bool unlocked */
#if defined(VGO_solaris)
,
/* To notify the drd tool of a bind_guard call from runtime linker. */
- VG_USERREQ__RTLD_BIND_GUARD,
+ VG_USERREQ_DRD_RTLD_BIND_GUARD,
/* args: Int flags */
/* To notify the drd tool of a bind_clear call from runtime linker. */
- VG_USERREQ__RTLD_BIND_CLEAR
+ VG_USERREQ_DRD_RTLD_BIND_CLEAR
/* args: Int flags */
#endif /* VGO_solaris */
};
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
guard, mutex_type_cxa_guard, 0, 0, 0);
CALL_FN_W_W(ret, fn, guard);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
guard, 1, 0, 0, 0);
if (ret == 0) {
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_UNLOCK,
guard, mutex_type_cxa_guard, 0, 0, 0);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_UNLOCK,
guard, 0, 0, 0, 0);
}
return ret;
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_UNLOCK,
guard, mutex_type_cxa_guard, 0, 0, 0);
CALL_FN_W_W(ret, fn, guard);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_UNLOCK,
guard, 0, 0, 0, 0);
}
static void DRD_(set_joinable)(const pthread_t tid, const int joinable)
{
assert(joinable == 0 || joinable == 1);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__SET_JOINABLE,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_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_STMT(VG_USERREQ__ENTERING_PTHREAD_CREATE,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_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_STMT(VG_USERREQ__LEFT_PTHREAD_CREATE,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_LEFT_PTHREAD_CREATE,
0, 0, 0, 0, 0);
}
arg_ptr = (DrdPosixThreadArgs*)arg;
arg_copy = *arg_ptr;
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__SET_PTHREADID,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_SET_PTHREADID,
pthread_self(), 0, 0, 0, 0);
DRD_(set_joinable)(pthread_self(),
*/
static void DRD_(set_pthread_id)(void)
{
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__SET_PTHREADID,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_SET_PTHREADID,
pthread_self(), 0, 0, 0, 0);
}
DRD_(sema_destroy)(&wrapper_started);
- VALGRIND_DO_CLIENT_REQUEST_STMT(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;
DRD_(sema_destroy)(&wrapper_started);
- VALGRIND_DO_CLIENT_REQUEST_STMT(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;
*/
static __always_inline
int DRD_(_ti_bind_guard_intercept)(int flags) {
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__RTLD_BIND_GUARD,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_RTLD_BIND_GUARD,
flags, 0, 0, 0, 0);
return DRD_(rtld_bind_guard)(flags);
}
static __always_inline
int DRD_(_ti_bind_clear_intercept)(int flags) {
int ret = DRD_(rtld_bind_clear)(flags);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__RTLD_BIND_CLEAR,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_RTLD_BIND_CLEAR,
flags, 0, 0, 0, 0);
return ret;
}
CALL_FN_W_WW(ret, fn, pt_joinee, thread_return);
if (ret == 0)
{
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_THREAD_JOIN,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_THREAD_JOIN,
pt_joinee, 0, 0, 0, 0);
}
ANNOTATE_IGNORE_READS_AND_WRITES_END();
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_THREAD_CANCEL,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_THREAD_CANCEL,
pt_thread, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, pt_thread);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_THREAD_CANCEL,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_THREAD_CANCEL,
pt_thread, ret==0, 0, 0, 0);
return ret;
}
mt = PTHREAD_MUTEX_DEFAULT;
if (attr)
pthread_mutexattr_gettype(attr, &mt);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_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_STMT(VG_USERREQ__POST_MUTEX_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_INIT,
mutex, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_DESTROY,
mutex, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_DESTROY,
mutex, DRD_(mutex_type)(mutex), 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, DRD_(mutex_type)(mutex), 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, DRD_(mutex_type)(mutex), 1, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, DRD_(mutex_type)(mutex), 0, 0, 0);
CALL_FN_W_WW(ret, fn, mutex, abs_timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, DRD_(mutex_type)(mutex), 0, 0, 0);
CALL_FN_W_WWW(ret, fn, mutex, clockid, abs_timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_UNLOCK,
mutex, DRD_(mutex_type)(mutex), 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_UNLOCK,
mutex, 0, 0, 0, 0);
return ret;
}
{
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_UNLOCK,
mutex,
DRD_(mutex_type)((pthread_mutex_t *) mutex),
0, 0, 0);
CALL_FN_v_W(fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_UNLOCK,
mutex, 0, 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_INIT,
cond, 0, 0, 0, 0);
CALL_FN_W_WW(ret, fn, cond, attr);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_INIT,
cond, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_DESTROY,
cond, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, cond);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_DESTROY,
cond, ret==0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_WAIT,
cond, mutex, DRD_(mutex_type)(mutex), 0, 0);
CALL_FN_W_WW(ret, fn, cond, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_WAIT,
cond, mutex, 1, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_WAIT,
cond, mutex, DRD_(mutex_type)(mutex), 0, 0);
CALL_FN_W_WWW(ret, fn, cond, mutex, abstime);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_WAIT,
cond, mutex, 1, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_WAIT,
cond, mutex, DRD_(mutex_type)(mutex), 0, 0);
CALL_FN_W_WWWW(ret, fn, cond, mutex, clockid, abstime);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_WAIT,
cond, mutex, 1, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_SIGNAL,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_SIGNAL,
cond, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, cond);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_SIGNAL,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_SIGNAL,
cond, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_BROADCAST,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_COND_BROADCAST,
cond, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, cond);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_BROADCAST,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_COND_BROADCAST,
cond, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SPIN_INIT_OR_UNLOCK,
spinlock, 0, 0, 0, 0);
CALL_FN_W_WW(ret, fn, spinlock, pshared);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SPIN_INIT_OR_UNLOCK,
spinlock, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_DESTROY,
spinlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, spinlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_DESTROY,
spinlock, mutex_type_spinlock, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
spinlock, mutex_type_spinlock, 0, 0, 0);
CALL_FN_W_W(ret, fn, spinlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
spinlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
spinlock, mutex_type_spinlock, 0, 0, 0);
CALL_FN_W_W(ret, fn, spinlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
spinlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SPIN_INIT_OR_UNLOCK,
spinlock, mutex_type_spinlock, 0, 0, 0);
CALL_FN_W_W(ret, fn, spinlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SPIN_INIT_OR_UNLOCK,
spinlock, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_BARRIER_INIT,
barrier, pthread_barrier, count, 0, 0);
CALL_FN_W_WWW(ret, fn, barrier, attr, count);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_BARRIER_INIT,
barrier, pthread_barrier, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_BARRIER_DESTROY,
barrier, pthread_barrier, 0, 0, 0);
CALL_FN_W_W(ret, fn, barrier);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_BARRIER_DESTROY,
barrier, pthread_barrier, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_BARRIER_WAIT,
barrier, pthread_barrier, 0, 0, 0);
CALL_FN_W_W(ret, fn, barrier);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_BARRIER_WAIT,
barrier, pthread_barrier,
ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD,
ret == PTHREAD_BARRIER_SERIAL_THREAD, 0);
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_INIT,
sem, pshared, value, 0, 0);
CALL_FN_W_WWW(ret, fn, sem, pshared, value);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_INIT,
sem, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_DESTROY,
sem, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, sem);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_DESTROY,
sem, 0, 0, 0, 0);
return ret;
}
sem_t *ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_OPEN,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_OPEN,
name, oflag, mode, value, 0);
CALL_FN_W_WWWW(ret, fn, name, oflag, mode, value);
// To do: figure out why gcc 9.2.1 miscompiles this function if the printf()
// call below is left out.
printf("");
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_OPEN,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_OPEN,
ret != SEM_FAILED ? ret : 0,
name, oflag, mode, value);
return ret;
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_CLOSE,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_CLOSE,
sem, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, sem);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_CLOSE,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_CLOSE,
sem, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_WAIT,
sem, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, sem);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_WAIT,
sem, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_WAIT,
sem, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, sem);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_WAIT,
sem, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_WAIT,
sem, 0, 0, 0, 0);
CALL_FN_W_WW(ret, fn, sem, abs_timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_WAIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_WAIT,
sem, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_POST,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_SEM_POST,
sem, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, sem);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_POST,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_SEM_POST,
sem, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_INIT,
rwlock, 0, 0, 0, 0);
CALL_FN_W_WW(ret, fn, rwlock, attr);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_INIT,
rwlock, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_DESTROY,
rwlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_DESTROY,
rwlock, 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_RDLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_RDLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_WRLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
{
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_v_W(fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_WRLOCK,
rwlock, True /* took_lock */, 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_RDLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_WW(ret, fn, rwlock, timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_RDLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_RDLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_WWW(ret, fn, rwlock, clockid, timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_RDLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_WW(ret, fn, rwlock, timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_WRLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_WWW(ret, fn, rwlock, clockid, timeout);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_WRLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_RDLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_RDLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_RDLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_WRLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_WRLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_WRLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_RWLOCK_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_RWLOCK_UNLOCK,
rwlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, rwlock);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_RWLOCK_UNLOCK,
rwlock, ret == 0, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_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_STMT(VG_USERREQ__POST_MUTEX_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_INIT,
mutex, 0, 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_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_STMT(VG_USERREQ__POST_MUTEX_INIT,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_INIT,
mutex, 0, 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_DESTROY,
mutex, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_DESTROY,
mutex, mutex_type(mutex), 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_DESTROY,
mutex, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_DESTROY,
mutex, mutex_type(mutex), 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, mutex_type(mutex), 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, 1, 0, 0, 0);
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, mutex_type(mutex), 1, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, ret, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_LOCK,
mutex, mutex_type(mutex), 1, 0, 0);
CALL_FN_W_WW(ret, fn, mutex, timeout_ms);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_LOCK,
mutex, ret, 0, 0, 0);
return ret;
}
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_PRE_MUTEX_UNLOCK,
mutex, mutex_type(mutex), 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
- VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
+ VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ_DRD_POST_MUTEX_UNLOCK,
mutex, 0, 0, 0, 0);
}
default:
/* Unhandled Helgrind client request! */
- tl_assert2(0, "unhandled Helgrind client request 0x%lx",
- args[0]);
+ VG_(message)(Vg_UserMsg,
+ "Warning: unknown Helgrind client request code %llx\n",
+ (ULong)args[0]);
+ return False;
}
return True;
}
default:
- VG_(message)(
- Vg_UserMsg,
- "Warning: unknown memcheck client request code %llx\n",
- (ULong)arg[0]
- );
+ VG_(message)(Vg_UserMsg,
+ "Warning: unknown memcheck client request code %llx\n",
+ (ULong)arg[0]);
return False;
}
return True;
projects / thirdparty / valgrind.git / commitdiff
