[lsan] [aarch64] Fix printing of pointers in make check tests

[spetrovic]

Summary

This patch replaces fprintf with print_address function in LSAN tests. This is necessary because of different printing of pointers in fprintf and sanitizer's print function. After this patch is committed, we can enable make check-lsan option on aarch64 architecture.

[peter.smith]

This looks good to me. I can't see any problems with changing from fprintf.

[kcc]

This does not look good to me
Why would lsan tests include ../../tsan/test.h ?

At the very least this header should be moved into a common dir

[spetrovic]

In tsan/test.h is function print_address, I didn't see any common folder with header files in santizer tests, so I take this function from tsan.h. Do you have proposal for the common place ?

[kcc]

In D25270#577464, @spetrovic wrote:

In tsan/test.h is function print_address, I didn't see any common folder with header files in santizer tests, so I take this function from tsan.h. Do you have proposal for the common place ?

I would create a separate header file with print_address in test/sanitizer_common

[kcc]

Ping?
This is a minor problem but I don't like that the change was made and reviewed by non-owners and the problem is not being fixed.

[spetrovic]

Comments addressed.

[kcc]

This patch was already submitted, so no reason to update the review here.
Please create a separate patch.

test/lsan/TestCases/cleanup_in_tsd_destructor.c

 // Regression test for thread lifetime tracking. Thread data should be
 // considered live during the thread's termination, at least until the
 // user-installed TSD destructors have finished running (since they may contain
 // additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it
 // makes its best effort.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0"
 // RUN: %clang_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=1 %run %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=0 not %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 pthread_key_t key;
 __thread void *p;
 
 void key_destructor(void *arg) {
   // Generally this may happen on a different thread.
   __lsan_do_leak_check();
 }

test/lsan/TestCases/large_allocation_leak.cc

 // Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 int main() {
   // maxsize in primary allocator is always less than this (1 << 25).
   void *large_alloc = malloc(33554432);
   print_address("Test alloc: ", 1, large_alloc);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (33554432 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/pointer_to_self.cc

 // Regression test: pointers to self should not confuse LSan into thinking the
 // object is indirectly leaked. Only external pointers count.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 int main() {
   void *p = malloc(1337);
   *reinterpret_cast<void **>(p) = p;
   print_address("Test alloc: ", 1, p);
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/stale_stack_leak.cc

 // Test that out-of-scope local variables are ignored by LSan.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=1"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE":exitcode=0" %run %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 void **pp;
 
 // Put pointer far enough on the stack that LSan has space to run in without
 // overwriting it.
 // Hopefully the argument p will be passed on a register, saving us from false
 // negatives.
 __attribute__((noinline))

test/lsan/TestCases/use_after_return.cc

 // Test that fake stack (introduced by ASan's use-after-return mode) is included
 // in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0"
 // RUN: %clangxx_lsan %s -O2 -o %t
 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS="" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 int main() {
   void *stack_var = malloc(1337);
   print_address("Test alloc: ", 1, stack_var);
   // Take pointer to variable, to ensure it's not optimized into a register.
   print_address("Stack var at: ", 1, &stack_var);
   // Do not return from main to prevent the pointer from going out of scope.
   exit(0);
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_globals_initialized.cc

 // Test that initialized globals are included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 void *data_var = (void *)1;
 
 int main() {
   data_var = malloc(1337);
   print_address("Test alloc: ", 1, data_var);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_globals_uninitialized.cc

 // Test that uninitialized globals are included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 void *bss_var;
 
 int main() {
   bss_var = malloc(1337);
   print_address("Test alloc: ", 1, bss_var);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_poisoned_asan.cc

 // ASan-poisoned memory should be ignored if use_poisoned is false.
 // REQUIRES: asan
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=1" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <sanitizer/asan_interface.h>
 #include <assert.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 void **p;
 
 int main() {
   p = new void *;
   *p = malloc(1337);
   print_address("Test alloc: ", 1, *p);
   __asan_poison_memory_region(p, sizeof(*p));
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: AddressSanitizer:

test/lsan/TestCases/use_registers.cc

 // Test that registers of running threads are included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0"
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 extern "C"
 void *registers_thread_func(void *arg) {
   int *sync = reinterpret_cast<int *>(arg);
   void *p = malloc(1337);
   // To store the pointer, choose a register which is unlikely to be reused by
   // a function call.
 #if defined(__i386__)

test/lsan/TestCases/use_stacks.cc

 // Test that stack of main thread is included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 int main() {
   void *stack_var = malloc(1337);
   print_address("Test alloc: ", 1, stack_var);
   // Do not return from main to prevent the pointer from going out of scope.
   exit(0);
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_stacks_threaded.cc

 // Test that stacks of non-main threads are included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0"
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 extern "C"
 void *stacks_thread_func(void *arg) {
   int *sync = reinterpret_cast<int *>(arg);
   void *p = malloc(1337);
   print_address("Test alloc: ", 1, p);
   fflush(stderr);
   __sync_fetch_and_xor(sync, 1);

test/lsan/TestCases/use_tls_dynamic.cc

 // Test that dynamically allocated TLS space is included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0:use_ld_allocations=0"
 // RUN: %clangxx %s -DBUILD_DSO -fPIC -shared -o %t-so.so
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #ifndef BUILD_DSO
 #include <assert.h>
 #include <dlfcn.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 int main(int argc, char *argv[]) {
   std::string path = std::string(argv[0]) + "-so.so";
 
   void *handle = dlopen(path.c_str(), RTLD_LAZY);
   assert(handle != 0);
   typedef void **(* store_t)(void *p);
   store_t StoreToTLS = (store_t)dlsym(handle, "StoreToTLS");

test/lsan/TestCases/use_tls_pthread_specific_dynamic.cc

 // Test that dynamically allocated thread-specific storage is included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 // From glibc: this many keys are stored in the thread descriptor directly.
 const unsigned PTHREAD_KEY_2NDLEVEL_SIZE = 32;
 
 int main() {
   static const unsigned kDummyKeysCount = PTHREAD_KEY_2NDLEVEL_SIZE;
   int res;
   pthread_key_t dummy_keys[kDummyKeysCount];

test/lsan/TestCases/use_tls_pthread_specific_static.cc

 // Test that statically allocated thread-specific storage is included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 // From glibc: this many keys are stored in the thread descriptor directly.
 const unsigned PTHREAD_KEY_2NDLEVEL_SIZE = 32;
 
 int main() {
   pthread_key_t key;
   int res;
   res = pthread_key_create(&key, NULL);

test/lsan/TestCases/use_tls_static.cc

 // Test that statically allocated TLS space is included in the root set.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
 // RUN: LSAN_OPTIONS="" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 __thread void *tls_var;
 
 int main() {
   tls_var = malloc(1337);
   print_address("Test alloc: ", 1, tls_var);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_unaligned.cc

 // Test that unaligned pointers are detected correctly.
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=0" not %run %t 2>&1 | FileCheck %s
 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=1" %run %t 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "../../tsan/test.h"
+#include "print_address.h"
 
 void *arr[2];
 
 int main() {
   void *p = malloc(1337);
   print_address("Test alloc: ", 1, p);
   char *char_arr = (char *)arr;
   memcpy(char_arr + 1, &p, sizeof(p));
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/lit.common.cfg

elif lsan_lit_test_mode == "AddressSanitizer":
   lsan_cflags = ["-fsanitize=address"]
   config.available_features.add('asan')
 else:
   lit_config.fatal("Unknown LSan test mode: %r" % lsan_lit_test_mode)
 config.name += config.name_suffix
 
 clang_cflags = ["-O0", config.target_cflags] + config.debug_info_flags
 clang_cxxflags = config.cxx_mode_flags + clang_cflags
-clang_lsan_cflags = clang_cflags + lsan_cflags
-clang_lsan_cxxflags = clang_cxxflags + lsan_cflags
+lsan_incdir = config.test_source_root + "/../sanitizer_common/"
+clang_lsan_cflags = clang_cflags + lsan_cflags + ["-I%s" % lsan_incdir]
+clang_lsan_cxxflags = clang_cxxflags + lsan_cflags + ["-I%s" % lsan_incdir]
 
 config.clang_cflags = clang_cflags
 config.clang_cxxflags = clang_cxxflags
 
 def build_invocation(compile_flags):
   return " " + " ".join([config.clang] + compile_flags) + " "
 
 config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )

test/sanitizer_common/print_address.h

+#include <stdio.h>
+#include <stdarg.h>
+
+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__) || defined(__powerpc64__)
+    // 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) p);
+#endif
+  }
+  fprintf(stderr, "\n");
+}

test/tsan/deadlock_detector_stress_test.cc

 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadMutex
 // RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOT-SECOND
 // RUN: %env_tsan_opts=detect_deadlocks=1:second_deadlock_stack=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SECOND
 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadSpinLock
 // RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s
 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRWLock
 // RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RD
 // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRecursiveMutex
 // RUN: %env_tsan_opts=detect_deadlocks=1 %deflake %run %t | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-REC
 #include "test.h"
 #undef NDEBUG
 #include <assert.h>
 #include <new>
+#include "print_address.h"
 
 #ifndef LockType
 #define LockType PthreadMutex
 #endif
 
 // You can optionally pass [test_number [iter_count]] on command line.
 static int test_number = -1;
 static int iter_count = 100000;

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"
+#include "print_address.h"
 
 int GlobalData[10];
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
   GlobalData[2] = 42;
   return 0;
 }

test/tsan/global_race2.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
+#include "print_address.h"
 
 int x;
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
   x = 1;
   return 0;
 }

test/tsan/global_race3.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
+#include "print_address.h"
 
 namespace XXX {
   struct YYY {
     static int ZZZ[10];
   };
   int YYY::ZZZ[10];
 }
 

test/tsan/lit.cfg

else:
   extra_cflags = []
 
 # Setup default compiler flags used with -fsanitize=thread option.
 clang_tsan_cflags = (["-fsanitize=thread",
                       "-Wall"] +
                       [config.target_cflags] +
                       config.debug_info_flags +
                       extra_cflags)
-clang_tsan_cxxflags = config.cxx_mode_flags + clang_tsan_cflags + ["-std=c++11"]
+tsan_incdir = config.test_source_root + "/../sanitizer_common/"
+clang_tsan_cxxflags = config.cxx_mode_flags + clang_tsan_cflags + ["-std=c++11"] + ["-I%s" % tsan_incdir]
 # Add additional flags if we're using instrumented libc++.
 # Instrumented libcxx currently not supported on Darwin.
 if config.has_libcxx and config.host_os != 'Darwin':
   # FIXME: Dehardcode this path somehow.
   libcxx_path = os.path.join(config.compiler_rt_obj_root, "lib",
                              "tsan", "libcxx_tsan_" + config.target_arch)
   libcxx_incdir = os.path.join(libcxx_path, "include", "c++", "v1")
   libcxx_libdir = os.path.join(libcxx_path, "lib")

test/tsan/memcmp_race.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
 #include <string.h>
+#include "print_address.h"
 
 char *data0 = new char[10];
 char *data1 = new char[10];
 char *data2 = new char[10];
 
 void *Thread1(void *x) {
   static volatile int size = 1;
   static volatile int sink;

test/tsan/memcpy_race.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
 #include <string.h>
+#include "print_address.h"
 
 char *data = new char[10];
 char *data1 = new char[10];
 char *data2 = new char[10];
 
 void *Thread1(void *x) {
   static volatile int size = 1;
   memcpy(data+5, data1, size);

test/tsan/mop_with_offset.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
+#include "print_address.h"
 
 void *Thread1(void *x) {
   int *p = (int*)x;
   p[0] = 1;
   barrier_wait(&barrier);
   return NULL;
 }
 

test/tsan/mop_with_offset2.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
+#include "print_address.h"
 
 void *Thread1(void *x) {
   barrier_wait(&barrier);
   int *p = (int*)x;
   p[0] = 1;
   return NULL;
 }
 

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"
+#include "print_address.h"
 
 void *Thread1(void *p) {
   *(int*)p = 42;
   return 0;
 }
 
 void *Thread2(void *p) {
   *(int*)p = 44;

test/tsan/test.h

 
 static inline void barrier_wait(invisible_barrier_t *barrier) {
   __tsan_testonly_barrier_wait(barrier);
 }
 
 // Default instance of the barrier, but a test can declare more manually.
 invisible_barrier_t barrier;
 
-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__) || defined(__powerpc64__)
-    // 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) 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() {