| /* Copyright (c) 2008-2009, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * --- |
| * Author: Kostya Serebryany |
| */ |
| |
| /* This file defines dynamic annotations for use with dynamic analysis |
| tool such as valgrind, PIN, etc. |
| |
| Dynamic annotation is a source code annotation that affects |
| the generated code (that is, the annotation is not a comment). |
| Each such annotation is attached to a particular |
| instruction and/or to a particular object (address) in the program. |
| |
| The annotations that should be used by users are macros in all upper-case |
| (e.g., ANNOTATE_NEW_MEMORY). |
| |
| Actual implementation of these macros may differ depending on the |
| dynamic analysis tool being used. |
| |
| See http://code.google.com/p/data-race-test/ for more information. |
| |
| This file supports the following dynamic analysis tools: |
| - None (DYNAMIC_ANNOTATIONS_ENABLED is not defined or zero). |
| Macros are defined empty. |
| - ThreadSanitizer, Helgrind, DRD (DYNAMIC_ANNOTATIONS_ENABLED is 1). |
| Macros are defined as calls to non-inlinable empty functions |
| that are intercepted by Valgrind. */ |
| |
| #ifndef __DYNAMIC_ANNOTATIONS_H__ |
| #define __DYNAMIC_ANNOTATIONS_H__ |
| |
| #ifndef DYNAMIC_ANNOTATIONS_ENABLED |
| #define DYNAMIC_ANNOTATIONS_ENABLED 0 |
| #endif |
| |
| #if DYNAMIC_ANNOTATIONS_ENABLED != 0 |
| |
| /* ------------------------------------------------------------- |
| Annotations useful when implementing condition variables such as CondVar, |
| using conditional critical sections (Await/LockWhen) and when constructing |
| user-defined synchronization mechanisms. |
| |
| The annotations ANNOTATE_HAPPENS_BEFORE() and ANNOTATE_HAPPENS_AFTER() can |
| be used to define happens-before arcs in user-defined synchronization |
| mechanisms: the race detector will infer an arc from the former to the |
| latter when they share the same argument pointer. |
| |
| Example 1 (reference counting): |
| |
| void Unref() { |
| ANNOTATE_HAPPENS_BEFORE(&refcount_); |
| if (AtomicDecrementByOne(&refcount_) == 0) { |
| ANNOTATE_HAPPENS_AFTER(&refcount_); |
| delete this; |
| } |
| } |
| |
| Example 2 (message queue): |
| |
| void MyQueue::Put(Type *e) { |
| MutexLock lock(&mu_); |
| ANNOTATE_HAPPENS_BEFORE(e); |
| PutElementIntoMyQueue(e); |
| } |
| |
| Type *MyQueue::Get() { |
| MutexLock lock(&mu_); |
| Type *e = GetElementFromMyQueue(); |
| ANNOTATE_HAPPENS_AFTER(e); |
| return e; |
| } |
| |
| Note: when possible, please use the existing reference counting and message |
| queue implementations instead of inventing new ones. */ |
| |
| /* Report that wait on the condition variable at address "cv" has succeeded |
| and the lock at address "lock" is held. */ |
| #define ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) AnnotateCondVarWait(__FILE__, __LINE__, cv, lock) |
| |
| /* Report that wait on the condition variable at "cv" has succeeded. Variant |
| w/o lock. */ |
| #define ANNOTATE_CONDVAR_WAIT(cv) AnnotateCondVarWait(__FILE__, __LINE__, cv, NULL) |
| |
| /* Report that we are about to signal on the condition variable at address |
| "cv". */ |
| #define ANNOTATE_CONDVAR_SIGNAL(cv) AnnotateCondVarSignal(__FILE__, __LINE__, cv) |
| |
| /* Report that we are about to signal_all on the condition variable at "cv". */ |
| #define ANNOTATE_CONDVAR_SIGNAL_ALL(cv) AnnotateCondVarSignalAll(__FILE__, __LINE__, cv) |
| |
| /* Annotations for user-defined synchronization mechanisms. */ |
| #define ANNOTATE_HAPPENS_BEFORE(obj) ANNOTATE_CONDVAR_SIGNAL(obj) |
| #define ANNOTATE_HAPPENS_AFTER(obj) ANNOTATE_CONDVAR_WAIT(obj) |
| |
| /* Report that the bytes in the range [pointer, pointer+size) are about |
| to be published safely. The race checker will create a happens-before |
| arc from the call ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) to |
| subsequent accesses to this memory. |
| Note: this annotation may not work properly if the race detector uses |
| sampling, i.e. does not observe all memory accesses. |
| */ |
| #define ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \ |
| AnnotatePublishMemoryRange(__FILE__, __LINE__, pointer, size) |
| |
| /* DEPRECATED. Don't use it. */ |
| #define ANNOTATE_UNPUBLISH_MEMORY_RANGE(pointer, size) \ |
| AnnotateUnpublishMemoryRange(__FILE__, __LINE__, pointer, size) |
| |
| /* DEPRECATED. Don't use it. */ |
| #define ANNOTATE_SWAP_MEMORY_RANGE(pointer, size) \ |
| do { \ |
| ANNOTATE_UNPUBLISH_MEMORY_RANGE(pointer, size); \ |
| ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size); \ |
| } while (0) |
| |
| /* Instruct the tool to create a happens-before arc between mu->Unlock() and |
| mu->Lock(). This annotation may slow down the race detector and hide real |
| races. Normally it is used only when it would be difficult to annotate each |
| of the mutex's critical sections individually using the annotations above. |
| This annotation makes sense only for hybrid race detectors. For pure |
| happens-before detectors this is a no-op. For more details see |
| http://code.google.com/p/data-race-test/wiki/PureHappensBeforeVsHybrid . */ |
| #define ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) AnnotateMutexIsUsedAsCondVar(__FILE__, __LINE__, mu) |
| |
| /* Deprecated. Use ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX. */ |
| #define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) AnnotateMutexIsUsedAsCondVar(__FILE__, __LINE__, mu) |
| |
| /* ------------------------------------------------------------- |
| Annotations useful when defining memory allocators, or when memory that |
| was protected in one way starts to be protected in another. */ |
| |
| /* Report that a new memory at "address" of size "size" has been allocated. |
| This might be used when the memory has been retrieved from a free list and |
| is about to be reused, or when a the locking discipline for a variable |
| changes. */ |
| #define ANNOTATE_NEW_MEMORY(address, size) AnnotateNewMemory(__FILE__, __LINE__, address, size) |
| |
| /* ------------------------------------------------------------- |
| Annotations useful when defining FIFO queues that transfer data between |
| threads. */ |
| |
| /* Report that the producer-consumer queue (such as ProducerConsumerQueue) at |
| address "pcq" has been created. The ANNOTATE_PCQ_* annotations |
| should be used only for FIFO queues. For non-FIFO queues use |
| ANNOTATE_HAPPENS_BEFORE (for put) and ANNOTATE_HAPPENS_AFTER (for get). */ |
| #define ANNOTATE_PCQ_CREATE(pcq) AnnotatePCQCreate(__FILE__, __LINE__, pcq) |
| |
| /* Report that the queue at address "pcq" is about to be destroyed. */ |
| #define ANNOTATE_PCQ_DESTROY(pcq) AnnotatePCQDestroy(__FILE__, __LINE__, pcq) |
| |
| /* Report that we are about to put an element into a FIFO queue at address |
| "pcq". */ |
| #define ANNOTATE_PCQ_PUT(pcq) AnnotatePCQPut(__FILE__, __LINE__, pcq) |
| |
| /* Report that we've just got an element from a FIFO queue at address "pcq". */ |
| #define ANNOTATE_PCQ_GET(pcq) AnnotatePCQGet(__FILE__, __LINE__, pcq) |
| |
| /* ------------------------------------------------------------- |
| Annotations that suppress errors. It is usually better to express the |
| program's synchronization using the other annotations, but these can |
| be used when all else fails. */ |
| |
| /* Report that we may have a benign race at "pointer", with size |
| "sizeof(*(pointer))". "pointer" must be a non-void* pointer. Insert at the |
| point where "pointer" has been allocated, preferably close to the point |
| where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC. */ |
| #define ANNOTATE_BENIGN_RACE(pointer, description) \ |
| AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, sizeof(*(pointer)), description) |
| |
| /* Same as ANNOTATE_BENIGN_RACE(address, description), but applies to |
| the memory range [address, address+size). */ |
| #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \ |
| AnnotateBenignRaceSized(__FILE__, __LINE__, address, size, description) |
| |
| /* Request the analysis tool to ignore all reads in the current thread |
| until ANNOTATE_IGNORE_READS_END is called. |
| Useful to ignore intentional racey reads, while still checking |
| other reads and all writes. |
| See also ANNOTATE_UNPROTECTED_READ. */ |
| #define ANNOTATE_IGNORE_READS_BEGIN() AnnotateIgnoreReadsBegin(__FILE__, __LINE__) |
| |
| /* Stop ignoring reads. */ |
| #define ANNOTATE_IGNORE_READS_END() AnnotateIgnoreReadsEnd(__FILE__, __LINE__) |
| |
| /* Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes. */ |
| #define ANNOTATE_IGNORE_WRITES_BEGIN() AnnotateIgnoreWritesBegin(__FILE__, __LINE__) |
| |
| /* Stop ignoring writes. */ |
| #define ANNOTATE_IGNORE_WRITES_END() AnnotateIgnoreWritesEnd(__FILE__, __LINE__) |
| |
| /* Start ignoring all memory accesses (reads and writes). */ |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ |
| do { \ |
| ANNOTATE_IGNORE_READS_BEGIN(); \ |
| ANNOTATE_IGNORE_WRITES_BEGIN(); \ |
| } while (0) |
| |
| /* Stop ignoring all memory accesses. */ |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \ |
| do { \ |
| ANNOTATE_IGNORE_WRITES_END(); \ |
| ANNOTATE_IGNORE_READS_END(); \ |
| } while (0) |
| |
| /* Start ignoring all synchronization until ANNOTATE_IGNORE_SYNC_END |
| is called. */ |
| #define ANNOTATE_IGNORE_SYNC_BEGIN() AnnotateIgnoreSyncBegin(__FILE__, __LINE__) |
| |
| /* Stop ignoring all synchronization. */ |
| #define ANNOTATE_IGNORE_SYNC_END() AnnotateIgnoreSyncEnd(__FILE__, __LINE__) |
| |
| /* Enable (enable!=0) or disable (enable==0) race detection for all threads. |
| This annotation could be useful if you want to skip expensive race analysis |
| during some period of program execution, e.g. during initialization. */ |
| #define ANNOTATE_ENABLE_RACE_DETECTION(enable) \ |
| AnnotateEnableRaceDetection(__FILE__, __LINE__, enable) |
| |
| /* ------------------------------------------------------------- |
| Annotations useful for debugging. */ |
| |
| /* Request to trace every access to "address". */ |
| #define ANNOTATE_TRACE_MEMORY(address) AnnotateTraceMemory(__FILE__, __LINE__, address) |
| |
| /* Report the current thread name to a race detector. */ |
| #define ANNOTATE_THREAD_NAME(name) AnnotateThreadName(__FILE__, __LINE__, name) |
| |
| /* ------------------------------------------------------------- |
| Annotations useful when implementing locks. They are not |
| normally needed by modules that merely use locks. |
| The "lock" argument is a pointer to the lock object. */ |
| |
| /* Report that a lock has been created at address "lock". */ |
| #define ANNOTATE_RWLOCK_CREATE(lock) AnnotateRWLockCreate(__FILE__, __LINE__, lock) |
| |
| /* Report that a linker initialized lock has been created at address "lock". |
| */ |
| #ifdef THREAD_SANITIZER |
| #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) AnnotateRWLockCreateStatic(__FILE__, __LINE__, lock) |
| #else |
| #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock) |
| #endif |
| |
| /* Report that the lock at address "lock" is about to be destroyed. */ |
| #define ANNOTATE_RWLOCK_DESTROY(lock) AnnotateRWLockDestroy(__FILE__, __LINE__, lock) |
| |
| /* Report that the lock at address "lock" has been acquired. |
| is_w=1 for writer lock, is_w=0 for reader lock. */ |
| #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w) |
| |
| /* Report that the lock at address "lock" is about to be released. */ |
| #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w) |
| |
| /* ------------------------------------------------------------- |
| Annotations useful when implementing barriers. They are not |
| normally needed by modules that merely use barriers. |
| The "barrier" argument is a pointer to the barrier object. */ |
| |
| /* Report that the "barrier" has been initialized with initial "count". |
| If 'reinitialization_allowed' is true, initialization is allowed to happen |
| multiple times w/o calling barrier_destroy() */ |
| #define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \ |
| AnnotateBarrierInit(__FILE__, __LINE__, barrier, count, reinitialization_allowed) |
| |
| /* Report that we are about to enter barrier_wait("barrier"). */ |
| #define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) AnnotateBarrierWaitBefore(__FILE__, __LINE__, barrier) |
| |
| /* Report that we just exited barrier_wait("barrier"). */ |
| #define ANNOTATE_BARRIER_WAIT_AFTER(barrier) AnnotateBarrierWaitAfter(__FILE__, __LINE__, barrier) |
| |
| /* Report that the "barrier" has been destroyed. */ |
| #define ANNOTATE_BARRIER_DESTROY(barrier) AnnotateBarrierDestroy(__FILE__, __LINE__, barrier) |
| |
| /* ------------------------------------------------------------- |
| Annotations useful for testing race detectors. */ |
| |
| /* Report that we expect a race on the variable at "address". |
| Use only in unit tests for a race detector. */ |
| #define ANNOTATE_EXPECT_RACE(address, description) \ |
| AnnotateExpectRace(__FILE__, __LINE__, address, description) |
| |
| /* A no-op. Insert where you like to test the interceptors. */ |
| #define ANNOTATE_NO_OP(arg) AnnotateNoOp(__FILE__, __LINE__, arg) |
| |
| /* Force the race detector to flush its state. The actual effect depends on |
| * the implementation of the detector. */ |
| #define ANNOTATE_FLUSH_STATE() AnnotateFlushState(__FILE__, __LINE__) |
| |
| #else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */ |
| |
| #define ANNOTATE_RWLOCK_CREATE(lock) /* empty */ |
| #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) /* empty */ |
| #define ANNOTATE_RWLOCK_DESTROY(lock) /* empty */ |
| #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) /* empty */ |
| #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) /* empty */ |
| #define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) /* */ |
| #define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) /* empty */ |
| #define ANNOTATE_BARRIER_WAIT_AFTER(barrier) /* empty */ |
| #define ANNOTATE_BARRIER_DESTROY(barrier) /* empty */ |
| #define ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) /* empty */ |
| #define ANNOTATE_CONDVAR_WAIT(cv) /* empty */ |
| #define ANNOTATE_CONDVAR_SIGNAL(cv) /* empty */ |
| #define ANNOTATE_CONDVAR_SIGNAL_ALL(cv) /* empty */ |
| #define ANNOTATE_HAPPENS_BEFORE(obj) /* empty */ |
| #define ANNOTATE_HAPPENS_AFTER(obj) /* empty */ |
| #define ANNOTATE_PUBLISH_MEMORY_RANGE(address, size) /* empty */ |
| #define ANNOTATE_UNPUBLISH_MEMORY_RANGE(address, size) /* empty */ |
| #define ANNOTATE_SWAP_MEMORY_RANGE(address, size) /* empty */ |
| #define ANNOTATE_PCQ_CREATE(pcq) /* empty */ |
| #define ANNOTATE_PCQ_DESTROY(pcq) /* empty */ |
| #define ANNOTATE_PCQ_PUT(pcq) /* empty */ |
| #define ANNOTATE_PCQ_GET(pcq) /* empty */ |
| #define ANNOTATE_NEW_MEMORY(address, size) /* empty */ |
| #define ANNOTATE_EXPECT_RACE(address, description) /* empty */ |
| #define ANNOTATE_BENIGN_RACE(address, description) /* empty */ |
| #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) /* empty */ |
| #define ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) /* empty */ |
| #define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) /* empty */ |
| #define ANNOTATE_TRACE_MEMORY(arg) /* empty */ |
| #define ANNOTATE_THREAD_NAME(name) /* empty */ |
| #define ANNOTATE_IGNORE_READS_BEGIN() /* empty */ |
| #define ANNOTATE_IGNORE_READS_END() /* empty */ |
| #define ANNOTATE_IGNORE_WRITES_BEGIN() /* empty */ |
| #define ANNOTATE_IGNORE_WRITES_END() /* empty */ |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() /* empty */ |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */ |
| #define ANNOTATE_IGNORE_SYNC_BEGIN() /* empty */ |
| #define ANNOTATE_IGNORE_SYNC_END() /* empty */ |
| #define ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */ |
| #define ANNOTATE_NO_OP(arg) /* empty */ |
| #define ANNOTATE_FLUSH_STATE() /* empty */ |
| |
| #endif /* DYNAMIC_ANNOTATIONS_ENABLED */ |
| |
| /* Macro definitions for GCC attributes that allow static thread safety |
| analysis to recognize and use some of the dynamic annotations as |
| escape hatches. |
| TODO(user): remove the check for __SUPPORT_DYN_ANNOTATION__ once the |
| default crosstool/GCC supports these GCC attributes. */ |
| |
| #define ANNOTALYSIS_STATIC_INLINE |
| #define ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY ; |
| #define ANNOTALYSIS_IGNORE_READS_BEGIN |
| #define ANNOTALYSIS_IGNORE_READS_END |
| #define ANNOTALYSIS_IGNORE_WRITES_BEGIN |
| #define ANNOTALYSIS_IGNORE_WRITES_END |
| #define ANNOTALYSIS_UNPROTECTED_READ |
| |
| #if defined(__GNUC__) && (!defined(SWIG)) && (!defined(__clang__)) |
| |
| #if DYNAMIC_ANNOTATIONS_ENABLED == 0 |
| #define ANNOTALYSIS_ONLY 1 |
| #undef ANNOTALYSIS_STATIC_INLINE |
| #define ANNOTALYSIS_STATIC_INLINE inline //static inline |
| #undef ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY |
| #define ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY \ |
| { \ |
| (void)file; \ |
| (void)line; \ |
| } |
| #endif |
| |
| /* Only emit attributes when annotalysis is enabled. */ |
| #if defined(__SUPPORT_TS_ANNOTATION__) && defined(__SUPPORT_DYN_ANNOTATION__) |
| #undef ANNOTALYSIS_IGNORE_READS_BEGIN |
| #define ANNOTALYSIS_IGNORE_READS_BEGIN __attribute__((ignore_reads_begin)) |
| #undef ANNOTALYSIS_IGNORE_READS_END |
| #define ANNOTALYSIS_IGNORE_READS_END __attribute__((ignore_reads_end)) |
| #undef ANNOTALYSIS_IGNORE_WRITES_BEGIN |
| #define ANNOTALYSIS_IGNORE_WRITES_BEGIN __attribute__((ignore_writes_begin)) |
| #undef ANNOTALYSIS_IGNORE_WRITES_END |
| #define ANNOTALYSIS_IGNORE_WRITES_END __attribute__((ignore_writes_end)) |
| #undef ANNOTALYSIS_UNPROTECTED_READ |
| #define ANNOTALYSIS_UNPROTECTED_READ __attribute__((unprotected_read)) |
| #endif |
| |
| #endif // defined(__GNUC__) && (!defined(SWIG)) && (!defined(__clang__)) |
| |
| /* TODO(user) -- Replace __CLANG_SUPPORT_DYN_ANNOTATION__ with the |
| appropriate feature ID. */ |
| #if defined(__clang__) && (!defined(SWIG)) && defined(__CLANG_SUPPORT_DYN_ANNOTATION__) |
| |
| /* TODO(user) -- The exclusive lock here ignores writes as well, but |
| allows INGORE_READS_AND_WRITES to work properly. */ |
| #undef ANNOTALYSIS_IGNORE_READS_BEGIN |
| #define ANNOTALYSIS_IGNORE_READS_BEGIN __attribute__((exclusive_lock_function("*"))) |
| #undef ANNOTALYSIS_IGNORE_READS_END |
| #define ANNOTALYSIS_IGNORE_READS_END __attribute__((unlock_function("*"))) |
| |
| #if DYNAMIC_ANNOTATIONS_ENABLED == 0 |
| /* Turn on certain macros for static analysis, even if dynamic annotations are |
| not enabled. */ |
| #define CLANG_ANNOTALYSIS_ONLY 1 |
| |
| #undef ANNOTALYSIS_STATIC_INLINE |
| #define ANNOTALYSIS_STATIC_INLINE inline //static inline |
| #undef ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY |
| #define ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY \ |
| { \ |
| (void)file; \ |
| (void)line; \ |
| } |
| |
| #endif /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */ |
| #endif /* defined(__clang__) && (!defined(SWIG)) */ |
| |
| /* Use the macros above rather than using these functions directly. */ |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| void AnnotateRWLockCreate(const char* file, int line, const volatile void* lock); |
| void AnnotateRWLockCreateStatic(const char* file, int line, const volatile void* lock); |
| void AnnotateRWLockDestroy(const char* file, int line, const volatile void* lock); |
| void AnnotateRWLockAcquired(const char* file, int line, const volatile void* lock, long is_w); |
| void AnnotateRWLockReleased(const char* file, int line, const volatile void* lock, long is_w); |
| void AnnotateBarrierInit(const char* file, int line, const volatile void* barrier, long count, |
| long reinitialization_allowed); |
| void AnnotateBarrierWaitBefore(const char* file, int line, const volatile void* barrier); |
| void AnnotateBarrierWaitAfter(const char* file, int line, const volatile void* barrier); |
| void AnnotateBarrierDestroy(const char* file, int line, const volatile void* barrier); |
| void AnnotateCondVarWait(const char* file, int line, const volatile void* cv, |
| const volatile void* lock); |
| void AnnotateCondVarSignal(const char* file, int line, const volatile void* cv); |
| void AnnotateCondVarSignalAll(const char* file, int line, const volatile void* cv); |
| void AnnotatePublishMemoryRange(const char* file, int line, const volatile void* address, |
| long size); |
| void AnnotateUnpublishMemoryRange(const char* file, int line, const volatile void* address, |
| long size); |
| void AnnotatePCQCreate(const char* file, int line, const volatile void* pcq); |
| void AnnotatePCQDestroy(const char* file, int line, const volatile void* pcq); |
| void AnnotatePCQPut(const char* file, int line, const volatile void* pcq); |
| void AnnotatePCQGet(const char* file, int line, const volatile void* pcq); |
| void AnnotateNewMemory(const char* file, int line, const volatile void* address, long size); |
| void AnnotateExpectRace(const char* file, int line, const volatile void* address, |
| const char* description); |
| void AnnotateBenignRace(const char* file, int line, const volatile void* address, |
| const char* description); |
| void AnnotateBenignRaceSized(const char* file, int line, const volatile void* address, long size, |
| const char* description); |
| void AnnotateMutexIsUsedAsCondVar(const char* file, int line, const volatile void* mu); |
| void AnnotateTraceMemory(const char* file, int line, const volatile void* arg); |
| void AnnotateThreadName(const char* file, int line, const char* name); |
| ANNOTALYSIS_STATIC_INLINE |
| void AnnotateIgnoreReadsBegin(const char* file, int line) |
| ANNOTALYSIS_IGNORE_READS_BEGIN ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY ANNOTALYSIS_STATIC_INLINE |
| void AnnotateIgnoreReadsEnd(const char* file, int line) ANNOTALYSIS_IGNORE_READS_END |
| ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY ANNOTALYSIS_STATIC_INLINE |
| void AnnotateIgnoreWritesBegin(const char* file, int line) ANNOTALYSIS_IGNORE_WRITES_BEGIN |
| ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY ANNOTALYSIS_STATIC_INLINE |
| void AnnotateIgnoreWritesEnd(const char* file, int line) |
| ANNOTALYSIS_IGNORE_WRITES_END ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY |
| void AnnotateIgnoreSyncBegin(const char* file, int line); |
| void AnnotateIgnoreSyncEnd(const char* file, int line); |
| void AnnotateEnableRaceDetection(const char* file, int line, int enable); |
| void AnnotateNoOp(const char* file, int line, const volatile void* arg); |
| void AnnotateFlushState(const char* file, int line); |
| |
| /* AddressSanitizer annotations from LLVM asan_interface.h */ |
| |
| #if defined(__SANITIZE_ADDRESS__) || defined(ADDRESS_SANITIZER) |
| // Marks memory region [addr, addr+size) as unaddressable. |
| // This memory must be previously allocated by the user program. Accessing |
| // addresses in this region from instrumented code is forbidden until |
| // this region is unpoisoned. This function is not guaranteed to poison |
| // the whole region - it may poison only subregion of [addr, addr+size) due |
| // to ASan alignment restrictions. |
| // Method is NOT thread-safe in the sense that no two threads can |
| // (un)poison memory in the same memory region simultaneously. |
| void __asan_poison_memory_region(void const volatile* addr, size_t size); |
| // Marks memory region [addr, addr+size) as addressable. |
| // This memory must be previously allocated by the user program. Accessing |
| // addresses in this region is allowed until this region is poisoned again. |
| // This function may unpoison a superregion of [addr, addr+size) due to |
| // ASan alignment restrictions. |
| // Method is NOT thread-safe in the sense that no two threads can |
| // (un)poison memory in the same memory region simultaneously. |
| void __asan_unpoison_memory_region(void const volatile* addr, size_t size); |
| |
| // User code should use macros instead of functions. |
| #define ASAN_POISON_MEMORY_REGION(addr, size) __asan_poison_memory_region((addr), (size)) |
| #define ASAN_UNPOISON_MEMORY_REGION(addr, size) __asan_unpoison_memory_region((addr), (size)) |
| #else |
| #define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) |
| #define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) |
| #endif |
| |
| // Sets the callback to be called right before death on error. |
| // Passing 0 will unset the callback. |
| void __asan_set_death_callback(void (*callback)(void)); |
| |
| #if defined(__SANITIZE_ADDRESS__) || defined(ADDRESS_SANITIZER) |
| #define ASAN_SET_DEATH_CALLBACK(cb) __asan_set_death_callback((cb)) |
| #else |
| #define ASAN_SET_DEATH_CALLBACK(cb) ((void)(cb)) |
| #endif |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus) |
| |
| /* ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads. |
| |
| Instead of doing |
| ANNOTATE_IGNORE_READS_BEGIN(); |
| ... = x; |
| ANNOTATE_IGNORE_READS_END(); |
| one can use |
| ... = ANNOTATE_UNPROTECTED_READ(x); */ |
| template <class T> |
| T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_READ { |
| ANNOTATE_IGNORE_READS_BEGIN(); |
| T res = x; |
| ANNOTATE_IGNORE_READS_END(); |
| return res; |
| } |
| /* Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable. */ |
| #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description) \ |
| namespace { \ |
| class static_var##_annotator { \ |
| public: \ |
| static_var##_annotator() { \ |
| ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \ |
| #static_var ": " description); \ |
| } \ |
| }; \ |
| static static_var##_annotator the##static_var##_annotator; \ |
| } |
| #else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */ |
| |
| #define ANNOTATE_UNPROTECTED_READ(x) (x) |
| #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description) /* empty */ |
| |
| #endif /* DYNAMIC_ANNOTATIONS_ENABLED */ |
| |
| /* Annotalysis, a GCC based static analyzer, is able to understand and use |
| some of the dynamic annotations defined in this file. However, dynamic |
| annotations are usually disabled in the opt mode (to avoid additional |
| runtime overheads) while Annotalysis only works in the opt mode. |
| In order for Annotalysis to use these dynamic annotations when they |
| are disabled, we re-define these annotations here. Note that unlike the |
| original macro definitions above, these macros are expanded to calls to |
| static inline functions so that the compiler will be able to remove the |
| calls after the analysis. */ |
| |
| #ifdef ANNOTALYSIS_ONLY |
| |
| #undef ANNOTALYSIS_ONLY |
| |
| /* Undefine and re-define the macros that the static analyzer understands. */ |
| #undef ANNOTATE_IGNORE_READS_BEGIN |
| #define ANNOTATE_IGNORE_READS_BEGIN() AnnotateIgnoreReadsBegin(__FILE__, __LINE__) |
| |
| #undef ANNOTATE_IGNORE_READS_END |
| #define ANNOTATE_IGNORE_READS_END() AnnotateIgnoreReadsEnd(__FILE__, __LINE__) |
| |
| #undef ANNOTATE_IGNORE_WRITES_BEGIN |
| #define ANNOTATE_IGNORE_WRITES_BEGIN() AnnotateIgnoreWritesBegin(__FILE__, __LINE__) |
| |
| #undef ANNOTATE_IGNORE_WRITES_END |
| #define ANNOTATE_IGNORE_WRITES_END() AnnotateIgnoreWritesEnd(__FILE__, __LINE__) |
| |
| #undef ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ |
| do { \ |
| ANNOTATE_IGNORE_READS_BEGIN(); \ |
| ANNOTATE_IGNORE_WRITES_BEGIN(); \ |
| } while (0) |
| |
| #undef ANNOTATE_IGNORE_READS_AND_WRITES_END |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \ |
| do { \ |
| ANNOTATE_IGNORE_WRITES_END(); \ |
| ANNOTATE_IGNORE_READS_END(); \ |
| } while (0) |
| |
| #if defined(__cplusplus) |
| #undef ANNOTATE_UNPROTECTED_READ |
| template <class T> |
| T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_READ { |
| ANNOTATE_IGNORE_READS_BEGIN(); |
| T res = x; |
| ANNOTATE_IGNORE_READS_END(); |
| return res; |
| } |
| #endif /* __cplusplus */ |
| |
| #endif /* ANNOTALYSIS_ONLY */ |
| |
| #ifdef CLANG_ANNOTALYSIS_ONLY |
| |
| #undef CLANG_ANNOTALYSIS_ONLY |
| |
| /* Turn on macros that the static analyzer understands. These should be on |
| * even if dynamic annotations are off. */ |
| |
| #undef ANNOTATE_IGNORE_READS_BEGIN |
| #define ANNOTATE_IGNORE_READS_BEGIN() AnnotateIgnoreReadsBegin(__FILE__, __LINE__) |
| |
| #undef ANNOTATE_IGNORE_READS_END |
| #define ANNOTATE_IGNORE_READS_END() AnnotateIgnoreReadsEnd(__FILE__, __LINE__) |
| |
| #undef ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ |
| do { \ |
| ANNOTATE_IGNORE_READS_BEGIN(); \ |
| ANNOTATE_IGNORE_WRITES_BEGIN(); \ |
| } while (0) |
| |
| #undef ANNOTATE_IGNORE_READS_AND_WRITES_END |
| #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \ |
| do { \ |
| ANNOTATE_IGNORE_WRITES_END(); \ |
| ANNOTATE_IGNORE_READS_END(); \ |
| } while (0) |
| |
| #if defined(__cplusplus) |
| #undef ANNOTATE_UNPROTECTED_READ |
| template <class T> |
| T ANNOTATE_UNPROTECTED_READ(const volatile T& x) { |
| ANNOTATE_IGNORE_READS_BEGIN(); |
| T res = x; |
| ANNOTATE_IGNORE_READS_END(); |
| return res; |
| } |
| #endif |
| |
| #endif /* CLANG_ANNOTALYSIS_ONLY */ |
| |
| /* Undefine the macros intended only in this file. */ |
| #undef ANNOTALYSIS_STATIC_INLINE |
| #undef ANNOTALYSIS_SEMICOLON_OR_EMPTY_BODY |
| |
| #endif /* __DYNAMIC_ANNOTATIONS_H__ */ |
