自学教程：C++ CALL_FN_W_WW函数代码示例

// pthread_rwlock_initPTH_FUNC(int, pthreadZurwlockZuinit, // pthread_rwlock_init              pthread_rwlock_t *rwl,              pthread_rwlockattr_t* attr){   int    ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   if (TRACE_PTH_FNS) {      fprintf(stderr, "<< pthread_rwl_init %p", rwl); fflush(stderr);   }   CALL_FN_W_WW(ret, fn, rwl,attr);   if (ret == 0 /*success*/) {      DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST,                  pthread_rwlock_t*,rwl);   } else {       DO_PthAPIerror( "pthread_rwlock_init", ret );   }   if (TRACE_PTH_FNS) {      fprintf(stderr, " :: rwl_init -> %d >>/n", ret);   }   return ret;}

// TODO: Can we do additional checks?CUresult I_WRAP_SONAME_FNNAME_ZZ(libcudaZdsoZa, cuArrayGetDescriptor)(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, CUarray hArray) {   OrigFn         fn;   CUresult       result;   CUcontext      ctx = NULL;   cgCtxListType  *ctxNode;   cgArrListType  *node;      VALGRIND_GET_ORIG_FN(fn);   cgLock();   CALL_FN_W_WW(result, fn, pArrayDescriptor, hArray);      // Determine context of current thread ..   cgGetCtx(&ctx);   // .. locate the respective ctx node ..   ctxNode = cgFindCtx(ctx);   // .. and finally locate the array in the context's list of arrays.   node = cgFindArr(ctxNode, hArray);      if (result == CUDA_SUCCESS && !node) {      VALGRIND_PRINTF("cuArrayGetDescriptor returned successfully, but array not found/n");      VALGRIND_PRINTF_BACKTRACE("   in cudagrind's internal list. Reason: Unknown/n");   } else if (result != CUDA_SUCCESS && node) {      VALGRIND_PRINTF("cuArrayGetDescriptor returned with error code: %d,/n", result);      VALGRIND_PRINTF_BACKTRACE("   but array is found in cudagrind's internal list./n");   } else if (result != CUDA_SUCCESS) {      VALGRIND_PRINTF("cuArrayGetDescriptor returned with error code: %d,/n", result);      VALGRIND_PRINTF_BACKTRACE("   possible reason: Wrong context or array not previously created./n");   }      cgUnlock();   return result;}

static __always_inlineint pthread_rwlock_init_intercept(pthread_rwlock_t* rwlock,                                  const pthread_rwlockattr_t* attr){   int   ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   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;}

UInt I_WRAP_SONAME_FNNAME_ZU(NONE,fn_2) ( UInt a1, UInt a2 ){   UInt r;   void* fn;   VALGRIND_GET_ORIG_FN(fn);   printf("fn_2  wrapper pre ( %d, %d )/n", (int)a1, (int)a2);   CALL_FN_W_WW(r, fn, a1, a2);   printf("fn_2  wrapper post1 = %d/n", (int)r);   CALL_FN_v_WW(fn, a1, a2);   printf("fn_2  wrapper post2 = %d/n", (int)r);   return r;}

// pthread_spin_initPTH_FUNC(int, pthreadZuspinZuinit, // pthread_spin_init         pthread_spinlock_t *spinlock,         int pshared){    int ret;    int res;    OrigFn fn;    VALGRIND_GET_ORIG_FN(fn);    VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__SPIN_INIT_OR_UNLOCK,                               spinlock, mutex_type_spinlock, 0, 0, 0);    CALL_FN_W_WW(ret, fn, spinlock, pshared);    return ret;}

static __always_inlineint sem_timedwait_intercept(sem_t *sem, const struct timespec *abs_timeout){   int   ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   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_STMT(VG_USERREQ__POST_SEM_WAIT,                                   sem, ret == 0, 0, 0, 0);   return ret;}

// QMutex::QMutex(RecursionMode) -- _ZN6QMutexC1ENS_13RecursionModeE,QT4CORE_FUNC(void, _ZN6QMutexC1ENS_13RecursionModeE,             void* mutex,             qt_mutex_mode mode){   int    ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_INIT,                                   mutex, qt_to_drd_mutex_type(mode), 0, 0, 0);   CALL_FN_W_WW(ret, fn, mutex, mode);   VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_INIT,                                   mutex, 0, 0, 0, 0);}

static __always_inlineint pthread_spin_init_intercept(pthread_spinlock_t *spinlock, int pshared){   int ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   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_STMT(VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK,                                   spinlock, 0, 0, 0, 0);   return ret;}

GOMP_FUNC(void, gompZubarrierZureinit, // gomp_barrier_reinit          gomp_barrier_t* barrier, unsigned count){    int    ret;    int    res;    OrigFn fn;    VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_INIT,                               barrier, gomp_barrier, count, 1, 0);    VALGRIND_GET_ORIG_FN(fn);    CALL_FN_W_WW(ret, fn, barrier, count);    VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_INIT,                               barrier, gomp_barrier, 0, 0, 0);}

static __always_inlineint 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_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_STMT(VG_USERREQ__POST_COND_WAIT,                                   cond, mutex, 1, 0, 0);   return ret;}

static __always_inlineint pthread_cond_init_intercept(pthread_cond_t* cond,                                const pthread_condattr_t* attr){   int ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   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_STMT(VG_USERREQ__POST_COND_INIT,                                   cond, 0, 0, 0, 0);   return ret;}

void* VG_WRAP_FUNCTION_ZZ(dyld, ZuZZN4dyld18fastBindLazySymbolEPP11ImageLoaderm)     (void** imageLoaderCache, uintptr_t lazyBindingInfoOffset){   void* res;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();   CALL_FN_W_WW(res, fn, imageLoaderCache, lazyBindingInfoOffset);   ANNOTATE_IGNORE_READS_AND_WRITES_END();   return res;}

static __always_inlineint pthread_rwlock_timedwrlock_intercept(pthread_rwlock_t* rwlock,                                         const struct timespec *timeout){   int   ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__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,                                   rwlock, ret == 0, 0, 0, 0);   return ret;}

long I_WRAP_SONAME_FNNAME_ZU(NONE,foo) (long x, long y){	OrigFn fn;	VALGRIND_GET_ORIG_FN(fn);	printf("WRAPPER: foo(%ld, %ld);/n", x, y);	long result;	CALL_FN_W_WW(result, fn, x,y);	printf("WRAPPER: return %ld;/n", result);	return result;}

// pthread_rwlock_initPTH_FUNC(int,         pthreadZurwlockZuinitZa, // pthread_rwlock_init*         pthread_rwlock_t* rwlock,         const pthread_rwlockattr_t* attr){   int   ret;   int   res;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_INIT,                              rwlock, 0, 0, 0, 0);   CALL_FN_W_WW(ret, fn, rwlock, attr);   return ret;}

static __always_inlineint pthread_mutex_timedlock_intercept(pthread_mutex_t *mutex,                                      const struct timespec *abs_timeout){   int   ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   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_STMT(VG_USERREQ__POST_MUTEX_LOCK,                                   mutex, ret == 0, 0, 0, 0);   return ret;}

// pthread_mutex_initPTH_FUNC(int, pthreadZumutexZuinit,         pthread_mutex_t *mutex,         const pthread_mutexattr_t* attr){  int ret;  int res;  OrigFn fn;  int mt;  VALGRIND_GET_ORIG_FN(fn);  mt = PTHREAD_MUTEX_DEFAULT;  if (attr)    pthread_mutexattr_gettype(attr, &mt);  VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_INIT,                             mutex, pthread_to_drd_mutex_type(mt), 0, 0, 0);  CALL_FN_W_WW(ret, fn, mutex, attr);  VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_INIT,                             mutex, 0, 0, 0, 0);  return ret;}

static __always_inlineint pthread_once_intercept(pthread_once_t *once_control,                           void (*init_routine)(void)){   int ret;   OrigFn fn;   VALGRIND_GET_ORIG_FN(fn);   /*    * Ignore any data races triggered by the implementation of pthread_once().    * Necessary for Darwin. This is not necessary for Linux but doesn't have    * any known adverse effects.    */   DRD_IGNORE_VAR(*once_control);   ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();   CALL_FN_W_WW(ret, fn, once_control, init_routine);   ANNOTATE_IGNORE_READS_AND_WRITES_END();   DRD_STOP_IGNORING_VAR(*once_control);   return ret;}

static __always_inlineint pthread_mutex_init_intercept(pthread_mutex_t *mutex,                                 const pthread_mutexattr_t* attr){   int ret;   OrigFn fn;   int mt;   VALGRIND_GET_ORIG_FN(fn);   mt = PTHREAD_MUTEX_DEFAULT;   if (attr)      pthread_mutexattr_gettype(attr, &mt);   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_STMT(VG_USERREQ__POST_MUTEX_INIT,                                   mutex, 0, 0, 0, 0);   return ret;}