[tsan] Fix pthread_once() on Mac OS X

[melver]

Summary

Change 636428c727cd enabled BlockingRegion hooks for pthread_once().
Unfortunately this seems to cause crashes on Mac OS X which uses
pthread_once() from locations that seem to result in crashes:

ThreadSanitizer:DEADLYSIGNAL

==31465==ERROR: ThreadSanitizer: stack-overflow on address 0x7ffee73fffd8 (pc 0x00010807fd2a bp 0x7ffee7400050 sp 0x7ffee73fffb0 T93815)

#0 tsan::MetaMap::GetSync(tsan::ThreadState*, unsigned long, unsigned long, bool, bool) tsan_sync.cpp:195 (libclang_rt.tsan_osx_dynamic.dylib:x86_64+0x78d2a)

#1 tsan::MutexPreLock(tsan::ThreadState*, unsigned long, unsigned long, unsigned int) tsan_rtl_mutex.cpp:143 (libclang_rt.tsan_osx_dynamic.dylib:x86_64+0x6cefc)

#2 wrap_pthread_mutex_lock sanitizer_common_interceptors.inc:4240 (libclang_rt.tsan_osx_dynamic.dylib:x86_64+0x3dae0)

#3 flockfile <null>:2 (libsystem_c.dylib:x86_64+0x38a69)

#4 puts <null>:2 (libsystem_c.dylib:x86_64+0x3f69b)

#5 wrap_puts sanitizer_common_interceptors.inc (libclang_rt.tsan_osx_dynamic.dylib:x86_64+0x34d83)

#6 __tsan::OnPotentiallyBlockingRegionBegin() cxa_guard_acquire.cpp:8 (foo:x86_64+0x100000e48)

#7 wrap_pthread_once tsan_interceptors_posix.cpp:1512 (libclang_rt.tsan_osx_dynamic.dylib:x86_64+0x2f6e6)

From the stack trace it can be seen that the caller is unknown, and the
resulting stack-overflow seems to indicate that whoever the caller is
does not have enough stack space or otherwise is running in a limited
environment not yet ready for full instrumentation.

Fix it by reverting behaviour on Mac OS X to not call BlockingRegion
hooks from pthread_once().

Reported-by: azharudd

[glider]

LGTM, thanks!

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 // that any non-0 value in the first byte means that
 // initialization is completed. Contents of the remaining
 // bytes are up to us.
 constexpr u32 kGuardInit = 0;
 constexpr u32 kGuardDone = 1;
 constexpr u32 kGuardRunning = 1 << 16;
 constexpr u32 kGuardWaiter = 1 << 17;
 
-static int guard_acquire(ThreadState *thr, uptr pc, atomic_uint32_t *g) {
+static int guard_acquire(ThreadState *thr, uptr pc, atomic_uint32_t *g,
+                         bool blocking_hooks = true) {
+  if (blocking_hooks)
     OnPotentiallyBlockingRegionBegin();
-  auto on_exit = at_scope_exit(&OnPotentiallyBlockingRegionEnd);
+  auto on_exit = at_scope_exit([blocking_hooks] {
+    if (blocking_hooks)
+      OnPotentiallyBlockingRegionEnd();
+  });
+
   for (;;) {
     u32 cmp = atomic_load(g, memory_order_acquire);
     if (cmp == kGuardInit) {
       if (atomic_compare_exchange_strong(g, &cmp, kGuardRunning,
                                          memory_order_relaxed))
         return 1;
     } else if (cmp == kGuardDone) {
       if (!thr->in_ignored_lib)
TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) {
   if (SANITIZER_MAC)
     a = static_cast<atomic_uint32_t*>((void *)((char *)o + sizeof(long_t)));
   else if (SANITIZER_NETBSD)
     a = static_cast<atomic_uint32_t*>
           ((void *)((char *)o + __sanitizer::pthread_mutex_t_sz));
   else
     a = static_cast<atomic_uint32_t*>(o);
 
-  if (guard_acquire(thr, pc, a)) {
+  // Mac OS X appears to use pthread_once() where calling BlockingRegion hooks
+  // result in crashes due to too little stack space.
+  if (guard_acquire(thr, pc, a, !SANITIZER_MAC)) {
     (*f)();
     guard_release(thr, pc, a);
   }
   return 0;
 }
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 TSAN_INTERCEPTOR(int, __fxstat, int version, int fd, void *buf) {