[tsan] Fix detached threads in unit tests on OS X

[kubamracek]

Summary

We need to call the intercepted version of pthread_detach. Secondly, PTHREAD_CREATE_JOINABLE and PTHREAD_CREATE_DETACHED are not 0 and 1 on OS X, so we need to properly pass these constants and not just a bool.

compiler-rt/trunk/lib/tsan/tests/rtl/tsan_test_util_posix.cc

 static __thread bool expect_report_reported;
 static __thread ReportType expect_report_type;
 
 #ifdef __APPLE__
 #define __interceptor_memcpy wrap_memcpy
 #define __interceptor_memset wrap_memset
 #define __interceptor_pthread_create wrap_pthread_create
 #define __interceptor_pthread_join wrap_pthread_join
+#define __interceptor_pthread_detach wrap_pthread_detach
 #define __interceptor_pthread_mutex_init wrap_pthread_mutex_init
 #define __interceptor_pthread_mutex_lock wrap_pthread_mutex_lock
 #define __interceptor_pthread_mutex_unlock wrap_pthread_mutex_unlock
 #define __interceptor_pthread_mutex_destroy wrap_pthread_mutex_destroy
 #define __interceptor_pthread_mutex_trylock wrap_pthread_mutex_trylock
 #define __interceptor_pthread_rwlock_init wrap_pthread_rwlock_init
 #define __interceptor_pthread_rwlock_destroy wrap_pthread_rwlock_destroy
 #define __interceptor_pthread_rwlock_trywrlock wrap_pthread_rwlock_trywrlock
 #define __interceptor_pthread_rwlock_wrlock wrap_pthread_rwlock_wrlock
 #define __interceptor_pthread_rwlock_unlock wrap_pthread_rwlock_unlock
 #define __interceptor_pthread_rwlock_rdlock wrap_pthread_rwlock_rdlock
 #define __interceptor_pthread_rwlock_tryrdlock wrap_pthread_rwlock_tryrdlock
 #endif
 
 extern "C" void *__interceptor_memcpy(void *, const void *, uptr);
 extern "C" void *__interceptor_memset(void *, int, uptr);
 extern "C" int __interceptor_pthread_create(pthread_t *thread,
                                             const pthread_attr_t *attr,
                                             void *(*start_routine)(void *),
                                             void *arg);
 extern "C" int __interceptor_pthread_join(pthread_t thread, void **value_ptr);
+extern "C" int __interceptor_pthread_detach(pthread_t thread);
 
 extern "C" int __interceptor_pthread_mutex_init(
     pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
 extern "C" int __interceptor_pthread_mutex_lock(pthread_mutex_t *mutex);
 extern "C" int __interceptor_pthread_mutex_unlock(pthread_mutex_t *mutex);
 extern "C" int __interceptor_pthread_mutex_destroy(pthread_mutex_t *mutex);
 extern "C" int __interceptor_pthread_mutex_trylock(pthread_mutex_t *mutex);
 

 ScopedThread::ScopedThread(bool detached, bool main) {
   impl_ = new Impl;
   impl_->main = main;
   impl_->detached = detached;
   atomic_store(&impl_->event, 0, memory_order_relaxed);
   if (!main) {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, detached);
+    pthread_attr_setdetachstate(
+        &attr, detached ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE);
     pthread_attr_setstacksize(&attr, 64*1024);
     __interceptor_pthread_create(&impl_->thread, &attr,
         ScopedThread::Impl::ScopedThreadCallback, impl_);
   }
 }
 
 ScopedThread::~ScopedThread() {
   if (!impl_->main) {
     Event event(Event::SHUTDOWN);
     impl_->send(&event);
     if (!impl_->detached)
       __interceptor_pthread_join(impl_->thread, 0);
   }
   delete impl_;
 }
 
 void ScopedThread::Detach() {
   CHECK(!impl_->main);
   CHECK(!impl_->detached);
   impl_->detached = true;
-  pthread_detach(impl_->thread);
+  __interceptor_pthread_detach(impl_->thread);
 }
 
 void ScopedThread::Access(void *addr, bool is_write,
                           int size, bool expect_race) {
   Event event(is_write ? Event::WRITE : Event::READ, addr, size);
   if (expect_race)
     event.ExpectReport(ReportTypeRace);
   impl_->send(&event);