tsan: remove in_rtl counter

[dvyukov]

Summary

This is intended to address the following problem.
Episodically we see CHECK-failures when recursive interceptors call back into user code. Effectively we are not "in_rtl" at this point, but it's very complicated and fragile to properly maintain in_rtl property. Instead get rid of it. It was used mostly for sanity CHECKs, which basically never uncover real problems.
Instead introduce ignore_interceptors flag, which is used in very few narrow places to disable recursive interceptors (e.g. during runtime initialization).

[dvyukov]

This is mostly FYI. If you want to review, say so.

[glider]

Minor nit.

rtl/tsan_rtl_report.cc

603

typo?

[dvyukov]

Thanks
Fixed

[Eugene.Zelenko]

Committed in r197979.

Makefile.old

 presubmit:
   ../sanitizer_common/scripts/check_lint.sh
   # Debug build with clang.
   $(MAKE) -f Makefile.old clean
   $(MAKE) -f Makefile.old run DEBUG=1 -j 16 CC=$(CLANG) CXX=$(CLANG)++
   # Release build with clang.
   $(MAKE) -f Makefile.old clean
   $(MAKE) -f Makefile.old run DEBUG=0 -j 16 CC=$(CLANG) CXX=$(CLANG)++
+  ./check_memcpy.sh
   # Debug build with gcc
   $(MAKE) -f Makefile.old clean
   $(MAKE) -f Makefile.old run DEBUG=1 -j 16 CC=gcc CXX=g++
   # Release build with gcc
   $(MAKE) -f Makefile.old clean
   $(MAKE) -f Makefile.old run DEBUG=0 -j 16 CC=gcc CXX=g++
+  ./check_memcpy.sh
   ./check_analyze.sh
   # Sanity check for Go runtime
   (cd go && ./buildgo.sh)
   # Check cmake build
   ./check_cmake.sh
   @ echo PRESUBMIT PASSED
 
 install_deps:

check_memcpy.sh

+#!/bin/bash
+
+# Ensure that tsan runtime does not contain compiler-emitted memcpy and memset calls.
+
+set -eu
+
+ROOTDIR=$(dirname $0)
+
+: ${CXX:=clang++}
+CFLAGS="-fsanitize=thread -fPIE -O1 -g"
+LDFLAGS="-pie -lpthread -ldl -lrt -lm -Wl,--whole-archive $ROOTDIR/rtl/libtsan.a -Wl,--no-whole-archive"
+
+SRC=$ROOTDIR/lit_tests/simple_race.cc
+OBJ=$SRC.o
+EXE=$SRC.exe
+$CXX $SRC $CFLAGS -c -o $OBJ
+$CXX $OBJ $LDFLAGS -o $EXE
+
+NCALL=$(objdump -d $EXE | egrep "callq .*__interceptor_mem(cpy|set)" | wc -l)
+if [ "$NCALL" != "0" ]; then
+  echo FAIL: found $NCALL memcpy/memset calls
+  exit 1
+fi

go/tsan_go.cc

ThreadState *thr = (ThreadState*)internal_alloc(MBlockThreadContex,
       sizeof(ThreadState));
   internal_memset(thr, 0, sizeof(*thr));
   return thr;
 }
 
 void __tsan_init(ThreadState **thrp) {
   ThreadState *thr = AllocGoroutine();
   main_thr = *thrp = thr;
-  thr->in_rtl++;
   Initialize(thr);
-  thr->in_rtl--;
 }
 
 void __tsan_fini() {
   // FIXME: Not necessary thread 0.
   ThreadState *thr = main_thr;
-  thr->in_rtl++;
   int res = Finalize(thr);
-  thr->in_rtl--;
   exit(res);
 }
 
 void __tsan_map_shadow(uptr addr, uptr size) {
   MapShadow(addr, size);
 }
 
 void __tsan_read(ThreadState *thr, void *addr, void *pc) {

 
 void __tsan_func_exit(ThreadState *thr) {
   FuncExit(thr);
 }
 
 void __tsan_malloc(ThreadState *thr, void *p, uptr sz, void *pc) {
   if (thr == 0)  // probably before __tsan_init()
     return;
-  thr->in_rtl++;
   MemoryResetRange(thr, (uptr)pc, (uptr)p, sz);
-  thr->in_rtl--;
 }
 
 void __tsan_free(void *p) {
   (void)p;
 }
 
 void __tsan_go_start(ThreadState *parent, ThreadState **pthr, void *pc) {
   ThreadState *thr = AllocGoroutine();
   *pthr = thr;
-  thr->in_rtl++;
-  parent->in_rtl++;
   int goid = ThreadCreate(parent, (uptr)pc, 0, true);
   ThreadStart(thr, goid, 0);
-  parent->in_rtl--;
-  thr->in_rtl--;
 }
 
 void __tsan_go_end(ThreadState *thr) {
-  thr->in_rtl++;
   ThreadFinish(thr);
-  thr->in_rtl--;
   internal_free(thr);
 }
 
 void __tsan_acquire(ThreadState *thr, void *addr) {
-  thr->in_rtl++;
   Acquire(thr, 0, (uptr)addr);
-  thr->in_rtl--;
 }
 
 void __tsan_release(ThreadState *thr, void *addr) {
-  thr->in_rtl++;
   ReleaseStore(thr, 0, (uptr)addr);
-  thr->in_rtl--;
 }
 
 void __tsan_release_merge(ThreadState *thr, void *addr) {
-  thr->in_rtl++;
   Release(thr, 0, (uptr)addr);
-  thr->in_rtl--;
 }
 
 void __tsan_finalizer_goroutine(ThreadState *thr) {
   AcquireGlobal(thr, 0);
 }
 
 }  // extern "C"
 }  // namespace __tsan
 
 namespace __sanitizer {
 
 void SymbolizerPrepareForSandboxing() {
   // Nothing to do here for Go.
 }
 
 }  // namespace __sanitizer

lit_tests/malloc_hook.cc

+// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+
+static int malloc_count;
+static int free_count;
+
+extern "C" {
+void __tsan_malloc_hook(void *ptr, size_t size) {
+  (void)ptr;
+  (void)size;
+  __sync_fetch_and_add(&malloc_count, 1);
+}
+
+void __tsan_free_hook(void *ptr) {
+  (void)ptr;
+  __sync_fetch_and_add(&free_count, 1);
+}
+}
+
+void *Thread1(void *x) {
+  ((int*)x)[0]++;
+  return 0;
+}
+
+void *Thread2(void *x) {
+  sleep(1);
+  ((int*)x)[0]++;
+  return 0;
+}
+
+int main() {
+  int *x = new int;
+  pthread_t t[2];
+  pthread_create(&t[0], 0, Thread1, x);
+  pthread_create(&t[1], 0, Thread2, x);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  delete x;
+  if (malloc_count == 0 || free_count == 0) {
+    fprintf(stderr, "FAILED %d %d\n", malloc_count, free_count);
+    exit(1);
+  }
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: FAILED
+// CHECK: DONE

rtl/tsan_interceptors.cc

void InitializeLibIgnore() {
   libignore()->OnLibraryLoaded(0);
 }
 
 }  // namespace __tsan
 
 static SignalContext *SigCtx(ThreadState *thr) {
   SignalContext *ctx = (SignalContext*)thr->signal_ctx;
   if (ctx == 0 && thr->is_alive) {
-    ScopedInRtl in_rtl;
     ctx = (SignalContext*)MmapOrDie(sizeof(*ctx), "SignalContext");
     MemoryResetRange(thr, (uptr)&SigCtx, (uptr)ctx, sizeof(*ctx));
     thr->signal_ctx = ctx;
   }
   return ctx;
 }
 
 static unsigned g_thread_finalize_key;
 
 class ScopedInterceptor {
  public:
   ScopedInterceptor(ThreadState *thr, const char *fname, uptr pc);
   ~ScopedInterceptor();
  private:
   ThreadState *const thr_;
   const uptr pc_;
-  const int in_rtl_;
   bool in_ignored_lib_;
 };
 
 ScopedInterceptor::ScopedInterceptor(ThreadState *thr, const char *fname,
                                      uptr pc)
     : thr_(thr)
     , pc_(pc)
-    , in_rtl_(thr->in_rtl)
     , in_ignored_lib_(false) {
-  if (thr_->in_rtl == 0) {
+  if (!thr_->ignore_interceptors) {
     Initialize(thr);
     FuncEntry(thr, pc);
-    thr_->in_rtl++;
-    DPrintf("#%d: intercept %s()\n", thr_->tid, fname);
-  } else {
-    thr_->in_rtl++;
   }
+  DPrintf("#%d: intercept %s()\n", thr_->tid, fname);
   if (!thr_->in_ignored_lib && libignore()->IsIgnored(pc)) {
     in_ignored_lib_ = true;
     thr_->in_ignored_lib = true;
     ThreadIgnoreBegin(thr_, pc_);
   }
 }
 
 ScopedInterceptor::~ScopedInterceptor() {
   if (in_ignored_lib_) {
     thr_->in_ignored_lib = false;
     ThreadIgnoreEnd(thr_, pc_);
   }
-  thr_->in_rtl--;
-  if (thr_->in_rtl == 0) {
+  if (!thr_->ignore_interceptors) {
     FuncExit(thr_);
     ProcessPendingSignals(thr_);
   }
-  CHECK_EQ(in_rtl_, thr_->in_rtl);
 }
 
 #define SCOPED_INTERCEPTOR_RAW(func, ...) \
     ThreadState *thr = cur_thread(); \
     StatInc(thr, StatInterceptor); \
     StatInc(thr, StatInt_##func); \
     const uptr caller_pc = GET_CALLER_PC(); \
     ScopedInterceptor si(thr, #func, caller_pc); \
     const uptr pc = __sanitizer::StackTrace::GetCurrentPc(); \
     (void)pc; \
 /**/
 
 #define SCOPED_TSAN_INTERCEPTOR(func, ...) \
     SCOPED_INTERCEPTOR_RAW(func, __VA_ARGS__); \
     if (REAL(func) == 0) { \
       Printf("FATAL: ThreadSanitizer: failed to intercept %s\n", #func); \
       Die(); \
     } \
-    if (thr->in_rtl > 1 || thr->in_ignored_lib) \
+    if (thr->ignore_interceptors || thr->in_ignored_lib) \
       return REAL(func)(__VA_ARGS__); \
 /**/
 
 #define TSAN_INTERCEPTOR(ret, func, ...) INTERCEPTOR(ret, func, __VA_ARGS__)
 #define TSAN_INTERCEPT(func) INTERCEPT_FUNCTION(func)
 
 #define BLOCK_REAL(name) (BlockingCall(thr), REAL(name))
 
 struct BlockingCall {
   explicit BlockingCall(ThreadState *thr)
       : ctx(SigCtx(thr)) {
     ctx->in_blocking_func++;
   }
 
   ~BlockingCall() {
     ctx->in_blocking_func--;
   }
 
   SignalContext *ctx;
+
+  // When we are in a "blocking call", we process signals asynchronously
+  // (right when they arrive). In this context we do not expect to be
+  // executing any user/runtime code. The known interceptor sequence when
+  // this is not true is: pthread_join -> munmap(stack). It's fine
+  // to ignore munmap in this case -- we handle stack shadow separately.
+  ScopedIgnoreInterceptors ignore_interceptors;
 };
 
 TSAN_INTERCEPTOR(unsigned, sleep, unsigned sec) {
   SCOPED_TSAN_INTERCEPTOR(sleep, sec);
   unsigned res = BLOCK_REAL(sleep)(sec);
   AfterSleep(thr, pc);
   return res;
 }
TSAN_INTERCEPTOR(int, nanosleep, void *req, void *rem) {
   SCOPED_TSAN_INTERCEPTOR(nanosleep, req, rem);
   int res = BLOCK_REAL(nanosleep)(req, rem);
   AfterSleep(thr, pc);
   return res;
 }
 
 TSAN_INTERCEPTOR(void*, dlopen, const char *filename, int flag) {
   SCOPED_INTERCEPTOR_RAW(dlopen, filename, flag);
-  // dlopen will execute global constructors, so it must be not in rtl.
-  CHECK_EQ(thr->in_rtl, 1);
-  thr->in_rtl = 0;
   void *res = REAL(dlopen)(filename, flag);
-  thr->in_rtl = 1;
   libignore()->OnLibraryLoaded(filename);
   return res;
 }
 
 TSAN_INTERCEPTOR(int, dlclose, void *handle) {
   SCOPED_INTERCEPTOR_RAW(dlclose, handle);
-  // dlclose will execute global destructors, so it must be not in rtl.
-  CHECK_EQ(thr->in_rtl, 1);
-  thr->in_rtl = 0;
   int res = REAL(dlclose)(handle);
-  thr->in_rtl = 1;
   libignore()->OnLibraryUnloaded();
   return res;
 }
 
 class AtExitContext {
  public:
   AtExitContext()
     : mtx_(MutexTypeAtExit, StatMtxAtExit)
int atexit(ThreadState *thr, uptr pc, bool is_on_exit,
     stack_[pos_] = f;
     args_[pos_] = arg;
     is_on_exits_[pos_] = is_on_exit;
     pos_++;
     return 0;
   }
 
   void exit(ThreadState *thr, uptr pc) {
-    CHECK_EQ(thr->in_rtl, 0);
     for (;;) {
       atexit_t f = 0;
       void *arg = 0;
       bool is_on_exit = false;
       {
         Lock l(&mtx_);
         if (pos_) {
           pos_--;
           f = stack_[pos_];
           arg = args_[pos_];
           is_on_exit = is_on_exits_[pos_];
-          ScopedInRtl in_rtl;
           Acquire(thr, pc, (uptr)this);
         }
       }
       if (f == 0)
         break;
       DPrintf("#%d: executing atexit func %p\n", thr->tid, f);
-      CHECK_EQ(thr->in_rtl, 0);
       if (is_on_exit)
         ((void(*)(int status, void *arg))f)(0, arg);
       else
         ((void(*)(void *arg, void *dso))f)(arg, 0);
     }
   }
 
  private:
for (uptr i = 0; i < thr->jmp_bufs.Size(); i++) {
     }
   }
   Printf("ThreadSanitizer: can't find longjmp buf\n");
   CHECK(0);
 }
 
 // FIXME: put everything below into a common extern "C" block?
 extern "C" void __tsan_setjmp(uptr sp, uptr mangled_sp) {
-  ScopedInRtl in_rtl;
   SetJmp(cur_thread(), sp, mangled_sp);
 }
 
 // Not called.  Merely to satisfy TSAN_INTERCEPT().
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 int __interceptor_setjmp(void *env);
 extern "C" int __interceptor_setjmp(void *env) {
   CHECK(0);
static void thread_finalize(void *v) {
   if (iter > 1) {
     if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
       Printf("ThreadSanitizer: failed to set thread key\n");
       Die();
     }
     return;
   }
   {
-    ScopedInRtl in_rtl;
     ThreadState *thr = cur_thread();
     ThreadFinish(thr);
     SignalContext *sctx = thr->signal_ctx;
     if (sctx) {
       thr->signal_ctx = 0;
       UnmapOrDie(sctx, sizeof(*sctx));
     }
   }
 }
 
 
 struct ThreadParam {
   void* (*callback)(void *arg);
   void *param;
   atomic_uintptr_t tid;
 };
 
 extern "C" void *__tsan_thread_start_func(void *arg) {
   ThreadParam *p = (ThreadParam*)arg;
   void* (*callback)(void *arg) = p->callback;
   void *param = p->param;
   int tid = 0;
   {
     ThreadState *thr = cur_thread();
-    ScopedInRtl in_rtl;
+    // Thread-local state is not initialized yet.
+    ScopedIgnoreInterceptors ignore;
     if (pthread_setspecific(g_thread_finalize_key,
                             (void *)kPthreadDestructorIterations)) {
       Printf("ThreadSanitizer: failed to set thread key\n");
       Die();
     }
     while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
       pthread_yield();
     atomic_store(&p->tid, 0, memory_order_release);
     ThreadStart(thr, tid, GetTid());
-    CHECK_EQ(thr->in_rtl, 1);
   }
   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,
   int detached = 0;
   REAL(pthread_attr_getdetachstate)(attr, &detached);
   AdjustStackSizeLinux(attr);
 
   ThreadParam p;
   p.callback = callback;
   p.param = param;
   atomic_store(&p.tid, 0, memory_order_relaxed);
-  int res = REAL(pthread_create)(th, attr, __tsan_thread_start_func, &p);
+  int res = -1;
+  {
+    // Otherwise we see false positives in pthread stack manipulation.
+    ScopedIgnoreInterceptors ignore;
+    res = REAL(pthread_create)(th, attr, __tsan_thread_start_func, &p);
+  }
   if (res == 0) {
     int tid = ThreadCreate(thr, pc, *(uptr*)th, detached);
     CHECK_NE(tid, 0);
     atomic_store(&p.tid, tid, memory_order_release);
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
       pthread_yield();
   }
   if (attr == &myattr)
TSAN_INTERCEPTOR(int, pthread_barrier_wait, void *b) {
   if (res == 0 || res == PTHREAD_BARRIER_SERIAL_THREAD) {
     Acquire(thr, pc, (uptr)b);
   }
   return res;
 }
 
 TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) {
   SCOPED_INTERCEPTOR_RAW(pthread_once, o, f);
-  // Using SCOPED_INTERCEPTOR_RAW, because if we are called from an ignored lib,
-  // the user callback must be executed with thr->in_rtl == 0.
   if (o == 0 || f == 0)
     return EINVAL;
   atomic_uint32_t *a = static_cast<atomic_uint32_t*>(o);
   u32 v = atomic_load(a, memory_order_acquire);
   if (v == 0 && atomic_compare_exchange_strong(a, &v, 1,
                                                memory_order_relaxed)) {
-    const int old_in_rtl = thr->in_rtl;
-    thr->in_rtl = 0;
     (*f)();
-    CHECK_EQ(thr->in_rtl, 0);
-    thr->in_rtl = old_in_rtl;
     if (!thr->in_ignored_lib)
       Release(thr, pc, (uptr)o);
     atomic_store(a, 2, memory_order_release);
   } else {
     while (v != 2) {
       pthread_yield();
       v = atomic_load(a, memory_order_acquire);
     }
void ALWAYS_INLINE rtl_generic_sighandler(bool sigact, int sig,
   // Don't mess with synchronous signals.
   if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
       sig == SIGABRT || sig == SIGFPE || sig == SIGPIPE || sig == SIGSYS ||
       // If we are sending signal to ourselves, we must process it now.
       (sctx && sig == sctx->int_signal_send) ||
       // If we are in blocking function, we can safely process it now
       // (but check if we are in a recursive interceptor,
       // i.e. pthread_join()->munmap()).
-      (sctx && sctx->in_blocking_func == 1 && thr->in_rtl == 1)) {
-    int in_rtl = thr->in_rtl;
-    thr->in_rtl = 0;
+      (sctx && sctx->in_blocking_func == 1)) {
     CHECK_EQ(thr->in_signal_handler, false);
     thr->in_signal_handler = true;
     if (sigact)
       sigactions[sig].sa_sigaction(sig, info, ctx);
     else
       sigactions[sig].sa_handler(sig);
     CHECK_EQ(thr->in_signal_handler, true);
     thr->in_signal_handler = false;
-    thr->in_rtl = in_rtl;
     return;
   }
 
   if (sctx == 0)
     return;
   SignalDesc *signal = &sctx->pending_signals[sig];
   if (signal->armed == false) {
     signal->armed = true;

 
 TSAN_INTERCEPTOR(int, getaddrinfo, void *node, void *service,
     void *hints, void *rv) {
   SCOPED_TSAN_INTERCEPTOR(getaddrinfo, node, service, hints, rv);
   // We miss atomic synchronization in getaddrinfo,
   // and can report false race between malloc and free
   // inside of getaddrinfo. So ignore memory accesses.
   ThreadIgnoreBegin(thr, pc);
-  // getaddrinfo calls fopen, which can be intercepted by user.
-  thr->in_rtl--;
-  CHECK_EQ(thr->in_rtl, 0);
   int res = REAL(getaddrinfo)(node, service, hints, rv);
-  thr->in_rtl++;
   ThreadIgnoreEnd(thr, pc);
   return res;
 }
 
 // Linux kernel has a bug that leads to kernel deadlock if a process
 // maps TBs of memory and then calls mlock().
 static void MlockIsUnsupported() {
   static atomic_uint8_t printed;
#define TSAN_SYSCALL() \
   ScopedSyscall scoped_syscall(thr) \
 /**/
 
 struct ScopedSyscall {
   ThreadState *thr;
 
   explicit ScopedSyscall(ThreadState *thr)
       : thr(thr) {
-    if (thr->in_rtl == 0)
-      Initialize(thr);
-    thr->in_rtl++;
   }
 
   ~ScopedSyscall() {
-    thr->in_rtl--;
-    if (thr->in_rtl == 0)
-      ProcessPendingSignals(thr);
   }
 };
 
 static void syscall_access_range(uptr pc, uptr p, uptr s, bool write) {
   TSAN_SYSCALL();
   MemoryAccessRange(thr, pc, p, s, write);
 }
 
static void finalize(void *arg) {
   atexit_ctx->exit(thr, pc);
   int status = Finalize(thr);
   REAL(fflush)(0);
   if (status)
     REAL(_exit)(status);
 }
 
 void ProcessPendingSignals(ThreadState *thr) {
-  CHECK_EQ(thr->in_rtl, 0);
   SignalContext *sctx = SigCtx(thr);
   if (sctx == 0 || sctx->pending_signal_count == 0 || thr->in_signal_handler)
     return;
   Context *ctx = CTX();
   thr->in_signal_handler = true;
   sctx->pending_signal_count = 0;
   // These are too big for stack.
   static THREADLOCAL __sanitizer_sigset_t emptyset, oldset;
   REAL(sigfillset)(&emptyset);
   pthread_sigmask(SIG_SETMASK, &emptyset, &oldset);
   for (int sig = 0; sig < kSigCount; sig++) {
     SignalDesc *signal = &sctx->pending_signals[sig];
     if (signal->armed) {
       signal->armed = false;
       if (sigactions[sig].sa_handler != SIG_DFL
           && sigactions[sig].sa_handler != SIG_IGN) {
         // Insure that the handler does not spoil errno.
         const int saved_errno = errno;
         errno = 0;
         if (signal->sigaction)
           sigactions[sig].sa_sigaction(sig, &signal->siginfo, &signal->ctx);
         else
           sigactions[sig].sa_handler(sig);
         if (flags()->report_bugs && errno != 0) {
-          ScopedInRtl in_rtl;
           __tsan::StackTrace stack;
           uptr pc = signal->sigaction ?
               (uptr)sigactions[sig].sa_sigaction :
               (uptr)sigactions[sig].sa_handler;
           pc += 1;  // return address is expected, OutputReport() will undo this
           stack.Init(&pc, 1);
           ThreadRegistryLock l(ctx->thread_registry);
           ScopedReport rep(ReportTypeErrnoInSignal);

 }
 
 static void unreachable() {
   Printf("FATAL: ThreadSanitizer: unreachable called\n");
   Die();
 }
 
 void InitializeInterceptors() {
-  CHECK_GT(cur_thread()->in_rtl, 0);
-
   // We need to setup it early, because functions like dlsym() can call it.
   REAL(memset) = internal_memset;
   REAL(memcpy) = internal_memcpy;
   REAL(memcmp) = internal_memcmp;
 
   // Instruct libc malloc to consume less memory.
   mallopt(1, 0);  // M_MXFAST
   mallopt(-3, 32*1024);  // M_MMAP_THRESHOLD

rtl/tsan_interface_ann.cc

 using namespace __tsan;  // NOLINT
 
 namespace __tsan {
 
 class ScopedAnnotation {
  public:
   ScopedAnnotation(ThreadState *thr, const char *aname, const char *f, int l,
                    uptr pc)
-      : thr_(thr)
-      , in_rtl_(thr->in_rtl) {
-    CHECK_EQ(thr_->in_rtl, 0);
+      : thr_(thr) {
     FuncEntry(thr_, pc);
-    thr_->in_rtl++;
     DPrintf("#%d: annotation %s() %s:%d\n", thr_->tid, aname, f, l);
   }
 
   ~ScopedAnnotation() {
-    thr_->in_rtl--;
-    CHECK_EQ(in_rtl_, thr_->in_rtl);
     FuncExit(thr_);
   }
  private:
   ThreadState *const thr_;
-  const int in_rtl_;
 };
 
 #define SCOPED_ANNOTATION(typ) \
     if (!flags()->enable_annotations) \
       return; \
     ThreadState *thr = cur_thread(); \
     const uptr caller_pc = (uptr)__builtin_return_address(0); \
     StatInc(thr, StatAnnotation); \

rtl/tsan_interface_atomic.cc

typedef enum {
   mo_seq_cst
 } morder;
 
 class ScopedAtomic {
  public:
   ScopedAtomic(ThreadState *thr, uptr pc, const volatile void *a,
                morder mo, const char *func)
       : thr_(thr) {
-    CHECK_EQ(thr_->in_rtl, 0);
     ProcessPendingSignals(thr);
     FuncEntry(thr_, pc);
     DPrintf("#%d: %s(%p, %d)\n", thr_->tid, func, a, mo);
-    thr_->in_rtl++;
   }
   ~ScopedAtomic() {
-    thr_->in_rtl--;
-    CHECK_EQ(thr_->in_rtl, 0);
     FuncExit(thr_);
   }
  private:
   ThreadState *thr_;
 };
 
 static void AtomicStatInc(ThreadState *thr, uptr size, morder mo, StatType t) {
   StatInc(thr, StatAtomic);

rtl/tsan_interface_java.cc

 };
 
 class ScopedJavaFunc {
  public:
   ScopedJavaFunc(ThreadState *thr, uptr pc)
       : thr_(thr) {
     Initialize(thr_);
     FuncEntry(thr, pc);
-    CHECK_EQ(thr_->in_rtl, 0);
-    thr_->in_rtl++;
   }
 
   ~ScopedJavaFunc() {
-    thr_->in_rtl--;
-    CHECK_EQ(thr_->in_rtl, 0);
     FuncExit(thr_);
     // FIXME(dvyukov): process pending signals.
   }
 
  private:
   ThreadState *thr_;
 };
 

rtl/tsan_mman.cc

static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
   ScopedReport rep(ReportTypeSignalUnsafe);
   if (!IsFiredSuppression(ctx, rep, stack)) {
     rep.AddStack(&stack);
     OutputReport(ctx, rep, rep.GetReport()->stacks[0]);
   }
 }
 
 void *user_alloc(ThreadState *thr, uptr pc, uptr sz, uptr align) {
-  CHECK_GT(thr->in_rtl, 0);
   if ((sz >= (1ull << 40)) || (align >= (1ull << 40)))
     return AllocatorReturnNull();
   void *p = allocator()->Allocate(&thr->alloc_cache, sz, align);
   if (p == 0)
     return 0;
   MBlock *b = new(allocator()->GetMetaData(p)) MBlock;
   b->Init(sz, thr->tid, CurrentStackId(thr, pc));
   if (CTX() && CTX()->initialized) {
     if (thr->ignore_reads_and_writes == 0)
       MemoryRangeImitateWrite(thr, pc, (uptr)p, sz);
     else
       MemoryResetRange(thr, pc, (uptr)p, sz);
   }
   DPrintf("#%d: alloc(%zu) = %p\n", thr->tid, sz, p);
   SignalUnsafeCall(thr, pc);
   return p;
 }
 
 void user_free(ThreadState *thr, uptr pc, void *p) {
-  CHECK_GT(thr->in_rtl, 0);
   CHECK_NE(p, (void*)0);
   DPrintf("#%d: free(%p)\n", thr->tid, p);
   MBlock *b = (MBlock*)allocator()->GetMetaData(p);
   if (b->ListHead()) {
     MBlock::ScopedLock l(b);
     for (SyncVar *s = b->ListHead(); s;) {
       SyncVar *res = s;
       s = s->next;
       StatInc(thr, StatSyncDestroyed);
       res->mtx.Lock();
       res->mtx.Unlock();
       DestroyAndFree(res);
     }
     b->ListReset();
   }
-  if (CTX() && CTX()->initialized && thr->in_rtl == 1) {
+  if (CTX() && CTX()->initialized) {
     if (thr->ignore_reads_and_writes == 0)
       MemoryRangeFreed(thr, pc, (uptr)p, b->Size());
   }
   allocator()->Deallocate(&thr->alloc_cache, p);
   SignalUnsafeCall(thr, pc);
 }
 
 void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
-  CHECK_GT(thr->in_rtl, 0);
   void *p2 = 0;
   // FIXME: Handle "shrinking" more efficiently,
   // it seems that some software actually does this.
   if (sz) {
     p2 = user_alloc(thr, pc, sz);
     if (p2 == 0)
       return 0;
     if (p) {
       MBlock *b = user_mblock(thr, p);
       CHECK_NE(b, 0);
       internal_memcpy(p2, p, min(b->Size(), sz));
     }
   }
   if (p)
     user_free(thr, pc, p);
   return p2;
 }
 
 uptr user_alloc_usable_size(ThreadState *thr, uptr pc, void *p) {
-  CHECK_GT(thr->in_rtl, 0);
   if (p == 0)
     return 0;
   MBlock *b = (MBlock*)allocator()->GetMetaData(p);
   return b ? b->Size() : 0;
 }
 
 MBlock *user_mblock(ThreadState *thr, void *p) {
   CHECK_NE(p, 0);
   Allocator *a = allocator();
   void *b = a->GetBlockBegin(p);
   if (b == 0)
     return 0;
   return (MBlock*)a->GetMetaData(b);
 }
 
 void invoke_malloc_hook(void *ptr, uptr size) {
   Context *ctx = CTX();
   ThreadState *thr = cur_thread();
-  if (ctx == 0 || !ctx->initialized || thr->in_rtl)
+  if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
     return;
   __tsan_malloc_hook(ptr, size);
 }
 
 void invoke_free_hook(void *ptr) {
   Context *ctx = CTX();
   ThreadState *thr = cur_thread();
-  if (ctx == 0 || !ctx->initialized || thr->in_rtl)
+  if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
     return;
   __tsan_free_hook(ptr);
 }
 
 void *internal_alloc(MBlockType typ, uptr sz) {
   ThreadState *thr = cur_thread();
-  CHECK_GT(thr->in_rtl, 0);
   CHECK_LE(sz, InternalSizeClassMap::kMaxSize);
   if (thr->nomalloc) {
     thr->nomalloc = 0;  // CHECK calls internal_malloc().
     CHECK(0);
   }
   return InternalAlloc(sz, &thr->internal_alloc_cache);
 }
 
 void internal_free(void *p) {
   ThreadState *thr = cur_thread();
-  CHECK_GT(thr->in_rtl, 0);
   if (thr->nomalloc) {
     thr->nomalloc = 0;  // CHECK calls internal_malloc().
     CHECK(0);
   }
   InternalFree(p, &thr->internal_alloc_cache);
 }
 
 }  // namespace __tsan

rtl/tsan_mutexset.h

public:
   MutexSet();
   // The 'id' is obtained from SyncVar::GetId().
   void Add(u64 id, bool write, u64 epoch);
   void Del(u64 id, bool write);
   void Remove(u64 id);  // Removes the mutex completely (if it's destroyed).
   uptr Size() const;
   Desc Get(uptr i) const;
 
+  void operator=(const MutexSet &other) {
+    internal_memcpy(this, &other, sizeof(*this));
+  }
+
  private:
 #ifndef TSAN_GO
   uptr size_;
   Desc descs_[kMaxSize];
 #endif
 
   void RemovePos(uptr i);
+  MutexSet(const MutexSet&);
 };
 
 // Go does not have mutexes, so do not spend memory and time.
 // (Go sync.Mutex is actually a semaphore -- can be unlocked
 // in different goroutine).
 #ifdef TSAN_GO
 MutexSet::MutexSet() {}
 void MutexSet::Add(u64 id, bool write, u64 epoch) {}

rtl/tsan_platform_linux.cc

 #endif
 
 extern "C" struct mallinfo __libc_mallinfo();
 
 namespace __tsan {
 
 const uptr kPageSize = 4096;
 
-#ifndef TSAN_GO
-ScopedInRtl::ScopedInRtl()
-    : thr_(cur_thread()) {
-  in_rtl_ = thr_->in_rtl;
-  thr_->in_rtl++;
-  errno_ = errno;
-}
-
-ScopedInRtl::~ScopedInRtl() {
-  thr_->in_rtl--;
-  errno = errno_;
-  CHECK_EQ(in_rtl_, thr_->in_rtl);
-}
-#else
-ScopedInRtl::ScopedInRtl() {
-}
-
-ScopedInRtl::~ScopedInRtl() {
-}
-#endif
-
 void FillProfileCallback(uptr start, uptr rss, bool file,
                          uptr *mem, uptr stats_size) {
   CHECK_EQ(7, stats_size);
   mem[6] += rss;  // total
   start >>= 40;
   if (start < 0x10)  // shadow
     mem[0] += rss;
   else if (start >= 0x20 && start < 0x30)  // compat modules

 }
 
 void FlushShadowMemory() {
   StopTheWorld(FlushShadowMemoryCallback, 0);
 }
 
 #ifndef TSAN_GO
 static void ProtectRange(uptr beg, uptr end) {
-  ScopedInRtl in_rtl;
   CHECK_LE(beg, end);
   if (beg == end)
     return;
   if (beg != (uptr)Mprotect(beg, end - beg)) {
     Printf("FATAL: ThreadSanitizer can not protect [%zx,%zx]\n", beg, end);
     Printf("FATAL: Make sure you are not using unlimited stack\n");
     Die();
   }

rtl/tsan_rtl.h

#endif
   u64 *racy_shadow_addr;
   u64 racy_state[2];
   MutexSet mset;
   ThreadClock clock;
 #ifndef TSAN_GO
   AllocatorCache alloc_cache;
   InternalAllocatorCache internal_alloc_cache;
   Vector<JmpBuf> jmp_bufs;
+  int ignore_interceptors;
 #endif
   u64 stat[StatCnt];
   const int tid;
   const int unique_id;
-  int in_rtl;
   bool in_symbolizer;
   bool in_ignored_lib;
   bool is_alive;
   bool is_freeing;
   bool is_vptr_access;
   const uptr stk_addr;
   const uptr stk_size;
   const uptr tls_addr;
struct Context {
 
   Flags flags;
 
   u64 stat[StatCnt];
   u64 int_alloc_cnt[MBlockTypeCount];
   u64 int_alloc_siz[MBlockTypeCount];
 };
 
-class ScopedInRtl {
- public:
-  ScopedInRtl();
-  ~ScopedInRtl();
- private:
-  ThreadState*thr_;
-  int in_rtl_;
-  int errno_;
+struct ScopedIgnoreInterceptors {
+  ScopedIgnoreInterceptors() {
+#ifndef TSAN_GO
+    cur_thread()->ignore_interceptors++;
+#endif
+  }
+
+  ~ScopedIgnoreInterceptors() {
+#ifndef TSAN_GO
+    cur_thread()->ignore_interceptors--;
+#endif
+  }
 };
 
 class ScopedReport {
  public:
   explicit ScopedReport(ReportType typ);
   ~ScopedReport();
 
   void AddStack(const StackTrace *stack);
   void AddMemoryAccess(uptr addr, Shadow s, const StackTrace *stack,
                        const MutexSet *mset);
   void AddThread(const ThreadContext *tctx);
   void AddMutex(const SyncVar *s);
   void AddLocation(uptr addr, uptr size);
   void AddSleep(u32 stack_id);
   void SetCount(int count);
 
   const ReportDesc *GetReport() const;
 
  private:
   Context *ctx_;
   ReportDesc *rep_;
+  // Symbolizer makes lots of intercepted calls. If we try to process them,
+  // at best it will cause deadlocks on internal mutexes.
+  ScopedIgnoreInterceptors ignore_interceptors_;
 
   void AddMutex(u64 id);
 
   ScopedReport(const ScopedReport&);
   void operator = (const ScopedReport&);
 };
 
 void RestoreStack(int tid, const u64 epoch, StackTrace *stk, MutexSet *mset);

rtl/tsan_rtl.cc

 // The objects are allocated in TLS, so one may rely on zero-initialization.
 ThreadState::ThreadState(Context *ctx, int tid, int unique_id, u64 epoch,
                          uptr stk_addr, uptr stk_size,
                          uptr tls_addr, uptr tls_size)
   : fast_state(tid, epoch)
   // Do not touch these, rely on zero initialization,
   // they may be accessed before the ctor.
   // , ignore_reads_and_writes()
-  // , in_rtl()
+  // , ignore_interceptors()
 #ifndef TSAN_GO
   , jmp_bufs(MBlockJmpBuf)
 #endif
   , tid(tid)
   , unique_id(unique_id)
   , stk_addr(stk_addr)
   , stk_size(stk_size)
   , tls_addr(tls_addr)
   , tls_size(tls_size) {
 }
 
 static void MemoryProfiler(Context *ctx, fd_t fd, int i) {
   uptr n_threads;
   uptr n_running_threads;
   ctx->thread_registry->GetNumberOfThreads(&n_threads, &n_running_threads);
   InternalScopedBuffer<char> buf(4096);
   internal_snprintf(buf.data(), buf.size(), "%d: nthr=%d nlive=%d\n",
       i, n_threads, n_running_threads);
   internal_write(fd, buf.data(), internal_strlen(buf.data()));
   WriteMemoryProfile(buf.data(), buf.size());
   internal_write(fd, buf.data(), internal_strlen(buf.data()));
 }
 
 static void BackgroundThread(void *arg) {
-  ScopedInRtl in_rtl;
   Context *ctx = CTX();
+  // This is a non-initialized non-user thread, nothing to see here.
+  ScopedIgnoreInterceptors ignore;
   const u64 kMs2Ns = 1000 * 1000;
 
   fd_t mprof_fd = kInvalidFd;
   if (flags()->profile_memory && flags()->profile_memory[0]) {
     InternalScopedBuffer<char> filename(4096);
     internal_snprintf(filename.data(), filename.size(), "%s.%d",
         flags()->profile_memory, (int)internal_getpid());
     uptr openrv = OpenFile(filename.data(), true);

 }
 
 void Initialize(ThreadState *thr) {
   // Thread safe because done before all threads exist.
   static bool is_initialized = false;
   if (is_initialized)
     return;
   is_initialized = true;
+  // We are not ready to handle interceptors yet.
+  ScopedIgnoreInterceptors ignore;
   SanitizerToolName = "ThreadSanitizer";
   // Install tool-specific callbacks in sanitizer_common.
   SetCheckFailedCallback(TsanCheckFailed);
 
-  ScopedInRtl in_rtl;
 #ifndef TSAN_GO
   InitializeAllocator();
 #endif
   InitializeInterceptors();
   const char *env = InitializePlatform();
   InitializeMutex();
   InitializeDynamicAnnotations();
   ctx = new(ctx_placeholder) Context;
#endif
   if (ctx->flags.verbosity)
     Printf("***** Running under ThreadSanitizer v2 (pid %d) *****\n",
            (int)internal_getpid());
 
   // Initialize thread 0.
   int tid = ThreadCreate(thr, 0, 0, true);
   CHECK_EQ(tid, 0);
   ThreadStart(thr, tid, internal_getpid());
-  CHECK_EQ(thr->in_rtl, 1);
   ctx->initialized = true;
 
   if (flags()->stop_on_start) {
     Printf("ThreadSanitizer is suspended at startup (pid %d)."
            " Call __tsan_resume().\n",
            (int)internal_getpid());
     while (__tsan_resumed == 0) {}
   }
 }
 
 int Finalize(ThreadState *thr) {
-  ScopedInRtl in_rtl;
   Context *ctx = __tsan::ctx;
   bool failed = false;
 
   if (flags()->atexit_sleep_ms > 0 && ThreadCount(thr) > 1)
     SleepForMillis(flags()->atexit_sleep_ms);
 
   // Wait for pending reports.
   ctx->report_mtx.Lock();
u32 CurrentStackId(ThreadState *thr, uptr pc) {
   if (pc)
     thr->shadow_stack_pos--;
   return id;
 }
 #endif
 
 void TraceSwitch(ThreadState *thr) {
   thr->nomalloc++;
-  ScopedInRtl in_rtl;
   Trace *thr_trace = ThreadTrace(thr->tid);
   Lock l(&thr_trace->mtx);
   unsigned trace = (thr->fast_state.epoch() / kTracePartSize) % TraceParts();
   TraceHeader *hdr = &thr_trace->headers[trace];
   hdr->epoch0 = thr->fast_state.epoch();
   hdr->stack0.ObtainCurrent(thr, 0);
   hdr->mset0 = thr->mset;
   thr->nomalloc--;
void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size) {
   s.ClearIgnoreBit();
   s.SetWrite(true);
   s.SetAddr0AndSizeLog(0, 3);
   MemoryRangeSet(thr, pc, addr, size, s.raw());
 }
 
 ALWAYS_INLINE USED
 void FuncEntry(ThreadState *thr, uptr pc) {
-  DCHECK_EQ(thr->in_rtl, 0);
   StatInc(thr, StatFuncEnter);
   DPrintf2("#%d: FuncEntry %p\n", (int)thr->fast_state.tid(), (void*)pc);
   thr->fast_state.IncrementEpoch();
   TraceAddEvent(thr, thr->fast_state, EventTypeFuncEnter, pc);
 
   // Shadow stack maintenance can be replaced with
   // stack unwinding during trace switch (which presumably must be faster).
   DCHECK_GE(thr->shadow_stack_pos, thr->shadow_stack);
#else
   }
 #endif
   thr->shadow_stack_pos[0] = pc;
   thr->shadow_stack_pos++;
 }
 
 ALWAYS_INLINE USED
 void FuncExit(ThreadState *thr) {
-  DCHECK_EQ(thr->in_rtl, 0);
   StatInc(thr, StatFuncExit);
   DPrintf2("#%d: FuncExit\n", (int)thr->fast_state.tid());
   thr->fast_state.IncrementEpoch();
   TraceAddEvent(thr, thr->fast_state, EventTypeFuncExit, 0);
 
   DCHECK_GT(thr->shadow_stack_pos, thr->shadow_stack);
 #ifndef TSAN_GO
   DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end);

rtl/tsan_rtl_mutex.cc

 #include "tsan_symbolize.h"
 #include "tsan_platform.h"
 
 namespace __tsan {
 
 void MutexCreate(ThreadState *thr, uptr pc, uptr addr,
                  bool rw, bool recursive, bool linker_init) {
   Context *ctx = CTX();
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexCreate %zx\n", thr->tid, addr);
   StatInc(thr, StatMutexCreate);
   if (!linker_init && IsAppMem(addr)) {
     CHECK(!thr->is_freeing);
     thr->is_freeing = true;
     MemoryWrite(thr, pc, addr, kSizeLog1);
     thr->is_freeing = false;
   }
   SyncVar *s = ctx->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   s->is_rw = rw;
   s->is_recursive = recursive;
   s->is_linker_init = linker_init;
   s->mtx.Unlock();
 }
 
 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr) {
   Context *ctx = CTX();
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexDestroy %zx\n", thr->tid, addr);
   StatInc(thr, StatMutexDestroy);
 #ifndef TSAN_GO
   // Global mutexes not marked as LINKER_INITIALIZED
   // cause tons of not interesting reports, so just ignore it.
   if (IsGlobalVar(addr))
     return;
 #endif
if (flags()->report_destroy_locked
     rep.AddLocation(s->addr, 1);
     OutputReport(ctx, rep);
   }
   thr->mset.Remove(s->GetId());
   DestroyAndFree(s);
 }
 
 void MutexLock(ThreadState *thr, uptr pc, uptr addr, int rec) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexLock %zx rec=%d\n", thr->tid, addr, rec);
   CHECK_GT(rec, 0);
   if (IsAppMem(addr))
     MemoryReadAtomic(thr, pc, addr, kSizeLog1);
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   thr->fast_state.IncrementEpoch();
   TraceAddEvent(thr, thr->fast_state, EventTypeLock, s->GetId());
   if (s->owner_tid == SyncVar::kInvalidTid) {
if (s->recursion == 0) {
     StatInc(thr, StatMutexRecLock);
   }
   s->recursion += rec;
   thr->mset.Add(s->GetId(), true, thr->fast_state.epoch());
   s->mtx.Unlock();
 }
 
 int MutexUnlock(ThreadState *thr, uptr pc, uptr addr, bool all) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexUnlock %zx all=%d\n", thr->tid, addr, all);
   if (IsAppMem(addr))
     MemoryReadAtomic(thr, pc, addr, kSizeLog1);
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   thr->fast_state.IncrementEpoch();
   TraceAddEvent(thr, thr->fast_state, EventTypeUnlock, s->GetId());
   int rec = 0;
   if (s->recursion == 0) {
if (s->recursion == 0) {
     }
   }
   thr->mset.Del(s->GetId(), true);
   s->mtx.Unlock();
   return rec;
 }
 
 void MutexReadLock(ThreadState *thr, uptr pc, uptr addr) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexReadLock %zx\n", thr->tid, addr);
   StatInc(thr, StatMutexReadLock);
   if (IsAppMem(addr))
     MemoryReadAtomic(thr, pc, addr, kSizeLog1);
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, false);
   thr->fast_state.IncrementEpoch();
   TraceAddEvent(thr, thr->fast_state, EventTypeRLock, s->GetId());
   if (s->owner_tid != SyncVar::kInvalidTid) {
     Printf("ThreadSanitizer WARNING: read lock of a write locked mutex %p\n",
            addr);
     PrintCurrentStack(thr, pc);
   }
   AcquireImpl(thr, pc, &s->clock);
   s->last_lock = thr->fast_state.raw();
   thr->mset.Add(s->GetId(), false, thr->fast_state.epoch());
   s->mtx.ReadUnlock();
 }
 
 void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexReadUnlock %zx\n", thr->tid, addr);
   StatInc(thr, StatMutexReadUnlock);
   if (IsAppMem(addr))
     MemoryReadAtomic(thr, pc, addr, kSizeLog1);
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   thr->fast_state.IncrementEpoch();
   TraceAddEvent(thr, thr->fast_state, EventTypeRUnlock, s->GetId());
   if (s->owner_tid != SyncVar::kInvalidTid) {
     Printf("ThreadSanitizer WARNING: read unlock of a write locked mutex %p\n",
            addr);
     PrintCurrentStack(thr, pc);
   }
   ReleaseImpl(thr, pc, &s->read_clock);
   s->mtx.Unlock();
   thr->mset.Del(s->GetId(), false);
 }
 
 void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexReadOrWriteUnlock %zx\n", thr->tid, addr);
   if (IsAppMem(addr))
     MemoryReadAtomic(thr, pc, addr, kSizeLog1);
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   bool write = true;
   if (s->owner_tid == SyncVar::kInvalidTid) {
     // Seems to be read unlock.
     write = false;
if (s->owner_tid == SyncVar::kInvalidTid) {
     PrintCurrentStack(thr, pc);
   }
   thr->mset.Del(s->GetId(), write);
   s->mtx.Unlock();
 }
 
 void MutexRepair(ThreadState *thr, uptr pc, uptr addr) {
   Context *ctx = CTX();
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: MutexRepair %zx\n", thr->tid, addr);
   SyncVar *s = ctx->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   s->owner_tid = SyncVar::kInvalidTid;
   s->recursion = 0;
   s->mtx.Unlock();
 }
 
 void Acquire(ThreadState *thr, uptr pc, uptr addr) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: Acquire %zx\n", thr->tid, addr);
   if (thr->ignore_sync)
     return;
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, false);
   AcquireImpl(thr, pc, &s->clock);
   s->mtx.ReadUnlock();
 }
 
void AcquireGlobal(ThreadState *thr, uptr pc) {
   if (thr->ignore_sync)
     return;
   ThreadRegistryLock l(CTX()->thread_registry);
   CTX()->thread_registry->RunCallbackForEachThreadLocked(
       UpdateClockCallback, thr);
 }
 
 void Release(ThreadState *thr, uptr pc, uptr addr) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: Release %zx\n", thr->tid, addr);
   if (thr->ignore_sync)
     return;
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   thr->fast_state.IncrementEpoch();
   // Can't increment epoch w/o writing to the trace as well.
   TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
   ReleaseImpl(thr, pc, &s->clock);
   s->mtx.Unlock();
 }
 
 void ReleaseStore(ThreadState *thr, uptr pc, uptr addr) {
-  CHECK_GT(thr->in_rtl, 0);
   DPrintf("#%d: ReleaseStore %zx\n", thr->tid, addr);
   if (thr->ignore_sync)
     return;
   SyncVar *s = CTX()->synctab.GetOrCreateAndLock(thr, pc, addr, true);
   thr->fast_state.IncrementEpoch();
   // Can't increment epoch w/o writing to the trace as well.
   TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
   ReleaseStoreImpl(thr, pc, &s->clock);

rtl/tsan_rtl_report.cc

 namespace __tsan {
 
 using namespace __sanitizer;  // NOLINT
 
 static ReportStack *SymbolizeStack(const StackTrace& trace);
 
 void TsanCheckFailed(const char *file, int line, const char *cond,
                      u64 v1, u64 v2) {
-  ScopedInRtl in_rtl;
+  // There is high probability that interceptors will check-fail as well,
+  // on the other hand there is no sense in processing interceptors
+  // since we are going to die soon.
+  ScopedIgnoreInterceptors ignore;
   Printf("FATAL: ThreadSanitizer CHECK failed: "
          "%s:%d \"%s\" (0x%zx, 0x%zx)\n",
          file, line, cond, (uptr)v1, (uptr)v2);
   PrintCurrentStackSlow();
   Die();
 }
 
 // Can be overriden by an application/test to intercept reports.

 }
 
 static bool RaceBetweenAtomicAndFree(ThreadState *thr) {
   Shadow s0(thr->racy_state[0]);
   Shadow s1(thr->racy_state[1]);
   CHECK(!(s0.IsAtomic() && s1.IsAtomic()));
   if (!s0.IsAtomic() && !s1.IsAtomic())
     return true;
-  if (s0.IsAtomic() && s1.IsFreed())
+  if (s0.IsAtomic() && s1
+  .IsFreed())
     return true;
   if (s1.IsAtomic() && thr->is_freeing)
     return true;
   return false;
 }
 
 void ReportRace(ThreadState *thr) {
+  // Symbolizer makes lots of intercepted calls. If we try to process them,
+  // at best it will cause deadlocks on internal mutexes.
+  ScopedIgnoreInterceptors ignore;
+
   if (!flags()->report_bugs)
     return;
-  ScopedInRtl in_rtl;
-
   if (!flags()->report_atomic_races && !RaceBetweenAtomicAndFree(thr))
     return;
 
   bool freed = false;
   {
     Shadow s(thr->racy_state[1]);
     freed = s.GetFreedAndReset();
     thr->racy_state[1] = s.raw();

rtl/tsan_rtl_thread.cc

static void ThreadCheckIgnore(ThreadState *thr) {
   if (thr->ignore_sync)
     ReportIgnoresEnabled(thr->tctx, &thr->sync_ignore_set);
 }
 #else
 static void ThreadCheckIgnore(ThreadState *thr) {}
 #endif
 
 void ThreadFinalize(ThreadState *thr) {
-  CHECK_GT(thr->in_rtl, 0);
   ThreadCheckIgnore(thr);
 #ifndef TSAN_GO
   if (!flags()->report_thread_leaks)
     return;
   ThreadRegistryLock l(CTX()->thread_registry);
   Vector<ThreadLeak> leaks(MBlockScopedBuf);
   CTX()->thread_registry->RunCallbackForEachThreadLocked(
       MaybeReportThreadLeak, &leaks);
   for (uptr i = 0; i < leaks.Size(); i++) {
     ScopedReport rep(ReportTypeThreadLeak);
     rep.AddThread(leaks[i].tctx);
     rep.SetCount(leaks[i].count);
     OutputReport(CTX(), rep);
   }
 #endif
 }
 
 int ThreadCount(ThreadState *thr) {
-  CHECK_GT(thr->in_rtl, 0);
   Context *ctx = CTX();
   uptr result;
   ctx->thread_registry->GetNumberOfThreads(0, 0, &result);
   return (int)result;
 }
 
 int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) {
-  CHECK_GT(thr->in_rtl, 0);
   StatInc(thr, StatThreadCreate);
   Context *ctx = CTX();
   OnCreatedArgs args = { thr, pc };
   int tid = ctx->thread_registry->CreateThread(uid, detached, thr->tid, &args);
   DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", thr->tid, tid, uid);
   StatSet(thr, StatThreadMaxAlive, ctx->thread_registry->GetMaxAliveThreads());
   return tid;
 }
 
 void ThreadStart(ThreadState *thr, int tid, uptr os_id) {
   Context *ctx = CTX();
-  CHECK_GT(thr->in_rtl, 0);
   uptr stk_addr = 0;
   uptr stk_size = 0;
   uptr tls_addr = 0;
   uptr tls_size = 0;
   GetThreadStackAndTls(tid == 0, &stk_addr, &stk_size, &tls_addr, &tls_size);
 
   if (tid) {
     if (stk_addr && stk_size)
void ThreadStart(ThreadState *thr, int tid, uptr os_id) {
   tr->StartThread(tid, os_id, &args);
 
   tr->Lock();
   thr->tctx = (ThreadContext*)tr->GetThreadLocked(tid);
   tr->Unlock();
 }
 
 void ThreadFinish(ThreadState *thr) {
-  CHECK_GT(thr->in_rtl, 0);
   ThreadCheckIgnore(thr);
   StatInc(thr, StatThreadFinish);
   if (thr->stk_addr && thr->stk_size)
     DontNeedShadowFor(thr->stk_addr, thr->stk_size);
   if (thr->tls_addr && thr->tls_size)
     DontNeedShadowFor(thr->tls_addr, thr->tls_size);
   thr->is_alive = false;
   Context *ctx = CTX();
   ctx->thread_registry->FinishThread(thr->tid);
 }
 
 static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) {
   uptr uid = (uptr)arg;
   if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) {
     tctx->user_id = 0;
     return true;
   }
   return false;
 }
 
 int ThreadTid(ThreadState *thr, uptr pc, uptr uid) {
-  CHECK_GT(thr->in_rtl, 0);
   Context *ctx = CTX();
   int res = ctx->thread_registry->FindThread(FindThreadByUid, (void*)uid);
   DPrintf("#%d: ThreadTid uid=%zu tid=%d\n", thr->tid, uid, res);
   return res;
 }
 
 void ThreadJoin(ThreadState *thr, uptr pc, int tid) {
-  CHECK_GT(thr->in_rtl, 0);
   CHECK_GT(tid, 0);
   CHECK_LT(tid, kMaxTid);
   DPrintf("#%d: ThreadJoin tid=%d\n", thr->tid, tid);
   Context *ctx = CTX();
   ctx->thread_registry->JoinThread(tid, thr);
 }
 
 void ThreadDetach(ThreadState *thr, uptr pc, int tid) {
-  CHECK_GT(thr->in_rtl, 0);
   CHECK_GT(tid, 0);
   CHECK_LT(tid, kMaxTid);
   Context *ctx = CTX();
   ctx->thread_registry->DetachThread(tid);
 }
 
 void ThreadSetName(ThreadState *thr, const char *name) {
-  CHECK_GT(thr->in_rtl, 0);
   CTX()->thread_registry->SetThreadName(thr->tid, name);
 }
 
 void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr,
                        uptr size, bool is_write) {
   if (size == 0)
     return;
 

rtl/tsan_vector.h

T &operator[](uptr i) {
     return begin_[i];
   }
 
   const T &operator[](uptr i) const {
     DCHECK_LT(i, end_ - begin_);
     return begin_[i];
   }
 
-  T *PushBack(T v = T()) {
+  T *PushBack() {
     EnsureSize(Size() + 1);
-    end_[-1] = v;
-    return &end_[-1];
+    T *p = &end_[-1];
+    internal_memset(p, 0, sizeof(*p));
+    return p;
+  }
+
+  T *PushBack(const T& v) {
+    EnsureSize(Size() + 1);
+    T *p = &end_[-1];
+    internal_memcpy(p, &v, sizeof(*p));
+    return p;
   }
 
   void PopBack() {
     DCHECK_GT(end_, begin_);
     end_--;
   }
 
   void Resize(uptr size) {

tests/unit/tsan_clock_test.cc

 //===----------------------------------------------------------------------===//
 #include "tsan_clock.h"
 #include "tsan_rtl.h"
 #include "gtest/gtest.h"
 
 namespace __tsan {
 
 TEST(Clock, VectorBasic) {
-  ScopedInRtl in_rtl;
   ThreadClock clk;
   CHECK_EQ(clk.size(), 0);
   clk.tick(0);
   CHECK_EQ(clk.size(), 1);
   CHECK_EQ(clk.get(0), 1);
   clk.tick(3);
   CHECK_EQ(clk.size(), 4);
   CHECK_EQ(clk.get(0), 1);
   CHECK_EQ(clk.get(1), 0);
   CHECK_EQ(clk.get(2), 0);
   CHECK_EQ(clk.get(3), 1);
   clk.tick(3);
   CHECK_EQ(clk.get(3), 2);
 }
 
 TEST(Clock, ChunkedBasic) {
-  ScopedInRtl in_rtl;
   ThreadClock vector;
   SyncClock chunked;
   CHECK_EQ(vector.size(), 0);
   CHECK_EQ(chunked.size(), 0);
   vector.acquire(&chunked);
   CHECK_EQ(vector.size(), 0);
   CHECK_EQ(chunked.size(), 0);
   vector.release(&chunked);
   CHECK_EQ(vector.size(), 0);
   CHECK_EQ(chunked.size(), 0);
   vector.acq_rel(&chunked);
   CHECK_EQ(vector.size(), 0);
   CHECK_EQ(chunked.size(), 0);
 }
 
 TEST(Clock, AcquireRelease) {
-  ScopedInRtl in_rtl;
   ThreadClock vector1;
   vector1.tick(100);
   SyncClock chunked;
   vector1.release(&chunked);
   CHECK_EQ(chunked.size(), 101);
   ThreadClock vector2;
   vector2.acquire(&chunked);
   CHECK_EQ(vector2.size(), 101);
   CHECK_EQ(vector2.get(0), 0);
   CHECK_EQ(vector2.get(1), 0);
   CHECK_EQ(vector2.get(99), 0);
   CHECK_EQ(vector2.get(100), 1);
 }
 
 TEST(Clock, ManyThreads) {
-  ScopedInRtl in_rtl;
   SyncClock chunked;
   for (int i = 0; i < 100; i++) {
     ThreadClock vector;
     vector.tick(i);
     vector.release(&chunked);
     CHECK_EQ(chunked.size(), i + 1);
     vector.acquire(&chunked);
     CHECK_EQ(vector.size(), i + 1);
   }
   ThreadClock vector;
   vector.acquire(&chunked);
   CHECK_EQ(vector.size(), 100);
   for (int i = 0; i < 100; i++)
     CHECK_EQ(vector.get(i), 1);
 }
 
 TEST(Clock, DifferentSizes) {
-  ScopedInRtl in_rtl;
   {
     ThreadClock vector1;
     vector1.tick(10);
     ThreadClock vector2;
     vector2.tick(20);
     {
       SyncClock chunked;
       vector1.release(&chunked);

tests/unit/tsan_flags_test.cc

 #include "tsan_flags.h"
 #include "tsan_rtl.h"
 #include "gtest/gtest.h"
 #include <string>
 
 namespace __tsan {
 
 TEST(Flags, Basic) {
-  ScopedInRtl in_rtl;
   // At least should not crash.
   Flags f;
   InitializeFlags(&f, 0);
   InitializeFlags(&f, "");
 }
 
 TEST(Flags, DefaultValues) {
-  ScopedInRtl in_rtl;
   Flags f;
 
   f.enable_annotations = false;
   f.exitcode = -11;
   InitializeFlags(&f, "");
   EXPECT_EQ(66, f.exitcode);
   EXPECT_EQ(true, f.enable_annotations);
 }

 }
 
 static const char *test_default_options;
 extern "C" const char *__tsan_default_options() {
   return test_default_options;
 }
 
 TEST(Flags, ParseDefaultOptions) {
-  ScopedInRtl in_rtl;
   Flags f;
 
   test_default_options = options1;
   InitializeFlags(&f, "");
   VerifyOptions1(&f);
 
   test_default_options = options2;
   InitializeFlags(&f, "");
   VerifyOptions2(&f);
 }
 
 TEST(Flags, ParseEnvOptions) {
-  ScopedInRtl in_rtl;
   Flags f;
 
   InitializeFlags(&f, options1);
   VerifyOptions1(&f);
 
   InitializeFlags(&f, options2);
   VerifyOptions2(&f);
 }
 
 TEST(Flags, ParsePriority) {
-  ScopedInRtl in_rtl;
   Flags f;
 
   test_default_options = options2;
   InitializeFlags(&f, options1);
   VerifyOptions1(&f);
 
   test_default_options = options1;
   InitializeFlags(&f, options2);
   VerifyOptions2(&f);
 }
 
 }  // namespace __tsan

tests/unit/tsan_mman_test.cc

 uptr __tsan_get_estimated_allocated_size(uptr size);
 bool __tsan_get_ownership(void *p);
 uptr __tsan_get_allocated_size(void *p);
 }
 
 namespace __tsan {
 
 TEST(Mman, Internal) {
-  ScopedInRtl in_rtl;
   char *p = (char*)internal_alloc(MBlockScopedBuf, 10);
   EXPECT_NE(p, (char*)0);
   char *p2 = (char*)internal_alloc(MBlockScopedBuf, 20);
   EXPECT_NE(p2, (char*)0);
   EXPECT_NE(p2, p);
   for (int i = 0; i < 10; i++) {
     p[i] = 42;
   }
   for (int i = 0; i < 20; i++) {
     ((char*)p2)[i] = 42;
   }
   internal_free(p);
   internal_free(p2);
 }
 
 TEST(Mman, User) {
-  ScopedInRtl in_rtl;
   ThreadState *thr = cur_thread();
   uptr pc = 0;
   char *p = (char*)user_alloc(thr, pc, 10);
   EXPECT_NE(p, (char*)0);
   char *p2 = (char*)user_alloc(thr, pc, 20);
   EXPECT_NE(p2, (char*)0);
   EXPECT_NE(p2, p);
   MBlock *b = user_mblock(thr, p);
for (int i = 0; i < 20; i++) {
     ((char*)p2)[i] = 42;
     EXPECT_EQ(b2, user_mblock(thr, p2 + i));
   }
   user_free(thr, pc, p);
   user_free(thr, pc, p2);
 }
 
 TEST(Mman, UserRealloc) {
-  ScopedInRtl in_rtl;
   ThreadState *thr = cur_thread();
   uptr pc = 0;
   {
     void *p = user_realloc(thr, pc, 0, 0);
     // Strictly saying this is incorrect, realloc(NULL, N) is equivalent to
     // malloc(N), thus must return non-NULL pointer.
     EXPECT_EQ(p, (void*)0);
   }
uptr pc = 0;
     EXPECT_NE(p2, (void*)0);
     for (int i = 0; i < 10; i++)
       EXPECT_EQ(((char*)p2)[i], (char)0xde);
     user_free(thr, pc, p2);
   }
 }
 
 TEST(Mman, UsableSize) {
-  ScopedInRtl in_rtl;
   ThreadState *thr = cur_thread();
   uptr pc = 0;
   char *p = (char*)user_alloc(thr, pc, 10);
   char *p2 = (char*)user_alloc(thr, pc, 20);
   EXPECT_EQ(0U, user_alloc_usable_size(thr, pc, NULL));
   EXPECT_EQ(10U, user_alloc_usable_size(thr, pc, p));
   EXPECT_EQ(20U, user_alloc_usable_size(thr, pc, p2));
   user_free(thr, pc, p);
   user_free(thr, pc, p2);
 }
 
 TEST(Mman, Stats) {
-  ScopedInRtl in_rtl;
   ThreadState *thr = cur_thread();
 
   uptr alloc0 = __tsan_get_current_allocated_bytes();
   uptr heap0 = __tsan_get_heap_size();
   uptr free0 = __tsan_get_free_bytes();
   uptr unmapped0 = __tsan_get_unmapped_bytes();
 
   EXPECT_EQ(__tsan_get_estimated_allocated_size(10), (uptr)10);

tests/unit/tsan_stack_test.cc

static void TestStackTrace(StackTrace *trace) {
   trace->ObtainCurrent(&thr, 42);
   EXPECT_EQ(trace->Size(), (uptr)3);
   EXPECT_EQ(trace->Get(0), (uptr)100);
   EXPECT_EQ(trace->Get(1), (uptr)101);
   EXPECT_EQ(trace->Get(2), (uptr)42);
 }
 
 TEST(StackTrace, Basic) {
-  ScopedInRtl in_rtl;
   StackTrace trace;
   TestStackTrace(&trace);
 }
 
 TEST(StackTrace, StaticBasic) {
-  ScopedInRtl in_rtl;
   uptr buf[10];
   StackTrace trace1(buf, 10);
   TestStackTrace(&trace1);
   StackTrace trace2(buf, 3);
   TestStackTrace(&trace2);
 }
 
 TEST(StackTrace, StaticTrim) {
-  ScopedInRtl in_rtl;
   uptr buf[2];
   StackTrace trace(buf, 2);
 
   ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0);
   uptr stack[128];
   thr.shadow_stack = &stack[0];
   thr.shadow_stack_pos = &stack[0];
   thr.shadow_stack_end = &stack[128];

tests/unit/tsan_sync_test.cc

 #include <map>
 
 namespace __tsan {
 
 TEST(Sync, Table) {
   const uintptr_t kIters = 512*1024;
   const uintptr_t kRange = 10000;
 
-  ScopedInRtl in_rtl;
   ThreadState *thr = cur_thread();
   uptr pc = 0;
 
   SyncTab tab;
   SyncVar *golden[kRange] = {};
   unsigned seed = 0;
   for (uintptr_t i = 0; i < kIters; i++) {
     uintptr_t addr = rand_r(&seed) % (kRange - 1) + 1;

tests/unit/tsan_vector_test.cc

 //===----------------------------------------------------------------------===//
 #include "tsan_vector.h"
 #include "tsan_rtl.h"
 #include "gtest/gtest.h"
 
 namespace __tsan {
 
 TEST(Vector, Basic) {
-  ScopedInRtl in_rtl;
   Vector<int> v(MBlockScopedBuf);
   EXPECT_EQ(v.Size(), (uptr)0);
   v.PushBack(42);
   EXPECT_EQ(v.Size(), (uptr)1);
   EXPECT_EQ(v[0], 42);
   v.PushBack(43);
   EXPECT_EQ(v.Size(), (uptr)2);
   EXPECT_EQ(v[0], 42);
   EXPECT_EQ(v[1], 43);
 }
 
 TEST(Vector, Stride) {
-  ScopedInRtl in_rtl;
   Vector<int> v(MBlockScopedBuf);
   for (int i = 0; i < 1000; i++) {
     v.PushBack(i);
     EXPECT_EQ(v.Size(), (uptr)(i + 1));
     EXPECT_EQ(v[i], i);
   }
   for (int i = 0; i < 1000; i++) {
     EXPECT_EQ(v[i], i);
   }
 }
 
 }  // namespace __tsan