Allow TSAN to work with libc-internal locking on FreeBSD

[arichardson]

Summary

On FreeBSD locking inside libc (e.g. for stdio) calls the libthr private
API (using _pthread_* functions)rather than the standard pthread_*.
This can lead to many false-positive race reports unless we also intercept
the version with the leading underscore.
Unfortunately this is a rather large diff since all pthread interceptors
had to be changed to use a new macro.

I don't have access to a NetBSD system for testing, but it seems like this
approach could also be used to handle the NetBSD __libc_pthread_* functions.

[krytarowski]

Can you follow the NetBSD approach and go for something like TSAN_MAYBE_INTERCEPT_NETBSD_ALIAS instead of patching shared code between all platforms?

[arichardson]

In D96251#2548159, @krytarowski wrote:

Can you follow the NetBSD approach and go for something like TSAN_MAYBE_INTERCEPT_NETBSD_ALIAS instead of patching shared code between all platforms?

I can definitely do that and intercept only the locking ones. I chose this approach because intercepting all aliases makes it less likely to miss one required function that only rarely results in false-positives.

Would it be possible for NetBSD to also use this approach for the __libc_pthread_ functions? Or is only a subset exported as __libc_pthread_?

#elif SANITIZER_NETBSD
#define INTERCEPTOR_PTHREAD(ret, func, ...)      \
  INTERCEPTOR(ret, __libc_pthread_##func, __VA_ARGS__) \
  ALIAS(WRAPPER_NAME(pthread_##func));           \
  INTERCEPTOR(ret, pthread_##func, __VA_ARGS__)
#define INTERCEPT_PTHREAD_FUNCTION(name) \
  INTERCEPT_FUNCTION(pthread_##name);    \
  INTERCEPT_FUNCTION(__libc_pthread_##name)

[krytarowski]

Would it be possible for NetBSD to also use this approach for the libc_pthread_ functions? Or is only a subset exported as libc_pthread_?

No. It's a subset that might go on libc major version bump away. It's a legacy indirection subset, not used in new pthread calls.

[arichardson]

In D96251#2548333, @krytarowski wrote:

Would it be possible for NetBSD to also use this approach for the libc_pthread_ functions? Or is only a subset exported as libc_pthread_?

No. It's a subset that might go on libc bump away. It's a legacy indirection subset, not used in new pthread calls.

Thanks for the explanation. In that case it might make more sense to restrict this to the FreeBSD functions defined in lib/libc/gen/_pthread_stubs.c

[vitalybuka]

I assume it's stale?

compiler-rt/lib/asan/asan_interceptors.cpp

 
 #if ASAN_INTERCEPT_PTHREAD_CREATE
 static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
   AsanThread *t = (AsanThread *)arg;
   SetCurrentThread(t);
   return t->ThreadStart(GetTid());
 }
 
-INTERCEPTOR(int, pthread_create, void *thread,
-    void *attr, void *(*start_routine)(void*), void *arg) {
+INTERCEPTOR_PTHREAD(int, create, void *thread, void *attr,
+                    void *(*start_routine)(void *), void *arg) {
   EnsureMainThreadIDIsCorrect();
   // Strict init-order checking is thread-hostile.
   if (flags()->strict_init_order)
     StopInitOrderChecking();
   GET_STACK_TRACE_THREAD;
   int detached = 0;
   if (attr)
     REAL(pthread_attr_getdetachstate)(attr, &detached);
if (result != 0) {
     // If the thread didn't start delete the AsanThread to avoid leaking it.
     // Note AsanThreadContexts never get destroyed so the AsanThreadContext
     // that was just created for the AsanThread is wasted.
     t->Destroy();
   }
   return result;
 }
 
-INTERCEPTOR(int, pthread_join, void *t, void **arg) {
+INTERCEPTOR_PTHREAD(int, join, void *t, void **arg) {
   return real_pthread_join(t, arg);
 }
 
 DEFINE_REAL_PTHREAD_FUNCTIONS
 #endif  // ASAN_INTERCEPT_PTHREAD_CREATE
 
 #if ASAN_INTERCEPT_SWAPCONTEXT
 static void ClearShadowMemoryForContextStack(uptr stack, uptr ssize) {

 #endif
 
 #if ASAN_INTERCEPT_PTHREAD_ATFORK
 extern "C" {
 extern int _pthread_atfork(void (*prepare)(), void (*parent)(),
                            void (*child)());
 };
 
-INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(),
+INTERCEPTOR_PTHREAD(int, atfork, void (*prepare)(), void (*parent)(),
                     void (*child)()) {
 #if CAN_SANITIZE_LEAKS
   __lsan::ScopedInterceptorDisabler disabler;
 #endif
   // REAL(pthread_atfork) cannot be called due to symbol indirections at least
   // on NetBSD
   return _pthread_atfork(prepare, parent, child);
 }
 #endif

compiler-rt/lib/hwasan/hwasan_interceptors.cpp

 
 static void *HwasanThreadStartFunc(void *arg) {
   __hwasan_thread_enter();
   ThreadStartArg A = *reinterpret_cast<ThreadStartArg*>(arg);
   UnmapOrDie(arg, GetPageSizeCached());
   return A.callback(A.param);
 }
 
-INTERCEPTOR(int, pthread_create, void *th, void *attr, void *(*callback)(void*),
-            void * param) {
+INTERCEPTOR_PTHREAD(int, create, void *th, void *attr,
+                    void *(*callback)(void *), void *param) {
   ScopedTaggingDisabler disabler;
   ThreadStartArg *A = reinterpret_cast<ThreadStartArg *> (MmapOrDie(
       GetPageSizeCached(), "pthread_create"));
   *A = {callback, param};
   int res = REAL(pthread_create)(UntagPtr(th), UntagPtr(attr),
                                  &HwasanThreadStartFunc, A);
   return res;
 }

compiler-rt/lib/interception/interception.h

# define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_MAC(func, symver)
 #elif SANITIZER_WINDOWS
 # include "interception_win.h"
 # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_WIN(func)
 # define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_WIN(func, symver)
 #endif
 
+#if SANITIZER_FREEBSD
+// On FreeBSD we also have to intercept the _pthread_* aliases since those are
+// used for direct libthr calls from within libc. If we don't intercept both
+// pthread_foo and _pthread_foo we see lots of false-positives.
+#define INTERCEPTOR_PTHREAD(ret, func, ...)      \
+  INTERCEPTOR(ret, _pthread_##func, __VA_ARGS__) \
+  ALIAS(WRAPPER_NAME(pthread_##func));           \
+  INTERCEPTOR(ret, pthread_##func, __VA_ARGS__)
+#define INTERCEPT_PTHREAD_FUNCTION(name) \
+  INTERCEPT_FUNCTION(pthread_##name);    \
+  INTERCEPT_FUNCTION(_pthread_##name)
+#else
+#define INTERCEPTOR_PTHREAD(ret, func, ...) \
+  INTERCEPTOR(ret, pthread_##func, __VA_ARGS__)
+#define INTERCEPT_PTHREAD_FUNCTION(name) INTERCEPT_FUNCTION(pthread_##name)
+#endif
+
 #undef INCLUDED_FROM_INTERCEPTION_LIB
 
 #endif  // INTERCEPTION_H

compiler-rt/lib/lsan/lsan_interceptors.cpp

 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_ATFORK
 extern "C" {
 extern int _pthread_atfork(void (*prepare)(), void (*parent)(),
                            void (*child)());
 };
 
-INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(),
+INTERCEPTOR_PTHREAD(int, atfork, void (*prepare)(), void (*parent)(),
                     void (*child)()) {
   __lsan::ScopedInterceptorDisabler disabler;
   // REAL(pthread_atfork) cannot be called due to symbol indirections at least
   // on NetBSD
   return _pthread_atfork(prepare, parent, child);
 }
 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK INTERCEPT_FUNCTION(pthread_atfork)
 #else
 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK
#endif
   int tid = 0;
   while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
     internal_sched_yield();
   ThreadStart(tid, GetTid());
   atomic_store(&p->tid, 0, memory_order_release);
   return callback(param);
 }
 
-INTERCEPTOR(int, pthread_create, void *th, void *attr,
+INTERCEPTOR_PTHREAD(int, create, void *th, void *attr,
                     void *(*callback)(void *), void *param) {
   ENSURE_LSAN_INITED;
   EnsureMainThreadIDIsCorrect();
   __sanitizer_pthread_attr_t myattr;
   if (!attr) {
     pthread_attr_init(&myattr);
     attr = &myattr;
   }
   AdjustStackSize(attr);
if (res == 0) {
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
       internal_sched_yield();
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return res;
 }
 
-INTERCEPTOR(int, pthread_join, void *th, void **ret) {
+INTERCEPTOR_PTHREAD(int, join, void *th, void **ret) {
   ENSURE_LSAN_INITED;
   int tid = ThreadTid((uptr)th);
   int res = REAL(pthread_join)(th, ret);
   if (res == 0)
     ThreadJoin(tid);
   return res;
 }
 
-INTERCEPTOR(int, pthread_detach, void *th) {
+INTERCEPTOR_PTHREAD(int, detach, void *th) {
   ENSURE_LSAN_INITED;
   int tid = ThreadTid((uptr)th);
   int res = REAL(pthread_detach)(th);
   if (res == 0)
     ThreadDetach(tid);
   return res;
 }
 

compiler-rt/lib/memprof/memprof_interceptors.cpp

static thread_return_t THREAD_CALLING_CONV memprof_thread_start(void *arg) {
   MemprofThread *t = nullptr;
   while ((t = reinterpret_cast<MemprofThread *>(
               atomic_load(&param->t, memory_order_acquire))) == nullptr)
     internal_sched_yield();
   SetCurrentThread(t);
   return t->ThreadStart(GetTid(), &param->is_registered);
 }
 
-INTERCEPTOR(int, pthread_create, void *thread, void *attr,
+INTERCEPTOR_PTHREAD(int, create, void *thread, void *attr,
                     void *(*start_routine)(void *), void *arg) {
   EnsureMainThreadIDIsCorrect();
   GET_STACK_TRACE_THREAD;
   int detached = 0;
   if (attr)
     REAL(pthread_attr_getdetachstate)(attr, &detached);
   ThreadStartParam param;
   atomic_store(&param.t, 0, memory_order_relaxed);
   atomic_store(&param.is_registered, 0, memory_order_relaxed);
if (result == 0) {
     // Wait until the MemprofThread object is initialized and the
     // ThreadRegistry entry is in "started" state.
     while (atomic_load(&param.is_registered, memory_order_acquire) == 0)
       internal_sched_yield();
   }
   return result;
 }
 
-INTERCEPTOR(int, pthread_join, void *t, void **arg) {
+INTERCEPTOR_PTHREAD(int, join, void *t, void **arg) {
   return real_pthread_join(t, arg);
 }
 
 DEFINE_REAL_PTHREAD_FUNCTIONS
 
 INTERCEPTOR(char *, index, const char *string, int c)
 ALIAS(WRAPPER_NAME(strchr));
 

compiler-rt/lib/msan/msan_interceptors.cpp

 extern "C" int pthread_attr_destroy(void *attr);
 
 static void *MsanThreadStartFunc(void *arg) {
   MsanThread *t = (MsanThread *)arg;
   SetCurrentThread(t);
   return t->ThreadStart();
 }
 
-INTERCEPTOR(int, pthread_create, void *th, void *attr, void *(*callback)(void*),
-            void * param) {
+INTERCEPTOR_PTHREAD(int, create, void *th, void *attr,
+                    void *(*callback)(void *), void *param) {
   ENSURE_MSAN_INITED(); // for GetTlsSize()
   __sanitizer_pthread_attr_t myattr;
   if (!attr) {
     pthread_attr_init(&myattr);
     attr = &myattr;
   }
 
   AdjustStackSize(attr);
 
   MsanThread *t = MsanThread::Create(callback, param);
 
   int res = REAL(pthread_create)(th, attr, MsanThreadStartFunc, t);
 
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   if (!res) {
     __msan_unpoison(th, __sanitizer::pthread_t_sz);
   }
   return res;
 }
 
-INTERCEPTOR(int, pthread_key_create, __sanitizer_pthread_key_t *key,
+INTERCEPTOR_PTHREAD(int, key_create, __sanitizer_pthread_key_t *key,
                     void (*dtor)(void *value)) {
   if (msan_init_is_running) return REAL(pthread_key_create)(key, dtor);
   ENSURE_MSAN_INITED();
   int res = REAL(pthread_key_create)(key, dtor);
   if (!res && key)
     __msan_unpoison(key, sizeof(*key));
   return res;
 }
 
 #if SANITIZER_NETBSD
 INTERCEPTOR(int, __libc_thr_keycreate, __sanitizer_pthread_key_t *m,
             void (*dtor)(void *value))
 ALIAS(WRAPPER_NAME(pthread_key_create));
 #endif
 
-INTERCEPTOR(int, pthread_join, void *th, void **retval) {
+INTERCEPTOR_PTHREAD(int, join, void *th, void **retval) {
   ENSURE_MSAN_INITED();
   int res = REAL(pthread_join)(th, retval);
   if (!res && retval)
     __msan_unpoison(retval, sizeof(*retval));
   return res;
 }
 
 extern char *tzname[2];

compiler-rt/lib/safestack/safestack.cpp

void thread_cleanup_handler(void *_iter) {
   pthread_mutex_unlock(&thread_stacks_mutex);
 
   unsafe_stack_start = nullptr;
 }
 
 void EnsureInterceptorsInitialized();
 
 /// Intercept thread creation operation to allocate and setup the unsafe stack
-INTERCEPTOR(int, pthread_create, pthread_t *thread,
-            const pthread_attr_t *attr,
-            void *(*start_routine)(void*), void *arg) {
+INTERCEPTOR_PTHREAD(int, create, pthread_t *thread, const pthread_attr_t *attr,
+                    void *(*start_routine)(void *), void *arg) {
   EnsureInterceptorsInitialized();
   size_t size = 0;
   size_t guard = 0;
 
   if (attr) {
     pthread_attr_getstacksize(attr, &size);
     pthread_attr_getguardsize(attr, &guard);
   } else {

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

enum {
     CIMT_FILE
   } type;
   union {
     FileMetadata file;
   };
 };
 
 #if SI_POSIX
 typedef AddrHashMap<CommonInterceptorMetadata, 31051> MetadataHashMap;
 
 static MetadataHashMap *interceptor_metadata_map;
 
 UNUSED static void SetInterceptorMetadata(__sanitizer_FILE *addr,
                                           const FileMetadata &file) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr);
   CHECK(h.created());
   h->type = CommonInterceptorMetadata::CIMT_FILE;
   h->file = file;
 }
 
 UNUSED static const FileMetadata *GetInterceptorMetadata(
     __sanitizer_FILE *addr) {

 
 UNUSED static void DeleteInterceptorMetadata(void *addr) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr, true);
   CHECK(h.exists());
 }
 #endif  // SI_POSIX
 
 #if SANITIZER_INTERCEPT_STRLEN
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
   // Sometimes strlen is called prior to InitializeCommonInterceptors,
   // in which case the REAL(strlen) typically used in
   // COMMON_INTERCEPTOR_ENTER will fail.  We use internal_strlen here
   // to handle that.
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strlen(s);
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strlen, s);
   SIZE_T result = REAL(strlen)(s);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, result + 1);
   return result;
 }
 #define INIT_STRLEN COMMON_INTERCEPT_FUNCTION(strlen)
 #else
 #define INIT_STRLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNLEN
 INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strnlen, s, maxlen);
   SIZE_T length = REAL(strnlen)(s, maxlen);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, Min(length + 1, maxlen));
   return length;
 }
 #define INIT_STRNLEN COMMON_INTERCEPT_FUNCTION(strnlen)
 #else
 #define INIT_STRNLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNDUP
 INTERCEPTOR(char*, strndup, const char *s, uptr size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
 #define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
 #else
 #define INIT_STRNDUP
 #endif // SANITIZER_INTERCEPT_STRNDUP
 
INTERCEPTOR(int, inet_aton, const char *cp, void *dst) {
   return res;
 }
 #define INIT_INET_ATON COMMON_INTERCEPT_FUNCTION(inet_aton);
 #else
 #define INIT_INET_ATON
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_GETSCHEDPARAM
-INTERCEPTOR(int, pthread_getschedparam, uptr thread, int *policy, int *param) {
+INTERCEPTOR_PTHREAD(int, getschedparam, uptr thread, int *policy, int *param) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_getschedparam, thread, policy, param);
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
   int res = REAL(pthread_getschedparam)(thread, policy, param);
   if (res == 0) {
     if (policy) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, policy, sizeof(*policy));
     if (param) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, param, sizeof(*param));
   }
   return res;
 }
 #define INIT_PTHREAD_GETSCHEDPARAM \
-  COMMON_INTERCEPT_FUNCTION(pthread_getschedparam);
+  INTERCEPT_PTHREAD_FUNCTION(getschedparam);
 #else
 #define INIT_PTHREAD_GETSCHEDPARAM
 #endif
 
 #if SANITIZER_INTERCEPT_GETADDRINFO
 INTERCEPTOR(int, getaddrinfo, char *node, char *service,
             struct __sanitizer_addrinfo *hints,
             struct __sanitizer_addrinfo **out) {
INTERCEPTOR(int, sigprocmask, int how, __sanitizer_sigset_t *set,
   return res;
 }
 #define INIT_SIGPROCMASK COMMON_INTERCEPT_FUNCTION(sigprocmask);
 #else
 #define INIT_SIGPROCMASK
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_SIGMASK
-INTERCEPTOR(int, pthread_sigmask, int how, __sanitizer_sigset_t *set,
+INTERCEPTOR_PTHREAD(int, sigmask, int how, __sanitizer_sigset_t *set,
             __sanitizer_sigset_t *oldset) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_sigmask, how, set, oldset);
   if (set) COMMON_INTERCEPTOR_READ_RANGE(ctx, set, sizeof(*set));
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
   int res = REAL(pthread_sigmask)(how, set, oldset);
   if (!res && oldset)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldset, sizeof(*oldset));
   return res;
 }
-#define INIT_PTHREAD_SIGMASK COMMON_INTERCEPT_FUNCTION(pthread_sigmask);
+#define INIT_PTHREAD_SIGMASK INTERCEPT_PTHREAD_FUNCTION(sigmask);
 #else
 #define INIT_PTHREAD_SIGMASK
 #endif
 
 #if SANITIZER_INTERCEPT_BACKTRACE
 INTERCEPTOR(int, backtrace, void **buffer, int size) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, backtrace, buffer, size);
INTERCEPTOR(void, _exit, int status) {
   REAL(_exit)(status);
 }
 #define INIT__EXIT COMMON_INTERCEPT_FUNCTION(_exit);
 #else
 #define INIT__EXIT
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEX
-INTERCEPTOR(int, pthread_mutex_lock, void *m) {
+INTERCEPTOR_PTHREAD(int, mutex_lock, void *m) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_lock, m);
   COMMON_INTERCEPTOR_MUTEX_PRE_LOCK(ctx, m);
   int res = REAL(pthread_mutex_lock)(m);
   if (res == errno_EOWNERDEAD)
     COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m);
   if (res == 0 || res == errno_EOWNERDEAD)
     COMMON_INTERCEPTOR_MUTEX_POST_LOCK(ctx, m);
   if (res == errno_EINVAL)
     COMMON_INTERCEPTOR_MUTEX_INVALID(ctx, m);
   return res;
 }
 
-INTERCEPTOR(int, pthread_mutex_unlock, void *m) {
+INTERCEPTOR_PTHREAD(int, mutex_unlock, void *m) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_unlock, m);
   COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m);
   int res = REAL(pthread_mutex_unlock)(m);
   if (res == errno_EINVAL)
     COMMON_INTERCEPTOR_MUTEX_INVALID(ctx, m);
   return res;
 }
 
-#define INIT_PTHREAD_MUTEX_LOCK COMMON_INTERCEPT_FUNCTION(pthread_mutex_lock)
+#define INIT_PTHREAD_MUTEX_LOCK INTERCEPT_PTHREAD_FUNCTION(mutex_lock)
 #define INIT_PTHREAD_MUTEX_UNLOCK \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutex_unlock)
+  INTERCEPT_PTHREAD_FUNCTION(mutex_unlock)
 #else
 #define INIT_PTHREAD_MUTEX_LOCK
 #define INIT_PTHREAD_MUTEX_UNLOCK
 #endif
 
 #if SANITIZER_INTERCEPT___PTHREAD_MUTEX
 INTERCEPTOR(int, __pthread_mutex_lock, void *m) {
   void *ctx;

 // https://github.com/google/sanitizers/issues/321.
 #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GET ||              \
     SANITIZER_INTERCEPT_PTHREAD_ATTR_GET_SCHED ||        \
     SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSSCHED || \
     SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GET ||         \
     SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GET ||        \
     SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GET ||          \
     SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GET
-#define INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(fn, sz)            \
-  INTERCEPTOR(int, fn, void *attr, void *r) {                  \
-    void *ctx;                                                 \
-    COMMON_INTERCEPTOR_ENTER(ctx, fn, attr, r);                \
-    int res = REAL(fn)(attr, r);                               \
-    if (!res && r) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, sz); \
-    return res;                                                \
+#define INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(fn, sz)       \
+  INTERCEPTOR_PTHREAD(int, fn, void *attr, void *r) {     \
+    void *ctx;                                            \
+    COMMON_INTERCEPTOR_ENTER(ctx, pthread_##fn, attr, r); \
+    int res = REAL(pthread_##fn)(attr, r);                \
+    if (!res && r)                                        \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, sz);         \
+    return res;                                           \
   }
 #define INTERCEPTOR_PTHREAD_ATTR_GET(what, sz) \
-  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_attr_get##what, sz)
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(attr_get##what, sz)
 #define INTERCEPTOR_PTHREAD_MUTEXATTR_GET(what, sz) \
-  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_mutexattr_get##what, sz)
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(mutexattr_get##what, sz)
 #define INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(what, sz) \
-  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_rwlockattr_get##what, sz)
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(rwlockattr_get##what, sz)
 #define INTERCEPTOR_PTHREAD_CONDATTR_GET(what, sz) \
-  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_condattr_get##what, sz)
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(condattr_get##what, sz)
 #define INTERCEPTOR_PTHREAD_BARRIERATTR_GET(what, sz) \
-  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_barrierattr_get##what, sz)
+  INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(barrierattr_get##what, sz)
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GET
 INTERCEPTOR_PTHREAD_ATTR_GET(detachstate, sizeof(int))
 INTERCEPTOR_PTHREAD_ATTR_GET(guardsize, sizeof(SIZE_T))
 INTERCEPTOR_PTHREAD_ATTR_GET(scope, sizeof(int))
 INTERCEPTOR_PTHREAD_ATTR_GET(stacksize, sizeof(SIZE_T))
-INTERCEPTOR(int, pthread_attr_getstack, void *attr, void **addr, SIZE_T *size) {
+INTERCEPTOR_PTHREAD(int, attr_getstack, void *attr, void **addr, SIZE_T *size) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getstack, attr, addr, size);
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
   int res = REAL(pthread_attr_getstack)(attr, addr, size);
   if (!res) {
     if (addr) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, addr, sizeof(*addr));

 extern "C" {
 int real_pthread_attr_getstack(void *attr, void **addr, SIZE_T *size) {
   return REAL(pthread_attr_getstack)(attr, addr, size);
 }
 }  // extern "C"
 }  // namespace __sanitizer
 
 #define INIT_PTHREAD_ATTR_GET                             \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getdetachstate); \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getguardsize);   \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getscope);       \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getstacksize);   \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getstack);
+  INTERCEPT_PTHREAD_FUNCTION(attr_getdetachstate); \
+  INTERCEPT_PTHREAD_FUNCTION(attr_getguardsize);   \
+  INTERCEPT_PTHREAD_FUNCTION(attr_getscope);       \
+  INTERCEPT_PTHREAD_FUNCTION(attr_getstacksize);   \
+  INTERCEPT_PTHREAD_FUNCTION(attr_getstack);
 #else
 #define INIT_PTHREAD_ATTR_GET
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GET_SCHED
 INTERCEPTOR_PTHREAD_ATTR_GET(schedparam, struct_sched_param_sz)
 INTERCEPTOR_PTHREAD_ATTR_GET(schedpolicy, sizeof(int))
 
 #define INIT_PTHREAD_ATTR_GET_SCHED                      \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getschedparam); \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getschedpolicy);
+  INTERCEPT_PTHREAD_FUNCTION(attr_getschedparam); \
+  INTERCEPT_PTHREAD_FUNCTION(attr_getschedpolicy);
 #else
 #define INIT_PTHREAD_ATTR_GET_SCHED
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED
 INTERCEPTOR_PTHREAD_ATTR_GET(inheritsched, sizeof(int))
 
 #define INIT_PTHREAD_ATTR_GETINHERITSCHED \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getinheritsched);
+  INTERCEPT_PTHREAD_FUNCTION(attr_getinheritsched);
 #else
 #define INIT_PTHREAD_ATTR_GETINHERITSCHED
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP
-INTERCEPTOR(int, pthread_attr_getaffinity_np, void *attr, SIZE_T cpusetsize,
+INTERCEPTOR_PTHREAD(int, attr_getaffinity_np, void *attr, SIZE_T cpusetsize,
             void *cpuset) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getaffinity_np, attr, cpusetsize,
                            cpuset);
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
   int res = REAL(pthread_attr_getaffinity_np)(attr, cpusetsize, cpuset);
   if (!res && cpusetsize && cpuset)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cpuset, cpusetsize);
   return res;
 }
 
 #define INIT_PTHREAD_ATTR_GETAFFINITY_NP \
-  COMMON_INTERCEPT_FUNCTION(pthread_attr_getaffinity_np);
+  INTERCEPT_PTHREAD_FUNCTION(attr_getaffinity_np);
 #else
 #define INIT_PTHREAD_ATTR_GETAFFINITY_NP
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED
 INTERCEPTOR_PTHREAD_MUTEXATTR_GET(pshared, sizeof(int))
 #define INIT_PTHREAD_MUTEXATTR_GETPSHARED \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getpshared);
+  INTERCEPT_PTHREAD_FUNCTION(mutexattr_getpshared);
 #else
 #define INIT_PTHREAD_MUTEXATTR_GETPSHARED
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE
 INTERCEPTOR_PTHREAD_MUTEXATTR_GET(type, sizeof(int))
 #define INIT_PTHREAD_MUTEXATTR_GETTYPE \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_gettype);
+  INTERCEPT_PTHREAD_FUNCTION(mutexattr_gettype);
 #else
 #define INIT_PTHREAD_MUTEXATTR_GETTYPE
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL
 INTERCEPTOR_PTHREAD_MUTEXATTR_GET(protocol, sizeof(int))
 #define INIT_PTHREAD_MUTEXATTR_GETPROTOCOL \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getprotocol);
+  INTERCEPT_PTHREAD_FUNCTION(mutexattr_getprotocol);
 #else
 #define INIT_PTHREAD_MUTEXATTR_GETPROTOCOL
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING
 INTERCEPTOR_PTHREAD_MUTEXATTR_GET(prioceiling, sizeof(int))
 #define INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getprioceiling);
+  INTERCEPT_PTHREAD_FUNCTION(mutexattr_getprioceiling);
 #else
 #define INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST
 INTERCEPTOR_PTHREAD_MUTEXATTR_GET(robust, sizeof(int))
 #define INIT_PTHREAD_MUTEXATTR_GETROBUST \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getrobust);
+  INTERCEPT_PTHREAD_FUNCTION(mutexattr_getrobust);
 #else
 #define INIT_PTHREAD_MUTEXATTR_GETROBUST
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST_NP
 INTERCEPTOR_PTHREAD_MUTEXATTR_GET(robust_np, sizeof(int))
 #define INIT_PTHREAD_MUTEXATTR_GETROBUST_NP \
-  COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getrobust_np);
+  INTERCEPT_PTHREAD_FUNCTION(mutexattr_getrobust_np);
 #else
 #define INIT_PTHREAD_MUTEXATTR_GETROBUST_NP
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETPSHARED
 INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(pshared, sizeof(int))
 #define INIT_PTHREAD_RWLOCKATTR_GETPSHARED \
-  COMMON_INTERCEPT_FUNCTION(pthread_rwlockattr_getpshared);
+  INTERCEPT_PTHREAD_FUNCTION(rwlockattr_getpshared);
 #else
 #define INIT_PTHREAD_RWLOCKATTR_GETPSHARED
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETKIND_NP
 INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(kind_np, sizeof(int))
 #define INIT_PTHREAD_RWLOCKATTR_GETKIND_NP \
-  COMMON_INTERCEPT_FUNCTION(pthread_rwlockattr_getkind_np);
+  INTERCEPT_PTHREAD_FUNCTION(rwlockattr_getkind_np);
 #else
 #define INIT_PTHREAD_RWLOCKATTR_GETKIND_NP
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETPSHARED
 INTERCEPTOR_PTHREAD_CONDATTR_GET(pshared, sizeof(int))
 #define INIT_PTHREAD_CONDATTR_GETPSHARED \
-  COMMON_INTERCEPT_FUNCTION(pthread_condattr_getpshared);
+  INTERCEPT_PTHREAD_FUNCTION(condattr_getpshared);
 #else
 #define INIT_PTHREAD_CONDATTR_GETPSHARED
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETCLOCK
 INTERCEPTOR_PTHREAD_CONDATTR_GET(clock, sizeof(int))
 #define INIT_PTHREAD_CONDATTR_GETCLOCK \
-  COMMON_INTERCEPT_FUNCTION(pthread_condattr_getclock);
+  INTERCEPT_PTHREAD_FUNCTION(condattr_getclock);
 #else
 #define INIT_PTHREAD_CONDATTR_GETCLOCK
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GETPSHARED
 INTERCEPTOR_PTHREAD_BARRIERATTR_GET(pshared, sizeof(int)) // !mac !android
 #define INIT_PTHREAD_BARRIERATTR_GETPSHARED \
-  COMMON_INTERCEPT_FUNCTION(pthread_barrierattr_getpshared);
+  INTERCEPT_PTHREAD_FUNCTION(barrierattr_getpshared);
 #else
 #define INIT_PTHREAD_BARRIERATTR_GETPSHARED
 #endif
 
 #if SANITIZER_INTERCEPT_TMPNAM
 INTERCEPTOR(char *, tmpnam, char *s) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, tmpnam, s);
INTERCEPTOR(char *, tempnam, char *dir, char *pfx) {
   if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
   return res;
 }
 #define INIT_TEMPNAM COMMON_INTERCEPT_FUNCTION(tempnam);
 #else
 #define INIT_TEMPNAM
 #endif
 
-#if SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && !SANITIZER_NETBSD
-INTERCEPTOR(int, pthread_setname_np, uptr thread, const char *name) {
+#if SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && SANITIZER_FREEBSD
+INTERCEPTOR_PTHREAD(int, set_name_np, uptr thread, const char *name) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pthread_set_name_np, thread, name);
+  COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
+  COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name);
+  return REAL(pthread_set_name_np)(thread, name);
+}
+#define INIT_PTHREAD_SETNAME_NP INTERCEPT_PTHREAD_FUNCTION(set_name_np);
+#elif SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && !SANITIZER_NETBSD
+INTERCEPTOR_PTHREAD(int, setname_np, uptr thread, const char *name) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_setname_np, thread, name);
   COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
   COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name);
   return REAL(pthread_setname_np)(thread, name);
 }
-#define INIT_PTHREAD_SETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_setname_np);
+#define INIT_PTHREAD_SETNAME_NP INTERCEPT_PTHREAD_FUNCTION(setname_np);
 #elif SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && SANITIZER_NETBSD
-INTERCEPTOR(int, pthread_setname_np, uptr thread, const char *name, void *arg) {
+INTERCEPTOR_PTHREAD(int, setname_np, uptr thread, const char *name, void *arg) {
   void *ctx;
   char newname[32]; // PTHREAD_MAX_NAMELEN_NP=32
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_setname_np, thread, name, arg);
   COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
   internal_snprintf(newname, sizeof(newname), name, arg);
   COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, newname);
   return REAL(pthread_setname_np)(thread, name, arg);
 }
-#define INIT_PTHREAD_SETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_setname_np);
+#define INIT_PTHREAD_SETNAME_NP INTERCEPT_PTHREAD_FUNCTION(setname_np);
 #else
 #define INIT_PTHREAD_SETNAME_NP
 #endif
 
 #if SANITIZER_INTERCEPT_PTHREAD_GETNAME_NP
-INTERCEPTOR(int, pthread_getname_np, uptr thread, char *name, SIZE_T len) {
+INTERCEPTOR_PTHREAD(int, getname_np, uptr thread, char *name, SIZE_T len) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_getname_np, thread, name, len);
   int res = REAL(pthread_getname_np)(thread, name, len);
   if (!res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, internal_strnlen(name, len) + 1);
   return res;
 }
-#define INIT_PTHREAD_GETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_getname_np);
+#define INIT_PTHREAD_GETNAME_NP INTERCEPT_PTHREAD_FUNCTION(getname_np);
 #else
 #define INIT_PTHREAD_GETNAME_NP
 #endif
 
 #if SANITIZER_INTERCEPT_SINCOS
 INTERCEPTOR(void, sincos, double x, double *sin, double *cos) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, sincos, x, sin, cos);
#define INIT_SEM                                                               \
   COMMON_INTERCEPT_FUNCTION(sem_timedwait);                                    \
   COMMON_INTERCEPT_FUNCTION(sem_post);                                         \
   COMMON_INTERCEPT_FUNCTION(sem_getvalue);
 #else
 #define INIT_SEM
 #endif // SANITIZER_INTERCEPT_SEM
 
 #if SANITIZER_INTERCEPT_PTHREAD_SETCANCEL
-INTERCEPTOR(int, pthread_setcancelstate, int state, int *oldstate) {
+INTERCEPTOR_PTHREAD(int, setcancelstate, int state, int *oldstate) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcancelstate, state, oldstate);
   int res = REAL(pthread_setcancelstate)(state, oldstate);
   if (res == 0 && oldstate != nullptr)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldstate, sizeof(*oldstate));
   return res;
 }
 
-INTERCEPTOR(int, pthread_setcanceltype, int type, int *oldtype) {
+INTERCEPTOR_PTHREAD(int, setcanceltype, int type, int *oldtype) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcanceltype, type, oldtype);
   int res = REAL(pthread_setcanceltype)(type, oldtype);
   if (res == 0 && oldtype != nullptr)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldtype, sizeof(*oldtype));
   return res;
 }
 #define INIT_PTHREAD_SETCANCEL                                                 \
-  COMMON_INTERCEPT_FUNCTION(pthread_setcancelstate);                           \
-  COMMON_INTERCEPT_FUNCTION(pthread_setcanceltype);
+  INTERCEPT_PTHREAD_FUNCTION(setcancelstate);                           \
+  INTERCEPT_PTHREAD_FUNCTION(setcanceltype);
 #else
 #define INIT_PTHREAD_SETCANCEL
 #endif
 
 #if SANITIZER_INTERCEPT_MINCORE
 INTERCEPTOR(int, mincore, void *addr, uptr length, unsigned char *vec) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, mincore, addr, length, vec);

compiler-rt/lib/tsan/dd/dd_interceptors.cpp

static bool InitThread() {
   }
   thr = (Thread*)InternalAlloc(sizeof(*thr));
   internal_memset(thr, 0, sizeof(*thr));
   ThreadInit(thr);
   initing = false;
   return true;
 }
 
-INTERCEPTOR(int, pthread_mutex_destroy, pthread_mutex_t *m) {
+INTERCEPTOR_PTHREAD(int, mutex_destroy, pthread_mutex_t *m) {
   InitThread();
   MutexDestroy(thr, (uptr)m);
   return REAL(pthread_mutex_destroy)(m);
 }
 
-INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *m) {
+INTERCEPTOR_PTHREAD(int, mutex_lock, pthread_mutex_t *m) {
   InitThread();
   MutexBeforeLock(thr, (uptr)m, true);
   int res = REAL(pthread_mutex_lock)(m);
   MutexAfterLock(thr, (uptr)m, true, false);
   return res;
 }
 
-INTERCEPTOR(int, pthread_mutex_trylock, pthread_mutex_t *m) {
+INTERCEPTOR_PTHREAD(int, mutex_trylock, pthread_mutex_t *m) {
   InitThread();
   int res = REAL(pthread_mutex_trylock)(m);
   if (res == 0)
     MutexAfterLock(thr, (uptr)m, true, true);
   return res;
 }
 
-INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *m) {
+INTERCEPTOR_PTHREAD(int, mutex_unlock, pthread_mutex_t *m) {
   InitThread();
   MutexBeforeUnlock(thr, (uptr)m, true);
   return REAL(pthread_mutex_unlock)(m);
 }
 
-INTERCEPTOR(int, pthread_spin_destroy, pthread_spinlock_t *m) {
+INTERCEPTOR_PTHREAD(int, spin_destroy, pthread_spinlock_t *m) {
   InitThread();
   int res = REAL(pthread_spin_destroy)(m);
   MutexDestroy(thr, (uptr)m);
   return res;
 }
 
-INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *m) {
+INTERCEPTOR_PTHREAD(int, spin_lock, pthread_spinlock_t *m) {
   InitThread();
   MutexBeforeLock(thr, (uptr)m, true);
   int res = REAL(pthread_spin_lock)(m);
   MutexAfterLock(thr, (uptr)m, true, false);
   return res;
 }
 
-INTERCEPTOR(int, pthread_spin_trylock, pthread_spinlock_t *m) {
+INTERCEPTOR_PTHREAD(int, spin_trylock, pthread_spinlock_t *m) {
   InitThread();
   int res = REAL(pthread_spin_trylock)(m);
   if (res == 0)
     MutexAfterLock(thr, (uptr)m, true, true);
   return res;
 }
 
-INTERCEPTOR(int, pthread_spin_unlock, pthread_spinlock_t *m) {
+INTERCEPTOR_PTHREAD(int, spin_unlock, pthread_spinlock_t *m) {
   InitThread();
   MutexBeforeUnlock(thr, (uptr)m, true);
   return REAL(pthread_spin_unlock)(m);
 }
 
-INTERCEPTOR(int, pthread_rwlock_destroy, pthread_rwlock_t *m) {
+INTERCEPTOR_PTHREAD(int, rwlock_destroy, pthread_rwlock_t *m) {
   InitThread();
   MutexDestroy(thr, (uptr)m);
   return REAL(pthread_rwlock_destroy)(m);
 }
 
-INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *m) {
+INTERCEPTOR_PTHREAD(int, rwlock_rdlock, pthread_rwlock_t *m) {
   InitThread();
   MutexBeforeLock(thr, (uptr)m, false);
   int res = REAL(pthread_rwlock_rdlock)(m);
   MutexAfterLock(thr, (uptr)m, false, false);
   return res;
 }
 
-INTERCEPTOR(int, pthread_rwlock_tryrdlock, pthread_rwlock_t *m) {
+INTERCEPTOR_PTHREAD(int, rwlock_tryrdlock, pthread_rwlock_t *m) {
   InitThread();
   int res = REAL(pthread_rwlock_tryrdlock)(m);
   if (res == 0)
     MutexAfterLock(thr, (uptr)m, false, true);
   return res;
 }
 
-INTERCEPTOR(int, pthread_rwlock_timedrdlock, pthread_rwlock_t *m,
+INTERCEPTOR_PTHREAD(int, rwlock_timedrdlock, pthread_rwlock_t *m,
                     const timespec *abstime) {
   InitThread();
   int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
   if (res == 0)
     MutexAfterLock(thr, (uptr)m, false, true);
   return res;
 }
 
-INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *m) {
+INTERCEPTOR_PTHREAD(int, rwlock_wrlock, pthread_rwlock_t *m) {
   InitThread();
   MutexBeforeLock(thr, (uptr)m, true);
   int res = REAL(pthread_rwlock_wrlock)(m);
   MutexAfterLock(thr, (uptr)m, true, false);
   return res;
 }
 
-INTERCEPTOR(int, pthread_rwlock_trywrlock, pthread_rwlock_t *m) {
+INTERCEPTOR_PTHREAD(int, rwlock_trywrlock, pthread_rwlock_t *m) {
   InitThread();
   int res = REAL(pthread_rwlock_trywrlock)(m);
   if (res == 0)
     MutexAfterLock(thr, (uptr)m, true, true);
   return res;
 }
 
-INTERCEPTOR(int, pthread_rwlock_timedwrlock, pthread_rwlock_t *m,
+INTERCEPTOR_PTHREAD(int, rwlock_timedwrlock, pthread_rwlock_t *m,
                     const timespec *abstime) {
   InitThread();
   int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
   if (res == 0)
     MutexAfterLock(thr, (uptr)m, true, true);
   return res;
 }
 
-INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *m) {
+INTERCEPTOR_PTHREAD(int, rwlock_unlock, pthread_rwlock_t *m) {
   InitThread();
   MutexBeforeUnlock(thr, (uptr)m, true);  // note: not necessary write unlock
   return REAL(pthread_rwlock_unlock)(m);
 }
 
 static pthread_cond_t *init_cond(pthread_cond_t *c, bool force = false) {
   atomic_uintptr_t *p = (atomic_uintptr_t*)c;
   uptr cond = atomic_load(p, memory_order_acquire);
   if (!force && cond != 0)
     return (pthread_cond_t*)cond;
   void *newcond = InternalAlloc(sizeof(pthread_cond_t));
   internal_memset(newcond, 0, sizeof(pthread_cond_t));
   if (atomic_compare_exchange_strong(p, &cond, (uptr)newcond,
       memory_order_acq_rel))
     return (pthread_cond_t*)newcond;
   InternalFree(newcond);
   return (pthread_cond_t*)cond;
 }
 
-INTERCEPTOR(int, pthread_cond_init, pthread_cond_t *c,
+INTERCEPTOR_PTHREAD(int, cond_init, pthread_cond_t *c,
                     const pthread_condattr_t *a) {
   InitThread();
   pthread_cond_t *cond = init_cond(c, true);
   return REAL(pthread_cond_init)(cond, a);
 }
 
-INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *c, pthread_mutex_t *m) {
+INTERCEPTOR_PTHREAD(int, cond_wait, pthread_cond_t *c, pthread_mutex_t *m) {
   InitThread();
   pthread_cond_t *cond = init_cond(c);
   MutexBeforeUnlock(thr, (uptr)m, true);
   MutexBeforeLock(thr, (uptr)m, true);
   int res = REAL(pthread_cond_wait)(cond, m);
   MutexAfterLock(thr, (uptr)m, true, false);
   return res;
 }
 
-INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *c, pthread_mutex_t *m,
+INTERCEPTOR_PTHREAD(int, cond_timedwait, pthread_cond_t *c, pthread_mutex_t *m,
                     const timespec *abstime) {
   InitThread();
   pthread_cond_t *cond = init_cond(c);
   MutexBeforeUnlock(thr, (uptr)m, true);
   MutexBeforeLock(thr, (uptr)m, true);
   int res = REAL(pthread_cond_timedwait)(cond, m, abstime);
   MutexAfterLock(thr, (uptr)m, true, false);
   return res;
 }
 
-INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *c) {
+INTERCEPTOR_PTHREAD(int, cond_signal, pthread_cond_t *c) {
   InitThread();
   pthread_cond_t *cond = init_cond(c);
   return REAL(pthread_cond_signal)(cond);
 }
 
-INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *c) {
+INTERCEPTOR_PTHREAD(int, cond_broadcast, pthread_cond_t *c) {
   InitThread();
   pthread_cond_t *cond = init_cond(c);
   return REAL(pthread_cond_broadcast)(cond);
 }
 
-INTERCEPTOR(int, pthread_cond_destroy, pthread_cond_t *c) {
+INTERCEPTOR_PTHREAD(int, cond_destroy, pthread_cond_t *c) {
   InitThread();
   pthread_cond_t *cond = init_cond(c);
   int res = REAL(pthread_cond_destroy)(cond);
   InternalFree(cond);
   atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
   return res;
 }
 

compiler-rt/lib/tsan/rtl/tsan_interceptors.h

 
 #define SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START() \
     si.DisableIgnores();
 
 #define SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END() \
     si.EnableIgnores();
 
 #define TSAN_INTERCEPTOR(ret, func, ...) INTERCEPTOR(ret, func, __VA_ARGS__)
+#define TSAN_INTERCEPTOR_PTHREAD(ret, func, ...) \
+  INTERCEPTOR_PTHREAD(ret, func, __VA_ARGS__)
 
 #if SANITIZER_NETBSD
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS(ret, func, ...) \
   TSAN_INTERCEPTOR(ret, __libc_##func, __VA_ARGS__) \
   ALIAS(WRAPPER_NAME(pthread_##func));
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS_THR(ret, func, ...) \
   TSAN_INTERCEPTOR(ret, __libc_thr_##func, __VA_ARGS__) \
   ALIAS(WRAPPER_NAME(pthread_##func));

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

if (ignoring_) {
     if (in_ignored_lib_) {
       DCHECK(thr_->in_ignored_lib);
       thr_->in_ignored_lib = false;
     }
   }
 }
 
 #define TSAN_INTERCEPT(func) INTERCEPT_FUNCTION(func)
+#define TSAN_INTERCEPT_PTHREAD(func) INTERCEPT_PTHREAD_FUNCTION(func)
 #if SANITIZER_FREEBSD
 # define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION(func)
 # define TSAN_MAYBE_INTERCEPT_NETBSD_ALIAS(func)
 # define TSAN_MAYBE_INTERCEPT_NETBSD_ALIAS_THR(func)
 #elif SANITIZER_NETBSD
 # define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION(func)
 # define TSAN_MAYBE_INTERCEPT_NETBSD_ALIAS(func) \
          INTERCEPT_FUNCTION(__libc_##func)
#endif
   void *res = callback(param);
   // Prevent the callback from being tail called,
   // it mixes up stack traces.
   volatile int foo = 42;
   foo++;
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_create,
-    void *th, void *attr, void *(*callback)(void*), void * param) {
+TSAN_INTERCEPTOR_PTHREAD(int, create, void *th, void *attr,
+                         void *(*callback)(void *), void *param) {
   SCOPED_INTERCEPTOR_RAW(pthread_create, th, attr, callback, param);
 
   MaybeSpawnBackgroundThread();
 
   if (ctx->after_multithreaded_fork) {
     if (flags()->die_after_fork) {
       Report("ThreadSanitizer: starting new threads after multi-threaded "
           "fork is not supported. Dying (set die_after_fork=0 to override)\n");
if (res == 0) {
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
       internal_sched_yield();
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) {
+TSAN_INTERCEPTOR_PTHREAD(int, join, void *th, void **ret) {
   SCOPED_INTERCEPTOR_RAW(pthread_join, th, ret);
   int tid = ThreadConsumeTid(thr, pc, (uptr)th);
   ThreadIgnoreBegin(thr, pc);
   int res = BLOCK_REAL(pthread_join)(th, ret);
   ThreadIgnoreEnd(thr, pc);
   if (res == 0) {
     ThreadJoin(thr, pc, tid);
   }
   return res;
 }
 
 DEFINE_REAL_PTHREAD_FUNCTIONS
 
-TSAN_INTERCEPTOR(int, pthread_detach, void *th) {
+TSAN_INTERCEPTOR_PTHREAD(int, detach, void *th) {
   SCOPED_INTERCEPTOR_RAW(pthread_detach, th);
   int tid = ThreadConsumeTid(thr, pc, (uptr)th);
   int res = REAL(pthread_detach)(th);
   if (res == 0) {
     ThreadDetach(thr, pc, tid);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(void, pthread_exit, void *retval) {
+TSAN_INTERCEPTOR_PTHREAD(void, exit, void *retval) {
   {
     SCOPED_INTERCEPTOR_RAW(pthread_exit, retval);
 #if !SANITIZER_MAC && !SANITIZER_ANDROID
     CHECK_EQ(thr, &cur_thread_placeholder);
 #endif
   }
   REAL(pthread_exit)(retval);
 }
 
 #if SANITIZER_LINUX
-TSAN_INTERCEPTOR(int, pthread_tryjoin_np, void *th, void **ret) {
+TSAN_INTERCEPTOR_PTHREAD(int, tryjoin_np, void *th, void **ret) {
   SCOPED_INTERCEPTOR_RAW(pthread_tryjoin_np, th, ret);
   int tid = ThreadConsumeTid(thr, pc, (uptr)th);
   ThreadIgnoreBegin(thr, pc);
   int res = REAL(pthread_tryjoin_np)(th, ret);
   ThreadIgnoreEnd(thr, pc);
   if (res == 0)
     ThreadJoin(thr, pc, tid);
   else
     ThreadNotJoined(thr, pc, tid, (uptr)th);
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_timedjoin_np, void *th, void **ret,
+TSAN_INTERCEPTOR_PTHREAD(int, timedjoin_np, void *th, void **ret,
                          const struct timespec *abstime) {
   SCOPED_INTERCEPTOR_RAW(pthread_timedjoin_np, th, ret, abstime);
   int tid = ThreadConsumeTid(thr, pc, (uptr)th);
   ThreadIgnoreBegin(thr, pc);
   int res = BLOCK_REAL(pthread_timedjoin_np)(th, ret, abstime);
   ThreadIgnoreEnd(thr, pc);
   if (res == 0)
     ThreadJoin(thr, pc, tid);
   else
void CondMutexUnlockCtx<Fn>::Unlock() const {
   atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
   MutexPostLock(thr, pc, (uptr)m, MutexFlagDoPreLockOnPostLock);
   // Undo BlockingCall ctor effects.
   thr->ignore_interceptors--;
   si->~ScopedInterceptor();
 }
 }  // namespace
 
-INTERCEPTOR(int, pthread_cond_init, void *c, void *a) {
+TSAN_INTERCEPTOR_PTHREAD(int, cond_init, void *c, void *a) {
   void *cond = init_cond(c, true);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_init, cond, a);
   MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true);
   return REAL(pthread_cond_init)(cond, a);
 }
 
 template <class Fn>
 int cond_wait(ThreadState *thr, uptr pc, ScopedInterceptor *si, const Fn &fn,
res = call_pthread_cancel_with_cleanup(
         [](void *arg) { ((const CondMutexUnlockCtx<Fn> *)arg)->Unlock(); },
         &arg);
   }
   if (res == errno_EOWNERDEAD) MutexRepair(thr, pc, (uptr)m);
   MutexPostLock(thr, pc, (uptr)m, MutexFlagDoPreLockOnPostLock);
   return res;
 }
 
-INTERCEPTOR(int, pthread_cond_wait, void *c, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, cond_wait, void *c, void *m) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_wait, cond, m);
   return cond_wait(
       thr, pc, &si, [=]() { return REAL(pthread_cond_wait)(cond, m); }, cond,
       m);
 }
 
-INTERCEPTOR(int, pthread_cond_timedwait, void *c, void *m, void *abstime) {
+TSAN_INTERCEPTOR_PTHREAD(int, cond_timedwait, void *c, void *m, void *abstime) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_timedwait, cond, m, abstime);
   return cond_wait(
       thr, pc, &si,
       [=]() { return REAL(pthread_cond_timedwait)(cond, m, abstime); }, cond,
       m);
 }
 
 #if SANITIZER_LINUX
-INTERCEPTOR(int, pthread_cond_clockwait, void *c, void *m,
+TSAN_INTERCEPTOR_PTHREAD(int, cond_clockwait, void *c, void *m,
                          __sanitizer_clockid_t clock, void *abstime) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_clockwait, cond, m, clock, abstime);
   return cond_wait(
       thr, pc, &si,
       [=]() { return REAL(pthread_cond_clockwait)(cond, m, clock, abstime); },
       cond, m);
 }
-#define TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT TSAN_INTERCEPT(pthread_cond_clockwait)
+#define TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT TSAN_INTERCEPT_PTHREAD(cond_clockwait)
 #else
 #define TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT
 #endif
 
 #if SANITIZER_MAC
-INTERCEPTOR(int, pthread_cond_timedwait_relative_np, void *c, void *m,
+TSAN_INTERCEPTOR_PTHREAD(int, cond_timedwait_relative_np, void *c, void *m,
                          void *reltime) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_timedwait_relative_np, cond, m, reltime);
   return cond_wait(
       thr, pc, &si,
       [=]() {
         return REAL(pthread_cond_timedwait_relative_np)(cond, m, reltime);
       },
       cond, m);
 }
 #endif
 
-INTERCEPTOR(int, pthread_cond_signal, void *c) {
+TSAN_INTERCEPTOR_PTHREAD(int, cond_signal, void *c) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_signal, cond);
   MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
   return REAL(pthread_cond_signal)(cond);
 }
 
-INTERCEPTOR(int, pthread_cond_broadcast, void *c) {
+TSAN_INTERCEPTOR_PTHREAD(int, cond_broadcast, void *c) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_broadcast, cond);
   MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
   return REAL(pthread_cond_broadcast)(cond);
 }
 
-INTERCEPTOR(int, pthread_cond_destroy, void *c) {
+TSAN_INTERCEPTOR_PTHREAD(int, cond_destroy, void *c) {
   void *cond = init_cond(c);
   SCOPED_TSAN_INTERCEPTOR(pthread_cond_destroy, cond);
   MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true);
   int res = REAL(pthread_cond_destroy)(cond);
   if (common_flags()->legacy_pthread_cond) {
     // Free our aux cond and zero the pointer to not leave dangling pointers.
     WRAP(free)(cond);
     atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_mutex_init, void *m, void *a) {
+TSAN_INTERCEPTOR_PTHREAD(int, mutex_init, void *m, void *a) {
   SCOPED_TSAN_INTERCEPTOR(pthread_mutex_init, m, a);
   int res = REAL(pthread_mutex_init)(m, a);
   if (res == 0) {
     u32 flagz = 0;
     if (a) {
       int type = 0;
       if (REAL(pthread_mutexattr_gettype)(a, &type) == 0)
         if (type == PTHREAD_MUTEX_RECURSIVE ||
             type == PTHREAD_MUTEX_RECURSIVE_NP)
           flagz |= MutexFlagWriteReentrant;
     }
     MutexCreate(thr, pc, (uptr)m, flagz);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_mutex_destroy, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, mutex_destroy, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_mutex_destroy, m);
   int res = REAL(pthread_mutex_destroy)(m);
   if (res == 0 || res == errno_EBUSY) {
     MutexDestroy(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_mutex_trylock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, mutex_trylock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_mutex_trylock, m);
   int res = REAL(pthread_mutex_trylock)(m);
   if (res == errno_EOWNERDEAD)
     MutexRepair(thr, pc, (uptr)m);
   if (res == 0 || res == errno_EOWNERDEAD)
     MutexPostLock(thr, pc, (uptr)m, MutexFlagTryLock);
   return res;
 }
 
 #if !SANITIZER_MAC
-TSAN_INTERCEPTOR(int, pthread_mutex_timedlock, void *m, void *abstime) {
+TSAN_INTERCEPTOR_PTHREAD(int, mutex_timedlock, void *m, void *abstime) {
   SCOPED_TSAN_INTERCEPTOR(pthread_mutex_timedlock, m, abstime);
   int res = REAL(pthread_mutex_timedlock)(m, abstime);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m, MutexFlagTryLock);
   }
   return res;
 }
 #endif
 
 #if !SANITIZER_MAC
-TSAN_INTERCEPTOR(int, pthread_spin_init, void *m, int pshared) {
+TSAN_INTERCEPTOR_PTHREAD(int, spin_init, void *m, int pshared) {
   SCOPED_TSAN_INTERCEPTOR(pthread_spin_init, m, pshared);
   int res = REAL(pthread_spin_init)(m, pshared);
   if (res == 0) {
     MutexCreate(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_spin_destroy, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, spin_destroy, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_spin_destroy, m);
   int res = REAL(pthread_spin_destroy)(m);
   if (res == 0) {
     MutexDestroy(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_spin_lock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, spin_lock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_spin_lock, m);
   MutexPreLock(thr, pc, (uptr)m);
   int res = REAL(pthread_spin_lock)(m);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_spin_trylock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, spin_trylock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_spin_trylock, m);
   int res = REAL(pthread_spin_trylock)(m);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m, MutexFlagTryLock);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_spin_unlock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, spin_unlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_spin_unlock, m);
   MutexUnlock(thr, pc, (uptr)m);
   int res = REAL(pthread_spin_unlock)(m);
   return res;
 }
 #endif
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_init, void *m, void *a) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_init, void *m, void *a) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_init, m, a);
   int res = REAL(pthread_rwlock_init)(m, a);
   if (res == 0) {
     MutexCreate(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_destroy, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_destroy, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_destroy, m);
   int res = REAL(pthread_rwlock_destroy)(m);
   if (res == 0) {
     MutexDestroy(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_rdlock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_rdlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_rdlock, m);
   MutexPreReadLock(thr, pc, (uptr)m);
   int res = REAL(pthread_rwlock_rdlock)(m);
   if (res == 0) {
     MutexPostReadLock(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_tryrdlock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_tryrdlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_tryrdlock, m);
   int res = REAL(pthread_rwlock_tryrdlock)(m);
   if (res == 0) {
     MutexPostReadLock(thr, pc, (uptr)m, MutexFlagTryLock);
   }
   return res;
 }
 
 #if !SANITIZER_MAC
-TSAN_INTERCEPTOR(int, pthread_rwlock_timedrdlock, void *m, void *abstime) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_timedrdlock, void *m, void *abstime) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_timedrdlock, m, abstime);
   int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
   if (res == 0) {
     MutexPostReadLock(thr, pc, (uptr)m);
   }
   return res;
 }
 #endif
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_wrlock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_wrlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_wrlock, m);
   MutexPreLock(thr, pc, (uptr)m);
   int res = REAL(pthread_rwlock_wrlock)(m);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m);
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_trywrlock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_trywrlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_trywrlock, m);
   int res = REAL(pthread_rwlock_trywrlock)(m);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m, MutexFlagTryLock);
   }
   return res;
 }
 
 #if !SANITIZER_MAC
-TSAN_INTERCEPTOR(int, pthread_rwlock_timedwrlock, void *m, void *abstime) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_timedwrlock, void *m, void *abstime) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_timedwrlock, m, abstime);
   int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m, MutexFlagTryLock);
   }
   return res;
 }
 #endif
 
-TSAN_INTERCEPTOR(int, pthread_rwlock_unlock, void *m) {
+TSAN_INTERCEPTOR_PTHREAD(int, rwlock_unlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_unlock, m);
   MutexReadOrWriteUnlock(thr, pc, (uptr)m);
   int res = REAL(pthread_rwlock_unlock)(m);
   return res;
 }
 
 #if !SANITIZER_MAC
-TSAN_INTERCEPTOR(int, pthread_barrier_init, void *b, void *a, unsigned count) {
+TSAN_INTERCEPTOR_PTHREAD(int, barrier_init, void *b, void *a, unsigned count) {
   SCOPED_TSAN_INTERCEPTOR(pthread_barrier_init, b, a, count);
   MemoryWrite(thr, pc, (uptr)b, kSizeLog1);
   int res = REAL(pthread_barrier_init)(b, a, count);
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_barrier_destroy, void *b) {
+TSAN_INTERCEPTOR_PTHREAD(int, barrier_destroy, void *b) {
   SCOPED_TSAN_INTERCEPTOR(pthread_barrier_destroy, b);
   MemoryWrite(thr, pc, (uptr)b, kSizeLog1);
   int res = REAL(pthread_barrier_destroy)(b);
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_barrier_wait, void *b) {
+TSAN_INTERCEPTOR_PTHREAD(int, barrier_wait, void *b) {
   SCOPED_TSAN_INTERCEPTOR(pthread_barrier_wait, b);
   Release(thr, pc, (uptr)b);
   MemoryRead(thr, pc, (uptr)b, kSizeLog1);
   int res = REAL(pthread_barrier_wait)(b);
   MemoryRead(thr, pc, (uptr)b, kSizeLog1);
   if (res == 0 || res == PTHREAD_BARRIER_SERIAL_THREAD) {
     Acquire(thr, pc, (uptr)b);
   }
   return res;
 }
 #endif
 
-TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) {
+TSAN_INTERCEPTOR_PTHREAD(int, once, void *o, void (*f)()) {
   SCOPED_INTERCEPTOR_RAW(pthread_once, o, f);
   if (o == 0 || f == 0)
     return errno_EINVAL;
   atomic_uint32_t *a;
 
   if (SANITIZER_MAC)
     a = static_cast<atomic_uint32_t*>((void *)((char *)o + sizeof(long_t)));
   else if (SANITIZER_NETBSD)
TSAN_INTERCEPTOR(int, sigblock, int mask) {
   return REAL(sigblock)(mask);
 }
 
 TSAN_INTERCEPTOR(int, sigsetmask, int mask) {
   SCOPED_TSAN_INTERCEPTOR(sigsetmask, mask);
   return REAL(sigsetmask)(mask);
 }
 
-TSAN_INTERCEPTOR(int, pthread_sigmask, int how, const __sanitizer_sigset_t *set,
+TSAN_INTERCEPTOR_PTHREAD(int, sigmask, int how, const __sanitizer_sigset_t *set,
                          __sanitizer_sigset_t *oldset) {
   SCOPED_TSAN_INTERCEPTOR(pthread_sigmask, how, set, oldset);
   return REAL(pthread_sigmask)(how, set, oldset);
 }
 
 namespace __tsan {
 
 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
                                   bool sigact, int sig,
TSAN_INTERCEPTOR(int, kill, int pid, int sig) {
   int res = REAL(kill)(pid, sig);
   if (pid == (int)internal_getpid()) {
     CHECK_EQ(sctx->int_signal_send, sig);
     sctx->int_signal_send = prev;
   }
   return res;
 }
 
-TSAN_INTERCEPTOR(int, pthread_kill, void *tid, int sig) {
+TSAN_INTERCEPTOR_PTHREAD(int, kill, void *tid, int sig) {
   SCOPED_TSAN_INTERCEPTOR(pthread_kill, tid, sig);
   ThreadSignalContext *sctx = SigCtx(thr);
   CHECK_NE(sctx, 0);
   int prev = sctx->int_signal_send;
   if (tid == pthread_self()) {
     sctx->int_signal_send = sig;
   }
   int res = REAL(pthread_kill)(tid, sig);
#endif
   TSAN_INTERCEPT(valloc);
   TSAN_MAYBE_INTERCEPT_PVALLOC;
   TSAN_INTERCEPT(posix_memalign);
 
   TSAN_INTERCEPT(strcpy);
   TSAN_INTERCEPT(strncpy);
   TSAN_INTERCEPT(strdup);
 
-  TSAN_INTERCEPT(pthread_create);
-  TSAN_INTERCEPT(pthread_join);
-  TSAN_INTERCEPT(pthread_detach);
-  TSAN_INTERCEPT(pthread_exit);
-  #if SANITIZER_LINUX
-  TSAN_INTERCEPT(pthread_tryjoin_np);
-  TSAN_INTERCEPT(pthread_timedjoin_np);
-  #endif
+  TSAN_INTERCEPT_PTHREAD(create);
+  TSAN_INTERCEPT_PTHREAD(join);
+  TSAN_INTERCEPT_PTHREAD(detach);
+  TSAN_INTERCEPT_PTHREAD(exit);
+  TSAN_INTERCEPT_PTHREAD(tryjoin_np);
+  TSAN_INTERCEPT_PTHREAD(timedjoin_np);
 
   TSAN_INTERCEPT_VER(pthread_cond_init, PTHREAD_ABI_BASE);
   TSAN_INTERCEPT_VER(pthread_cond_signal, PTHREAD_ABI_BASE);
   TSAN_INTERCEPT_VER(pthread_cond_broadcast, PTHREAD_ABI_BASE);
   TSAN_INTERCEPT_VER(pthread_cond_wait, PTHREAD_ABI_BASE);
   TSAN_INTERCEPT_VER(pthread_cond_timedwait, PTHREAD_ABI_BASE);
   TSAN_INTERCEPT_VER(pthread_cond_destroy, PTHREAD_ABI_BASE);
 
   TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT;
 
-  TSAN_INTERCEPT(pthread_mutex_init);
-  TSAN_INTERCEPT(pthread_mutex_destroy);
-  TSAN_INTERCEPT(pthread_mutex_trylock);
-  TSAN_INTERCEPT(pthread_mutex_timedlock);
-
-  TSAN_INTERCEPT(pthread_spin_init);
-  TSAN_INTERCEPT(pthread_spin_destroy);
-  TSAN_INTERCEPT(pthread_spin_lock);
-  TSAN_INTERCEPT(pthread_spin_trylock);
-  TSAN_INTERCEPT(pthread_spin_unlock);
-
-  TSAN_INTERCEPT(pthread_rwlock_init);
-  TSAN_INTERCEPT(pthread_rwlock_destroy);
-  TSAN_INTERCEPT(pthread_rwlock_rdlock);
-  TSAN_INTERCEPT(pthread_rwlock_tryrdlock);
-  TSAN_INTERCEPT(pthread_rwlock_timedrdlock);
-  TSAN_INTERCEPT(pthread_rwlock_wrlock);
-  TSAN_INTERCEPT(pthread_rwlock_trywrlock);
-  TSAN_INTERCEPT(pthread_rwlock_timedwrlock);
-  TSAN_INTERCEPT(pthread_rwlock_unlock);
-
-  TSAN_INTERCEPT(pthread_barrier_init);
-  TSAN_INTERCEPT(pthread_barrier_destroy);
-  TSAN_INTERCEPT(pthread_barrier_wait);
+  TSAN_INTERCEPT_PTHREAD(mutex_init);
+  TSAN_INTERCEPT_PTHREAD(mutex_destroy);
+  TSAN_INTERCEPT_PTHREAD(mutex_trylock);
+  TSAN_INTERCEPT_PTHREAD(mutex_timedlock);
+
+  TSAN_INTERCEPT_PTHREAD(spin_init);
+  TSAN_INTERCEPT_PTHREAD(spin_destroy);
+  TSAN_INTERCEPT_PTHREAD(spin_lock);
+  TSAN_INTERCEPT_PTHREAD(spin_trylock);
+  TSAN_INTERCEPT_PTHREAD(spin_unlock);
+
+  TSAN_INTERCEPT_PTHREAD(rwlock_init);
+  TSAN_INTERCEPT_PTHREAD(rwlock_destroy);
+  TSAN_INTERCEPT_PTHREAD(rwlock_rdlock);
+  TSAN_INTERCEPT_PTHREAD(rwlock_tryrdlock);
+  TSAN_INTERCEPT_PTHREAD(rwlock_timedrdlock);
+  TSAN_INTERCEPT_PTHREAD(rwlock_wrlock);
+  TSAN_INTERCEPT_PTHREAD(rwlock_trywrlock);
+  TSAN_INTERCEPT_PTHREAD(rwlock_timedwrlock);
+  TSAN_INTERCEPT_PTHREAD(rwlock_unlock);
+
+  TSAN_INTERCEPT_PTHREAD(barrier_init);
+  TSAN_INTERCEPT_PTHREAD(barrier_destroy);
+  TSAN_INTERCEPT_PTHREAD(barrier_wait);
 
-  TSAN_INTERCEPT(pthread_once);
+  TSAN_INTERCEPT_PTHREAD(once);
 
   TSAN_INTERCEPT(fstat);
   TSAN_MAYBE_INTERCEPT___FXSTAT;
   TSAN_MAYBE_INTERCEPT_FSTAT64;
   TSAN_MAYBE_INTERCEPT___FXSTAT64;
   TSAN_INTERCEPT(open);
   TSAN_MAYBE_INTERCEPT_OPEN64;
   TSAN_INTERCEPT(creat);
#endif
   TSAN_MAYBE_INTERCEPT_TMPFILE64;
   TSAN_INTERCEPT(abort);
   TSAN_INTERCEPT(rmdir);
   TSAN_INTERCEPT(closedir);
 
   TSAN_INTERCEPT(sigsuspend);
   TSAN_INTERCEPT(sigblock);
   TSAN_INTERCEPT(sigsetmask);
-  TSAN_INTERCEPT(pthread_sigmask);
+  TSAN_INTERCEPT_PTHREAD(sigmask);
   TSAN_INTERCEPT(raise);
   TSAN_INTERCEPT(kill);
-  TSAN_INTERCEPT(pthread_kill);
+  TSAN_INTERCEPT_PTHREAD(kill);
   TSAN_INTERCEPT(sleep);
   TSAN_INTERCEPT(usleep);
   TSAN_INTERCEPT(nanosleep);
   TSAN_INTERCEPT(pause);
   TSAN_INTERCEPT(gettimeofday);
   TSAN_INTERCEPT(getaddrinfo);
 
   TSAN_INTERCEPT(fork);

compiler-rt/test/tsan/freebsd_libc_locks.cpp

+// RUN: %clangxx_tsan -O1 %s -o %t && %run %t | FileCheck %s
+// REQUIRES: freebsd
+// FreeBSD libc uses _pthread_* calls (with an extra underscore). Check that
+// those are also intercepted and no false-positive race is reported here.
+#include "test.h"
+
+int Global;
+pthread_mutex_t mtx;
+
+extern "C" int _pthread_mutex_lock(pthread_mutex_t *);
+extern "C" int _pthread_mutex_unlock(pthread_mutex_t *);
+
+void *Thread1(void *x) {
+  pthread_mutex_lock(&mtx);
+  Global++;
+  pthread_mutex_unlock(&mtx);
+  return NULL;
+}
+
+void *Thread2(void *x) {
+  _pthread_mutex_lock(&mtx);
+  Global++;
+  _pthread_mutex_unlock(&mtx);
+  return NULL;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_mutex_init(&mtx, 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(&mtx);
+  printf("DONE\n");
+  // CHECK-NOT: WARNING: ThreadSanitizer:
+  // CHECK: DONE
+  // CHECK-NOT: WARNING: ThreadSanitizer:
+}