Hunk cherry-pick from 8a2198773e: fix InterceptorEnabled visibility.

compiler-rt/include/sanitizer/tsan_interface.h

@@ -309,6 +309,12 @@ int SANITIZER_CDECL __tsan_get_report_unique_tid(void *report,
 /// \returns An opaque pointer to the current report. Otherwise returns NULL.
 void *SANITIZER_CDECL __tsan_get_current_report();
 
+/////////////////////////////////////////////////////////////////////////////
+// This code is for disabling/enabling instrumentation
+// for specific code section
+void SANITIZER_CDECL __tsan_enable();
+void SANITIZER_CDECL __tsan_disable();
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

@@ -20,6 +20,9 @@
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 
+extern "C" __attribute__((visibility("default")))
+bool InterceptorEnabled = true;
+
 namespace __sanitizer {
 
 const char *SanitizerToolName = "SanitizerTool";

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

@@ -44,6 +44,8 @@
 #include "sanitizer_symbolizer.h"
 #include "sanitizer_tls_get_addr.h"
 
+extern "C" bool InterceptorEnabled;
+
 #if SANITIZER_INTERCEPTOR_HOOKS
 #define CALL_WEAK_INTERCEPTOR_HOOK(f, ...) f(__VA_ARGS__);
 #define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...) \
@@ -378,6 +380,9 @@ UNUSED static void DeleteInterceptorMetadata(void *addr) {
 
 #if SANITIZER_INTERCEPT_STRLEN
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
+  if (!InterceptorEnabled)
+    return REAL(strlen)(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
@@ -457,6 +462,10 @@ DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strcmp, uptr called_pc,
                               const char *s1, const char *s2, int result)
 
 INTERCEPTOR(int, strcmp, const char *s1, const char *s2) {
+  // Enabling escape analysis based optimization
+  if (!InterceptorEnabled)
+    return REAL(strcmp)(s1, s2);
+
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strcmp, s1, s2);
   unsigned char c1, c2;
@@ -866,6 +875,10 @@ INTERCEPTOR(int, bcmp, const void *a1, const void *a2, uptr size) {
 
 #if SANITIZER_INTERCEPT_MEMCHR
 INTERCEPTOR(void*, memchr, const void *s, int c, SIZE_T n) {
+  // Enabling escape analysis based optimization
+  if (!InterceptorEnabled)
+    return REAL(memchr)(s, c, n);
+
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_memchr(s, c, n);
   void *ctx;

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc

@@ -31,6 +31,9 @@
 #include "interception/interception.h"
 #include "sanitizer_platform_interceptors.h"
 
+extern "C" __attribute__((visibility("default")))
+bool InterceptorEnabled;
+
 // Platform-specific options.
 #if SANITIZER_APPLE
 #define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 0
@@ -41,43 +44,49 @@
 #endif  // SANITIZER_APPLE
 
 #ifndef COMMON_INTERCEPTOR_MEMSET_IMPL
-#define COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, dst, v, size) \
-  {                                                       \
-    if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)        \
-      return internal_memset(dst, v, size);               \
-    COMMON_INTERCEPTOR_ENTER(ctx, memset, dst, v, size);  \
-    if (common_flags()->intercept_intrin)                 \
-      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);     \
-    return REAL(memset)(dst, v, size);                    \
+#define COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, dst, v, size)   \
+  {                                                         \
+    if (InterceptorEnabled) {                               \
+      if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)        \
+        return internal_memset(dst, v, size);               \
+      COMMON_INTERCEPTOR_ENTER(ctx, memset, dst, v, size);  \
+      if (common_flags()->intercept_intrin)                 \
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);     \
+    }                                                       \
+    return REAL(memset)(dst, v, size);                      \
   }
 #endif
 
 #ifndef COMMON_INTERCEPTOR_MEMMOVE_IMPL
-#define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, dst, src, size) \
-  {                                                          \
-    if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)           \
-      return internal_memmove(dst, src, size);               \
-    COMMON_INTERCEPTOR_ENTER(ctx, memmove, dst, src, size);  \
-    if (common_flags()->intercept_intrin) {                  \
-      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);        \
-      COMMON_INTERCEPTOR_READ_RANGE(ctx, src, size);         \
-    }                                                        \
-    return REAL(memmove)(dst, src, size);                    \
+#define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, dst, src, size)   \
+  {                                                            \
+    if (InterceptorEnabled) {                                  \
+      if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)           \
+        return internal_memmove(dst, src, size);               \
+      COMMON_INTERCEPTOR_ENTER(ctx, memmove, dst, src, size);  \
+      if (common_flags()->intercept_intrin) {                  \
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);        \
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, src, size);         \
+      }                                                        \
+    }                                                          \
+    return REAL(memmove)(dst, src, size);                      \
   }
 #endif
 
 #ifndef COMMON_INTERCEPTOR_MEMCPY_IMPL
-#define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, dst, src, size) \
-  {                                                         \
-    if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {        \
-      return internal_memmove(dst, src, size);              \
-    }                                                       \
-    COMMON_INTERCEPTOR_ENTER(ctx, memcpy, dst, src, size);  \
-    if (common_flags()->intercept_intrin) {                 \
-      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);       \
-      COMMON_INTERCEPTOR_READ_RANGE(ctx, src, size);        \
-    }                                                       \
-    return REAL(memcpy)(dst, src, size);                    \
+#define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, dst, src, size)   \
+  {                                                           \
+    if (InterceptorEnabled) {                                 \
+      if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {        \
+        return internal_memmove(dst, src, size);              \
+      }                                                       \
+      COMMON_INTERCEPTOR_ENTER(ctx, memcpy, dst, src, size);  \
+      if (common_flags()->intercept_intrin) {                 \
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);       \
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, src, size);        \
+      }                                                       \
+    }                                                         \
+    return REAL(memcpy)(dst, src, size);                      \
   }
 #endif
 

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

@@ -437,6 +437,10 @@ SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,
                                          u8 *a);
 
+// Functions for disabling/enabling instrumentation
+// for specific code section
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_disable();
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_enable();
 }  // extern "C"
 
 }  // namespace __tsan

compiler-rt/lib/tsan/rtl/tsan_interface.inc

@@ -188,3 +188,9 @@ void __tsan_read_range_pc(void *addr, uptr size, void *pc) {
 void __tsan_write_range_pc(void *addr, uptr size, void *pc) {
   MemoryAccessRange(cur_thread(), STRIP_PAC_PC(pc), (uptr)addr, size, true);
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// This is for disabling/enabling TSan instrumentation
+int GV;
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_disable() { GV++; };
+SANITIZER_INTERFACE_ATTRIBUTE void __tsan_enable() { GV++; };

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

@@ -499,6 +499,8 @@ bool OutputReport(ThreadState *thr, const ScopedReport &srep);
 bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace);
 bool IsExpectedReport(uptr addr, uptr size);
 
+//#define TSAN_DEBUG_OUTPUT 2
+
 #if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 1
 # define DPrintf Printf
 #else

compiler-rt/test/tsan/lit.cfg.py

@@ -47,6 +47,10 @@ def get_required_attr(config, attr_name):
 else:
     extra_cflags = []
 
+# Enable new Escape Analysis instead of default Capture Tracking
+#escape_analysis_flag = ["-mllvm -tsan-use-escape-analysis"]
+escape_analysis_flag = ["-mllvm -tsan-use-escape-analysis-global"]
+
 tsan_incdir = config.test_source_root + "/../"
 # Setup default compiler flags used with -fsanitize=thread option.
 clang_tsan_cflags = (
@@ -55,9 +59,11 @@ def get_required_attr(config, attr_name):
     + config.debug_info_flags
     + extra_cflags
     + ["-I%s" % tsan_incdir]
+    + escape_analysis_flag
 )
 clang_tsan_cxxflags = (
     config.cxx_mode_flags + clang_tsan_cflags + ["-std=c++11"] + ["-I%s" % tsan_incdir]
+    + escape_analysis_flag
 )
 # Add additional flags if we're using instrumented libc++.
 # Instrumented libcxx currently not supported on Darwin.

llvm/.gitignore

@@ -10,6 +10,7 @@
 # Nested build directory.
 #==============================================================================#
 /build
+/cmake-build*
 
 #==============================================================================#
 # Explicit files to ignore (only matches one).