tsan: declare annotations in test.h

[dvyukov]

Summary

We already declare subset of annotations in test.h.
But some are duplicated and declared in tests.
Move all annotation declarations to test.h.

compiler-rt/test/tsan/annotate_happens_before.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include "test.h"
 
 /*
 Annotations usage example.
 
 Tsan does not see synchronization in barrier_wait.
 ANNOTATE_HAPPENS_BEFORE/AFTER communicate the synchronization to tsan
 and prevent the race report.
-
-If the compiler does not support __has_feature macro, then you can build with
-CFLAGS="-fsanitize=thread -DTHREAD_SANITIZER" and then use
-#ifdef THREAD_SANITIZER to enabled annotations.
 */
 
-#if defined(__has_feature) && __has_feature(thread_sanitizer)
-# define ANNOTATE_HAPPENS_BEFORE(addr) \
-    AnnotateHappensBefore(__FILE__, __LINE__, (void*)(addr))
-# define ANNOTATE_HAPPENS_AFTER(addr) \
-    AnnotateHappensAfter(__FILE__, __LINE__, (void*)(addr))
-extern "C" void AnnotateHappensBefore(const char *f, int l, void *addr);
-extern "C" void AnnotateHappensAfter(const char *f, int l, void *addr);
-#else
-# define ANNOTATE_HAPPENS_BEFORE(addr)
-# define ANNOTATE_HAPPENS_AFTER(addr)
-#endif
-
 int Global;
 
 void *Thread1(void *x) {
   barrier_wait(&barrier);
   ANNOTATE_HAPPENS_AFTER(&barrier);
   Global++;
   return NULL;
 }

compiler-rt/test/tsan/benign_race.cpp

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include "test.h"
 
 int Global;
 int WTFGlobal;
 
-extern "C" {
-void AnnotateBenignRaceSized(const char *f, int l,
-                             void *mem, unsigned int size, const char *desc);
-void WTFAnnotateBenignRaceSized(const char *f, int l,
-                                void *mem, unsigned int size,
-                                const char *desc);
-}
-
-
 void *Thread(void *x) {
   Global = 42;
   WTFGlobal = 142;
   barrier_wait(&barrier);
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  AnnotateBenignRaceSized(__FILE__, __LINE__,
-                          &Global, sizeof(Global), "Race on Global");
-  WTFAnnotateBenignRaceSized(__FILE__, __LINE__,
-                             &WTFGlobal, sizeof(WTFGlobal),
-                             "Race on WTFGlobal");
+  ANNOTATE_BENIGN_RACE(Global);
+  WTF_ANNOTATE_BENIGN_RACE(WTFGlobal);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   barrier_wait(&barrier);
   Global = 43;
   WTFGlobal = 143;
   pthread_join(t, 0);
   fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

compiler-rt/test/tsan/ignore_sync.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-#include <pthread.h>
-#include <stdio.h>
-
-extern "C" void AnnotateIgnoreSyncBegin(const char*, int);
-extern "C" void AnnotateIgnoreSyncEnd(const char*, int);
+#include "test.h"
 
 int Global;
 pthread_mutex_t Mutex = PTHREAD_MUTEX_INITIALIZER;
 
 void *Thread(void *x) {
   AnnotateIgnoreSyncBegin(0, 0);
   pthread_mutex_lock(&Mutex);
   Global++;

compiler-rt/test/tsan/mutex_bad_read_lock.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
+#include "test.h"
 
 int main() {
   int m = 0;
   AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 1);
   AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 0);
   return 0;
 }
 

compiler-rt/test/tsan/mutex_bad_read_unlock.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
-extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw);
+#include "test.h"
 
 int main() {
   int m = 0;
   AnnotateRWLockAcquired(__FILE__, __LINE__, &m, 1);
   AnnotateRWLockReleased(__FILE__, __LINE__, &m, 0);
   return 0;
 }
 

compiler-rt/test/tsan/mutex_bad_unlock.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw);
+#include "test.h"
 
 int main() {
   int m = 0;
   AnnotateRWLockReleased(__FILE__, __LINE__, &m, 1);
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: unlock of an unlocked mutex (or by a wrong thread)
 // CHECK:     #0 AnnotateRWLockReleased
 // CHECK:     #1 main
 // CHECK: Location is stack of main thread.
 // CHECK:   Mutex {{.*}} created at:
 // CHECK:     #0 AnnotateRWLockReleased
 // CHECK:     #1 main
 // CHECK: SUMMARY: ThreadSanitizer: unlock of an unlocked mutex (or by a wrong thread)
 

compiler-rt/test/tsan/mutex_double_lock.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-#include <pthread.h>
-#include <unistd.h>
-
-extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
+#include "test.h"
 
 void *ThreadFunc(void *m) {
   AnnotateRWLockAcquired(__FILE__, __LINE__, m, 1);
   return 0;
 }
 
 int main() {
   int m = 0;

compiler-rt/test/tsan/mutexset5.cpp

int main() {
   // CHECK:                              (mutexes: write [[M1:M[0-9]+]]):
   // CHECK:   Previous write of size 4 at {{.*}} by thread T2
   // CHECK:                              (mutexes: write [[M2:M[0-9]+]]):
   // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
   // CHECK:     #0 pthread_mutex_init
   // CHECK:     #1 main {{.*}}mutexset5.cpp:[[@LINE+4]]
   // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
   // CHECK:     #0 pthread_mutex_init
-  // CHECK:     #1 main {{.*}}mutexset5.cpp:[[@LINE+5]]
+  // CHECK:     #1 main {{.*}}mutexset5.cpp:[[@LINE+2]]
   pthread_mutex_init(&mtx1, 0);
   pthread_mutex_init(&mtx2, 0);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   pthread_mutex_destroy(&mtx1);
   pthread_mutex_destroy(&mtx2);
 }

compiler-rt/test/tsan/signal_sync2.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: darwin
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include "test.h"
+#include <errno.h>
 #include <signal.h>
-#include <sys/types.h>
 #include <sys/time.h>
-#include <unistd.h>
-#include <errno.h>
+#include <sys/types.h>
 
 // Test synchronization in signal handled within IgnoreSync region.
 
-extern "C" void AnnotateIgnoreSyncBegin(const char *f, int l);
-extern "C" void AnnotateIgnoreSyncEnd(const char *f, int l);
-
 const int kSignalCount = 500;
 
 __thread int process_signals;
 int signals_handled;
 int done;
 int ready[kSignalCount];
 long long data[kSignalCount];
 

compiler-rt/test/tsan/test.h

 #else
 const int kPCInc = 1;
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+void AnnotateThreadName(const char *f, int l, const char *name);
+
 void AnnotateRWLockCreate(const char *f, int l, void *m);
 void AnnotateRWLockCreateStatic(const char *f, int l, void *m);
 void AnnotateRWLockDestroy(const char *f, int l, void *m);
 void AnnotateRWLockAcquired(const char *f, int l, void *m, long is_w);
 void AnnotateRWLockReleased(const char *f, int l, void *m, long is_w);
 
 void AnnotateIgnoreReadsBegin(const char *f, int l);
 void AnnotateIgnoreReadsEnd(const char *f, int l);
 void AnnotateIgnoreWritesBegin(const char *f, int l);
 void AnnotateIgnoreWritesEnd(const char *f, int l);
 
+void AnnotateIgnoreSyncBegin(const char *f, int l);
+void AnnotateIgnoreSyncEnd(const char *f, int l);
+
+void AnnotateHappensBefore(const char *f, int l, void *addr);
+void AnnotateHappensAfter(const char *f, int l, void *addr);
+
+void AnnotateBenignRaceSized(const char *f, int l, void *mem, unsigned int size, const char *desc);
+void WTFAnnotateBenignRaceSized(const char *f, int l, void *mem, unsigned int size, const char *desc);
+
 #ifdef __cplusplus
 }
 #endif
 
 #define ANNOTATE_RWLOCK_CREATE(m) \
     AnnotateRWLockCreate(__FILE__, __LINE__, m)
 #define ANNOTATE_RWLOCK_CREATE_STATIC(m) \
     AnnotateRWLockCreateStatic(__FILE__, __LINE__, m)
 #define ANNOTATE_RWLOCK_DESTROY(m) \
     AnnotateRWLockDestroy(__FILE__, __LINE__, m)
 #define ANNOTATE_RWLOCK_ACQUIRED(m, is_w) \
     AnnotateRWLockAcquired(__FILE__, __LINE__, m, is_w)
 #define ANNOTATE_RWLOCK_RELEASED(m, is_w) \
     AnnotateRWLockReleased(__FILE__, __LINE__, m, is_w)
+#define ANNOTATE_HAPPENS_BEFORE(addr) \
+  AnnotateHappensBefore(__FILE__, __LINE__, (void *)(addr))
+#define ANNOTATE_HAPPENS_AFTER(addr) \
+  AnnotateHappensAfter(__FILE__, __LINE__, (void *)(addr))
+#define ANNOTATE_BENIGN_RACE(var) \
+  AnnotateBenignRaceSized(__FILE__, __LINE__, &(var), sizeof(var), #var)
+#define WTF_ANNOTATE_BENIGN_RACE(var) \
+  WTFAnnotateBenignRaceSized(__FILE__, __LINE__, &(var), sizeof(var), #var)
 
 #ifdef __APPLE__
 #define ASM_SYMBOL(symbol) "_" #symbol
 #else
 #define ASM_SYMBOL(symbol) #symbol
 #endif

compiler-rt/test/tsan/thread_end_with_ignore.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-#include <pthread.h>
-#include <stdio.h>
-
-extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
+#include "test.h"
 
 void *Thread(void *x) {
   AnnotateIgnoreReadsBegin("", 0);
   return 0;
 }
 
 int main() {
   pthread_t t;

compiler-rt/test/tsan/thread_end_with_ignore2.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l);
+#include "test.h"
 
 int main() {
   AnnotateIgnoreWritesBegin("", 0);
 }
 
 // CHECK: ThreadSanitizer: main thread finished with ignores enabled
 // CHECK:   Ignore was enabled at:
 // CHECK:     #0 AnnotateIgnoreWritesBegin
 // CHECK:     #1 main
 

compiler-rt/test/tsan/thread_end_with_ignore3.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
-extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
-extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l);
+#include "test.h"
 
 int main() {
   AnnotateIgnoreReadsBegin("", 0);
   AnnotateIgnoreReadsBegin("", 0);
   AnnotateIgnoreReadsEnd("", 0);
   AnnotateIgnoreReadsEnd("", 0);
   AnnotateIgnoreReadsBegin("", 0);
   AnnotateIgnoreReadsBegin("", 0);
   AnnotateIgnoreReadsEnd("", 0);
 }
 
 // CHECK: ThreadSanitizer: main thread finished with ignores enabled
 // CHECK:   Ignore was enabled at:
 // CHECK:     #0 AnnotateIgnoreReadsBegin
-// CHECK:     #1 main {{.*}}thread_end_with_ignore3.cpp:10
+// CHECK:     #1 main {{.*}}thread_end_with_ignore3.cpp:9
 // CHECK:   Ignore was enabled at:
 // CHECK:     #0 AnnotateIgnoreReadsBegin
-// CHECK:     #1 main {{.*}}thread_end_with_ignore3.cpp:11
-
+// CHECK:     #1 main {{.*}}thread_end_with_ignore3.cpp:10

compiler-rt/test/tsan/thread_name.cpp

 #define tsan_pthread_setname_np pthread_set_name_np
 #elif defined(__NetBSD__)
 #define USE_PTHREAD_SETNAME_NP 1
 #define tsan_pthread_setname_np(a, b) pthread_setname_np((a), "%s", (void *)(b))
 #else
 #define USE_PTHREAD_SETNAME_NP 0
 #endif
 
-extern "C" void AnnotateThreadName(const char *f, int l, const char *name);
-
 int Global;
 
 void *Thread1(void *x) {
   barrier_wait(&barrier);
   AnnotateThreadName(__FILE__, __LINE__, "Thread1");
   Global++;
   return NULL;
 }