tsan: introduce LazyInitialize

[dvyukov]

Summary

We call non-inlinable Initialize from all interceptors/syscalls,
but most of the time runtime is already initialized and this just
introduces unnecessary overhead.
Add LazyInitialize that (1) inlinable, (2) does nothing if
.preinit_array is enabled (expected case on Linux).

Depends on D107071.

[melver]

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

391

Is it the case that now Initialize() should only be called if !is_initialized?

In which case CHECK(!is_initialized) could say if this is wrongly used instead of LazyInitialize().

[dvyukov]

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

391

No, it's not the case.

.preinit_array and module constructors call tsan_init multiple times.
tsan_init needs to call Initialize, it can't call LazyInitialize, because LazyInitialize is a nop if .preinit_array is enabled. So if we call LazyInitialize from .preinit_array, it won't actually initialize.

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

if (ctx == 0 && !thr->is_dead) {
     thr->signal_ctx = ctx;
   }
   return ctx;
 }
 
 ScopedInterceptor::ScopedInterceptor(ThreadState *thr, const char *fname,
                                      uptr pc)
     : thr_(thr), in_ignored_lib_(false), ignoring_(false) {
-  Initialize(thr);
+  LazyInitialize(thr);
   if (!thr_->is_inited) return;
   if (!thr_->ignore_interceptors) FuncEntry(thr, pc);
   DPrintf("#%d: intercept %s()\n", thr_->tid, fname);
   ignoring_ =
       !thr_->in_ignored_lib && (flags()->ignore_interceptors_accesses ||
                                 libignore()->IsIgnored(pc, &in_ignored_lib_));
   EnableIgnores();
 }
#define TSAN_SYSCALL()             \
   ThreadState *thr = cur_thread(); \
   if (thr->ignore_interceptors)    \
     return;                        \
   ScopedSyscall scoped_syscall(thr)
 
 struct ScopedSyscall {
   ThreadState *thr;
 
-  explicit ScopedSyscall(ThreadState *thr)
-      : thr(thr) {
-    Initialize(thr);
-  }
+  explicit ScopedSyscall(ThreadState *thr) : thr(thr) { LazyInitialize(thr); }
 
   ~ScopedSyscall() {
     ProcessPendingSignals(thr);
   }
 };
 
 #if !SANITIZER_FREEBSD && !SANITIZER_MAC
 static void syscall_access_range(uptr pc, uptr p, uptr s, bool write) {

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

 void FiberSwitch(ThreadState *thr, uptr pc, ThreadState *fiber, unsigned flags);
 
 // These need to match __tsan_switch_to_fiber_* flags defined in
 // tsan_interface.h. See documentation there as well.
 enum FiberSwitchFlags {
   FiberSwitchFlagNoSync = 1 << 0, // __tsan_switch_to_fiber_no_sync
 };
 
+extern bool is_initialized;
+
+ALWAYS_INLINE
+void LazyInitialize(ThreadState *thr) {
+  // If we can use .preinit_array, assume that __tsan_init
+  // called from .preinit_array initializes runtime before
+  // any instrumented code.
+#if !SANITIZER_CAN_USE_PREINIT_ARRAY
+  if (UNLIKELY(!is_initialized))
+    Initialize(thr);
+#endif
+}
+
 }  // namespace __tsan
 
 #endif  // TSAN_RTL_H

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

void CheckUnwind() {
   ScopedIgnoreInterceptors ignore;
 #if !SANITIZER_GO
   cur_thread()->ignore_sync++;
   cur_thread()->ignore_reads_and_writes++;
 #endif
   PrintCurrentStackSlow(StackTrace::GetCurrentPc());
 }
 
+bool is_initialized;
+
 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.
   SetCheckUnwindCallback(CheckUnwind);