src/base/third_party/dynamic_annotations/dynamic_annotations.h

   1 /* Copyright (c) 2011, Google Inc.
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Neither the name of Google Inc. nor the names of its
  11  * contributors may be used to endorse or promote products derived from
  12  * this software without specific prior written permission.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  15  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  16  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  17  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  18  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  20  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /* This file defines dynamic annotations for use with dynamic analysis
  28    tool such as valgrind, PIN, etc.
  29
  30    Dynamic annotation is a source code annotation that affects
  31    the generated code (that is, the annotation is not a comment).
  32    Each such annotation is attached to a particular
  33    instruction and/or to a particular object (address) in the program.
  34
  35    The annotations that should be used by users are macros in all upper-case
  36    (e.g., ANNOTATE_NEW_MEMORY).
  37
  38    Actual implementation of these macros may differ depending on the
  39    dynamic analysis tool being used.
  40
  41    See http://code.google.com/p/data-race-test/  for more information.
  42
  43    This file supports the following dynamic analysis tools:
  44    - None (DYNAMIC_ANNOTATIONS_ENABLED is not defined or zero).
  45       Macros are defined empty.
  46    - ThreadSanitizer, Helgrind, DRD (DYNAMIC_ANNOTATIONS_ENABLED is 1).
  47       Macros are defined as calls to non-inlinable empty functions
  48       that are intercepted by Valgrind. */
  49
  50 #ifndef __DYNAMIC_ANNOTATIONS_H__
  51 #define __DYNAMIC_ANNOTATIONS_H__
  52
  53 #ifndef DYNAMIC_ANNOTATIONS_PREFIX
  54 # define DYNAMIC_ANNOTATIONS_PREFIX
  55 #endif
  56
  57 #ifndef DYNAMIC_ANNOTATIONS_PROVIDE_RUNNING_ON_VALGRIND
  58 # define DYNAMIC_ANNOTATIONS_PROVIDE_RUNNING_ON_VALGRIND 1
  59 #endif
  60
  61 #ifdef DYNAMIC_ANNOTATIONS_WANT_ATTRIBUTE_WEAK
  62 # ifdef __GNUC__
  63 #  define DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK __attribute__((weak))
  64 # else
  65 /* TODO(glider): for Windows support we may want to change this macro in order
  66    to prepend __declspec(selectany) to the annotations' declarations. */
  67 #  error weak annotations are not supported for your compiler
  68 # endif
  69 #else
  70 # define DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK
  71 #endif
  72
  73 /* The following preprocessor magic prepends the value of
  74    DYNAMIC_ANNOTATIONS_PREFIX to annotation function names. */
  75 #define DYNAMIC_ANNOTATIONS_GLUE0(A, B) A##B
  76 #define DYNAMIC_ANNOTATIONS_GLUE(A, B) DYNAMIC_ANNOTATIONS_GLUE0(A, B)
  77 #define DYNAMIC_ANNOTATIONS_NAME(name) \
  78   DYNAMIC_ANNOTATIONS_GLUE(DYNAMIC_ANNOTATIONS_PREFIX, name)
  79
  80 #ifndef DYNAMIC_ANNOTATIONS_ENABLED
  81 # define DYNAMIC_ANNOTATIONS_ENABLED 0
  82 #endif
  83
  84 #if DYNAMIC_ANNOTATIONS_ENABLED != 0
  85
  86   /* -------------------------------------------------------------
  87      Annotations useful when implementing condition variables such as CondVar,
  88      using conditional critical sections (Await/LockWhen) and when constructing
  89      user-defined synchronization mechanisms.
  90
  91      The annotations ANNOTATE_HAPPENS_BEFORE() and ANNOTATE_HAPPENS_AFTER() can
  92      be used to define happens-before arcs in user-defined synchronization
  93      mechanisms:  the race detector will infer an arc from the former to the
  94      latter when they share the same argument pointer.
  95
  96      Example 1 (reference counting):
  97
  98      void Unref() {
  99        ANNOTATE_HAPPENS_BEFORE(&refcount_);
 100        if (AtomicDecrementByOne(&refcount_) == 0) {
 101          ANNOTATE_HAPPENS_AFTER(&refcount_);
 102          delete this;
 103        }
 104      }
 105
 106      Example 2 (message queue):
 107
 108      void MyQueue::Put(Type *e) {
 109        MutexLock lock(&mu_);
 110        ANNOTATE_HAPPENS_BEFORE(e);
 111        PutElementIntoMyQueue(e);
 112      }
 113
 114      Type *MyQueue::Get() {
 115        MutexLock lock(&mu_);
 116        Type *e = GetElementFromMyQueue();
 117        ANNOTATE_HAPPENS_AFTER(e);
 118        return e;
 119      }
 120
 121      Note: when possible, please use the existing reference counting and message
 122      queue implementations instead of inventing new ones. */
 123
 124   /* Report that wait on the condition variable at address "cv" has succeeded
 125      and the lock at address "lock" is held. */
 126   #define ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) \
 127     DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarWait)(__FILE__, __LINE__, cv, lock)
 128
 129   /* Report that wait on the condition variable at "cv" has succeeded.  Variant
 130      w/o lock. */
 131   #define ANNOTATE_CONDVAR_WAIT(cv) \
 132     DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarWait)(__FILE__, __LINE__, cv, NULL)
 133
 134   /* Report that we are about to signal on the condition variable at address
 135      "cv". */
 136   #define ANNOTATE_CONDVAR_SIGNAL(cv) \
 137     DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarSignal)(__FILE__, __LINE__, cv)
 138
 139   /* Report that we are about to signal_all on the condition variable at address
 140      "cv". */
 141   #define ANNOTATE_CONDVAR_SIGNAL_ALL(cv) \
 142     DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarSignalAll)(__FILE__, __LINE__, cv)
 143
 144   /* Annotations for user-defined synchronization mechanisms. */
 145   #define ANNOTATE_HAPPENS_BEFORE(obj) \
 146     DYNAMIC_ANNOTATIONS_NAME(AnnotateHappensBefore)(__FILE__, __LINE__, obj)
 147   #define ANNOTATE_HAPPENS_AFTER(obj) \
 148     DYNAMIC_ANNOTATIONS_NAME(AnnotateHappensAfter)(__FILE__, __LINE__, obj)
 149
 150   /* DEPRECATED. Don't use it. */
 151   #define ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \
 152     DYNAMIC_ANNOTATIONS_NAME(AnnotatePublishMemoryRange)(__FILE__, __LINE__, \
 153         pointer, size)
 154
 155   /* DEPRECATED. Don't use it. */
 156   #define ANNOTATE_UNPUBLISH_MEMORY_RANGE(pointer, size) \
 157     DYNAMIC_ANNOTATIONS_NAME(AnnotateUnpublishMemoryRange)(__FILE__, __LINE__, \
 158         pointer, size)
 159
 160   /* DEPRECATED. Don't use it. */
 161   #define ANNOTATE_SWAP_MEMORY_RANGE(pointer, size)   \
 162     do {                                              \
 163       ANNOTATE_UNPUBLISH_MEMORY_RANGE(pointer, size); \
 164       ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size);   \
 165     } while (0)
 166
 167   /* Instruct the tool to create a happens-before arc between mu->Unlock() and
 168      mu->Lock(). This annotation may slow down the race detector and hide real
 169      races. Normally it is used only when it would be difficult to annotate each
 170      of the mutex's critical sections individually using the annotations above.
 171      This annotation makes sense only for hybrid race detectors. For pure
 172      happens-before detectors this is a no-op. For more details see
 173      http://code.google.com/p/data-race-test/wiki/PureHappensBeforeVsHybrid . */
 174   #define ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) \
 175     DYNAMIC_ANNOTATIONS_NAME(AnnotateMutexIsUsedAsCondVar)(__FILE__, __LINE__, \
 176         mu)
 177
 178   /* Opposite to ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX.
 179      Instruct the tool to NOT create h-b arcs between Unlock and Lock, even in
 180      pure happens-before mode. For a hybrid mode this is a no-op. */
 181   #define ANNOTATE_NOT_HAPPENS_BEFORE_MUTEX(mu) \
 182     DYNAMIC_ANNOTATIONS_NAME(AnnotateMutexIsNotPHB)(__FILE__, __LINE__, mu)
 183
 184   /* Deprecated. Use ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX. */
 185   #define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) \
 186     DYNAMIC_ANNOTATIONS_NAME(AnnotateMutexIsUsedAsCondVar)(__FILE__, __LINE__, \
 187         mu)
 188
 189   /* -------------------------------------------------------------
 190      Annotations useful when defining memory allocators, or when memory that
 191      was protected in one way starts to be protected in another. */
 192
 193   /* Report that a new memory at "address" of size "size" has been allocated.
 194      This might be used when the memory has been retrieved from a free list and
 195      is about to be reused, or when a the locking discipline for a variable
 196      changes. */
 197   #define ANNOTATE_NEW_MEMORY(address, size) \
 198     DYNAMIC_ANNOTATIONS_NAME(AnnotateNewMemory)(__FILE__, __LINE__, address, \
 199         size)
 200
 201   /* -------------------------------------------------------------
 202      Annotations useful when defining FIFO queues that transfer data between
 203      threads. */
 204
 205   /* Report that the producer-consumer queue (such as ProducerConsumerQueue) at
 206      address "pcq" has been created.  The ANNOTATE_PCQ_* annotations
 207      should be used only for FIFO queues.  For non-FIFO queues use
 208      ANNOTATE_HAPPENS_BEFORE (for put) and ANNOTATE_HAPPENS_AFTER (for get). */
 209   #define ANNOTATE_PCQ_CREATE(pcq) \
 210     DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQCreate)(__FILE__, __LINE__, pcq)
 211
 212   /* Report that the queue at address "pcq" is about to be destroyed. */
 213   #define ANNOTATE_PCQ_DESTROY(pcq) \
 214     DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQDestroy)(__FILE__, __LINE__, pcq)
 215
 216   /* Report that we are about to put an element into a FIFO queue at address
 217      "pcq". */
 218   #define ANNOTATE_PCQ_PUT(pcq) \
 219     DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQPut)(__FILE__, __LINE__, pcq)
 220
 221   /* Report that we've just got an element from a FIFO queue at address
 222      "pcq". */
 223   #define ANNOTATE_PCQ_GET(pcq) \
 224     DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQGet)(__FILE__, __LINE__, pcq)
 225
 226   /* -------------------------------------------------------------
 227      Annotations that suppress errors.  It is usually better to express the
 228      program's synchronization using the other annotations, but these can
 229      be used when all else fails. */
 230
 231   /* Report that we may have a benign race at "pointer", with size
 232      "sizeof(*(pointer))". "pointer" must be a non-void* pointer.  Insert at the
 233      point where "pointer" has been allocated, preferably close to the point
 234      where the race happens.  See also ANNOTATE_BENIGN_RACE_STATIC. */
 235   #define ANNOTATE_BENIGN_RACE(pointer, description) \
 236     DYNAMIC_ANNOTATIONS_NAME(AnnotateBenignRaceSized)(__FILE__, __LINE__, \
 237         pointer, sizeof(*(pointer)), description)
 238
 239   /* Same as ANNOTATE_BENIGN_RACE(address, description), but applies to
 240      the memory range [address, address+size). */
 241   #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
 242     DYNAMIC_ANNOTATIONS_NAME(AnnotateBenignRaceSized)(__FILE__, __LINE__, \
 243         address, size, description)
 244
 245   /* Request the analysis tool to ignore all reads in the current thread
 246      until ANNOTATE_IGNORE_READS_END is called.
 247      Useful to ignore intentional racey reads, while still checking
 248      other reads and all writes.
 249      See also ANNOTATE_UNPROTECTED_READ. */
 250   #define ANNOTATE_IGNORE_READS_BEGIN() \
 251     DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__)
 252
 253   /* Stop ignoring reads. */
 254   #define ANNOTATE_IGNORE_READS_END() \
 255     DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
 256
 257   /* Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes. */
 258   #define ANNOTATE_IGNORE_WRITES_BEGIN() \
 259     DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
 260
 261   /* Stop ignoring writes. */
 262   #define ANNOTATE_IGNORE_WRITES_END() \
 263     DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
 264
 265   /* Start ignoring all memory accesses (reads and writes). */
 266   #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
 267     do {\
 268       ANNOTATE_IGNORE_READS_BEGIN();\
 269       ANNOTATE_IGNORE_WRITES_BEGIN();\
 270     }while(0)\
 271
 272   /* Stop ignoring all memory accesses. */
 273   #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \
 274     do {\
 275       ANNOTATE_IGNORE_WRITES_END();\
 276       ANNOTATE_IGNORE_READS_END();\
 277     }while(0)\
 278
 279   /* Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore synchronization events:
 280      RWLOCK* and CONDVAR*. */
 281   #define ANNOTATE_IGNORE_SYNC_BEGIN() \
 282     DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreSyncBegin)(__FILE__, __LINE__)
 283
 284   /* Stop ignoring sync events. */
 285   #define ANNOTATE_IGNORE_SYNC_END() \
 286     DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreSyncEnd)(__FILE__, __LINE__)
 287
 288
 289   /* Enable (enable!=0) or disable (enable==0) race detection for all threads.
 290      This annotation could be useful if you want to skip expensive race analysis
 291      during some period of program execution, e.g. during initialization. */
 292   #define ANNOTATE_ENABLE_RACE_DETECTION(enable) \
 293     DYNAMIC_ANNOTATIONS_NAME(AnnotateEnableRaceDetection)(__FILE__, __LINE__, \
 294         enable)
 295
 296   /* -------------------------------------------------------------
 297      Annotations useful for debugging. */
 298
 299   /* Request to trace every access to "address". */
 300   #define ANNOTATE_TRACE_MEMORY(address) \
 301     DYNAMIC_ANNOTATIONS_NAME(AnnotateTraceMemory)(__FILE__, __LINE__, address)
 302
 303   /* Report the current thread name to a race detector. */
 304   #define ANNOTATE_THREAD_NAME(name) \
 305     DYNAMIC_ANNOTATIONS_NAME(AnnotateThreadName)(__FILE__, __LINE__, name)
 306
 307   /* -------------------------------------------------------------
 308      Annotations useful when implementing locks.  They are not
 309      normally needed by modules that merely use locks.
 310      The "lock" argument is a pointer to the lock object. */
 311
 312   /* Report that a lock has been created at address "lock". */
 313   #define ANNOTATE_RWLOCK_CREATE(lock) \
 314     DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
 315
 316   /* Report that the lock at address "lock" is about to be destroyed. */
 317   #define ANNOTATE_RWLOCK_DESTROY(lock) \
 318     DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
 319
 320   /* Report that the lock at address "lock" has been acquired.
 321      is_w=1 for writer lock, is_w=0 for reader lock. */
 322   #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
 323     DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockAcquired)(__FILE__, __LINE__, lock, \
 324         is_w)
 325
 326   /* Report that the lock at address "lock" is about to be released. */
 327   #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
 328     DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockReleased)(__FILE__, __LINE__, lock, \
 329         is_w)
 330
 331   /* -------------------------------------------------------------
 332      Annotations useful when implementing barriers.  They are not
 333      normally needed by modules that merely use barriers.
 334      The "barrier" argument is a pointer to the barrier object. */
 335
 336   /* Report that the "barrier" has been initialized with initial "count".
 337    If 'reinitialization_allowed' is true, initialization is allowed to happen
 338    multiple times w/o calling barrier_destroy() */
 339   #define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \
 340     DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierInit)(__FILE__, __LINE__, barrier, \
 341         count, reinitialization_allowed)
 342
 343   /* Report that we are about to enter barrier_wait("barrier"). */
 344   #define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \
 345     DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierWaitBefore)(__FILE__, __LINE__, \
 346         barrier)
 347
 348   /* Report that we just exited barrier_wait("barrier"). */
 349   #define ANNOTATE_BARRIER_WAIT_AFTER(barrier) \
 350     DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierWaitAfter)(__FILE__, __LINE__, \
 351         barrier)
 352
 353   /* Report that the "barrier" has been destroyed. */
 354   #define ANNOTATE_BARRIER_DESTROY(barrier) \
 355     DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierDestroy)(__FILE__, __LINE__, \
 356         barrier)
 357
 358   /* -------------------------------------------------------------
 359      Annotations useful for testing race detectors. */
 360
 361   /* Report that we expect a race on the variable at "address".
 362      Use only in unit tests for a race detector. */
 363   #define ANNOTATE_EXPECT_RACE(address, description) \
 364     DYNAMIC_ANNOTATIONS_NAME(AnnotateExpectRace)(__FILE__, __LINE__, address, \
 365         description)
 366
 367   #define ANNOTATE_FLUSH_EXPECTED_RACES() \
 368     DYNAMIC_ANNOTATIONS_NAME(AnnotateFlushExpectedRaces)(__FILE__, __LINE__)
 369
 370   /* A no-op. Insert where you like to test the interceptors. */
 371   #define ANNOTATE_NO_OP(arg) \
 372     DYNAMIC_ANNOTATIONS_NAME(AnnotateNoOp)(__FILE__, __LINE__, arg)
 373
 374   /* Force the race detector to flush its state. The actual effect depends on
 375    * the implementation of the detector. */
 376   #define ANNOTATE_FLUSH_STATE() \
 377     DYNAMIC_ANNOTATIONS_NAME(AnnotateFlushState)(__FILE__, __LINE__)
 378
 379
 380 #else  /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
 381
 382   #define ANNOTATE_RWLOCK_CREATE(lock) /* empty */
 383   #define ANNOTATE_RWLOCK_DESTROY(lock) /* empty */
 384   #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) /* empty */
 385   #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) /* empty */
 386   #define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) /* */
 387   #define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) /* empty */
 388   #define ANNOTATE_BARRIER_WAIT_AFTER(barrier) /* empty */
 389   #define ANNOTATE_BARRIER_DESTROY(barrier) /* empty */
 390   #define ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) /* empty */
 391   #define ANNOTATE_CONDVAR_WAIT(cv) /* empty */
 392   #define ANNOTATE_CONDVAR_SIGNAL(cv) /* empty */
 393   #define ANNOTATE_CONDVAR_SIGNAL_ALL(cv) /* empty */
 394   #define ANNOTATE_HAPPENS_BEFORE(obj) /* empty */
 395   #define ANNOTATE_HAPPENS_AFTER(obj) /* empty */
 396   #define ANNOTATE_PUBLISH_MEMORY_RANGE(address, size) /* empty */
 397   #define ANNOTATE_UNPUBLISH_MEMORY_RANGE(address, size)  /* empty */
 398   #define ANNOTATE_SWAP_MEMORY_RANGE(address, size)  /* empty */
 399   #define ANNOTATE_PCQ_CREATE(pcq) /* empty */
 400   #define ANNOTATE_PCQ_DESTROY(pcq) /* empty */
 401   #define ANNOTATE_PCQ_PUT(pcq) /* empty */
 402   #define ANNOTATE_PCQ_GET(pcq) /* empty */
 403   #define ANNOTATE_NEW_MEMORY(address, size) /* empty */
 404   #define ANNOTATE_EXPECT_RACE(address, description) /* empty */
 405   #define ANNOTATE_FLUSH_EXPECTED_RACES(address, description) /* empty */
 406   #define ANNOTATE_BENIGN_RACE(address, description) /* empty */
 407   #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) /* empty */
 408   #define ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) /* empty */
 409   #define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) /* empty */
 410   #define ANNOTATE_TRACE_MEMORY(arg) /* empty */
 411   #define ANNOTATE_THREAD_NAME(name) /* empty */
 412   #define ANNOTATE_IGNORE_READS_BEGIN() /* empty */
 413   #define ANNOTATE_IGNORE_READS_END() /* empty */
 414   #define ANNOTATE_IGNORE_WRITES_BEGIN() /* empty */
 415   #define ANNOTATE_IGNORE_WRITES_END() /* empty */
 416   #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() /* empty */
 417   #define ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */
 418   #define ANNOTATE_IGNORE_SYNC_BEGIN() /* empty */
 419   #define ANNOTATE_IGNORE_SYNC_END() /* empty */
 420   #define ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */
 421   #define ANNOTATE_NO_OP(arg) /* empty */
 422   #define ANNOTATE_FLUSH_STATE() /* empty */
 423
 424 #endif  /* DYNAMIC_ANNOTATIONS_ENABLED */
 425
 426 /* Use the macros above rather than using these functions directly. */
 427 #ifdef __cplusplus
 428 extern "C" {
 429 #endif
 430
 431
 432 void DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockCreate)(
 433     const char *file, int line,
 434     const volatile void *lock) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 435 void DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockDestroy)(
 436     const char *file, int line,
 437     const volatile void *lock) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 438 void DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockAcquired)(
 439     const char *file, int line,
 440     const volatile void *lock, long is_w) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 441 void DYNAMIC_ANNOTATIONS_NAME(AnnotateRWLockReleased)(
 442     const char *file, int line,
 443     const volatile void *lock, long is_w) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 444 void DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierInit)(
 445     const char *file, int line, const volatile void *barrier, long count,
 446     long reinitialization_allowed) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 447 void DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierWaitBefore)(
 448     const char *file, int line,
 449     const volatile void *barrier) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 450 void DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierWaitAfter)(
 451     const char *file, int line,
 452     const volatile void *barrier) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 453 void DYNAMIC_ANNOTATIONS_NAME(AnnotateBarrierDestroy)(
 454     const char *file, int line,
 455     const volatile void *barrier) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 456 void DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarWait)(
 457     const char *file, int line, const volatile void *cv,
 458     const volatile void *lock) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 459 void DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarSignal)(
 460     const char *file, int line,
 461     const volatile void *cv) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 462 void DYNAMIC_ANNOTATIONS_NAME(AnnotateCondVarSignalAll)(
 463     const char *file, int line,
 464     const volatile void *cv) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 465 void DYNAMIC_ANNOTATIONS_NAME(AnnotateHappensBefore)(
 466     const char *file, int line,
 467     const volatile void *obj) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 468 void DYNAMIC_ANNOTATIONS_NAME(AnnotateHappensAfter)(
 469     const char *file, int line,
 470     const volatile void *obj) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 471 void DYNAMIC_ANNOTATIONS_NAME(AnnotatePublishMemoryRange)(
 472     const char *file, int line,
 473     const volatile void *address, long size) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 474 void DYNAMIC_ANNOTATIONS_NAME(AnnotateUnpublishMemoryRange)(
 475     const char *file, int line,
 476     const volatile void *address, long size) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 477 void DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQCreate)(
 478     const char *file, int line,
 479     const volatile void *pcq) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 480 void DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQDestroy)(
 481     const char *file, int line,
 482     const volatile void *pcq) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 483 void DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQPut)(
 484     const char *file, int line,
 485     const volatile void *pcq) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 486 void DYNAMIC_ANNOTATIONS_NAME(AnnotatePCQGet)(
 487     const char *file, int line,
 488     const volatile void *pcq) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 489 void DYNAMIC_ANNOTATIONS_NAME(AnnotateNewMemory)(
 490     const char *file, int line,
 491     const volatile void *mem, long size) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 492 void DYNAMIC_ANNOTATIONS_NAME(AnnotateExpectRace)(
 493     const char *file, int line, const volatile void *mem,
 494     const char *description) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 495 void DYNAMIC_ANNOTATIONS_NAME(AnnotateFlushExpectedRaces)(
 496     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 497 void DYNAMIC_ANNOTATIONS_NAME(AnnotateBenignRace)(
 498     const char *file, int line, const volatile void *mem,
 499     const char *description) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 500 void DYNAMIC_ANNOTATIONS_NAME(AnnotateBenignRaceSized)(
 501     const char *file, int line, const volatile void *mem, long size,
 502     const char *description) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 503 void DYNAMIC_ANNOTATIONS_NAME(AnnotateMutexIsUsedAsCondVar)(
 504     const char *file, int line,
 505     const volatile void *mu) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 506 void DYNAMIC_ANNOTATIONS_NAME(AnnotateMutexIsNotPHB)(
 507     const char *file, int line,
 508     const volatile void *mu) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 509 void DYNAMIC_ANNOTATIONS_NAME(AnnotateTraceMemory)(
 510     const char *file, int line,
 511     const volatile void *arg) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 512 void DYNAMIC_ANNOTATIONS_NAME(AnnotateThreadName)(
 513     const char *file, int line,
 514     const char *name) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 515 void DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreReadsBegin)(
 516     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 517 void DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreReadsEnd)(
 518     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 519 void DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreWritesBegin)(
 520     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 521 void DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreWritesEnd)(
 522     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 523 void DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreSyncBegin)(
 524     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 525 void DYNAMIC_ANNOTATIONS_NAME(AnnotateIgnoreSyncEnd)(
 526     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 527 void DYNAMIC_ANNOTATIONS_NAME(AnnotateEnableRaceDetection)(
 528     const char *file, int line, int enable) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 529 void DYNAMIC_ANNOTATIONS_NAME(AnnotateNoOp)(
 530     const char *file, int line,
 531     const volatile void *arg) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 532 void DYNAMIC_ANNOTATIONS_NAME(AnnotateFlushState)(
 533     const char *file, int line) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 534
 535 #if DYNAMIC_ANNOTATIONS_PROVIDE_RUNNING_ON_VALGRIND == 1
 536 /* Return non-zero value if running under valgrind.
 537
 538   If "valgrind.h" is included into dynamic_annotations.c,
 539   the regular valgrind mechanism will be used.
 540   See http://valgrind.org/docs/manual/manual-core-adv.html about
 541   RUNNING_ON_VALGRIND and other valgrind "client requests".
 542   The file "valgrind.h" may be obtained by doing
 543      svn co svn://svn.valgrind.org/valgrind/trunk/include
 544
 545   If for some reason you can't use "valgrind.h" or want to fake valgrind,
 546   there are two ways to make this function return non-zero:
 547     - Use environment variable: export RUNNING_ON_VALGRIND=1
 548     - Make your tool intercept the function RunningOnValgrind() and
 549       change its return value.
 550  */
 551 int RunningOnValgrind(void) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
 552 #endif /* DYNAMIC_ANNOTATIONS_PROVIDE_RUNNING_ON_VALGRIND == 1 */
 553
 554 #ifdef __cplusplus
 555 }
 556 #endif
 557
 558 #if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus)
 559
 560   /* ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
 561
 562      Instead of doing
 563         ANNOTATE_IGNORE_READS_BEGIN();
 564         ... = x;
 565         ANNOTATE_IGNORE_READS_END();
 566      one can use
 567         ... = ANNOTATE_UNPROTECTED_READ(x); */
 568   template <class T>
 569   inline T ANNOTATE_UNPROTECTED_READ(const volatile T &x) {
 570     ANNOTATE_IGNORE_READS_BEGIN();
 571     T res = x;
 572     ANNOTATE_IGNORE_READS_END();
 573     return res;
 574   }
 575   /* Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable. */
 576   #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)        \
 577     namespace {                                                       \
 578       class static_var ## _annotator {                                \
 579        public:                                                        \
 580         static_var ## _annotator() {                                  \
 581           ANNOTATE_BENIGN_RACE_SIZED(&static_var,                     \
 582                                       sizeof(static_var),             \
 583             # static_var ": " description);                           \
 584         }                                                             \
 585       };                                                              \
 586       static static_var ## _annotator the ## static_var ## _annotator;\
 587     }
 588 #else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
 589
 590   #define ANNOTATE_UNPROTECTED_READ(x) (x)
 591   #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)  /* empty */
 592
 593 #endif /* DYNAMIC_ANNOTATIONS_ENABLED */
 594
 595 #endif  /* __DYNAMIC_ANNOTATIONS_H__ */