[tsan] Implement an invisible barrier in the runtime to make it available on OS X

[kubamracek]

Summary

For the lit tests, we currently have a "TSan-invisible barrier" that is implemented by dlsym-ing pthread_barrier_wait. However, on OS X, pthread barriers are not available, so we need to reimplement them.

This patch proposes to provide __tsan_invisible_barrier_init and __tsan_invisible_barrier_wait in the TSan runtime, with different implementations based on the platform. This way, we don't need the dlsym trick.

[dvyukov]

I am not very comfortable complicating runtime for tests sake. As you see the runtime has enough complexity and platform-dependent stuff. Also this implementation can have problems on some other platforms.
Will http://reviews.llvm.org/D14434 work for you?

[kubamracek]

http://reviews.llvm.org/D14434 looks better, closing this revision.

lib/tsan/rtl/tsan.syms.extra

 __tsan_init
 __tsan_read*
 __tsan_write*
 __tsan_vptr*
 __tsan_func*
 __tsan_atomic*
 __tsan_java*
 __tsan_unaligned*
 __tsan_release
 __tsan_acquire
+__tsan_invisible_barrier_init
+__tsan_invisible_barrier_wait
 __ubsan_*
 Annotate*
 WTFAnnotate*
 RunningOnValgrind
 ValgrindSlowdown

lib/tsan/rtl/tsan_interface.h

 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc);
 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit();
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_read_range(void *addr, unsigned long size);  // NOLINT
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_write_range(void *addr, unsigned long size);  // NOLINT
 
+// For testing purposes only.
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_invisible_barrier_init(void *barrier, unsigned count);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_invisible_barrier_wait(void *barrier);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // TSAN_INTERFACE_H

lib/tsan/rtl/tsan_platform_linux.cc

 //
 // Linux- and FreeBSD-specific code.
 //===----------------------------------------------------------------------===//
 
 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 
+#include "interception/interception.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_posix.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
 #include "sanitizer_common/sanitizer_stoptheworld.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
+#include "tsan_interface.h"
 #include "tsan_platform.h"
 #include "tsan_rtl.h"
 #include "tsan_flags.h"
 
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>

 #endif
 
 #ifndef SANITIZER_GO
 void ReplaceSystemMalloc() { }
 #endif
 
 }  // namespace __tsan
 
+typedef pthread_barrier_t __tsan_invisible_barrier_t;
+
+DECLARE_REAL(int, pthread_barrier_init, void *b, void *a, unsigned count);
+DECLARE_REAL(int, pthread_barrier_wait, void *b);
+
+extern "C"
+void __tsan_invisible_barrier_init(void *barrier, unsigned count) {
+  CHECK_EQ(REAL(pthread_barrier_init)(barrier, 0, count), 0);
+}
+
+extern "C"
+void __tsan_invisible_barrier_wait(void *barrier) {
+  int res = REAL(pthread_barrier_wait)(barrier);
+  CHECK(res == PTHREAD_BARRIER_SERIAL_THREAD || res == 0);
+}
+
 #endif  // SANITIZER_LINUX || SANITIZER_FREEBSD

lib/tsan/rtl/tsan_platform_mac.cc

 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // Mac-specific code.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_MAC
 
+#include "interception/interception.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_posix.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
+#include "tsan_interface.h"
 #include "tsan_platform.h"
 #include "tsan_rtl.h"
 #include "tsan_flags.h"
 
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>

 #endif
 
 bool IsGlobalVar(uptr addr) {
   return false;
 }
 
 }  // namespace __tsan
 
+typedef struct {
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+  int current_count;
+  int max_count;
+} __tsan_invisible_barrier_t;
+
+extern "C"
+void __tsan_invisible_barrier_init(void *barrier, unsigned max_count) {
+  __tsan_invisible_barrier_t *b = (__tsan_invisible_barrier_t *)barrier;
+  CHECK_GT(max_count, 0);
+  CHECK_EQ(REAL(pthread_mutex_init)(&b->mutex, 0), 0);
+  CHECK_EQ(REAL(pthread_cond_init)(&b->cond, 0), 0);
+  b->max_count = max_count;
+  b->current_count = 0;
+}
+
+extern "C"
+void __tsan_invisible_barrier_wait(void *barrier) {
+  __tsan_invisible_barrier_t *b = (__tsan_invisible_barrier_t *)barrier;
+  REAL(pthread_mutex_lock)(&b->mutex);
+  b->current_count += 1;
+  if (b->current_count >= b->max_count) {
+    b->current_count = 0;
+    REAL(pthread_cond_broadcast)(&b->cond);
+    REAL(pthread_mutex_unlock)(&b->mutex);
+  } else {
+    REAL(pthread_cond_wait)(&b->cond, &b->mutex);
+    REAL(pthread_mutex_unlock)(&b->mutex);
+  }
+}
+
 #endif  // SANITIZER_MAC

test/tsan/test.h

 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <dlfcn.h>
 #include <stddef.h>
 
-// TSan-invisible barrier.
-// Tests use it to establish necessary execution order in a way that does not
-// interfere with tsan (does not establish synchronization between threads).
-__typeof(pthread_barrier_wait) *barrier_wait;
-
-void barrier_init(pthread_barrier_t *barrier, unsigned count) {
-#if defined(__FreeBSD__)
-  static const char libpthread_name[] = "libpthread.so";
-#else
-  static const char libpthread_name[] = "libpthread.so.0";
-#endif
+typedef struct {
+  char __opaque[128];
+} __tsan_invisible_barrier_t;
 
-  if (barrier_wait == 0) {
-    void *h = dlopen(libpthread_name, RTLD_LAZY);
-    if (h == 0) {
-      fprintf(stderr, "failed to dlopen %s, exiting\n", libpthread_name);
-      exit(1);
-    }
-    barrier_wait = (__typeof(barrier_wait))dlsym(h, "pthread_barrier_wait");
-    if (barrier_wait == 0) {
-      fprintf(stderr, "failed to resolve pthread_barrier_wait, exiting\n");
-      exit(1);
-    }
-  }
-  pthread_barrier_init(barrier, 0, count);
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+void __tsan_invisible_barrier_init(__tsan_invisible_barrier_t *barrier,
+                                   unsigned count);
+void __tsan_invisible_barrier_wait(__tsan_invisible_barrier_t *barrier);
+#ifdef __cplusplus
+}  // extern "C"
+#endif
 
 // Default instance of the barrier, but a test can declare more manually.
-pthread_barrier_t barrier;
+__tsan_invisible_barrier_t barrier;
+
+#define barrier_init __tsan_invisible_barrier_init
+#define barrier_wait __tsan_invisible_barrier_wait
 
 void print_address(void *address) {
 // On FreeBSD, the %p conversion specifier works as 0x%x and thus does not match
 // to the format used in the diagnotic message.
 #ifdef __x86_64__
   fprintf(stderr, "0x%012lx", (unsigned long) address);
 #elif defined(__mips64)
   fprintf(stderr, "0x%010lx", (unsigned long) address);