helgrind/hg_intercepts.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- pthread intercepts for thread checking.                      ---*/
   4 /*---                                              hg_intercepts.c ---*/
   5 /*--------------------------------------------------------------------*/
   6
   7 /*
   8    This file is part of Helgrind, a Valgrind tool for detecting errors
   9    in threaded programs.
  10
  11    Copyright (C) 2007-2013 OpenWorks LLP
  12       info@open-works.co.uk
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation; either version 2 of the
  17    License, or (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful, but
  20    WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  27    02111-1307, USA.
  28
  29    The GNU General Public License is contained in the file COPYING.
  30
  31    Neither the names of the U.S. Department of Energy nor the
  32    University of California nor the names of its contributors may be
  33    used to endorse or promote products derived from this software
  34    without prior written permission.
  35 */
  36
  37 /* RUNS ON SIMULATED CPU
  38    Interceptors for pthread_* functions, so that tc_main can see
  39    significant thread events.
  40
  41    Important: when adding a function wrapper to this file, remember to
  42    add a test case to tc20_verifywrap.c.  A common cause of failure is
  43    for wrappers to not engage on different distros, and
  44    tc20_verifywrap essentially checks that each wrapper is really
  45    doing something.
  46 */
  47
  48 // DDD: for Darwin, need to have non-"@*"-suffixed versions for all pthread
  49 // functions that currently have them.
  50 // Note also, in the comments and code below, all Darwin symbols start
  51 // with a leading underscore, which is not shown either in the comments
  52 // nor in the redirect specs.
  53
  54
  55 #include "pub_tool_basics.h"
  56 #include "pub_tool_redir.h"
  57 #include "pub_tool_clreq.h"
  58 #include "helgrind.h"
  59 #include "config.h"
  60
  61 #define TRACE_PTH_FNS 0
  62 #define TRACE_QT4_FNS 0
  63
  64
  65 /*----------------------------------------------------------------*/
  66 /*---                                                          ---*/
  67 /*----------------------------------------------------------------*/
  68
  69 #define PTH_FUNC(ret_ty, f, args...) \
  70    ret_ty I_WRAP_SONAME_FNNAME_ZZ(VG_Z_LIBPTHREAD_SONAME,f)(args); \
  71    ret_ty I_WRAP_SONAME_FNNAME_ZZ(VG_Z_LIBPTHREAD_SONAME,f)(args)
  72
  73 // Do a client request.  These are macros rather than a functions so
  74 // as to avoid having an extra frame in stack traces.
  75
  76 // NB: these duplicate definitions in helgrind.h.  But here, we
  77 // can have better typing (Word etc) and assertions, whereas
  78 // in helgrind.h we can't.  Obviously it's important the two
  79 // sets of definitions are kept in sync.
  80
  81 // nuke the previous definitions
  82 #undef DO_CREQ_v_W
  83 #undef DO_CREQ_v_WW
  84 #undef DO_CREQ_W_WW
  85 #undef DO_CREQ_v_WWW
  86
  87 #define DO_CREQ_v_W(_creqF, _ty1F,_arg1F)                \
  88    do {                                                  \
  89       Word _arg1;                                        \
  90       assert(sizeof(_ty1F) == sizeof(Word));             \
  91       _arg1 = (Word)(_arg1F);                            \
  92       VALGRIND_DO_CLIENT_REQUEST_STMT((_creqF),          \
  93                                  _arg1, 0,0,0,0);        \
  94    } while (0)
  95
  96 #define DO_CREQ_v_WW(_creqF, _ty1F,_arg1F, _ty2F,_arg2F) \
  97    do {                                                  \
  98       Word _arg1, _arg2;                                 \
  99       assert(sizeof(_ty1F) == sizeof(Word));             \
 100       assert(sizeof(_ty2F) == sizeof(Word));             \
 101       _arg1 = (Word)(_arg1F);                            \
 102       _arg2 = (Word)(_arg2F);                            \
 103       VALGRIND_DO_CLIENT_REQUEST_STMT((_creqF),          \
 104                                  _arg1,_arg2,0,0,0);     \
 105    } while (0)
 106
 107 #define DO_CREQ_W_WW(_resF, _creqF, _ty1F,_arg1F,        \
 108                      _ty2F,_arg2F)                       \
 109    do {                                                  \
 110       Word _res, _arg1, _arg2;                           \
 111       assert(sizeof(_ty1F) == sizeof(Word));             \
 112       assert(sizeof(_ty2F) == sizeof(Word));             \
 113       _arg1 = (Word)(_arg1F);                            \
 114       _arg2 = (Word)(_arg2F);                            \
 115       _res = VALGRIND_DO_CLIENT_REQUEST_EXPR(2,          \
 116                                  (_creqF),               \
 117                                  _arg1,_arg2,0,0,0);     \
 118       _resF = _res;                                      \
 119    } while (0)
 120
 121 #define DO_CREQ_v_WWW(_creqF, _ty1F,_arg1F,              \
 122                       _ty2F,_arg2F, _ty3F, _arg3F)       \
 123    do {                                                  \
 124       Word _arg1, _arg2, _arg3;                          \
 125       assert(sizeof(_ty1F) == sizeof(Word));             \
 126       assert(sizeof(_ty2F) == sizeof(Word));             \
 127       assert(sizeof(_ty3F) == sizeof(Word));             \
 128       _arg1 = (Word)(_arg1F);                            \
 129       _arg2 = (Word)(_arg2F);                            \
 130       _arg3 = (Word)(_arg3F);                            \
 131       VALGRIND_DO_CLIENT_REQUEST_STMT((_creqF),          \
 132                                  _arg1,_arg2,_arg3,0,0); \
 133    } while (0)
 134
 135
 136 #define DO_PthAPIerror(_fnnameF, _errF)                  \
 137    do {                                                  \
 138       char* _fnname = (char*)(_fnnameF);                 \
 139       long  _err    = (long)(int)(_errF);                \
 140       const char* _errstr = lame_strerror(_err);         \
 141       DO_CREQ_v_WWW(_VG_USERREQ__HG_PTH_API_ERROR,       \
 142                     char*,_fnname,                       \
 143                     long,_err, char*,_errstr);           \
 144    } while (0)
 145
 146
 147 /* Needed for older glibcs (2.3 and older, at least) who don't
 148    otherwise "know" about pthread_rwlock_anything or about
 149    PTHREAD_MUTEX_RECURSIVE (amongst things). */
 150 #define _GNU_SOURCE 1
 151
 152 #include <stdio.h>
 153 #include <assert.h>
 154 #include <errno.h>
 155 #include <pthread.h>
 156
 157 /* A standalone memcmp. */
 158 __attribute__((noinline))
 159 static int my_memcmp ( const void* ptr1, const void* ptr2, size_t size)
 160 {
 161    unsigned char* uchar_ptr1 = (unsigned char*) ptr1;
 162    unsigned char* uchar_ptr2 = (unsigned char*) ptr2;
 163    size_t i;
 164    for (i = 0; i < size; ++i) {
 165       if (uchar_ptr1[i] != uchar_ptr2[i])
 166          return (uchar_ptr1[i] < uchar_ptr2[i]) ? -1 : 1;
 167    }
 168    return 0;
 169 }
 170
 171 /* A lame version of strerror which doesn't use the real libc
 172    strerror_r, since using the latter just generates endless more
 173    threading errors (glibc goes off and does tons of crap w.r.t.
 174    locales etc) */
 175 static const HChar* lame_strerror ( long err )
 176 {
 177    switch (err) {
 178       case EPERM:       return "EPERM: Operation not permitted";
 179       case ENOENT:      return "ENOENT: No such file or directory";
 180       case ESRCH:       return "ESRCH: No such process";
 181       case EINTR:       return "EINTR: Interrupted system call";
 182       case EBADF:       return "EBADF: Bad file number";
 183       case EAGAIN:      return "EAGAIN: Try again";
 184       case ENOMEM:      return "ENOMEM: Out of memory";
 185       case EACCES:      return "EACCES: Permission denied";
 186       case EFAULT:      return "EFAULT: Bad address";
 187       case EEXIST:      return "EEXIST: File exists";
 188       case EINVAL:      return "EINVAL: Invalid argument";
 189       case EMFILE:      return "EMFILE: Too many open files";
 190       case ENOSYS:      return "ENOSYS: Function not implemented";
 191       case EOVERFLOW:   return "EOVERFLOW: Value too large "
 192                                "for defined data type";
 193       case EBUSY:       return "EBUSY: Device or resource busy";
 194       case ETIMEDOUT:   return "ETIMEDOUT: Connection timed out";
 195       case EDEADLK:     return "EDEADLK: Resource deadlock would occur";
 196       case EOPNOTSUPP:  return "EOPNOTSUPP: Operation not supported on "
 197                                "transport endpoint"; /* honest, guv */
 198       default:          return "tc_intercepts.c: lame_strerror(): "
 199                                "unhandled case -- please fix me!";
 200    }
 201 }
 202
 203
 204 /*----------------------------------------------------------------*/
 205 /*--- pthread_create, pthread_join, pthread_exit               ---*/
 206 /*----------------------------------------------------------------*/
 207
 208 static void* mythread_wrapper ( void* xargsV )
 209 {
 210    volatile Word* xargs = (volatile Word*) xargsV;
 211    void*(*fn)(void*) = (void*(*)(void*))xargs[0];
 212    void* arg         = (void*)xargs[1];
 213    pthread_t me = pthread_self();
 214    /* Tell the tool what my pthread_t is. */
 215    DO_CREQ_v_W(_VG_USERREQ__HG_SET_MY_PTHREAD_T, pthread_t,me);
 216    /* allow the parent to proceed.  We can't let it proceed until
 217       we're ready because (1) we need to make sure it doesn't exit and
 218       hence deallocate xargs[] while we still need it, and (2) we
 219       don't want either parent nor child to proceed until the tool has
 220       been notified of the child's pthread_t.
 221
 222       Note that parent and child access args[] without a lock,
 223       effectively using args[2] as a spinlock in order to get the
 224       parent to wait until the child passes this point.  The parent
 225       disables checking on xargs[] before creating the child and
 226       re-enables it once the child goes past this point, so the user
 227       never sees the race.  The previous approach (suppressing the
 228       resulting error) was flawed, because it could leave shadow
 229       memory for args[] in a state in which subsequent use of it by
 230       the parent would report further races. */
 231    xargs[2] = 0;
 232    /* Now we can no longer safely use xargs[]. */
 233    return (void*) fn( (void*)arg );
 234 }
 235
 236 //-----------------------------------------------------------
 237 // glibc:  pthread_create@GLIBC_2.0
 238 // glibc:  pthread_create@@GLIBC_2.1
 239 // glibc:  pthread_create@@GLIBC_2.2.5
 240 // darwin: pthread_create
 241 // darwin: pthread_create_suspended_np (trapped)
 242 //
 243 /* ensure this has its own frame, so as to make it more distinguishable
 244    in suppressions */
 245 __attribute__((noinline))
 246 static int pthread_create_WRK(pthread_t *thread, const pthread_attr_t *attr,
 247                               void *(*start) (void *), void *arg)
 248 {
 249    int    ret;
 250    OrigFn fn;
 251    volatile Word xargs[3];
 252
 253    VALGRIND_GET_ORIG_FN(fn);
 254    if (TRACE_PTH_FNS) {
 255       fprintf(stderr, "<< pthread_create wrapper"); fflush(stderr);
 256    }
 257    xargs[0] = (Word)start;
 258    xargs[1] = (Word)arg;
 259    xargs[2] = 1; /* serves as a spinlock -- sigh */
 260    /* Disable checking on the spinlock and the two words used to
 261       convey args to the child.  Basically we need to make it appear
 262       as if the child never accessed this area, since merely
 263       suppressing the resulting races does not address the issue that
 264       that piece of the parent's stack winds up in the "wrong" state
 265       and therefore may give rise to mysterious races when the parent
 266       comes to re-use this piece of stack in some other frame. */
 267    VALGRIND_HG_DISABLE_CHECKING(&xargs, sizeof(xargs));
 268
 269    CALL_FN_W_WWWW(ret, fn, thread,attr,mythread_wrapper,&xargs[0]);
 270
 271    if (ret == 0) {
 272       /* we have to wait for the child to notify the tool of its
 273          pthread_t before continuing */
 274       while (xargs[2] != 0) {
 275          /* Do nothing.  We need to spin until the child writes to
 276             xargs[2].  However, that can lead to starvation in the
 277             child and very long delays (eg, tc19_shadowmem on
 278             ppc64-linux Fedora Core 6).  So yield the cpu if we can,
 279             to let the child run at the earliest available
 280             opportunity. */
 281          sched_yield();
 282       }
 283    } else {
 284       DO_PthAPIerror( "pthread_create", ret );
 285    }
 286
 287    /* Reenable checking on the area previously used to communicate
 288       with the child. */
 289    VALGRIND_HG_ENABLE_CHECKING(&xargs, sizeof(xargs));
 290
 291    if (TRACE_PTH_FNS) {
 292       fprintf(stderr, " :: pth_create -> %d >>\n", ret);
 293    }
 294    return ret;
 295 }
 296 #if defined(VGO_linux)
 297    PTH_FUNC(int, pthreadZucreateZAZa, // pthread_create@*
 298                  pthread_t *thread, const pthread_attr_t *attr,
 299                  void *(*start) (void *), void *arg) {
 300       return pthread_create_WRK(thread, attr, start, arg);
 301    }
 302 #elif defined(VGO_darwin)
 303    PTH_FUNC(int, pthreadZucreate, // pthread_create
 304                  pthread_t *thread, const pthread_attr_t *attr,
 305                  void *(*start) (void *), void *arg) {
 306       return pthread_create_WRK(thread, attr, start, arg);
 307    }
 308    PTH_FUNC(int, pthreadZucreateZuZa, // pthread_create_*
 309                  pthread_t *thread, const pthread_attr_t *attr,
 310                  void *(*start) (void *), void *arg) {
 311       // trap anything else
 312       assert(0);
 313    }
 314 #else
 315 #  error "Unsupported OS"
 316 #endif
 317
 318
 319 //-----------------------------------------------------------
 320 // glibc:  pthread_join
 321 // darwin: pthread_join
 322 // darwin: pthread_join$NOCANCEL$UNIX2003
 323 // darwin  pthread_join$UNIX2003
 324 __attribute__((noinline))
 325 static int pthread_join_WRK(pthread_t thread, void** value_pointer)
 326 {
 327    int ret;
 328    OrigFn fn;
 329    VALGRIND_GET_ORIG_FN(fn);
 330    if (TRACE_PTH_FNS) {
 331       fprintf(stderr, "<< pthread_join wrapper"); fflush(stderr);
 332    }
 333
 334    CALL_FN_W_WW(ret, fn, thread,value_pointer);
 335
 336    /* At least with NPTL as the thread library, this is safe because
 337       it is guaranteed (by NPTL) that the joiner will completely gone
 338       before pthread_join (the original) returns.  See email below.*/
 339    if (ret == 0 /*success*/) {
 340       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_JOIN_POST, pthread_t,thread);
 341    } else {
 342       DO_PthAPIerror( "pthread_join", ret );
 343    }
 344
 345    if (TRACE_PTH_FNS) {
 346       fprintf(stderr, " :: pth_join -> %d >>\n", ret);
 347    }
 348    return ret;
 349 }
 350 #if defined(VGO_linux)
 351    PTH_FUNC(int, pthreadZujoin, // pthread_join
 352             pthread_t thread, void** value_pointer) {
 353       return pthread_join_WRK(thread, value_pointer);
 354    }
 355 #elif defined(VGO_darwin)
 356    PTH_FUNC(int, pthreadZujoinZa, // pthread_join*
 357             pthread_t thread, void** value_pointer) {
 358       return pthread_join_WRK(thread, value_pointer);
 359    }
 360 #else
 361 #  error "Unsupported OS"
 362 #endif
 363
 364
 365 /* Behaviour of pthread_join on NPTL:
 366
 367 Me:
 368 I have a question re the NPTL pthread_join implementation.
 369
 370   Suppose I am the thread 'stayer'.
 371
 372   If I call pthread_join(quitter), is it guaranteed that the
 373   thread 'quitter' has really exited before pthread_join returns?
 374
 375   IOW, is it guaranteed that 'quitter' will not execute any further
 376   instructions after pthread_join returns?
 377
 378 I believe this is true based on the following analysis of
 379 glibc-2.5 sources.  However am not 100% sure and would appreciate
 380 confirmation.
 381
 382   'quitter' will be running start_thread() in nptl/pthread_create.c
 383
 384   The last action of start_thread() is to exit via
 385   __exit_thread_inline(0), which simply does sys_exit
 386   (nptl/pthread_create.c:403)
 387
 388   'stayer' meanwhile is waiting for lll_wait_tid (pd->tid)
 389   (call at nptl/pthread_join.c:89)
 390
 391   As per comment at nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h:536,
 392   lll_wait_tid will not return until kernel notifies via futex
 393   wakeup that 'quitter' has terminated.
 394
 395   Hence pthread_join cannot return until 'quitter' really has
 396   completely disappeared.
 397
 398 Drepper:
 399 >   As per comment at nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h:536,
 400 >   lll_wait_tid will not return until kernel notifies via futex
 401 >   wakeup that 'quitter' has terminated.
 402 That's the key.  The kernel resets the TID field after the thread is
 403 done.  No way the joiner can return before the thread is gone.
 404 */
 405
 406
 407 /*----------------------------------------------------------------*/
 408 /*--- pthread_mutex_t functions                                ---*/
 409 /*----------------------------------------------------------------*/
 410
 411 /* Handled:   pthread_mutex_init pthread_mutex_destroy
 412               pthread_mutex_lock
 413               pthread_mutex_trylock pthread_mutex_timedlock
 414               pthread_mutex_unlock
 415 */
 416
 417 //-----------------------------------------------------------
 418 // glibc:  pthread_mutex_init
 419 // darwin: pthread_mutex_init
 420 PTH_FUNC(int, pthreadZumutexZuinit, // pthread_mutex_init
 421               pthread_mutex_t *mutex,
 422               pthread_mutexattr_t* attr)
 423 {
 424    int    ret;
 425    long   mbRec;
 426    OrigFn fn;
 427    VALGRIND_GET_ORIG_FN(fn);
 428    if (TRACE_PTH_FNS) {
 429       fprintf(stderr, "<< pthread_mxinit %p", mutex); fflush(stderr);
 430    }
 431
 432    mbRec = 0;
 433    if (attr) {
 434       int ty, zzz;
 435       zzz = pthread_mutexattr_gettype(attr, &ty);
 436       if (zzz == 0 && ty == PTHREAD_MUTEX_RECURSIVE)
 437          mbRec = 1;
 438    }
 439
 440    CALL_FN_W_WW(ret, fn, mutex,attr);
 441
 442    if (ret == 0 /*success*/) {
 443       DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,
 444                    pthread_mutex_t*,mutex, long,mbRec);
 445    } else {
 446       DO_PthAPIerror( "pthread_mutex_init", ret );
 447    }
 448
 449    if (TRACE_PTH_FNS) {
 450       fprintf(stderr, " :: mxinit -> %d >>\n", ret);
 451    }
 452    return ret;
 453 }
 454
 455
 456 //-----------------------------------------------------------
 457 // glibc:  pthread_mutex_destroy
 458 // darwin: pthread_mutex_destroy
 459 PTH_FUNC(int, pthreadZumutexZudestroy, // pthread_mutex_destroy
 460               pthread_mutex_t *mutex)
 461 {
 462    int    ret;
 463    unsigned long mutex_is_init;
 464    OrigFn fn;
 465
 466    VALGRIND_GET_ORIG_FN(fn);
 467    if (TRACE_PTH_FNS) {
 468       fprintf(stderr, "<< pthread_mxdestroy %p", mutex); fflush(stderr);
 469    }
 470
 471    if (mutex != NULL) {
 472       static const pthread_mutex_t mutex_init = PTHREAD_MUTEX_INITIALIZER;
 473       mutex_is_init = my_memcmp(mutex, &mutex_init, sizeof(*mutex)) == 0;
 474    } else {
 475       mutex_is_init = 0;
 476    }
 477
 478    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE,
 479                 pthread_mutex_t*, mutex, unsigned long, mutex_is_init);
 480
 481    CALL_FN_W_W(ret, fn, mutex);
 482
 483    if (ret != 0) {
 484       DO_PthAPIerror( "pthread_mutex_destroy", ret );
 485    }
 486
 487    if (TRACE_PTH_FNS) {
 488       fprintf(stderr, " :: mxdestroy -> %d >>\n", ret);
 489    }
 490    return ret;
 491 }
 492
 493
 494 //-----------------------------------------------------------
 495 // glibc:  pthread_mutex_lock
 496 // darwin: pthread_mutex_lock
 497 PTH_FUNC(int, pthreadZumutexZulock, // pthread_mutex_lock
 498               pthread_mutex_t *mutex)
 499 {
 500    int    ret;
 501    OrigFn fn;
 502    VALGRIND_GET_ORIG_FN(fn);
 503    if (TRACE_PTH_FNS) {
 504       fprintf(stderr, "<< pthread_mxlock %p", mutex); fflush(stderr);
 505    }
 506
 507    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
 508                 pthread_mutex_t*,mutex, long,0/*!isTryLock*/);
 509
 510    CALL_FN_W_W(ret, fn, mutex);
 511
 512    /* There's a hole here: libpthread now knows the lock is locked,
 513       but the tool doesn't, so some other thread could run and detect
 514       that the lock has been acquired by someone (this thread).  Does
 515       this matter?  Not sure, but I don't think so. */
 516
 517    if (ret == 0 /*success*/) {
 518       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
 519                   pthread_mutex_t*,mutex);
 520    } else {
 521       DO_PthAPIerror( "pthread_mutex_lock", ret );
 522    }
 523
 524    if (TRACE_PTH_FNS) {
 525       fprintf(stderr, " :: mxlock -> %d >>\n", ret);
 526    }
 527    return ret;
 528 }
 529
 530
 531 //-----------------------------------------------------------
 532 // glibc:  pthread_mutex_trylock
 533 // darwin: pthread_mutex_trylock
 534 //
 535 // pthread_mutex_trylock.  The handling needed here is very similar
 536 // to that for pthread_mutex_lock, except that we need to tell
 537 // the pre-lock creq that this is a trylock-style operation, and
 538 // therefore not to complain if the lock is nonrecursive and
 539 // already locked by this thread -- because then it'll just fail
 540 // immediately with EBUSY.
 541 PTH_FUNC(int, pthreadZumutexZutrylock, // pthread_mutex_trylock
 542               pthread_mutex_t *mutex)
 543 {
 544    int    ret;
 545    OrigFn fn;
 546    VALGRIND_GET_ORIG_FN(fn);
 547    if (TRACE_PTH_FNS) {
 548       fprintf(stderr, "<< pthread_mxtrylock %p", mutex); fflush(stderr);
 549    }
 550
 551    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
 552                 pthread_mutex_t*,mutex, long,1/*isTryLock*/);
 553
 554    CALL_FN_W_W(ret, fn, mutex);
 555
 556    /* There's a hole here: libpthread now knows the lock is locked,
 557       but the tool doesn't, so some other thread could run and detect
 558       that the lock has been acquired by someone (this thread).  Does
 559       this matter?  Not sure, but I don't think so. */
 560
 561    if (ret == 0 /*success*/) {
 562       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
 563                   pthread_mutex_t*,mutex);
 564    } else {
 565       if (ret != EBUSY)
 566          DO_PthAPIerror( "pthread_mutex_trylock", ret );
 567    }
 568
 569    if (TRACE_PTH_FNS) {
 570       fprintf(stderr, " :: mxtrylock -> %d >>\n", ret);
 571    }
 572    return ret;
 573 }
 574
 575
 576 //-----------------------------------------------------------
 577 // glibc:  pthread_mutex_timedlock
 578 // darwin: (doesn't appear to exist)
 579 //
 580 // pthread_mutex_timedlock.  Identical logic to pthread_mutex_trylock.
 581 PTH_FUNC(int, pthreadZumutexZutimedlock, // pthread_mutex_timedlock
 582          pthread_mutex_t *mutex,
 583          void* timeout)
 584 {
 585    int    ret;
 586    OrigFn fn;
 587    VALGRIND_GET_ORIG_FN(fn);
 588    if (TRACE_PTH_FNS) {
 589       fprintf(stderr, "<< pthread_mxtimedlock %p %p", mutex, timeout);
 590       fflush(stderr);
 591    }
 592
 593    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
 594                 pthread_mutex_t*,mutex, long,1/*isTryLock-ish*/);
 595
 596    CALL_FN_W_WW(ret, fn, mutex,timeout);
 597
 598    /* There's a hole here: libpthread now knows the lock is locked,
 599       but the tool doesn't, so some other thread could run and detect
 600       that the lock has been acquired by someone (this thread).  Does
 601       this matter?  Not sure, but I don't think so. */
 602
 603    if (ret == 0 /*success*/) {
 604       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
 605                   pthread_mutex_t*,mutex);
 606    } else {
 607       if (ret != ETIMEDOUT)
 608          DO_PthAPIerror( "pthread_mutex_timedlock", ret );
 609    }
 610
 611    if (TRACE_PTH_FNS) {
 612       fprintf(stderr, " :: mxtimedlock -> %d >>\n", ret);
 613    }
 614    return ret;
 615 }
 616
 617
 618 //-----------------------------------------------------------
 619 // glibc:  pthread_mutex_unlock
 620 // darwin: pthread_mutex_unlock
 621 PTH_FUNC(int, pthreadZumutexZuunlock, // pthread_mutex_unlock
 622               pthread_mutex_t *mutex)
 623 {
 624    int    ret;
 625    OrigFn fn;
 626    VALGRIND_GET_ORIG_FN(fn);
 627
 628    if (TRACE_PTH_FNS) {
 629       fprintf(stderr, "<< pthread_mxunlk %p", mutex); fflush(stderr);
 630    }
 631
 632    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
 633                pthread_mutex_t*,mutex);
 634
 635    CALL_FN_W_W(ret, fn, mutex);
 636
 637    if (ret == 0 /*success*/) {
 638       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
 639                   pthread_mutex_t*,mutex);
 640    } else {
 641       DO_PthAPIerror( "pthread_mutex_unlock", ret );
 642    }
 643
 644    if (TRACE_PTH_FNS) {
 645       fprintf(stderr, " mxunlk -> %d >>\n", ret);
 646    }
 647    return ret;
 648 }
 649
 650
 651 /*----------------------------------------------------------------*/
 652 /*--- pthread_cond_t functions                                 ---*/
 653 /*----------------------------------------------------------------*/
 654
 655 /* Handled:   pthread_cond_wait pthread_cond_timedwait
 656               pthread_cond_signal pthread_cond_broadcast
 657               pthread_cond_init
 658               pthread_cond_destroy
 659 */
 660
 661 //-----------------------------------------------------------
 662 // glibc:  pthread_cond_wait@GLIBC_2.2.5
 663 // glibc:  pthread_cond_wait@@GLIBC_2.3.2
 664 // darwin: pthread_cond_wait
 665 // darwin: pthread_cond_wait$NOCANCEL$UNIX2003
 666 // darwin: pthread_cond_wait$UNIX2003
 667 //
 668 __attribute__((noinline))
 669 static int pthread_cond_wait_WRK(pthread_cond_t* cond,
 670                                  pthread_mutex_t* mutex)
 671 {
 672    int ret;
 673    OrigFn fn;
 674    unsigned long mutex_is_valid;
 675
 676    VALGRIND_GET_ORIG_FN(fn);
 677
 678    if (TRACE_PTH_FNS) {
 679       fprintf(stderr, "<< pthread_cond_wait %p %p", cond, mutex);
 680       fflush(stderr);
 681    }
 682
 683    /* Tell the tool a cond-wait is about to happen, so it can check
 684       for bogus argument values.  In return it tells us whether it
 685       thinks the mutex is valid or not. */
 686    DO_CREQ_W_WW(mutex_is_valid,
 687                 _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,
 688                 pthread_cond_t*,cond, pthread_mutex_t*,mutex);
 689    assert(mutex_is_valid == 1 || mutex_is_valid == 0);
 690
 691    /* Tell the tool we're about to drop the mutex.  This reflects the
 692       fact that in a cond_wait, we show up holding the mutex, and the
 693       call atomically drops the mutex and waits for the cv to be
 694       signalled. */
 695    if (mutex_is_valid) {
 696       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
 697                   pthread_mutex_t*,mutex);
 698    }
 699
 700    CALL_FN_W_WW(ret, fn, cond,mutex);
 701
 702    /* these conditionals look stupid, but compare w/ same logic for
 703       pthread_cond_timedwait below */
 704    if (ret == 0 && mutex_is_valid) {
 705       /* and now we have the mutex again */
 706       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
 707                   pthread_mutex_t*,mutex);
 708    }
 709
 710    if (ret == 0 && mutex_is_valid) {
 711       DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,
 712                     pthread_cond_t*,cond, pthread_mutex_t*,mutex, long,0);
 713    }
 714
 715    if (ret != 0) {
 716       DO_PthAPIerror( "pthread_cond_wait", ret );
 717    }
 718
 719    if (TRACE_PTH_FNS) {
 720       fprintf(stderr, " cowait -> %d >>\n", ret);
 721    }
 722
 723    return ret;
 724 }
 725 #if defined(VGO_linux)
 726    PTH_FUNC(int, pthreadZucondZuwaitZAZa, // pthread_cond_wait@*
 727                  pthread_cond_t* cond, pthread_mutex_t* mutex) {
 728       return pthread_cond_wait_WRK(cond, mutex);
 729    }
 730 #elif defined(VGO_darwin)
 731    PTH_FUNC(int, pthreadZucondZuwaitZa, // pthread_cond_wait*
 732                  pthread_cond_t* cond, pthread_mutex_t* mutex) {
 733       return pthread_cond_wait_WRK(cond, mutex);
 734    }
 735 #else
 736 #  error "Unsupported OS"
 737 #endif
 738
 739
 740 //-----------------------------------------------------------
 741 // glibc:  pthread_cond_timedwait@@GLIBC_2.3.2
 742 // glibc:  pthread_cond_timedwait@GLIBC_2.2.5
 743 // glibc:  pthread_cond_timedwait@GLIBC_2.0
 744 // darwin: pthread_cond_timedwait
 745 // darwin: pthread_cond_timedwait$NOCANCEL$UNIX2003
 746 // darwin: pthread_cond_timedwait$UNIX2003
 747 // darwin: pthread_cond_timedwait_relative_np (trapped)
 748 //
 749 __attribute__((noinline))
 750 static int pthread_cond_timedwait_WRK(pthread_cond_t* cond,
 751                                       pthread_mutex_t* mutex,
 752                                       struct timespec* abstime)
 753 {
 754    int ret;
 755    OrigFn fn;
 756    unsigned long mutex_is_valid;
 757    Bool abstime_is_valid;
 758    VALGRIND_GET_ORIG_FN(fn);
 759
 760    if (TRACE_PTH_FNS) {
 761       fprintf(stderr, "<< pthread_cond_timedwait %p %p %p",
 762                       cond, mutex, abstime);
 763       fflush(stderr);
 764    }
 765
 766    /* Tell the tool a cond-wait is about to happen, so it can check
 767       for bogus argument values.  In return it tells us whether it
 768       thinks the mutex is valid or not. */
 769    DO_CREQ_W_WW(mutex_is_valid,
 770                 _VG_USERREQ__HG_PTHREAD_COND_WAIT_PRE,
 771                 pthread_cond_t*,cond, pthread_mutex_t*,mutex);
 772    assert(mutex_is_valid == 1 || mutex_is_valid == 0);
 773
 774    abstime_is_valid = abstime->tv_nsec >= 0 && abstime->tv_nsec < 1000000000;
 775
 776    /* Tell the tool we're about to drop the mutex.  This reflects the
 777       fact that in a cond_wait, we show up holding the mutex, and the
 778       call atomically drops the mutex and waits for the cv to be
 779       signalled. */
 780    if (mutex_is_valid && abstime_is_valid) {
 781       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
 782                   pthread_mutex_t*,mutex);
 783    }
 784
 785    CALL_FN_W_WWW(ret, fn, cond,mutex,abstime);
 786
 787    if (!abstime_is_valid && ret != EINVAL) {
 788       DO_PthAPIerror("Bug in libpthread: pthread_cond_timedwait "
 789                      "invalid abstime did not cause"
 790                      " EINVAL", ret);
 791    }
 792
 793    if ((ret == 0 || ret == ETIMEDOUT) && mutex_is_valid) {
 794       /* and now we have the mutex again */
 795       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
 796                   pthread_mutex_t*,mutex);
 797    }
 798
 799    if ((ret == 0 || ret == ETIMEDOUT) && mutex_is_valid) {
 800       DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_COND_WAIT_POST,
 801                     pthread_cond_t*,cond, pthread_mutex_t*,mutex,
 802                     long,ret == ETIMEDOUT);
 803    }
 804
 805    if (ret != 0 && ret != ETIMEDOUT) {
 806       DO_PthAPIerror( "pthread_cond_timedwait", ret );
 807    }
 808
 809    if (TRACE_PTH_FNS) {
 810       fprintf(stderr, " cotimedwait -> %d >>\n", ret);
 811    }
 812
 813    return ret;
 814 }
 815 #if defined(VGO_linux)
 816    PTH_FUNC(int, pthreadZucondZutimedwaitZAZa, // pthread_cond_timedwait@*
 817                  pthread_cond_t* cond, pthread_mutex_t* mutex,
 818                  struct timespec* abstime) {
 819       return pthread_cond_timedwait_WRK(cond, mutex, abstime);
 820    }
 821 #elif defined(VGO_darwin)
 822    PTH_FUNC(int, pthreadZucondZutimedwait, // pthread_cond_timedwait
 823                  pthread_cond_t* cond, pthread_mutex_t* mutex,
 824                  struct timespec* abstime) {
 825       return pthread_cond_timedwait_WRK(cond, mutex, abstime);
 826    }
 827    PTH_FUNC(int, pthreadZucondZutimedwaitZDZa, // pthread_cond_timedwait$*
 828                  pthread_cond_t* cond, pthread_mutex_t* mutex,
 829                  struct timespec* abstime) {
 830       return pthread_cond_timedwait_WRK(cond, mutex, abstime);
 831    }
 832    PTH_FUNC(int, pthreadZucondZutimedwaitZuZa, // pthread_cond_timedwait_*
 833                  pthread_cond_t* cond, pthread_mutex_t* mutex,
 834                  struct timespec* abstime) {
 835       assert(0);
 836    }
 837 #else
 838 #  error "Unsupported OS"
 839 #endif
 840
 841
 842 //-----------------------------------------------------------
 843 // glibc:  pthread_cond_signal@GLIBC_2.0
 844 // glibc:  pthread_cond_signal@GLIBC_2.2.5
 845 // glibc:  pthread_cond_signal@@GLIBC_2.3.2
 846 // darwin: pthread_cond_signal
 847 // darwin: pthread_cond_signal_thread_np (don't intercept this)
 848 //
 849 __attribute__((noinline))
 850 static int pthread_cond_signal_WRK(pthread_cond_t* cond)
 851 {
 852    int ret;
 853    OrigFn fn;
 854    VALGRIND_GET_ORIG_FN(fn);
 855
 856    if (TRACE_PTH_FNS) {
 857       fprintf(stderr, "<< pthread_cond_signal %p", cond);
 858       fflush(stderr);
 859    }
 860
 861    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_SIGNAL_PRE,
 862                pthread_cond_t*,cond);
 863
 864    CALL_FN_W_W(ret, fn, cond);
 865
 866    if (ret != 0) {
 867       DO_PthAPIerror( "pthread_cond_signal", ret );
 868    }
 869
 870    if (TRACE_PTH_FNS) {
 871       fprintf(stderr, " cosig -> %d >>\n", ret);
 872    }
 873
 874    return ret;
 875 }
 876 #if defined(VGO_linux)
 877    PTH_FUNC(int, pthreadZucondZusignalZAZa, // pthread_cond_signal@*
 878                  pthread_cond_t* cond) {
 879       return pthread_cond_signal_WRK(cond);
 880    }
 881 #elif defined(VGO_darwin)
 882    PTH_FUNC(int, pthreadZucondZusignal, // pthread_cond_signal
 883                  pthread_cond_t* cond) {
 884       return pthread_cond_signal_WRK(cond);
 885    }
 886 #else
 887 #  error "Unsupported OS"
 888 #endif
 889
 890
 891 //-----------------------------------------------------------
 892 // glibc:  pthread_cond_broadcast@GLIBC_2.0
 893 // glibc:  pthread_cond_broadcast@GLIBC_2.2.5
 894 // glibc:  pthread_cond_broadcast@@GLIBC_2.3.2
 895 // darwin: pthread_cond_broadcast
 896 //
 897 // Note, this is pretty much identical, from a dependency-graph
 898 // point of view, with cond_signal, so the code is duplicated.
 899 // Maybe it should be commoned up.
 900 //
 901 __attribute__((noinline))
 902 static int pthread_cond_broadcast_WRK(pthread_cond_t* cond)
 903 {
 904    int ret;
 905    OrigFn fn;
 906    VALGRIND_GET_ORIG_FN(fn);
 907
 908    if (TRACE_PTH_FNS) {
 909       fprintf(stderr, "<< pthread_cond_broadcast %p", cond);
 910       fflush(stderr);
 911    }
 912
 913    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE,
 914                pthread_cond_t*,cond);
 915
 916    CALL_FN_W_W(ret, fn, cond);
 917
 918    if (ret != 0) {
 919       DO_PthAPIerror( "pthread_cond_broadcast", ret );
 920    }
 921
 922    if (TRACE_PTH_FNS) {
 923       fprintf(stderr, " cobro -> %d >>\n", ret);
 924    }
 925
 926    return ret;
 927 }
 928 #if defined(VGO_linux)
 929    PTH_FUNC(int, pthreadZucondZubroadcastZAZa, // pthread_cond_broadcast@*
 930                  pthread_cond_t* cond) {
 931       return pthread_cond_broadcast_WRK(cond);
 932    }
 933 #elif defined(VGO_darwin)
 934    PTH_FUNC(int, pthreadZucondZubroadcast, // pthread_cond_broadcast
 935                  pthread_cond_t* cond) {
 936       return pthread_cond_broadcast_WRK(cond);
 937    }
 938 #else
 939 #   error "Unsupported OS"
 940 #endif
 941
 942 // glibc:  pthread_cond_init@GLIBC_2.0
 943 // glibc:  pthread_cond_init@GLIBC_2.2.5
 944 // glibc:  pthread_cond_init@@GLIBC_2.3.2
 945 // darwin: pthread_cond_init
 946 // Easy way out: Handling of attr could have been messier.
 947 // It turns out that pthread_cond_init under linux ignores
 948 // all information in cond_attr, so do we.
 949 // FIXME: MacOS X?
 950 __attribute__((noinline))
 951 static int pthread_cond_init_WRK(pthread_cond_t* cond, pthread_condattr_t *cond_attr)
 952 {
 953    int ret;
 954    OrigFn fn;
 955    VALGRIND_GET_ORIG_FN(fn);
 956
 957    if (TRACE_PTH_FNS) {
 958       fprintf(stderr, "<< pthread_cond_init %p", cond);
 959       fflush(stderr);
 960    }
 961
 962    CALL_FN_W_WW(ret, fn, cond, cond_attr);
 963
 964    if (ret == 0) {
 965       DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_COND_INIT_POST,
 966                    pthread_cond_t*,cond, pthread_condattr_t*, cond_attr);
 967    } else {
 968       DO_PthAPIerror( "pthread_cond_init", ret );
 969    }
 970
 971    if (TRACE_PTH_FNS) {
 972       fprintf(stderr, " coinit -> %d >>\n", ret);
 973    }
 974
 975    return ret;
 976 }
 977 #if defined(VGO_linux)
 978    PTH_FUNC(int, pthreadZucondZuinitZAZa, // pthread_cond_init@*
 979             pthread_cond_t* cond, pthread_condattr_t* cond_attr) {
 980      return pthread_cond_init_WRK(cond, cond_attr);
 981    }
 982 #elif defined(VGO_darwin)
 983    PTH_FUNC(int, pthreadZucondZuinit, // pthread_cond_init
 984             pthread_cond_t* cond, pthread_condattr_t * cond_attr) {
 985      return pthread_cond_init_WRK(cond, cond_attr);
 986    }
 987 #else
 988 #  error "Unsupported OS"
 989 #endif
 990
 991
 992 //-----------------------------------------------------------
 993 // glibc:  pthread_cond_destroy@@GLIBC_2.3.2
 994 // glibc:  pthread_cond_destroy@GLIBC_2.2.5
 995 // glibc:  pthread_cond_destroy@GLIBC_2.0
 996 // darwin: pthread_cond_destroy
 997 //
 998 __attribute__((noinline))
 999 static int pthread_cond_destroy_WRK(pthread_cond_t* cond)
1000 {
1001    int ret;
1002    unsigned long cond_is_init;
1003    OrigFn fn;
1004
1005    VALGRIND_GET_ORIG_FN(fn);
1006
1007    if (TRACE_PTH_FNS) {
1008       fprintf(stderr, "<< pthread_cond_destroy %p", cond);
1009       fflush(stderr);
1010    }
1011
1012    if (cond != NULL) {
1013       const pthread_cond_t cond_init = PTHREAD_COND_INITIALIZER;
1014       cond_is_init = my_memcmp(cond, &cond_init, sizeof(*cond)) == 0;
1015    } else {
1016      cond_is_init = 0;
1017    }
1018
1019    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_COND_DESTROY_PRE,
1020                 pthread_cond_t*, cond, unsigned long, cond_is_init);
1021
1022    CALL_FN_W_W(ret, fn, cond);
1023
1024    if (ret != 0) {
1025       DO_PthAPIerror( "pthread_cond_destroy", ret );
1026    }
1027
1028    if (TRACE_PTH_FNS) {
1029       fprintf(stderr, " codestr -> %d >>\n", ret);
1030    }
1031
1032    return ret;
1033 }
1034 #if defined(VGO_linux)
1035    PTH_FUNC(int, pthreadZucondZudestroyZAZa, // pthread_cond_destroy@*
1036                  pthread_cond_t* cond) {
1037       return pthread_cond_destroy_WRK(cond);
1038    }
1039 #elif defined(VGO_darwin)
1040    PTH_FUNC(int, pthreadZucondZudestroy, // pthread_cond_destroy
1041                  pthread_cond_t* cond) {
1042       return pthread_cond_destroy_WRK(cond);
1043    }
1044 #else
1045 #  error "Unsupported OS"
1046 #endif
1047
1048
1049 /*----------------------------------------------------------------*/
1050 /*--- pthread_barrier_t functions                              ---*/
1051 /*----------------------------------------------------------------*/
1052
1053 #if defined(HAVE_PTHREAD_BARRIER_INIT)
1054
1055 /* Handled:   pthread_barrier_init
1056               pthread_barrier_wait
1057               pthread_barrier_destroy
1058
1059    Unhandled: pthread_barrierattr_destroy
1060               pthread_barrierattr_getpshared
1061               pthread_barrierattr_init
1062               pthread_barrierattr_setpshared
1063               -- are these important?
1064 */
1065
1066 //-----------------------------------------------------------
1067 // glibc:  pthread_barrier_init
1068 // darwin: (doesn't appear to exist)
1069 PTH_FUNC(int, pthreadZubarrierZuinit, // pthread_barrier_init
1070          pthread_barrier_t* bar,
1071          pthread_barrierattr_t* attr, unsigned long count)
1072 {
1073    int ret;
1074    OrigFn fn;
1075    VALGRIND_GET_ORIG_FN(fn);
1076
1077    if (TRACE_PTH_FNS) {
1078       fprintf(stderr, "<< pthread_barrier_init %p %p %lu",
1079                       bar, attr, count);
1080       fflush(stderr);
1081    }
1082
1083    DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE,
1084                  pthread_barrier_t*, bar,
1085                  unsigned long, count,
1086                  unsigned long, 0/*!resizable*/);
1087
1088    CALL_FN_W_WWW(ret, fn, bar,attr,count);
1089
1090    if (ret != 0) {
1091       DO_PthAPIerror( "pthread_barrier_init", ret );
1092    }
1093
1094    if (TRACE_PTH_FNS) {
1095       fprintf(stderr, "  pthread_barrier_init -> %d >>\n", ret);
1096    }
1097
1098    return ret;
1099 }
1100
1101
1102 //-----------------------------------------------------------
1103 // glibc:  pthread_barrier_wait
1104 // darwin: (doesn't appear to exist)
1105 PTH_FUNC(int, pthreadZubarrierZuwait, // pthread_barrier_wait
1106               pthread_barrier_t* bar)
1107 {
1108    int ret;
1109    OrigFn fn;
1110    VALGRIND_GET_ORIG_FN(fn);
1111
1112    if (TRACE_PTH_FNS) {
1113       fprintf(stderr, "<< pthread_barrier_wait %p", bar);
1114       fflush(stderr);
1115    }
1116
1117    /* That this works correctly, and doesn't screw up when a thread
1118       leaving the barrier races round to the front and re-enters while
1119       other threads are still leaving it, is quite subtle.  See
1120       comments in the handler for PTHREAD_BARRIER_WAIT_PRE in
1121       hg_main.c. */
1122    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_BARRIER_WAIT_PRE,
1123                pthread_barrier_t*,bar);
1124
1125    CALL_FN_W_W(ret, fn, bar);
1126
1127    if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD) {
1128       DO_PthAPIerror( "pthread_barrier_wait", ret );
1129    }
1130
1131    if (TRACE_PTH_FNS) {
1132       fprintf(stderr, "  pthread_barrier_wait -> %d >>\n", ret);
1133    }
1134
1135    return ret;
1136 }
1137
1138
1139 //-----------------------------------------------------------
1140 // glibc:  pthread_barrier_destroy
1141 // darwin: (doesn't appear to exist)
1142 PTH_FUNC(int, pthreadZubarrierZudestroy, // pthread_barrier_destroy
1143          pthread_barrier_t* bar)
1144 {
1145    int ret;
1146    OrigFn fn;
1147    VALGRIND_GET_ORIG_FN(fn);
1148
1149    if (TRACE_PTH_FNS) {
1150       fprintf(stderr, "<< pthread_barrier_destroy %p", bar);
1151       fflush(stderr);
1152    }
1153
1154    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_BARRIER_DESTROY_PRE,
1155                pthread_barrier_t*,bar);
1156
1157    CALL_FN_W_W(ret, fn, bar);
1158
1159    if (ret != 0) {
1160       DO_PthAPIerror( "pthread_barrier_destroy", ret );
1161    }
1162
1163    if (TRACE_PTH_FNS) {
1164       fprintf(stderr, "  pthread_barrier_destroy -> %d >>\n", ret);
1165    }
1166
1167    return ret;
1168 }
1169
1170 #endif   // defined(HAVE_PTHREAD_BARRIER_INIT)
1171
1172
1173 /*----------------------------------------------------------------*/
1174 /*--- pthread_spinlock_t functions                             ---*/
1175 /*----------------------------------------------------------------*/
1176
1177 #if defined(HAVE_PTHREAD_SPIN_LOCK) \
1178     && !defined(DISABLE_PTHREAD_SPINLOCK_INTERCEPT)
1179
1180 /* Handled:   pthread_spin_init pthread_spin_destroy
1181               pthread_spin_lock pthread_spin_trylock
1182               pthread_spin_unlock
1183
1184    Unhandled:
1185 */
1186
1187 /* This is a nasty kludge, in that glibc "knows" that initialising a
1188    spin lock unlocks it, and pthread_spin_{init,unlock} are names for
1189    the same function.  Hence we have to have a wrapper which does both
1190    things, without knowing which the user intended to happen. */
1191
1192 //-----------------------------------------------------------
1193 // glibc:  pthread_spin_init
1194 // glibc:  pthread_spin_unlock
1195 // darwin: (doesn't appear to exist)
1196 __attribute__((noinline))
1197 static int pthread_spin_init_or_unlock_WRK(pthread_spinlock_t* lock,
1198                                            int pshared) {
1199    int    ret;
1200    OrigFn fn;
1201    VALGRIND_GET_ORIG_FN(fn);
1202    if (TRACE_PTH_FNS) {
1203       fprintf(stderr, "<< pthread_spin_iORu %p", lock); fflush(stderr);
1204    }
1205
1206    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_SPIN_INIT_OR_UNLOCK_PRE,
1207                pthread_spinlock_t*, lock);
1208
1209    CALL_FN_W_WW(ret, fn, lock,pshared);
1210
1211    if (ret == 0 /*success*/) {
1212       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_SPIN_INIT_OR_UNLOCK_POST,
1213                   pthread_spinlock_t*,lock);
1214    } else {
1215       DO_PthAPIerror( "pthread_spinlock_{init,unlock}", ret );
1216    }
1217
1218    if (TRACE_PTH_FNS) {
1219       fprintf(stderr, " :: spiniORu -> %d >>\n", ret);
1220    }
1221    return ret;
1222 }
1223 #if defined(VGO_linux)
1224    PTH_FUNC(int, pthreadZuspinZuinit, // pthread_spin_init
1225             pthread_spinlock_t* lock, int pshared) {
1226       return pthread_spin_init_or_unlock_WRK(lock, pshared);
1227    }
1228    PTH_FUNC(int, pthreadZuspinZuunlock, // pthread_spin_unlock
1229             pthread_spinlock_t* lock) {
1230       /* this is never actually called */
1231       return pthread_spin_init_or_unlock_WRK(lock, 0/*pshared*/);
1232    }
1233 #elif defined(VGO_darwin)
1234 #else
1235 #  error "Unsupported OS"
1236 #endif
1237
1238
1239 //-----------------------------------------------------------
1240 // glibc:  pthread_spin_destroy
1241 // darwin: (doesn't appear to exist)
1242 #if defined(VGO_linux)
1243
1244 PTH_FUNC(int, pthreadZuspinZudestroy, // pthread_spin_destroy
1245               pthread_spinlock_t* lock)
1246 {
1247    int    ret;
1248    OrigFn fn;
1249    VALGRIND_GET_ORIG_FN(fn);
1250    if (TRACE_PTH_FNS) {
1251       fprintf(stderr, "<< pthread_spin_destroy %p", lock);
1252       fflush(stderr);
1253    }
1254
1255    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_SPIN_DESTROY_PRE,
1256                pthread_spinlock_t*,lock);
1257
1258    CALL_FN_W_W(ret, fn, lock);
1259
1260    if (ret != 0) {
1261       DO_PthAPIerror( "pthread_spin_destroy", ret );
1262    }
1263
1264    if (TRACE_PTH_FNS) {
1265       fprintf(stderr, " :: spindestroy -> %d >>\n", ret);
1266    }
1267    return ret;
1268 }
1269
1270 #elif defined(VGO_darwin)
1271 #else
1272 #  error "Unsupported OS"
1273 #endif
1274
1275
1276 //-----------------------------------------------------------
1277 // glibc:  pthread_spin_lock
1278 // darwin: (doesn't appear to exist)
1279 #if defined(VGO_linux)
1280
1281 PTH_FUNC(int, pthreadZuspinZulock, // pthread_spin_lock
1282               pthread_spinlock_t* lock)
1283 {
1284    int    ret;
1285    OrigFn fn;
1286    VALGRIND_GET_ORIG_FN(fn);
1287    if (TRACE_PTH_FNS) {
1288       fprintf(stderr, "<< pthread_spinlock %p", lock);
1289       fflush(stderr);
1290    }
1291
1292    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_SPIN_LOCK_PRE,
1293                 pthread_spinlock_t*,lock, long,0/*!isTryLock*/);
1294
1295    CALL_FN_W_W(ret, fn, lock);
1296
1297    /* There's a hole here: libpthread now knows the lock is locked,
1298       but the tool doesn't, so some other thread could run and detect
1299       that the lock has been acquired by someone (this thread).  Does
1300       this matter?  Not sure, but I don't think so. */
1301
1302    if (ret == 0 /*success*/) {
1303       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_SPIN_LOCK_POST,
1304                   pthread_spinlock_t*,lock);
1305    } else {
1306       DO_PthAPIerror( "pthread_spin_lock", ret );
1307    }
1308
1309    if (TRACE_PTH_FNS) {
1310       fprintf(stderr, " :: spinlock -> %d >>\n", ret);
1311    }
1312    return ret;
1313 }
1314
1315 #elif defined(VGO_darwin)
1316 #else
1317 #  error "Unsupported OS"
1318 #endif
1319
1320
1321 //-----------------------------------------------------------
1322 // glibc:  pthread_spin_trylock
1323 // darwin: (doesn't appear to exist)
1324 #if defined(VGO_linux)
1325
1326 PTH_FUNC(int, pthreadZuspinZutrylock, // pthread_spin_trylock
1327               pthread_spinlock_t* lock)
1328 {
1329    int    ret;
1330    OrigFn fn;
1331    VALGRIND_GET_ORIG_FN(fn);
1332    if (TRACE_PTH_FNS) {
1333       fprintf(stderr, "<< pthread_spin_trylock %p", lock);
1334       fflush(stderr);
1335    }
1336
1337    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_SPIN_LOCK_PRE,
1338                 pthread_spinlock_t*,lock, long,1/*isTryLock*/);
1339
1340    CALL_FN_W_W(ret, fn, lock);
1341
1342    /* There's a hole here: libpthread now knows the lock is locked,
1343       but the tool doesn't, so some other thread could run and detect
1344       that the lock has been acquired by someone (this thread).  Does
1345       this matter?  Not sure, but I don't think so. */
1346
1347    if (ret == 0 /*success*/) {
1348       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_SPIN_LOCK_POST,
1349                   pthread_spinlock_t*,lock);
1350    } else {
1351       if (ret != EBUSY)
1352          DO_PthAPIerror( "pthread_spin_trylock", ret );
1353    }
1354
1355    if (TRACE_PTH_FNS) {
1356       fprintf(stderr, " :: spin_trylock -> %d >>\n", ret);
1357    }
1358    return ret;
1359 }
1360
1361 #elif defined(VGO_darwin)
1362 #else
1363 #  error "Unsupported OS"
1364 #endif
1365
1366 #endif // defined(HAVE_PTHREAD_SPIN_LOCK)
1367
1368
1369 /*----------------------------------------------------------------*/
1370 /*--- pthread_rwlock_t functions                               ---*/
1371 /*----------------------------------------------------------------*/
1372
1373 /* Android's pthread.h doesn't say anything about rwlocks, hence these
1374    functions have to be conditionally compiled. */
1375 #if defined(HAVE_PTHREAD_RWLOCK_T)
1376
1377 /* Handled:   pthread_rwlock_init pthread_rwlock_destroy
1378               pthread_rwlock_rdlock
1379               pthread_rwlock_wrlock
1380               pthread_rwlock_unlock
1381
1382    Unhandled: pthread_rwlock_timedrdlock
1383               pthread_rwlock_tryrdlock
1384
1385               pthread_rwlock_timedwrlock
1386               pthread_rwlock_trywrlock
1387 */
1388
1389 //-----------------------------------------------------------
1390 // glibc:  pthread_rwlock_init
1391 // darwin: pthread_rwlock_init
1392 // darwin: pthread_rwlock_init$UNIX2003
1393 __attribute__((noinline))
1394 static int pthread_rwlock_init_WRK(pthread_rwlock_t *rwl,
1395                                    pthread_rwlockattr_t* attr)
1396 {
1397    int    ret;
1398    OrigFn fn;
1399    VALGRIND_GET_ORIG_FN(fn);
1400    if (TRACE_PTH_FNS) {
1401       fprintf(stderr, "<< pthread_rwl_init %p", rwl); fflush(stderr);
1402    }
1403
1404    CALL_FN_W_WW(ret, fn, rwl,attr);
1405
1406    if (ret == 0 /*success*/) {
1407       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST,
1408                   pthread_rwlock_t*,rwl);
1409    } else {
1410       DO_PthAPIerror( "pthread_rwlock_init", ret );
1411    }
1412
1413    if (TRACE_PTH_FNS) {
1414       fprintf(stderr, " :: rwl_init -> %d >>\n", ret);
1415    }
1416    return ret;
1417 }
1418 #if defined(VGO_linux)
1419    PTH_FUNC(int, pthreadZurwlockZuinit, // pthread_rwlock_init
1420                  pthread_rwlock_t *rwl,
1421                  pthread_rwlockattr_t* attr) {
1422       return pthread_rwlock_init_WRK(rwl, attr);
1423    }
1424 #elif defined(VGO_darwin)
1425    PTH_FUNC(int, pthreadZurwlockZuinitZa, // pthread_rwlock_init*
1426                  pthread_rwlock_t *rwl,
1427                  pthread_rwlockattr_t* attr) {
1428       return pthread_rwlock_init_WRK(rwl, attr);
1429    }
1430 #else
1431 #  error "Unsupported OS"
1432 #endif
1433
1434
1435 //-----------------------------------------------------------
1436 // glibc:  pthread_rwlock_destroy
1437 // darwin: pthread_rwlock_destroy
1438 // darwin: pthread_rwlock_destroy$UNIX2003
1439 //
1440 __attribute__((noinline))
1441 static int pthread_rwlock_destroy_WRK(pthread_rwlock_t* rwl)
1442 {
1443    int    ret;
1444    OrigFn fn;
1445    VALGRIND_GET_ORIG_FN(fn);
1446    if (TRACE_PTH_FNS) {
1447       fprintf(stderr, "<< pthread_rwl_destroy %p", rwl); fflush(stderr);
1448    }
1449
1450    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE,
1451                pthread_rwlock_t*,rwl);
1452
1453    CALL_FN_W_W(ret, fn, rwl);
1454
1455    if (ret != 0) {
1456       DO_PthAPIerror( "pthread_rwlock_destroy", ret );
1457    }
1458
1459    if (TRACE_PTH_FNS) {
1460       fprintf(stderr, " :: rwl_destroy -> %d >>\n", ret);
1461    }
1462    return ret;
1463 }
1464 #if defined(VGO_linux)
1465    PTH_FUNC(int, pthreadZurwlockZudestroy, // pthread_rwlock_destroy
1466                  pthread_rwlock_t *rwl) {
1467       return pthread_rwlock_destroy_WRK(rwl);
1468    }
1469 #elif defined(VGO_darwin)
1470    PTH_FUNC(int, pthreadZurwlockZudestroyZa, // pthread_rwlock_destroy*
1471                  pthread_rwlock_t *rwl) {
1472       return pthread_rwlock_destroy_WRK(rwl);
1473    }
1474 #else
1475 #  error "Unsupported OS"
1476 #endif
1477
1478
1479 //-----------------------------------------------------------
1480 // glibc:  pthread_rwlock_wrlock
1481 // darwin: pthread_rwlock_wrlock
1482 // darwin: pthread_rwlock_wrlock$UNIX2003
1483 //
1484 __attribute__((noinline))
1485 static int pthread_rwlock_wrlock_WRK(pthread_rwlock_t* rwlock)
1486 {
1487    int    ret;
1488    OrigFn fn;
1489    VALGRIND_GET_ORIG_FN(fn);
1490    if (TRACE_PTH_FNS) {
1491       fprintf(stderr, "<< pthread_rwl_wlk %p", rwlock); fflush(stderr);
1492    }
1493
1494    DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
1495                  pthread_rwlock_t*,rwlock,
1496                  long,1/*isW*/, long,0/*!isTryLock*/);
1497
1498    CALL_FN_W_W(ret, fn, rwlock);
1499
1500    if (ret == 0 /*success*/) {
1501       DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
1502                    pthread_rwlock_t*,rwlock, long,1/*isW*/);
1503    } else {
1504       DO_PthAPIerror( "pthread_rwlock_wrlock", ret );
1505    }
1506
1507    if (TRACE_PTH_FNS) {
1508       fprintf(stderr, " :: rwl_wlk -> %d >>\n", ret);
1509    }
1510    return ret;
1511 }
1512 #if defined(VGO_linux)
1513    PTH_FUNC(int, pthreadZurwlockZuwrlock, // pthread_rwlock_wrlock
1514                  pthread_rwlock_t* rwlock) {
1515       return pthread_rwlock_wrlock_WRK(rwlock);
1516    }
1517 #elif defined(VGO_darwin)
1518    PTH_FUNC(int, pthreadZurwlockZuwrlockZa, // pthread_rwlock_wrlock*
1519                  pthread_rwlock_t* rwlock) {
1520       return pthread_rwlock_wrlock_WRK(rwlock);
1521    }
1522 #else
1523 #  error "Unsupported OS"
1524 #endif
1525
1526
1527 //-----------------------------------------------------------
1528 // glibc:  pthread_rwlock_rdlock
1529 // darwin: pthread_rwlock_rdlock
1530 // darwin: pthread_rwlock_rdlock$UNIX2003
1531 //
1532 __attribute__((noinline))
1533 static int pthread_rwlock_rdlock_WRK(pthread_rwlock_t* rwlock)
1534 {
1535    int    ret;
1536    OrigFn fn;
1537    VALGRIND_GET_ORIG_FN(fn);
1538    if (TRACE_PTH_FNS) {
1539       fprintf(stderr, "<< pthread_rwl_rlk %p", rwlock); fflush(stderr);
1540    }
1541
1542    DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
1543                  pthread_rwlock_t*,rwlock,
1544                  long,0/*!isW*/, long,0/*!isTryLock*/);
1545
1546    CALL_FN_W_W(ret, fn, rwlock);
1547
1548    if (ret == 0 /*success*/) {
1549       DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
1550                    pthread_rwlock_t*,rwlock, long,0/*!isW*/);
1551    } else {
1552       DO_PthAPIerror( "pthread_rwlock_rdlock", ret );
1553    }
1554
1555    if (TRACE_PTH_FNS) {
1556       fprintf(stderr, " :: rwl_rlk -> %d >>\n", ret);
1557    }
1558    return ret;
1559 }
1560 #if defined(VGO_linux)
1561    PTH_FUNC(int, pthreadZurwlockZurdlock, // pthread_rwlock_rdlock
1562                  pthread_rwlock_t* rwlock) {
1563       return pthread_rwlock_rdlock_WRK(rwlock);
1564    }
1565 #elif defined(VGO_darwin)
1566    PTH_FUNC(int, pthreadZurwlockZurdlockZa, // pthread_rwlock_rdlock*
1567                  pthread_rwlock_t* rwlock) {
1568       return pthread_rwlock_rdlock_WRK(rwlock);
1569    }
1570 #else
1571 #  error "Unsupported OS"
1572 #endif
1573
1574
1575 //-----------------------------------------------------------
1576 // glibc:  pthread_rwlock_trywrlock
1577 // darwin: pthread_rwlock_trywrlock
1578 // darwin: pthread_rwlock_trywrlock$UNIX2003
1579 //
1580 __attribute__((noinline))
1581 static int pthread_rwlock_trywrlock_WRK(pthread_rwlock_t* rwlock)
1582 {
1583    int    ret;
1584    OrigFn fn;
1585    VALGRIND_GET_ORIG_FN(fn);
1586    if (TRACE_PTH_FNS) {
1587       fprintf(stderr, "<< pthread_rwl_trywlk %p", rwlock); fflush(stderr);
1588    }
1589
1590    DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
1591                  pthread_rwlock_t*,rwlock,
1592                  long,1/*isW*/, long,1/*isTryLock*/);
1593
1594    CALL_FN_W_W(ret, fn, rwlock);
1595
1596    /* There's a hole here: libpthread now knows the lock is locked,
1597       but the tool doesn't, so some other thread could run and detect
1598       that the lock has been acquired by someone (this thread).  Does
1599       this matter?  Not sure, but I don't think so. */
1600
1601    if (ret == 0 /*success*/) {
1602       DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
1603                    pthread_rwlock_t*,rwlock, long,1/*isW*/);
1604    } else {
1605       if (ret != EBUSY)
1606          DO_PthAPIerror( "pthread_rwlock_trywrlock", ret );
1607    }
1608
1609    if (TRACE_PTH_FNS) {
1610       fprintf(stderr, " :: rwl_trywlk -> %d >>\n", ret);
1611    }
1612    return ret;
1613 }
1614 #if defined(VGO_linux)
1615    PTH_FUNC(int, pthreadZurwlockZutrywrlock, // pthread_rwlock_trywrlock
1616                  pthread_rwlock_t* rwlock) {
1617       return pthread_rwlock_trywrlock_WRK(rwlock);
1618    }
1619 #elif defined(VGO_darwin)
1620    PTH_FUNC(int, pthreadZurwlockZutrywrlockZa, // pthread_rwlock_trywrlock*
1621                  pthread_rwlock_t* rwlock) {
1622       return pthread_rwlock_trywrlock_WRK(rwlock);
1623    }
1624 #else
1625 #  error "Unsupported OS"
1626 #endif
1627
1628
1629 //-----------------------------------------------------------
1630 // glibc:  pthread_rwlock_tryrdlock
1631 // darwin: pthread_rwlock_trywrlock
1632 // darwin: pthread_rwlock_trywrlock$UNIX2003
1633 //
1634 __attribute__((noinline))
1635 static int pthread_rwlock_tryrdlock_WRK(pthread_rwlock_t* rwlock)
1636 {
1637    int    ret;
1638    OrigFn fn;
1639    VALGRIND_GET_ORIG_FN(fn);
1640    if (TRACE_PTH_FNS) {
1641       fprintf(stderr, "<< pthread_rwl_tryrlk %p", rwlock); fflush(stderr);
1642    }
1643
1644    DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
1645                  pthread_rwlock_t*,rwlock,
1646                  long,0/*!isW*/, long,1/*isTryLock*/);
1647
1648    CALL_FN_W_W(ret, fn, rwlock);
1649
1650    /* There's a hole here: libpthread now knows the lock is locked,
1651       but the tool doesn't, so some other thread could run and detect
1652       that the lock has been acquired by someone (this thread).  Does
1653       this matter?  Not sure, but I don't think so. */
1654
1655    if (ret == 0 /*success*/) {
1656       DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
1657                    pthread_rwlock_t*,rwlock, long,0/*!isW*/);
1658    } else {
1659       if (ret != EBUSY)
1660          DO_PthAPIerror( "pthread_rwlock_tryrdlock", ret );
1661    }
1662
1663    if (TRACE_PTH_FNS) {
1664       fprintf(stderr, " :: rwl_tryrlk -> %d >>\n", ret);
1665    }
1666    return ret;
1667 }
1668 #if defined(VGO_linux)
1669    PTH_FUNC(int, pthreadZurwlockZutryrdlock, // pthread_rwlock_tryrdlock
1670                  pthread_rwlock_t* rwlock) {
1671       return pthread_rwlock_tryrdlock_WRK(rwlock);
1672    }
1673 #elif defined(VGO_darwin)
1674    PTH_FUNC(int, pthreadZurwlockZutryrdlockZa, // pthread_rwlock_tryrdlock*
1675                  pthread_rwlock_t* rwlock) {
1676       return pthread_rwlock_tryrdlock_WRK(rwlock);
1677    }
1678 #else
1679 #  error "Unsupported OS"
1680 #endif
1681
1682
1683 //-----------------------------------------------------------
1684 // glibc:  pthread_rwlock_unlock
1685 // darwin: pthread_rwlock_unlock
1686 // darwin: pthread_rwlock_unlock$UNIX2003
1687 __attribute__((noinline))
1688 static int pthread_rwlock_unlock_WRK(pthread_rwlock_t* rwlock)
1689 {
1690    int    ret;
1691    OrigFn fn;
1692    VALGRIND_GET_ORIG_FN(fn);
1693    if (TRACE_PTH_FNS) {
1694       fprintf(stderr, "<< pthread_rwl_unlk %p", rwlock); fflush(stderr);
1695    }
1696
1697    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,
1698                pthread_rwlock_t*,rwlock);
1699
1700    CALL_FN_W_W(ret, fn, rwlock);
1701
1702    if (ret == 0 /*success*/) {
1703       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST,
1704                   pthread_rwlock_t*,rwlock);
1705    } else {
1706       DO_PthAPIerror( "pthread_rwlock_unlock", ret );
1707    }
1708
1709    if (TRACE_PTH_FNS) {
1710       fprintf(stderr, " :: rwl_unlk -> %d >>\n", ret);
1711    }
1712    return ret;
1713 }
1714 #if defined(VGO_linux)
1715    PTH_FUNC(int, pthreadZurwlockZuunlock, // pthread_rwlock_unlock
1716                  pthread_rwlock_t* rwlock) {
1717       return pthread_rwlock_unlock_WRK(rwlock);
1718    }
1719 #elif defined(VGO_darwin)
1720    PTH_FUNC(int, pthreadZurwlockZuunlockZa, // pthread_rwlock_unlock*
1721                  pthread_rwlock_t* rwlock) {
1722       return pthread_rwlock_unlock_WRK(rwlock);
1723    }
1724 #else
1725 #  error "Unsupported OS"
1726 #endif
1727
1728 #endif /* defined(HAVE_PTHREAD_RWLOCK_T) */
1729
1730
1731 /*----------------------------------------------------------------*/
1732 /*--- POSIX semaphores                                         ---*/
1733 /*----------------------------------------------------------------*/
1734
1735 #include <semaphore.h>
1736 #include <fcntl.h>       /* O_CREAT */
1737
1738 #define TRACE_SEM_FNS 0
1739
1740 /* Handled:
1741      int sem_init(sem_t *sem, int pshared, unsigned value);
1742      int sem_destroy(sem_t *sem);
1743      int sem_wait(sem_t *sem);
1744      int sem_post(sem_t *sem);
1745      sem_t* sem_open(const char *name, int oflag,
1746                      ... [mode_t mode, unsigned value]);
1747         [complete with its idiotic semantics]
1748      int sem_close(sem_t* sem);
1749
1750    Unhandled:
1751      int sem_trywait(sem_t *sem);
1752      int sem_timedwait(sem_t *restrict sem,
1753                        const struct timespec *restrict abs_timeout);
1754 */
1755
1756 //-----------------------------------------------------------
1757 // glibc:  sem_init@@GLIBC_2.2.5
1758 // glibc:  sem_init@@GLIBC_2.1
1759 // glibc:  sem_init@GLIBC_2.0
1760 // darwin: sem_init
1761 //
1762 __attribute__((noinline))
1763 static int sem_init_WRK(sem_t* sem, int pshared, unsigned long value)
1764 {
1765    OrigFn fn;
1766    int    ret;
1767    VALGRIND_GET_ORIG_FN(fn);
1768
1769    if (TRACE_SEM_FNS) {
1770       fprintf(stderr, "<< sem_init(%p,%d,%lu) ", sem,pshared,value);
1771       fflush(stderr);
1772    }
1773
1774    CALL_FN_W_WWW(ret, fn, sem,pshared,value);
1775
1776    if (ret == 0) {
1777       DO_CREQ_v_WW(_VG_USERREQ__HG_POSIX_SEM_INIT_POST,
1778                    sem_t*, sem, unsigned long, value);
1779    } else {
1780       DO_PthAPIerror( "sem_init", errno );
1781    }
1782
1783    if (TRACE_SEM_FNS) {
1784       fprintf(stderr, " sem_init -> %d >>\n", ret);
1785       fflush(stderr);
1786    }
1787
1788    return ret;
1789 }
1790 #if defined(VGO_linux)
1791    PTH_FUNC(int, semZuinitZAZa, // sem_init@*
1792                  sem_t* sem, int pshared, unsigned long value) {
1793       return sem_init_WRK(sem, pshared, value);
1794    }
1795 #elif defined(VGO_darwin)
1796    PTH_FUNC(int, semZuinit, // sem_init
1797                  sem_t* sem, int pshared, unsigned long value) {
1798       return sem_init_WRK(sem, pshared, value);
1799    }
1800 #else
1801 #  error "Unsupported OS"
1802 #endif
1803
1804
1805 //-----------------------------------------------------------
1806 // glibc:  sem_destroy@GLIBC_2.0
1807 // glibc:  sem_destroy@@GLIBC_2.1
1808 // glibc:  sem_destroy@@GLIBC_2.2.5
1809 // darwin: sem_destroy
1810 __attribute__((noinline))
1811 static int sem_destroy_WRK(sem_t* sem)
1812 {
1813    OrigFn fn;
1814    int    ret;
1815    VALGRIND_GET_ORIG_FN(fn);
1816
1817    if (TRACE_SEM_FNS) {
1818       fprintf(stderr, "<< sem_destroy(%p) ", sem);
1819       fflush(stderr);
1820    }
1821
1822    DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_DESTROY_PRE, sem_t*, sem);
1823
1824    CALL_FN_W_W(ret, fn, sem);
1825
1826    if (ret != 0) {
1827       DO_PthAPIerror( "sem_destroy", errno );
1828    }
1829
1830    if (TRACE_SEM_FNS) {
1831       fprintf(stderr, " sem_destroy -> %d >>\n", ret);
1832       fflush(stderr);
1833    }
1834
1835    return ret;
1836 }
1837 #if defined(VGO_linux)
1838    PTH_FUNC(int, semZudestroyZAZa,  // sem_destroy*
1839                  sem_t* sem) {
1840       return sem_destroy_WRK(sem);
1841    }
1842 #elif defined(VGO_darwin)
1843    PTH_FUNC(int, semZudestroy,  // sem_destroy
1844                  sem_t* sem) {
1845       return sem_destroy_WRK(sem);
1846    }
1847 #else
1848 #  error "Unsupported OS"
1849 #endif
1850
1851
1852 //-----------------------------------------------------------
1853 // glibc:  sem_wait
1854 // glibc:  sem_wait@GLIBC_2.0
1855 // glibc:  sem_wait@@GLIBC_2.1
1856 // darwin: sem_wait
1857 // darwin: sem_wait$NOCANCEL$UNIX2003
1858 // darwin: sem_wait$UNIX2003
1859 //
1860 /* wait: decrement semaphore - acquire lockage */
1861 __attribute__((noinline))
1862 static int sem_wait_WRK(sem_t* sem)
1863 {
1864    OrigFn fn;
1865    int    ret;
1866    VALGRIND_GET_ORIG_FN(fn);
1867
1868    if (TRACE_SEM_FNS) {
1869       fprintf(stderr, "<< sem_wait(%p) ", sem);
1870       fflush(stderr);
1871    }
1872
1873    CALL_FN_W_W(ret, fn, sem);
1874
1875    if (ret == 0) {
1876       DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_WAIT_POST, sem_t*,sem);
1877    } else {
1878       DO_PthAPIerror( "sem_wait", errno );
1879    }
1880
1881    if (TRACE_SEM_FNS) {
1882       fprintf(stderr, " sem_wait -> %d >>\n", ret);
1883       fflush(stderr);
1884    }
1885
1886    return ret;
1887 }
1888 #if defined(VGO_linux)
1889    PTH_FUNC(int, semZuwait, sem_t* sem) { /* sem_wait */
1890       return sem_wait_WRK(sem);
1891    }
1892    PTH_FUNC(int, semZuwaitZAZa, sem_t* sem) { /* sem_wait@* */
1893       return sem_wait_WRK(sem);
1894    }
1895 #elif defined(VGO_darwin)
1896    PTH_FUNC(int, semZuwait, sem_t* sem) { /* sem_wait */
1897       return sem_wait_WRK(sem);
1898    }
1899    PTH_FUNC(int, semZuwaitZDZa, sem_t* sem) { /* sem_wait$* */
1900       return sem_wait_WRK(sem);
1901    }
1902 #else
1903 #  error "Unsupported OS"
1904 #endif
1905
1906
1907 //-----------------------------------------------------------
1908 // glibc:  sem_post
1909 // glibc:  sem_post@GLIBC_2.0
1910 // glibc:  sem_post@@GLIBC_2.1
1911 // darwin: sem_post
1912 //
1913 /* post: increment semaphore - release lockage */
1914 __attribute__((noinline))
1915 static int sem_post_WRK(sem_t* sem)
1916 {
1917    OrigFn fn;
1918    int    ret;
1919
1920    VALGRIND_GET_ORIG_FN(fn);
1921
1922    if (TRACE_SEM_FNS) {
1923       fprintf(stderr, "<< sem_post(%p) ", sem);
1924       fflush(stderr);
1925    }
1926
1927    DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_POST_PRE, sem_t*,sem);
1928
1929    CALL_FN_W_W(ret, fn, sem);
1930
1931    if (ret != 0) {
1932       DO_PthAPIerror( "sem_post", errno );
1933    }
1934
1935    if (TRACE_SEM_FNS) {
1936       fprintf(stderr, " sem_post -> %d >>\n", ret);
1937       fflush(stderr);
1938    }
1939
1940    return ret;
1941 }
1942 #if defined(VGO_linux)
1943    PTH_FUNC(int, semZupost, sem_t* sem) { /* sem_post */
1944       return sem_post_WRK(sem);
1945    }
1946    PTH_FUNC(int, semZupostZAZa, sem_t* sem) { /* sem_post@* */
1947       return sem_post_WRK(sem);
1948    }
1949 #elif defined(VGO_darwin)
1950    PTH_FUNC(int, semZupost, sem_t* sem) { /* sem_post */
1951       return sem_post_WRK(sem);
1952    }
1953 #else
1954 #  error "Unsupported OS"
1955 #endif
1956
1957
1958 //-----------------------------------------------------------
1959 // glibc:  sem_open
1960 // darwin: sem_open
1961 //
1962 PTH_FUNC(sem_t*, semZuopen,
1963                  const char* name, long oflag,
1964                  long mode, unsigned long value)
1965 {
1966    /* A copy of sem_init_WRK (more or less).  Is this correct? */
1967    OrigFn fn;
1968    sem_t* ret;
1969    VALGRIND_GET_ORIG_FN(fn);
1970
1971    if (TRACE_SEM_FNS) {
1972       fprintf(stderr, "<< sem_open(\"%s\",%ld,%lx,%lu) ",
1973                       name,oflag,mode,value);
1974       fflush(stderr);
1975    }
1976
1977    CALL_FN_W_WWWW(ret, fn, name,oflag,mode,value);
1978
1979    if (ret != SEM_FAILED && (oflag & O_CREAT)) {
1980       DO_CREQ_v_WW(_VG_USERREQ__HG_POSIX_SEM_INIT_POST,
1981                    sem_t*, ret, unsigned long, value);
1982    }
1983    if (ret == SEM_FAILED) {
1984       DO_PthAPIerror( "sem_open", errno );
1985    }
1986
1987    if (TRACE_SEM_FNS) {
1988       fprintf(stderr, " sem_open -> %p >>\n", ret);
1989       fflush(stderr);
1990    }
1991
1992    return ret;
1993 }
1994
1995
1996 //-----------------------------------------------------------
1997 // glibc:  sem_close
1998 // darwin: sem_close
1999 PTH_FUNC(int, sem_close, sem_t* sem)
2000 {
2001    OrigFn fn;
2002    int    ret;
2003    VALGRIND_GET_ORIG_FN(fn);
2004
2005    if (TRACE_SEM_FNS) {
2006       fprintf(stderr, "<< sem_close(%p) ", sem);
2007       fflush(stderr);
2008    }
2009
2010    DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_DESTROY_PRE, sem_t*, sem);
2011
2012    CALL_FN_W_W(ret, fn, sem);
2013
2014    if (ret != 0) {
2015       DO_PthAPIerror( "sem_close", errno );
2016    }
2017
2018    if (TRACE_SEM_FNS) {
2019       fprintf(stderr, " close -> %d >>\n", ret);
2020       fflush(stderr);
2021    }
2022
2023    return ret;
2024 }
2025
2026
2027 /*----------------------------------------------------------------*/
2028 /*--- Qt 4 threading functions (w/ GNU name mangling)          ---*/
2029 /*----------------------------------------------------------------*/
2030
2031 /* Handled:
2032       QMutex::lock()
2033       QMutex::unlock()
2034       QMutex::tryLock()
2035       QMutex::tryLock(int)
2036
2037       QMutex::QMutex(QMutex::RecursionMode)  _ZN6QMutexC1ENS_13RecursionModeE
2038       QMutex::QMutex(QMutex::RecursionMode)  _ZN6QMutexC2ENS_13RecursionModeE
2039       QMutex::~QMutex()                      _ZN6QMutexD1Ev
2040       QMutex::~QMutex()                      _ZN6QMutexD2Ev
2041
2042    Unhandled:
2043       QReadWriteLock::lockForRead()
2044       QReadWriteLock::lockForWrite()
2045       QReadWriteLock::unlock()
2046       QReadWriteLock::tryLockForRead(int)
2047       QReadWriteLock::tryLockForRead()
2048       QReadWriteLock::tryLockForWrite(int)
2049       QReadWriteLock::tryLockForWrite()
2050
2051       QWaitCondition::wait(QMutex*, unsigned long)
2052       QWaitCondition::wakeAll()
2053       QWaitCondition::wakeOne()
2054
2055       QSemaphore::*
2056 */
2057 /* More comments, 19 Nov 08, based on assessment of qt-4.5.0TP1,
2058    at least on Unix:
2059
2060    It's apparently only necessary to intercept QMutex, since that is
2061    not implemented using pthread_mutex_t; instead Qt4 has its own
2062    implementation based on atomics (to check the non-contended case)
2063    and pthread_cond_wait (to wait in the contended case).
2064
2065    QReadWriteLock is built on top of QMutex, counters, and a wait
2066    queue.  So we don't need to handle it specially once QMutex
2067    handling is correct -- presumably the dependencies through QMutex
2068    are sufficient to avoid any false race reports.  On the other hand,
2069    it is an open question whether too many dependencies are observed
2070    -- in which case we may miss races (false negatives).  I suspect
2071    this is likely to be the case, unfortunately.
2072
2073    QWaitCondition is built on pthread_cond_t, pthread_mutex_t, QMutex
2074    and QReadWriteLock.  Same compositional-correctness justificiation
2075    and limitations as fro QReadWriteLock.
2076
2077    Ditto QSemaphore (from cursory examination).
2078
2079    Does it matter that only QMutex is handled directly?  Open
2080    question.  From testing with drd/tests/qt4_* and with KDE4 apps, it
2081    appears that no false errors are reported; however it is not clear
2082    if this is causing false negatives.
2083
2084    Another problem with Qt4 is thread exiting.  Threads are created
2085    with pthread_create (fine); but they detach and simply exit when
2086    done.  There is no use of pthread_join, and the provided
2087    wait-for-a-thread-to-exit mechanism (QThread::wait, I believe)
2088    relies on a system of mutexes and flags.  I suspect this also
2089    causes too many dependencies to appear.  Consequently H sometimes
2090    fails to detect races at exit in some very short-lived racy
2091    programs, because it appears that a thread can exit _and_ have an
2092    observed dependency edge back to the main thread (presumably)
2093    before the main thread reaps the child (that is, calls
2094    QThread::wait).
2095
2096    This theory is supported by the observation that if all threads are
2097    made to wait at a pthread_barrier_t immediately before they exit,
2098    then H's detection of races in such programs becomes reliable;
2099    without the barrier, it is varies from run to run, depending
2100    (according to investigation) on whether aforementioned
2101    exit-before-reaping behaviour happens or not.
2102
2103    Finally, why is it necessary to intercept the QMutex constructors
2104    and destructors?  The constructors are intercepted only as a matter
2105    of convenience, so H can print accurate "first observed at"
2106    clauses.  However, it is actually necessary to intercept the
2107    destructors (as it is with pthread_mutex_destroy) in order that
2108    locks get removed from LAOG when they are destroyed.
2109 */
2110
2111 // soname is libQtCore.so.4 ; match against libQtCore.so*
2112 #define QT4_FUNC(ret_ty, f, args...) \
2113    ret_ty I_WRAP_SONAME_FNNAME_ZU(libQtCoreZdsoZa,f)(args); \
2114    ret_ty I_WRAP_SONAME_FNNAME_ZU(libQtCoreZdsoZa,f)(args)
2115
2116 // soname is libQt5Core.so.4 ; match against libQt5Core.so*
2117 #define QT5_FUNC(ret_ty, f, args...) \
2118    ret_ty I_WRAP_SONAME_FNNAME_ZU(libQt5CoreZdsoZa,f)(args); \
2119    ret_ty I_WRAP_SONAME_FNNAME_ZU(libQt5CoreZdsoZa,f)(args)
2120
2121 //-----------------------------------------------------------
2122 // QMutex::lock()
2123 __attribute__((noinline))
2124 static void QMutex_lock_WRK(void* self)
2125 {
2126    OrigFn fn;
2127    VALGRIND_GET_ORIG_FN(fn);
2128    if (TRACE_QT4_FNS) {
2129       fprintf(stderr, "<< QMutex::lock %p", self); fflush(stderr);
2130    }
2131
2132    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
2133                 void*,self, long,0/*!isTryLock*/);
2134
2135    CALL_FN_v_W(fn, self);
2136
2137    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
2138                void*, self);
2139
2140    if (TRACE_QT4_FNS) {
2141       fprintf(stderr, " :: Q::lock done >>\n");
2142    }
2143 }
2144
2145 QT4_FUNC(void, _ZN6QMutex4lockEv, void* self) {
2146     QMutex_lock_WRK(self);
2147 }
2148 QT5_FUNC(void, _ZN6QMutex4lockEv, void* self) {
2149     QMutex_lock_WRK(self);
2150 }
2151
2152 //-----------------------------------------------------------
2153 // QMutex::unlock()
2154 __attribute__((noinline))
2155 static void QMutex_unlock_WRK(void* self)
2156 {
2157    OrigFn fn;
2158    VALGRIND_GET_ORIG_FN(fn);
2159
2160    if (TRACE_QT4_FNS) {
2161       fprintf(stderr, "<< QMutex::unlock %p", self); fflush(stderr);
2162    }
2163
2164    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
2165                void*, self);
2166
2167    CALL_FN_v_W(fn, self);
2168
2169    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
2170                void*, self);
2171
2172    if (TRACE_QT4_FNS) {
2173       fprintf(stderr, " Q::unlock done >>\n");
2174    }
2175 }
2176
2177 QT4_FUNC(void, _ZN6QMutex6unlockEv, void* self) {
2178     QMutex_unlock_WRK(self);
2179 }
2180 QT5_FUNC(void, _ZN6QMutex6unlockEv, void* self) {
2181     QMutex_unlock_WRK(self);
2182 }
2183
2184 //-----------------------------------------------------------
2185 // bool QMutex::tryLock()
2186 // using 'long' to mimic C++ 'bool'
2187 __attribute__((noinline))
2188 static long QMutex_tryLock_WRK(void* self)
2189 {
2190    OrigFn fn;
2191    long   ret;
2192    VALGRIND_GET_ORIG_FN(fn);
2193    if (TRACE_QT4_FNS) {
2194       fprintf(stderr, "<< QMutex::tryLock %p", self); fflush(stderr);
2195    }
2196
2197    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
2198                 void*,self, long,1/*isTryLock*/);
2199
2200    CALL_FN_W_W(ret, fn, self);
2201
2202    // assumes that only the low 8 bits of the 'bool' are significant
2203    if (ret & 0xFF) {
2204       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
2205                   void*, self);
2206    }
2207
2208    if (TRACE_QT4_FNS) {
2209       fprintf(stderr, " :: Q::tryLock -> %lu >>\n", ret);
2210    }
2211
2212    return ret;
2213 }
2214
2215 QT4_FUNC(long, _ZN6QMutex7tryLockEv, void* self) {
2216     return QMutex_tryLock_WRK(self);
2217 }
2218 QT5_FUNC(long, _ZN6QMutex7tryLockEv, void* self) {
2219     return QMutex_tryLock_WRK(self);
2220 }
2221
2222 //-----------------------------------------------------------
2223 // bool QMutex::tryLock(int)
2224 // using 'long' to mimic C++ 'bool'
2225 __attribute__((noinline))
2226 static long QMutex_tryLock_int_WRK(void* self, long arg2)
2227 {
2228    OrigFn fn;
2229    long   ret;
2230    VALGRIND_GET_ORIG_FN(fn);
2231    if (TRACE_QT4_FNS) {
2232       fprintf(stderr, "<< QMutex::tryLock(int) %p %d", self, (int)arg2);
2233       fflush(stderr);
2234    }
2235
2236    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
2237                 void*,self, long,1/*isTryLock*/);
2238
2239    CALL_FN_W_WW(ret, fn, self,arg2);
2240
2241    // assumes that only the low 8 bits of the 'bool' are significant
2242    if (ret & 0xFF) {
2243       DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
2244                   void*, self);
2245    }
2246
2247    if (TRACE_QT4_FNS) {
2248       fprintf(stderr, " :: Q::tryLock(int) -> %lu >>\n", ret);
2249    }
2250
2251    return ret;
2252 }
2253
2254 QT4_FUNC(long, _ZN6QMutex7tryLockEi, void* self, long arg2) {
2255     return QMutex_tryLock_int_WRK(self, arg2);
2256 }
2257 QT5_FUNC(long, _ZN6QMutex7tryLockEi, void* self, long arg2) {
2258     return QMutex_tryLock_int_WRK(self, arg2);
2259 }
2260
2261 //-----------------------------------------------------------
2262 // It's not really very clear what the args are here.  But from
2263 // a bit of dataflow analysis of the generated machine code of
2264 // the original function, it appears this takes two args, and
2265 // returns nothing.  Nevertheless preserve return value just in
2266 // case.  A bit of debug printing indicates that the first arg
2267 // is that of the mutex and the second is either zero or one,
2268 // probably being the recursion mode, therefore.
2269 // QMutex::QMutex(QMutex::RecursionMode)  ("C1ENS" variant)
2270 __attribute__((noinline))
2271 static void* QMutex_constructor_WRK(void* mutex, long recmode)
2272 {
2273    OrigFn fn;
2274    long   ret;
2275    VALGRIND_GET_ORIG_FN(fn);
2276    CALL_FN_W_WW(ret, fn, mutex, recmode);
2277    //   fprintf(stderr, "QMutex constructor 1: %p <- %p %p\n", ret, arg1, arg2);
2278    DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,
2279                 void*,mutex, long,1/*mbRec*/);
2280    return (void*)ret;
2281 }
2282
2283 QT4_FUNC(void*, _ZN6QMutexC1ENS_13RecursionModeE, void* self, long recmode) {
2284     return QMutex_constructor_WRK(self, recmode);
2285 }
2286 QT5_FUNC(void*, _ZN6QMutexC1ENS_13RecursionModeE, void* self, long recmode) {
2287     return QMutex_constructor_WRK(self, recmode);
2288 }
2289
2290 //-----------------------------------------------------------
2291 // QMutex::~QMutex()  ("D1Ev" variant)
2292 __attribute__((noinline))
2293 static void* QMutex_destructor_WRK(void* mutex)
2294 {
2295    OrigFn fn;
2296    long   ret;
2297    VALGRIND_GET_ORIG_FN(fn);
2298    DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE,
2299                void*,mutex);
2300    CALL_FN_W_W(ret, fn, mutex);
2301    return (void*)ret;
2302 }
2303
2304 QT4_FUNC(void*, _ZN6QMutexD1Ev, void* self) {
2305     return QMutex_destructor_WRK(self);
2306 }
2307 QT5_FUNC(void*, _ZN6QMutexD1Ev, void* self) {
2308     return QMutex_destructor_WRK(self);
2309 }
2310
2311 //-----------------------------------------------------------
2312 // QMutex::QMutex(QMutex::RecursionMode)  ("C2ENS" variant)
2313 QT4_FUNC(void*, _ZN6QMutexC2ENS_13RecursionModeE,
2314          void* mutex,
2315          long  recmode)
2316 {
2317    assert(0);
2318    /*NOTREACHED*/
2319    /* Android's gcc behaves like it doesn't know that assert(0)
2320       never returns.  Hence: */
2321    return NULL;
2322 }
2323
2324 QT5_FUNC(void*, _ZN6QMutexC2ENS_13RecursionModeE, void* self, long recmode)
2325 {
2326    assert(0);
2327    /*NOTREACHED*/
2328    return NULL;
2329 }
2330
2331 //-----------------------------------------------------------
2332 // QMutex::~QMutex()  ("D2Ev" variant)
2333 QT4_FUNC(void*, _ZN6QMutexD2Ev, void* mutex)
2334 {
2335    assert(0);
2336    /* Android's gcc behaves like it doesn't know that assert(0)
2337       never returns.  Hence: */
2338    return NULL;
2339 }
2340
2341 QT5_FUNC(void*, _ZN6QMutexD2Ev, void* self)
2342 {
2343    assert(0);
2344    /*NOTREACHED*/
2345    return NULL;
2346 }
2347
2348 // QReadWriteLock is not intercepted directly.  See comments
2349 // above.
2350
2351 //// QReadWriteLock::lockForRead()
2352 //// _ZN14QReadWriteLock11lockForReadEv == QReadWriteLock::lockForRead()
2353 //QT4_FUNC(void, ZuZZN14QReadWriteLock11lockForReadEv,
2354 //               // _ZN14QReadWriteLock11lockForReadEv
2355 //               void* self)
2356 //{
2357 //   OrigFn fn;
2358 //   VALGRIND_GET_ORIG_FN(fn);
2359 //   if (TRACE_QT4_FNS) {
2360 //      fprintf(stderr, "<< QReadWriteLock::lockForRead %p", self);
2361 //      fflush(stderr);
2362 //   }
2363 //
2364 //   DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
2365 //                 void*,self,
2366 //                 long,0/*!isW*/, long,0/*!isTryLock*/);
2367 //
2368 //   CALL_FN_v_W(fn, self);
2369 //
2370 //   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
2371 //                void*,self, long,0/*!isW*/);
2372 //
2373 //   if (TRACE_QT4_FNS) {
2374 //      fprintf(stderr, " :: Q::lockForRead :: done >>\n");
2375 //   }
2376 //}
2377 //
2378 //// QReadWriteLock::lockForWrite()
2379 //// _ZN14QReadWriteLock12lockForWriteEv == QReadWriteLock::lockForWrite()
2380 //QT4_FUNC(void, ZuZZN14QReadWriteLock12lockForWriteEv,
2381 //               // _ZN14QReadWriteLock12lockForWriteEv
2382 //               void* self)
2383 //{
2384 //   OrigFn fn;
2385 //   VALGRIND_GET_ORIG_FN(fn);
2386 //   if (TRACE_QT4_FNS) {
2387 //      fprintf(stderr, "<< QReadWriteLock::lockForWrite %p", self);
2388 //      fflush(stderr);
2389 //   }
2390 //
2391 //   DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_PRE,
2392 //                 void*,self,
2393 //                 long,1/*isW*/, long,0/*!isTryLock*/);
2394 //
2395 //   CALL_FN_v_W(fn, self);
2396 //
2397 //   DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST,
2398 //                void*,self, long,1/*isW*/);
2399 //
2400 //   if (TRACE_QT4_FNS) {
2401 //      fprintf(stderr, " :: Q::lockForWrite :: done >>\n");
2402 //   }
2403 //}
2404 //
2405 //// QReadWriteLock::unlock()
2406 //// _ZN14QReadWriteLock6unlockEv == QReadWriteLock::unlock()
2407 //QT4_FUNC(void, ZuZZN14QReadWriteLock6unlockEv,
2408 //               // _ZN14QReadWriteLock6unlockEv
2409 //               void* self)
2410 //{
2411 //   OrigFn fn;
2412 //   VALGRIND_GET_ORIG_FN(fn);
2413 //   if (TRACE_QT4_FNS) {
2414 //      fprintf(stderr, "<< QReadWriteLock::unlock %p", self);
2415 //      fflush(stderr);
2416 //   }
2417 //
2418 //   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE,
2419 //               void*,self);
2420 //
2421 //   CALL_FN_v_W(fn, self);
2422 //
2423 //   DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_POST,
2424 //               void*,self);
2425 //
2426 //   if (TRACE_QT4_FNS) {
2427 //      fprintf(stderr, " :: Q::unlock :: done >>\n");
2428 //   }
2429 //}
2430
2431
2432 /*----------------------------------------------------------------*/
2433 /*--- Replacements for basic string functions, that don't      ---*/
2434 /*--- overrun the input arrays.                                ---*/
2435 /*----------------------------------------------------------------*/
2436
2437 #include "../shared/vg_replace_strmem.c"
2438
2439 /*--------------------------------------------------------------------*/
2440 /*--- end                                          hg_intercepts.c ---*/
2441 /*--------------------------------------------------------------------*/