vendor/compiler-rt/compiler-rt-trunk-r256633

9 files changed, 159 insertions, 63 deletions

diff --git a/lib/tsan/tests/CMakeLists.txt b/lib/tsan/tests/CMakeLists.txt
index 1c3f98f3f0bca..51181bab3a79f 100644
--- a/lib/tsan/tests/CMakeLists.txt
+++ b/lib/tsan/tests/CMakeLists.txt
@@ -33,9 +33,12 @@ macro(tsan_compile obj_list source arch)
 endmacro()
 
 macro(add_tsan_unittest testname)
-  # Build unit tests only for 64-bit Linux.
-  if(UNIX AND NOT APPLE)
-    foreach(arch ${TSAN_SUPPORTED_ARCH})
+  set(TSAN_TEST_ARCH ${TSAN_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(TSAN_SUPPORTED_ARCH TSAN_TEST_ARCH)
+  endif()
+  if(UNIX)
+    foreach(arch ${TSAN_TEST_ARCH})
       cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
       set(TEST_OBJECTS)
       foreach(SOURCE ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE})
@@ -46,15 +49,38 @@ macro(add_tsan_unittest testname)
       if(NOT COMPILER_RT_STANDALONE_BUILD)
         list(APPEND TEST_DEPS tsan)
       endif()
-      # FIXME: Looks like we should link TSan with just-built runtime,
-      # and not rely on -fsanitize=thread, as these tests are essentially
-      # unit tests.
-      add_compiler_rt_test(TsanUnitTests ${testname}
-              OBJECTS ${TEST_OBJECTS}
-              DEPS ${TEST_DEPS}
-              LINK_FLAGS ${TARGET_LINK_FLAGS}
-                         -fsanitize=thread
-                         -lstdc++ -lm)
+      if(NOT APPLE)
+        # FIXME: Looks like we should link TSan with just-built runtime,
+        # and not rely on -fsanitize=thread, as these tests are essentially
+        # unit tests.
+        add_compiler_rt_test(TsanUnitTests ${testname}
+                OBJECTS ${TEST_OBJECTS}
+                DEPS ${TEST_DEPS}
+                LINK_FLAGS ${TARGET_LINK_FLAGS}
+                           -fsanitize=thread
+                           -lstdc++ -lm)
+      else()
+        set(TSAN_TEST_RUNTIME_OBJECTS
+          $<TARGET_OBJECTS:RTTsan_dynamic.osx>
+          $<TARGET_OBJECTS:RTInterception.osx>
+          $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+          $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+          $<TARGET_OBJECTS:RTUbsan.osx>)
+        set(TSAN_TEST_RUNTIME RTTsanTest.${testname}.${arch})
+        add_library(${TSAN_TEST_RUNTIME} STATIC ${TSAN_TEST_RUNTIME_OBJECTS})
+        set_target_properties(${TSAN_TEST_RUNTIME} PROPERTIES
+          ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+        list(APPEND TEST_OBJECTS lib${TSAN_TEST_RUNTIME}.a)
+        list(APPEND TEST_DEPS ${TSAN_TEST_RUNTIME})
+        # Intentionally do *not* link with `-fsanitize=thread`. We already link
+        # against a static version of the runtime, and we don't want the dynamic
+        # one.
+        add_compiler_rt_test(TsanUnitTests "${testname}-${arch}-Test"
+                OBJECTS ${TEST_OBJECTS}
+                DEPS ${TEST_DEPS}
+                LINK_FLAGS ${TARGET_LINK_FLAGS}
+                           -lc++)
+      endif()
     endforeach()
   endif()
 endmacro()
diff --git a/lib/tsan/tests/rtl/CMakeLists.txt b/lib/tsan/tests/rtl/CMakeLists.txt
index 989566d9e041f..a34f08ea965b8 100644
--- a/lib/tsan/tests/rtl/CMakeLists.txt
+++ b/lib/tsan/tests/rtl/CMakeLists.txt
@@ -7,8 +7,8 @@ set(TSAN_RTL_TEST_SOURCES
   tsan_test.cc
   tsan_thread.cc)
 
-if(UNIX AND NOT APPLE)
-  list(APPEND TSAN_RTL_TEST_SOURCES tsan_test_util_linux.cc)
+if(UNIX)
+  list(APPEND TSAN_RTL_TEST_SOURCES tsan_test_util_posix.cc)
 endif()
 
 set(TSAN_RTL_TEST_HEADERS
diff --git a/lib/tsan/tests/rtl/tsan_posix.cc b/lib/tsan/tests/rtl/tsan_posix.cc
index 0caedd7207e63..e1a61b5e43f1b 100644
--- a/lib/tsan/tests/rtl/tsan_posix.cc
+++ b/lib/tsan/tests/rtl/tsan_posix.cc
@@ -35,7 +35,7 @@ static void thread_secific_dtor(void *v) {
   __tsan_write4(&k->cnt);
   EXPECT_EQ(pthread_mutex_unlock(k->mtx), 0);
   if (k->val == 42) {
-    delete k;
+    // Okay.
   } else if (k->val == 43 || k->val == 44) {
     k->val--;
     EXPECT_EQ(pthread_setspecific(k->key, k), 0);
@@ -57,20 +57,20 @@ TEST(Posix, ThreadSpecificDtors) {
   pthread_mutex_t mtx;
   EXPECT_EQ(pthread_mutex_init(&mtx, 0), 0);
   pthread_t th[3];
-  thread_key *k[3];
-  k[0] = new thread_key(key, &mtx, 42, &cnt);
-  k[1] = new thread_key(key, &mtx, 43, &cnt);
-  k[2] = new thread_key(key, &mtx, 44, &cnt);
-  EXPECT_EQ(pthread_create(&th[0], 0, dtors_thread, k[0]), 0);
-  EXPECT_EQ(pthread_create(&th[1], 0, dtors_thread, k[1]), 0);
+  thread_key k1 = thread_key(key, &mtx, 42, &cnt);
+  thread_key k2 = thread_key(key, &mtx, 43, &cnt);
+  thread_key k3 = thread_key(key, &mtx, 44, &cnt);
+  EXPECT_EQ(pthread_create(&th[0], 0, dtors_thread, &k1), 0);
+  EXPECT_EQ(pthread_create(&th[1], 0, dtors_thread, &k2), 0);
   EXPECT_EQ(pthread_join(th[0], 0), 0);
-  EXPECT_EQ(pthread_create(&th[2], 0, dtors_thread, k[2]), 0);
+  EXPECT_EQ(pthread_create(&th[2], 0, dtors_thread, &k3), 0);
   EXPECT_EQ(pthread_join(th[1], 0), 0);
   EXPECT_EQ(pthread_join(th[2], 0), 0);
   EXPECT_EQ(pthread_key_delete(key), 0);
   EXPECT_EQ(6, cnt);
 }
 
+#ifndef __aarch64__
 static __thread int local_var;
 
 static void *local_thread(void *p) {
@@ -87,9 +87,14 @@ static void *local_thread(void *p) {
     EXPECT_EQ(pthread_join(th[i], 0), 0);
   return 0;
 }
+#endif
 
 TEST(Posix, ThreadLocalAccesses) {
+// The test is failing with high thread count for aarch64.
+// FIXME: track down the issue and re-enable the test.
+#ifndef __aarch64__
   local_thread((void*)2);
+#endif
 }
 
 struct CondContext {
diff --git a/lib/tsan/tests/rtl/tsan_test.cc b/lib/tsan/tests/rtl/tsan_test.cc
index b8b9555c2bff1..edfede078b683 100644
--- a/lib/tsan/tests/rtl/tsan_test.cc
+++ b/lib/tsan/tests/rtl/tsan_test.cc
@@ -47,6 +47,13 @@ int run_tests(int argc, char **argv) {
 
 const char *argv0;
 
+#ifdef __APPLE__
+// On Darwin, turns off symbolication and crash logs to make tests faster.
+extern "C" const char* __tsan_default_options() {
+  return "symbolize=false:abort_on_error=0";
+}
+#endif
+
 int main(int argc, char **argv) {
   argv0 = argv[0];
   return run_tests(argc, argv);
diff --git a/lib/tsan/tests/rtl/tsan_test_util.h b/lib/tsan/tests/rtl/tsan_test_util.h
index 84d277b137f07..31b1b188f6247 100644
--- a/lib/tsan/tests/rtl/tsan_test_util.h
+++ b/lib/tsan/tests/rtl/tsan_test_util.h
@@ -31,7 +31,15 @@ class MemLoc {
 
 class Mutex {
  public:
-  enum Type { Normal, Spin, RW };
+  enum Type {
+    Normal,
+    RW,
+#ifndef __APPLE__
+    Spin
+#else
+    Spin = Normal
+#endif
+  };
 
   explicit Mutex(Type type = Normal);
   ~Mutex();
diff --git a/lib/tsan/tests/rtl/tsan_test_util_linux.cc b/lib/tsan/tests/rtl/tsan_test_util_posix.cc
index 9298bf051af2c..c8be088d266f0 100644
--- a/lib/tsan/tests/rtl/tsan_test_util_linux.cc
+++ b/lib/tsan/tests/rtl/tsan_test_util_posix.cc
@@ -1,5 +1,4 @@
-
-//===-- tsan_test_util_linux.cc -------------------------------------------===//
+//===-- tsan_test_util_posix.cc -------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -10,7 +9,7 @@
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
-// Test utils, Linux and FreeBSD implementation.
+// Test utils, Linux, FreeBSD and Darwin implementation.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_atomic.h"
@@ -34,8 +33,51 @@ static __thread bool expect_report;
 static __thread bool expect_report_reported;
 static __thread ReportType expect_report_type;
 
-extern "C" void *__interceptor_memcpy(void*, const void*, uptr);
-extern "C" void *__interceptor_memset(void*, int, uptr);
+#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);
+
+extern "C" int __interceptor_pthread_rwlock_init(
+    pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
+extern "C" int __interceptor_pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
+extern "C" int __interceptor_pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
+
 
 static void *BeforeInitThread(void *param) {
   (void)param;
@@ -48,12 +90,12 @@ static void AtExit() {
 void TestMutexBeforeInit() {
   // Mutexes must be usable before __tsan_init();
   pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
-  pthread_mutex_lock(&mtx);
-  pthread_mutex_unlock(&mtx);
-  pthread_mutex_destroy(&mtx);
+  __interceptor_pthread_mutex_lock(&mtx);
+  __interceptor_pthread_mutex_unlock(&mtx);
+  __interceptor_pthread_mutex_destroy(&mtx);
   pthread_t thr;
-  pthread_create(&thr, 0, BeforeInitThread, 0);
-  pthread_join(thr, 0);
+  __interceptor_pthread_create(&thr, 0, BeforeInitThread, 0);
+  __interceptor_pthread_join(thr, 0);
   atexit(AtExit);
 }
 
@@ -105,11 +147,13 @@ void Mutex::Init() {
   CHECK(!alive_);
   alive_ = true;
   if (type_ == Normal)
-    CHECK_EQ(pthread_mutex_init((pthread_mutex_t*)mtx_, 0), 0);
+    CHECK_EQ(__interceptor_pthread_mutex_init((pthread_mutex_t*)mtx_, 0), 0);
+#ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_init((pthread_spinlock_t*)mtx_, 0), 0);
+#endif
   else if (type_ == RW)
-    CHECK_EQ(pthread_rwlock_init((pthread_rwlock_t*)mtx_, 0), 0);
+    CHECK_EQ(__interceptor_pthread_rwlock_init((pthread_rwlock_t*)mtx_, 0), 0);
   else
     CHECK(0);
 }
@@ -126,60 +170,68 @@ void Mutex::Destroy() {
   CHECK(alive_);
   alive_ = false;
   if (type_ == Normal)
-    CHECK_EQ(pthread_mutex_destroy((pthread_mutex_t*)mtx_), 0);
+    CHECK_EQ(__interceptor_pthread_mutex_destroy((pthread_mutex_t*)mtx_), 0);
+#ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_destroy((pthread_spinlock_t*)mtx_), 0);
+#endif
   else if (type_ == RW)
-    CHECK_EQ(pthread_rwlock_destroy((pthread_rwlock_t*)mtx_), 0);
+    CHECK_EQ(__interceptor_pthread_rwlock_destroy((pthread_rwlock_t*)mtx_), 0);
 }
 
 void Mutex::Lock() {
   CHECK(alive_);
   if (type_ == Normal)
-    CHECK_EQ(pthread_mutex_lock((pthread_mutex_t*)mtx_), 0);
+    CHECK_EQ(__interceptor_pthread_mutex_lock((pthread_mutex_t*)mtx_), 0);
+#ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_lock((pthread_spinlock_t*)mtx_), 0);
+#endif
   else if (type_ == RW)
-    CHECK_EQ(pthread_rwlock_wrlock((pthread_rwlock_t*)mtx_), 0);
+    CHECK_EQ(__interceptor_pthread_rwlock_wrlock((pthread_rwlock_t*)mtx_), 0);
 }
 
 bool Mutex::TryLock() {
   CHECK(alive_);
   if (type_ == Normal)
-    return pthread_mutex_trylock((pthread_mutex_t*)mtx_) == 0;
+    return __interceptor_pthread_mutex_trylock((pthread_mutex_t*)mtx_) == 0;
+#ifndef __APPLE__
   else if (type_ == Spin)
     return pthread_spin_trylock((pthread_spinlock_t*)mtx_) == 0;
+#endif
   else if (type_ == RW)
-    return pthread_rwlock_trywrlock((pthread_rwlock_t*)mtx_) == 0;
+    return __interceptor_pthread_rwlock_trywrlock((pthread_rwlock_t*)mtx_) == 0;
   return false;
 }
 
 void Mutex::Unlock() {
   CHECK(alive_);
   if (type_ == Normal)
-    CHECK_EQ(pthread_mutex_unlock((pthread_mutex_t*)mtx_), 0);
+    CHECK_EQ(__interceptor_pthread_mutex_unlock((pthread_mutex_t*)mtx_), 0);
+#ifndef __APPLE__
   else if (type_ == Spin)
     CHECK_EQ(pthread_spin_unlock((pthread_spinlock_t*)mtx_), 0);
+#endif
   else if (type_ == RW)
-    CHECK_EQ(pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
+    CHECK_EQ(__interceptor_pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
 }
 
 void Mutex::ReadLock() {
   CHECK(alive_);
   CHECK(type_ == RW);
-  CHECK_EQ(pthread_rwlock_rdlock((pthread_rwlock_t*)mtx_), 0);
+  CHECK_EQ(__interceptor_pthread_rwlock_rdlock((pthread_rwlock_t*)mtx_), 0);
 }
 
 bool Mutex::TryReadLock() {
   CHECK(alive_);
   CHECK(type_ == RW);
-  return pthread_rwlock_tryrdlock((pthread_rwlock_t*)mtx_) ==  0;
+  return __interceptor_pthread_rwlock_tryrdlock((pthread_rwlock_t*)mtx_) ==  0;
 }
 
 void Mutex::ReadUnlock() {
   CHECK(alive_);
   CHECK(type_ == RW);
-  CHECK_EQ(pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
+  CHECK_EQ(__interceptor_pthread_rwlock_unlock((pthread_rwlock_t*)mtx_), 0);
 }
 
 struct Event {
@@ -263,7 +315,7 @@ void ScopedThread::Impl::HandleEvent(Event *ev) {
       }
     }
     CHECK_NE(tsan_mop, 0);
-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__APPLE__)
     const int ErrCode = ESOCKTNOSUPPORT;
 #else
     const int ErrCode = ECHRNG;
@@ -327,7 +379,7 @@ void *ScopedThread::Impl::ScopedThreadCallback(void *arg) {
   for (;;) {
     Event* ev = (Event*)atomic_load(&impl->event, memory_order_acquire);
     if (ev == 0) {
-      pthread_yield();
+      sched_yield();
       continue;
     }
     if (ev->type == Event::SHUTDOWN) {
@@ -348,7 +400,7 @@ void ScopedThread::Impl::send(Event *e) {
     CHECK_EQ(atomic_load(&event, memory_order_relaxed), 0);
     atomic_store(&event, (uintptr_t)e, memory_order_release);
     while (atomic_load(&event, memory_order_acquire) != 0)
-      pthread_yield();
+      sched_yield();
   }
 }
 
@@ -360,9 +412,10 @@ ScopedThread::ScopedThread(bool detached, bool main) {
   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);
-    pthread_create(&impl_->thread, &attr,
+    __interceptor_pthread_create(&impl_->thread, &attr,
         ScopedThread::Impl::ScopedThreadCallback, impl_);
   }
 }
@@ -372,7 +425,7 @@ ScopedThread::~ScopedThread() {
     Event event(Event::SHUTDOWN);
     impl_->send(&event);
     if (!impl_->detached)
-      pthread_join(impl_->thread, 0);
+      __interceptor_pthread_join(impl_->thread, 0);
   }
   delete impl_;
 }
@@ -381,7 +434,7 @@ 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,
diff --git a/lib/tsan/tests/unit/tsan_clock_test.cc b/lib/tsan/tests/unit/tsan_clock_test.cc
index 92071827d3d87..83e25fb5a9336 100644
--- a/lib/tsan/tests/unit/tsan_clock_test.cc
+++ b/lib/tsan/tests/unit/tsan_clock_test.cc
@@ -13,6 +13,7 @@
 #include "tsan_clock.h"
 #include "tsan_rtl.h"
 #include "gtest/gtest.h"
+#include <sys/time.h>
 #include <time.h>
 
 namespace __tsan {
@@ -416,9 +417,9 @@ static bool ClockFuzzer(bool printing) {
 }
 
 TEST(Clock, Fuzzer) {
-  timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  int seed = ts.tv_sec + ts.tv_nsec;
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  int seed = tv.tv_sec + tv.tv_usec;
   printf("seed=%d\n", seed);
   srand(seed);
   if (!ClockFuzzer(false)) {
diff --git a/lib/tsan/tests/unit/tsan_flags_test.cc b/lib/tsan/tests/unit/tsan_flags_test.cc
index 22610c0dc42f5..aa8a024f9dc5e 100644
--- a/lib/tsan/tests/unit/tsan_flags_test.cc
+++ b/lib/tsan/tests/unit/tsan_flags_test.cc
@@ -28,9 +28,7 @@ TEST(Flags, DefaultValues) {
   Flags f;
 
   f.enable_annotations = false;
-  f.exitcode = -11;
   InitializeFlags(&f, "");
-  EXPECT_EQ(66, f.exitcode);
   EXPECT_EQ(true, f.enable_annotations);
 }
 
@@ -46,7 +44,6 @@ static const char *options1 =
   " report_atomic_races=0"
   " force_seq_cst_atomics=0"
   " print_benign=0"
-  " exitcode=111"
   " halt_on_error=0"
   " atexit_sleep_ms=222"
   " profile_memory=qqq"
@@ -72,7 +69,6 @@ static const char *options2 =
   " report_atomic_races=true"
   " force_seq_cst_atomics=true"
   " print_benign=true"
-  " exitcode=222"
   " halt_on_error=true"
   " atexit_sleep_ms=123"
   " profile_memory=bbbbb"
@@ -98,7 +94,6 @@ void VerifyOptions1(Flags *f) {
   EXPECT_EQ(f->report_atomic_races, 0);
   EXPECT_EQ(f->force_seq_cst_atomics, 0);
   EXPECT_EQ(f->print_benign, 0);
-  EXPECT_EQ(f->exitcode, 111);
   EXPECT_EQ(f->halt_on_error, 0);
   EXPECT_EQ(f->atexit_sleep_ms, 222);
   EXPECT_EQ(f->profile_memory, std::string("qqq"));
@@ -124,7 +119,6 @@ void VerifyOptions2(Flags *f) {
   EXPECT_EQ(f->report_atomic_races, true);
   EXPECT_EQ(f->force_seq_cst_atomics, true);
   EXPECT_EQ(f->print_benign, true);
-  EXPECT_EQ(f->exitcode, 222);
   EXPECT_EQ(f->halt_on_error, true);
   EXPECT_EQ(f->atexit_sleep_ms, 123);
   EXPECT_EQ(f->profile_memory, std::string("bbbbb"));
diff --git a/lib/tsan/tests/unit/tsan_mman_test.cc b/lib/tsan/tests/unit/tsan_mman_test.cc
index bfaefe6487055..609141c592947 100644
--- a/lib/tsan/tests/unit/tsan_mman_test.cc
+++ b/lib/tsan/tests/unit/tsan_mman_test.cc
@@ -141,11 +141,13 @@ TEST(Mman, CallocOverflow) {
   // which is overflown by tsan memory accesses functions in debug mode.
   return;
 #endif
+  ThreadState *thr = cur_thread();
+  uptr pc = 0;
   size_t kArraySize = 4096;
   volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max();
   volatile size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
   volatile void *p = NULL;
-  EXPECT_DEATH(p = calloc(kArraySize, kArraySize2),
+  EXPECT_DEATH(p = user_calloc(thr, pc, kArraySize, kArraySize2),
                "allocator is terminating the process instead of returning 0");
   EXPECT_EQ(0L, p);
 }