[tsan] Init TSAN from FuncEntry

[vitalybuka]

Summary

It's possible to create binaries with instrumented code which is called before
regular TSAN interceptors.

This patch replaces r270873. r270873 does not work with Google code.

[vitalybuka]

Fix comment

[vitalybuka]

Existing .preinit_array makes sense and consistent with other sanitizes.
Mentioned Google issues need to be fixed on Google side.

lib/tsan/CMakeLists.txt

set(TSAN_SOURCES
   rtl/tsan_interface_ann.cc
   rtl/tsan_interface_atomic.cc
   rtl/tsan_interface_java.cc
   rtl/tsan_malloc_mac.cc
   rtl/tsan_md5.cc
   rtl/tsan_mman.cc
   rtl/tsan_mutex.cc
   rtl/tsan_mutexset.cc
-  rtl/tsan_preinit.cc
   rtl/tsan_report.cc
   rtl/tsan_rtl.cc
   rtl/tsan_rtl_mutex.cc
   rtl/tsan_rtl_proc.cc
   rtl/tsan_rtl_report.cc
   rtl/tsan_rtl_thread.cc
   rtl/tsan_stack_trace.cc
   rtl/tsan_stat.cc

lib/tsan/rtl/tsan_preinit.cc

-//===-- tsan_preinit.cc ---------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of ThreadSanitizer.
-//
-// Call __tsan_init at the very early stage of process startup.
-//===----------------------------------------------------------------------===//
-
-#include "sanitizer_common/sanitizer_internal_defs.h"
-#include "tsan_interface.h"
-
-#if SANITIZER_CAN_USE_PREINIT_ARRAY
-
-// The symbol is called __local_tsan_preinit, because it's not intended to be
-// exported.
-// This code linked into the main executable when -fsanitize=thread is in
-// the link flags. It can only use exported interface functions.
-__attribute__((section(".preinit_array"), used))
-void (*__local_tsan_preinit)(void) = __tsan_init;
-
-#endif

lib/tsan/rtl/tsan_rtl.cc

bool OnFinalize(bool failed) {
   return failed;
 }
 SANITIZER_WEAK_CXX_DEFAULT_IMPL
 void OnInitialize() {}
 #endif
 
 static char thread_registry_placeholder[sizeof(ThreadRegistry)];
 
+static bool is_initialized = false;
+
 static ThreadContextBase *CreateThreadContext(u32 tid) {
   // Map thread trace when context is created.
   char name[50];
   internal_snprintf(name, sizeof(name), "trace %u", tid);
   MapThreadTrace(GetThreadTrace(tid), TraceSize() * sizeof(Event), name);
   const uptr hdr = GetThreadTraceHeader(tid);
   internal_snprintf(name, sizeof(name), "trace header %u", tid);
   MapThreadTrace(hdr, sizeof(Trace), name);
for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) {
         prev = p;
       }
     }
   }
 }
 
 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);
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) {
+  if (!is_initialized)
+    Initialize(thr);
   StatInc(thr, StatFuncEnter);
   DPrintf2("#%d: FuncEntry %p\n", (int)thr->fast_state.tid(), (void*)pc);
   if (kCollectHistory) {
     thr->fast_state.IncrementEpoch();
     TraceAddEvent(thr, thr->fast_state, EventTypeFuncEnter, pc);
   }
 
   // Shadow stack maintenance can be replaced with

test/tsan/Linux/check_preinit.cc

 // RUN: %clang_tsan -fno-sanitize=thread -shared -fPIC -O1 -DBUILD_SO=1 %s -o \
 // RUN:  %t.so && \
 // RUN:   %clang_tsan -O1 %s %t.so -o %t && %run %t 2>&1 | FileCheck %s
-// RUN: llvm-objdump -t %t | FileCheck %s --check-prefix=CHECK-DUMP
-// CHECK-DUMP:  {{[.]preinit_array.*__local_tsan_preinit}}
 
 // SANITIZER_CAN_USE_PREINIT_ARRAY is undefined on android.
 // UNSUPPORTED: android
 
-// Test checks if __tsan_init is called from .preinit_array.
-// Without initialization from .preinit_array, __tsan_init will be called from
-// constructors of the binary which are called after constructors of shared
-// library.
+// Test checks that instrumented code triggers __tsan_init even if it's called
+// as early as from .preinit_array.
 
 #include <stdio.h>
 
 #if BUILD_SO
 
 // "volatile" is needed to avoid compiler optimize-out constructors.
 volatile int counter = 0;
 volatile int lib_constructor_call = 0;
 volatile int tsan_init_call = 0;
+volatile int preinit_array_call = 0;
 
 __attribute__ ((constructor))
 void LibConstructor() {
   lib_constructor_call = ++counter;
 };
 
 #else  // BUILD_SO
 
 extern int counter;
 extern int lib_constructor_call;
 extern int tsan_init_call;
+extern int preinit_array_call;
 
 volatile int bin_constructor_call = 0;
 
 __attribute__ ((constructor))
 void BinConstructor() {
   bin_constructor_call = ++counter;
 };
 
 namespace __tsan {
 
 void OnInitialize() {
   tsan_init_call = ++counter;
 }
 
 }
 
+void PreinitArray() {
+  preinit_array_call = ++counter;
+};
+
+__attribute__((section(".preinit_array"), used))
+void (*__preinit_test)(void) = PreinitArray;
+
 int main() {
   // CHECK: TSAN_INIT 1
-  // CHECK: LIB_CONSTRUCTOR 2
-  // CHECK: BIN_CONSTRUCTOR 3
+  // CHECK: PREINIT_ARRAY 2
+  // CHECK: LIB_CONSTRUCTOR 3
+  // CHECK: BIN_CONSTRUCTOR 4
   printf("TSAN_INIT %d\n", tsan_init_call);
+  printf("PREINIT_ARRAY %d\n", preinit_array_call);
   printf("LIB_CONSTRUCTOR %d\n", lib_constructor_call);
   printf("BIN_CONSTRUCTOR %d\n", bin_constructor_call);
   return 0;
 }
 
 #endif  // BUILD_SO