[compiler-rt] Remove SANITIZER_AARCH64_VMA usage

[zatrazz]

Summary

This patch complete removed SANITIZER_AARCH64_VMA definition and usage.
AArch64 ports now supports runtime VMA detection and instrumentation
for 39 and 42-bit VMA.

It also cleans up the pointer print and check on tsan by using the 'print_address'
function where required (instead of using the naked %p format).

[dvyukov]

test/tsan/race_on_heap.cc

31

This is quite clumsy.

Please change print_format to always print "name=ptr\n" and so that name is function argument:

print_address("addr", p);

This will cover most of cases, and simplify the rest.

[zatrazz]

Changes from previous version:

• Rewrite print_address to take a variadic argument list (the addresses to print);
• Adjust the tests to new print_address signature.

lib/sanitizer_common/sanitizer_platform.h

 #endif
 
 #if defined(__x86_64__) && !defined(_LP64)
 # define SANITIZER_X32 1
 #else
 # define SANITIZER_X32 0
 #endif
 
-// VMA size definition for architecture that support multiple sizes.
-// AArch64 has 3 VMA sizes: 39, 42 and 48.
-#if !defined(SANITIZER_AARCH64_VMA)
-# define SANITIZER_AARCH64_VMA 39
-#else
-# if SANITIZER_AARCH64_VMA != 39 && SANITIZER_AARCH64_VMA != 42
-#  error "invalid SANITIZER_AARCH64_VMA size"
-# endif
-#endif
-
 // By default we allow to use SizeClassAllocator64 on 64-bit platform.
 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
 // does not work well and we need to fallback to SizeClassAllocator32.
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
 # if defined(__mips64) || defined(__aarch64__)
 #  define SANITIZER_CAN_USE_ALLOCATOR64 0

 // Since we don't want to include libc headers here, we check the
 // target only.
 #if defined(__arm__) || SANITIZER_X32 || defined(__sparc__)
 #define SANITIZER_USES_UID16_SYSCALLS 1
 #else
 #define SANITIZER_USES_UID16_SYSCALLS 0
 #endif
 
-#if defined(__mips__) || (defined(__aarch64__) && SANITIZER_AARCH64_VMA == 39)
+#if defined(__mips__)
 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10)
-#elif defined(__aarch64__) && SANITIZER_AARCH64_VMA == 42
-# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 11)
 #else
 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12)
 #endif
 
 // Assume obsolete RPC headers are available by default
 #if !defined(HAVE_RPC_XDR_H) && !defined(HAVE_TIRPC_RPC_XDR_H)
 # define HAVE_RPC_XDR_H (SANITIZER_LINUX && !SANITIZER_ANDROID)
 # define HAVE_TIRPC_RPC_XDR_H 0

lib/sanitizer_common/sanitizer_posix.cc

 
 SignalContext SignalContext::Create(void *siginfo, void *context) {
   uptr addr = (uptr)((siginfo_t*)siginfo)->si_addr;
   uptr pc, sp, bp;
   GetPcSpBp(context, &pc, &sp, &bp);
   return SignalContext(context, addr, pc, sp, bp);
 }
 
-// This function check is the built VMA matches the runtime one for
-// architectures with multiple VMA size.
-void CheckVMASize() {
-#ifdef __aarch64__
-  static const unsigned kBuiltVMA = SANITIZER_AARCH64_VMA;
-  unsigned maxRuntimeVMA =
-    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
-  if (kBuiltVMA != maxRuntimeVMA) {
-    Printf("WARNING: %s runtime VMA is not the one built for.\n",
-      SanitizerToolName);
-    Printf("\tBuilt VMA:   %u bits\n", kBuiltVMA);
-    Printf("\tRuntime VMA: %u bits\n", maxRuntimeVMA);
-  }
-#endif
-}
-
 } // namespace __sanitizer
 
 #endif // SANITIZER_POSIX

test/tsan/Darwin/symbolizer-atos.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %env_tsan_opts=verbosity=2:external_symbolizer_path=/usr/bin/atos %deflake %run %t | FileCheck %s
 #include "../test.h"
 
 int GlobalData[10];
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
   GlobalData[2] = 42;
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr=");
-  print_address(GlobalData);
-  fprintf(stderr, "\n");
+  print_address("addr=", 1, GlobalData);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   GlobalData[2] = 43;
   barrier_wait(&barrier);
   pthread_join(t, 0);
 }
 
 // CHECK: Using atos at user-specified path: /usr/bin/atos
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: Location is global 'GlobalData' at [[ADDR]] ({{.*}}+0x{{[0-9,a-f]+}})

test/tsan/Darwin/symbolizer-dladdr.cc

 // RUN: %clangxx_tsan %s -o %t
 // RUN: %env_tsan_opts=verbosity=2:external_symbolizer_path= %deflake %run %t | FileCheck %s
 #include "../test.h"
 
 int GlobalData[10];
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
   GlobalData[2] = 42;
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr=");
-  print_address(GlobalData);
-  fprintf(stderr, "\n");
+  print_address("addr=", 1, GlobalData);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   GlobalData[2] = 43;
   barrier_wait(&barrier);
   pthread_join(t, 0);
 }
 
 // CHECK: External symbolizer is explicitly disabled.
 // CHECK: Using dladdr symbolizer.
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: Location is global 'GlobalData' at [[ADDR]] ({{.*}}+0x{{[0-9,a-f]+}})

test/tsan/deadlock_detector_stress_test.cc

public:
   }
 
   // Simple lock order onversion.
   void Test1() {
     if (test_number > 0 && test_number != 1) return;
     fprintf(stderr, "Starting Test1\n");
     // CHECK: Starting Test1
     Init(5);
-    fprintf(stderr, "Expecting lock inversion: %p %p\n", A(0), A(1));
+    print_address("Expecting lock inversion: ", 2, A(0), A(1));
     // CHECK: Expecting lock inversion: [[A1:0x[a-f0-9]*]] [[A2:0x[a-f0-9]*]]
     Lock_0_1();
     Lock_1_0();
     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
     // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ([[A1]]) => [[M2:M[0-9]+]] ([[A2]]) => [[M1]]
     // CHECK: Mutex [[M2]] acquired here while holding mutex [[M1]]
     // CHECK:   #0 pthread_
     // CHECK-SECOND:   Mutex [[M1]] previously acquired by the same thread here:
public:
   }
 
   // Simple lock order inversion with 3 locks.
   void Test2() {
     if (test_number > 0 && test_number != 2) return;
     fprintf(stderr, "Starting Test2\n");
     // CHECK: Starting Test2
     Init(5);
-    fprintf(stderr, "Expecting lock inversion: %p %p %p\n", A(0), A(1), A(2));
+    print_address("Expecting lock inversion: ", 3, A(0), A(1), A(2));
     // CHECK: Expecting lock inversion: [[A1:0x[a-f0-9]*]] [[A2:0x[a-f0-9]*]] [[A3:0x[a-f0-9]*]]
     Lock2(0, 1);
     Lock2(1, 2);
     Lock2(2, 0);
     // CHECK: WARNING: ThreadSanitizer: lock-order-inversion (potential deadlock)
     // CHECK: Cycle in lock order graph: [[M1:M[0-9]+]] ([[A1]]) => [[M2:M[0-9]+]] ([[A2]]) => [[M3:M[0-9]+]] ([[A3]]) => [[M1]]
     // CHECK-NOT: WARNING: ThreadSanitizer:
   }

test/tsan/global_race.cc

 // RUN: %clangxx_tsan -O1 %s -o %T/global_race.cc.exe && %deflake %run %T/global_race.cc.exe | FileCheck %s
 #include "test.h"
 
 int GlobalData[10];
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
   GlobalData[2] = 42;
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr=");
-  print_address(GlobalData);
-  fprintf(stderr, "\n");
+  print_address("addr=", 1, GlobalData);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   GlobalData[2] = 43;
   barrier_wait(&barrier);
   pthread_join(t, 0);
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: Location is global 'GlobalData' {{(of size 40 )?}}at [[ADDR]] (global_race.cc.exe+0x{{[0-9,a-f]+}})
 

test/tsan/global_race2.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
 
 int x;
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
   x = 1;
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr2=");
-  print_address(&x);
-  fprintf(stderr, "\n");
+  print_address("addr2=", 1, &x);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   x = 0;
   barrier_wait(&barrier);
   pthread_join(t, 0);
 }
 
 // CHECK: addr2=[[ADDR2:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: Location is global 'x' {{(of size 4 )?}}at [[ADDR2]] ({{.*}}+0x{{[0-9,a-f]+}})
 

test/tsan/global_race3.cc

 void *Thread(void *a) {
   barrier_wait(&barrier);
   XXX::YYY::ZZZ[0] = 1;
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr3=");
-  print_address(XXX::YYY::ZZZ);
-  fprintf(stderr, "\n");
+  print_address("addr3=", 1, XXX::YYY::ZZZ);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   XXX::YYY::ZZZ[0] = 0;
   barrier_wait(&barrier);
   pthread_join(t, 0);
 }
 
 // CHECK: addr3=[[ADDR3:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: Location is global 'XXX::YYY::ZZZ' {{(of size 40 )?}}at [[ADDR3]] ({{.*}}+0x{{[0-9,a-f]+}})

test/tsan/memcmp_race.cc

void *Thread2(void *x) {
   static volatile int size = 4;
   barrier_wait(&barrier);
   memcpy(data0+5, data2, size);
   return NULL;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr=%p\n", &data0[5]);
+  print_address("addr=", 1, &data0[5]);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   return 0;
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 1 at [[ADDR]] by thread T2:
 // CHECK:     #0 {{(memcpy|memmove)}}
 // CHECK:     #1 Thread2
 // CHECK:   Previous read of size 1 at [[ADDR]] by thread T1:
 // CHECK:     #0 memcmp
 // CHECK:     #1 Thread1

test/tsan/memcpy_race.cc

void *Thread2(void *x) {
   static volatile int size = 4;
   barrier_wait(&barrier);
   memcpy(data+3, data2, size);
   return NULL;
 }
 
 int main() {
   barrier_init(&barrier, 2);
-  fprintf(stderr, "addr=%p\n", &data[5]);
+  print_address("addr=", 1, &data[5]);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   return 0;
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 1 at [[ADDR]] by thread T2:
 // CHECK:     #0 {{(memcpy|memmove)}}
 // CHECK:     #1 Thread2
 // CHECK:   Previous write of size 1 at [[ADDR]] by thread T1:
 // CHECK:     #0 {{(memcpy|memmove)}}
 // CHECK:     #1 Thread1

test/tsan/mop_with_offset.cc

void *Thread2(void *x) {
   char *p = (char*)x;
   p[2] = 1;
   return NULL;
 }
 
 int main() {
   barrier_init(&barrier, 2);
   int *data = new int(42);
-  fprintf(stderr, "ptr1=%p\n", data);
-  fprintf(stderr, "ptr2=%p\n", (char*)data + 2);
+  print_address("ptr1=", 1, data);
+  print_address("ptr2=", 1, (char*)data + 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, data);
   pthread_create(&t[1], NULL, Thread2, data);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   delete data;
 }
 
 // CHECK: ptr1=[[PTR1:0x[0-9,a-f]+]]
 // CHECK: ptr2=[[PTR2:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 1 at [[PTR2]] by thread T2:
 // CHECK:   Previous write of size 4 at [[PTR1]] by thread T1:

test/tsan/mop_with_offset2.cc

void *Thread2(void *x) {
   p[2] = 1;
   barrier_wait(&barrier);
   return NULL;
 }
 
 int main() {
   barrier_init(&barrier, 2);
   int *data = new int(42);
-  fprintf(stderr, "ptr1=%p\n", data);
-  fprintf(stderr, "ptr2=%p\n", (char*)data + 2);
+  print_address("ptr1=", 1, data);
+  print_address("ptr2=", 1, (char*)data + 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, data);
   pthread_create(&t[1], NULL, Thread2, data);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   delete data;
 }
 
 // CHECK: ptr1=[[PTR1:0x[0-9,a-f]+]]
 // CHECK: ptr2=[[PTR2:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 4 at [[PTR1]] by thread T1:
 // CHECK:   Previous write of size 1 at [[PTR2]] by thread T2:

test/tsan/race_on_heap.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include "test.h"
 
 void *Thread1(void *p) {
   *(int*)p = 42;
   return 0;
 }
 
 void *Thread2(void *p) {
   *(int*)p = 44;
   return 0;
 }
 
 void *alloc() {
   return malloc(99);
 }
 
 void *AllocThread(void* arg) {
   return alloc();
 }
 
 int main() {
   void *p = 0;
   pthread_t t[2];
   pthread_create(&t[0], 0, AllocThread, 0);
   pthread_join(t[0], &p);
-  fprintf(stderr, "addr=%p\n", p);
+  print_address("addr=", 1, p);
   pthread_create(&t[0], 0, Thread1, (char*)p + 16);
   pthread_create(&t[1], 0, Thread2, (char*)p + 16);
   pthread_join(t[0], 0);
   pthread_join(t[1], 0);
   return 0;
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race

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>
 
 #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).
for (;;) {
     // sleep" messages which fail some output tests.
     sched_yield();
   }
 }
 
 // Default instance of the barrier, but a test can declare more manually.
 invisible_barrier_t barrier;
 
-void print_address(void *address) {
-// On FreeBSD, the %p conversion specifier works as 0x%x and thus does not match
-// to the format used in the diagnotic message.
-#ifdef __x86_64__
-  fprintf(stderr, "0x%012lx", (unsigned long) address);
+void print_address(const char *str, int n, ...) {
+  fprintf(stderr, "%s", str);
+  va_list ap;
+  va_start(ap, n);
+  while (n--) {
+    void *p = va_arg(ap, void *);
+#if defined(__x86_64__) || defined(__aarch64__)
+    // On FreeBSD, the %p conversion specifier works as 0x%x and thus does not
+    // match to the format used in the diagnotic message.
+    fprintf(stderr, "0x%012lx ", (unsigned long) p);
 #elif defined(__mips64)
-  fprintf(stderr, "0x%010lx", (unsigned long) address);
-#elif defined(__aarch64__)
-  // AArch64 currently has 3 different VMA (39, 42, and 48 bits) and it requires
-  // different pointer size to match the diagnostic message.
-  const char *format = 0;
-  unsigned long vma = (unsigned long)__builtin_frame_address(0);
-  vma = 64 - __builtin_clzll(vma);
-  if (vma == 39)
-    format = "0x%010lx";
-  else if (vma == 42)
-    format = "0x%011lx";
-  else {
-    fprintf(stderr, "unsupported vma: %lu\n", vma);
-    exit(1);
-  }
-
-  fprintf(stderr, format, (unsigned long) address);
+    fprintf(stderr, "0x%010lx ", (unsigned long) p);
 #endif
   }
+  fprintf(stderr, "\n");
+}
 
 #ifdef __APPLE__
 unsigned long long monotonic_clock_ns() {
   static mach_timebase_info_data_t timebase_info;
   if (timebase_info.denom == 0) mach_timebase_info(&timebase_info);
   return (mach_absolute_time() * timebase_info.numer) / timebase_info.denom;
 }
 #else
 unsigned long long monotonic_clock_ns() {
   struct timespec t;
   clock_gettime(CLOCK_MONOTONIC, &t);
   return (unsigned long long)t.tv_sec * 1000000000ull + t.tv_nsec;
 }
 #endif