tsan: don't instrument runtime callbacks in tests

[dvyukov]

Summary

These runtime callbacks are supposed to be non-instrumented,
we can't handle runtime recursion well, nor can we afford
explicit recursion checks in the hot functions (memory access,
function entry/exit).
It used to work (not crash), but it won't work with the new runtime.
Mark all runtime callbacks as non-instrumented.

compiler-rt/test/tsan/Linux/double_race.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
 #include "../test.h"
 #include <memory.h>
 
 // A reproducer for a known issue.
 // See reference to double_race.cpp in tsan_rtl_report.cpp for an explanation.
 
 long long buf[2];
 volatile int nreport;
 
-void __sanitizer_report_error_summary(const char *summary) {
+__attribute__((disable_sanitizer_instrumentation)) void
+__sanitizer_report_error_summary(const char *summary) {
   nreport++;
 }
 
 const int kEventPCBits = 61;
 
-extern "C" bool __tsan_symbolize_external(unsigned long pc, char *func_buf,
-                                          unsigned long func_siz,
-                                          char *file_buf,
-                                          unsigned long file_siz, int *line,
-                                          int *col) {
+extern "C" __attribute__((disable_sanitizer_instrumentation)) bool
+__tsan_symbolize_external(unsigned long pc, char *func_buf,
+                          unsigned long func_siz, char *file_buf,
+                          unsigned long file_siz, int *line, int *col) {
   if (pc >> kEventPCBits) {
     printf("bad PC passed to __tsan_symbolize_external: %lx\n", pc);
     _exit(1);
   }
   return true;
 }
 
 void *Thread(void *arg) {
int main() {
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 8 at {{.*}} by thread T1:
 // CHECK:     #0 memset
 // CHECK:     #{{[12]}} Thread
 // CHECK-NOT: bad PC passed to __tsan_symbolize_external
-// CHECK: WARNING: ThreadSanitizer: data race
-// CHECK:   Write of size 8 at {{.*}} by thread T1:
-// CHECK:     #0 Thread
+// CHECK-NOT: __sanitizer_report_error_summary
+// CHECK-NOT: WARNING: ThreadSanitizer: data race

compiler-rt/test/tsan/debugging.cpp

int main() {
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   my_global = 41;
   barrier_wait(&barrier);
   pthread_join(t, 0);
   fprintf(stderr, "Done.\n");
 }
 
-void __tsan_on_report(void *report) {
+__attribute__((disable_sanitizer_instrumentation)) void
+__tsan_on_report(void *report) {
   fprintf(stderr, "__tsan_on_report(%p)\n", report);
   fprintf(stderr, "__tsan_get_current_report() = %p\n",
           __tsan_get_current_report());
   // CHECK: __tsan_on_report([[REPORT:0x[0-9a-f]+]])
   // CHECK: __tsan_get_current_report() = [[REPORT]]
 
   const char *description;
   int count;

compiler-rt/test/tsan/java_symbolization.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "java.h"
 #include <memory.h>
 
-extern "C" void __tsan_symbolize_external_ex(
-    jptr pc, void (*add_frame)(void *, const char *, const char *, int, int),
+extern "C" __attribute__((disable_sanitizer_instrumentation)) void
+__tsan_symbolize_external_ex(jptr pc,
+                             void (*add_frame)(void *, const char *,
+                                               const char *, int, int),
                              void *ctx) {
   if (pc == (1234 | kExternalPCBit)) {
     add_frame(ctx, "MyInnerFunc", "MyInnerFile.java", 1234, 56);
     add_frame(ctx, "MyOuterFunc", "MyOuterFile.java", 4321, 65);
   }
   if (pc == (2345 | kExternalPCBit)) {
     add_frame(ctx, "Caller1", "CallerFile.java", 111, 22);
     add_frame(ctx, "Caller2", "CallerFile.java", 333, 44);
   }

compiler-rt/test/tsan/java_symbolization_legacy.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "java.h"
 #include <memory.h>
 
-extern "C" bool __tsan_symbolize_external(jptr pc,
-                                          char *func_buf, jptr func_siz,
-                                          char *file_buf, jptr file_siz,
-                                          int *line, int *col) {
+extern "C" __attribute__((disable_sanitizer_instrumentation)) bool
+__tsan_symbolize_external(jptr pc, char *func_buf, jptr func_siz,
+                          char *file_buf, jptr file_siz, int *line, int *col) {
   if (pc == (1234 | kExternalPCBit)) {
     memcpy(func_buf, "MyFunc", sizeof("MyFunc"));
     memcpy(file_buf, "MyFile.java", sizeof("MyFile.java"));
     *line = 1234;
     *col = 56;
     return true;
   }
   return false;