[tsan] Include __tsan_external_* API from a header file instead of declaring them manually

[kubamracek]

Summary

NFC.

compiler-rt/trunk/test/tsan/Darwin/debug_external.cc

 void __tsan_on_report(void *report);
 int __tsan_get_report_loc(void *report, unsigned long idx, const char **type,
                           void **addr, void **start,
                           unsigned long *size, int *tid, int *fd,
                           int *suppressable, void **trace,
                           unsigned long trace_size);
 int __tsan_get_report_loc_object_type(void *report, unsigned long idx,
                                       const char **object_type);
-void *__tsan_external_register_tag(const char *object_type);
-void __tsan_external_assign_tag(void *addr, void *tag);
 }
 
 void *Thread(void *arg) {
   barrier_wait(&barrier);
   *((long *)arg) = 42;
   return NULL;
 }
 

compiler-rt/trunk/test/tsan/Darwin/external-dups.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #include <thread>
 
 #import "../test.h"
 
-extern "C" {
-void *__tsan_external_register_tag(const char *object_type);
-void *__tsan_external_assign_tag(void *addr, void *tag);
-void __tsan_external_read(void *addr, void *caller_pc, void *tag);
-void __tsan_external_write(void *addr, void *caller_pc, void *tag);
-void __tsan_write8(void *addr);
-}
-
 void *tag;
 
 __attribute__((no_sanitize("thread")))
 void ExternalWrite(void *addr) {
   __tsan_external_write(addr, __builtin_return_address(0), tag);
 }
 
 int main(int argc, char *argv[]) {

compiler-rt/trunk/test/tsan/test.h

 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <dlfcn.h>
 #include <stddef.h>
 #include <sched.h>
 #include <stdarg.h>
 #include "sanitizer_common/print_address.h"
 
+#include <sanitizer/tsan_interface.h>
+
 #ifdef __APPLE__
 #include <mach/mach_time.h>
 #endif
 
 // TSan-invisible barrier.
 // Tests use it to establish necessary execution order in a way that does not
 // interfere with tsan (does not establish synchronization between threads).
 typedef unsigned long long invisible_barrier_t;

compiler-rt/trunk/test/tsan/unaligned_race.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
 #include <stdint.h>
 
 #define NOINLINE __attribute__((noinline))
 
 volatile uint64_t objs[8*2*(2 + 4 + 8)][2];
 
-extern "C" {
-uint16_t __sanitizer_unaligned_load16(volatile void *addr);
-uint32_t __sanitizer_unaligned_load32(volatile void *addr);
-uint64_t __sanitizer_unaligned_load64(volatile void *addr);
-void __sanitizer_unaligned_store16(volatile void *addr, uint16_t v);
-void __sanitizer_unaligned_store32(volatile void *addr, uint32_t v);
-void __sanitizer_unaligned_store64(volatile void *addr, uint64_t v);
-}
-
 // All this mess is to generate unique stack for each race,
 // otherwise tsan will suppress similar stacks.
 
-static NOINLINE void access(volatile char *p, int sz, int rw) {
+static NOINLINE void access(volatile void *p, int sz, int rw) {
   if (rw) {
     switch (sz) {
-    case 0: __sanitizer_unaligned_store16(p, 0); break;
-    case 1: __sanitizer_unaligned_store32(p, 0); break;
-    case 2: __sanitizer_unaligned_store64(p, 0); break;
+    case 0: __sanitizer_unaligned_store16((void *)p, 0); break;
+    case 1: __sanitizer_unaligned_store32((void *)p, 0); break;
+    case 2: __sanitizer_unaligned_store64((void *)p, 0); break;
     default: exit(1);
     }
   } else {
     switch (sz) {
-    case 0: __sanitizer_unaligned_load16(p); break;
-    case 1: __sanitizer_unaligned_load32(p); break;
-    case 2: __sanitizer_unaligned_load64(p); break;
+    case 0: __sanitizer_unaligned_load16((void *)p); break;
+    case 1: __sanitizer_unaligned_load32((void *)p); break;
+    case 2: __sanitizer_unaligned_load64((void *)p); break;
     default: exit(1);
     }
   }
 }
 
 static int accesssize(int sz) {
   switch (sz) {
   case 0: return 2;