[compiler] [tsan] Enable tsan for aarch64

[zatrazz]

Summary

This patch enabled TSAN for aarch64 with 39-bit VMA layout. As defined by
tsan_platform.h the layout used is:

0000 4000 00 - 0200 0000 00: main binary
2000 0000 00 - 4000 0000 00: shadow memory
4000 0000 00 - 5000 0000 00: metainfo
5000 0000 00 - 6000 0000 00: -
6000 0000 00 - 6200 0000 00: traces
6200 0000 00 - 7d00 0000 00: -
7d00 0000 00 - 7e00 0000 00: heap
7e00 0000 00 - 7fff ffff ff: modules and main thread stack

Which gives it about 8GB for main binary, 4GB for heap and 8GB for
modules and main thread stack.

Most of tests are passing, with the execption of:

• ignore_lib0, ignore_lib1, ignore_lib3 due a kernel limitation for no support to make mmap page non-executable.
• longjmp tests due missing specialized assembly routines.

These tests are xfail for now. The only tsan issue still showing is:

rtl/TsanRtlTest/Posix.ThreadLocalAccesses

Which still required further investigation.

[rengolin]

cmake/config-ix.cmake

263

If you enable this by default, and there's still one test failing, the AArch64 buildbot will break.

[eugenis]

Great job! I'll leave the real review to Dmitry. Just a few comments inline.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

267

Looks like this if() is unnecessary, here and above.

299

Clang does not recognize this builtin on aarch64. It looks like it only exists on arm. Are you building with gcc?

[rengolin]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

299

shouldn't be too hard to implement that, now that we have direct access to reading and writing to specific special registers.

[zatrazz]

Hi Renato,

Thanks for review it.

[zatrazz]

Hi Evgeniy,

Thanks for the review.

[rengolin]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

299

This is now supported in Clang and LLVM.

[zatrazz]

Updated patch now that __builtin_thread_pointer is supported on clang/llvm. I also disabled the 'rtl/TsanRtlTest/Posix.ThreadLocalAccesses' for now, since it shows failures with high thread number (current 8, with 4 it shows no issue).

[rengolin]

lib/tsan/tests/rtl/tsan_posix.cc

95

Don't need to add your name to a TODO. :)

Also, we normally use FIXME.

[dvyukov]

Please reupload the change with full context, obtain the diff with:
$ svn diff --diff-cmd=diff -x -U999999

lib/sanitizer_common/sanitizer_linux_libcdep.cc

198

Please use a constant instead of macro:

const uptr kStackAlign = 16;

212

Why did you remove !SANITIZER_GO?

[zatrazz]

Update patch with full-context, change to use a constant to define the stack requirement and undo a comment removal.

[dvyukov]

LGTM
This is awesome!
Thank you

cmake/config-ix.cmake

filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
   ${SANITIZER_COMMON_SUPPORTED_ARCH})
 filter_available_targets(ASAN_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 powerpc64le arm mips mipsel mips64 mips64el aarch64)
 filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64 mips64 mips64el aarch64)
 filter_available_targets(LSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 filter_available_targets(MSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 filter_available_targets(PROFILE_SUPPORTED_ARCH x86_64 i386 i686 arm mips mips64
   mipsel mips64el aarch64 powerpc64 powerpc64le)
-filter_available_targets(TSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
+filter_available_targets(TSAN_SUPPORTED_ARCH x86_64 mips64 mips64el aarch64)
 filter_available_targets(UBSAN_SUPPORTED_ARCH x86_64 i386 i686 arm aarch64 mips
   mipsel mips64 mips64el powerpc64 powerpc64le)
 filter_available_targets(SAFESTACK_SUPPORTED_ARCH x86_64 i386 i686)
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")

lib/sanitizer_common/sanitizer_linux.h

 // Linux-only syscalls.
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 // Used only by sanitizer_stoptheworld. Signal handlers that are actually used
 // (like the process-wide error reporting SEGV handler) must use
 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
-#if defined(__x86_64__) || defined(__mips__)
+#if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);
 #endif
 #endif  // SANITIZER_LINUX
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
  public:

lib/sanitizer_common/sanitizer_linux.cc

#endif
                          "r"(parent_tidptr),
                          "r"(a3),
                          "r"(a4),
                          "i"(__NR_clone),
                          "i"(__NR_exit)
                        : "memory", "$29" );
   return res;
 }
+#elif defined(__aarch64__)
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  long long res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
+  ((unsigned long long *)child_stack)[0] = (uptr)fn;
+  ((unsigned long long *)child_stack)[1] = (uptr)arg;
+
+  register int (*__fn)(void *)  __asm__("x0") = fn;
+  register void *__stack __asm__("x1") = child_stack;
+  register int   __flags __asm__("x2") = flags;
+  register void *__arg   __asm__("x3") = arg;
+  register int  *__ptid  __asm__("x4") = parent_tidptr;
+  register void *__tls   __asm__("x5") = newtls;
+  register int  *__ctid  __asm__("x6") = child_tidptr;
+
+  __asm__ __volatile__(
+                       "mov x0,x2\n" /* flags  */
+                       "mov x2,x4\n" /* ptid  */
+                       "mov x3,x5\n" /* tls  */
+                       "mov x4,x6\n" /* ctid  */
+                       "mov x8,%9\n" /* clone  */
+
+                       "svc 0x0\n"
+
+                       /* if (%r0 != 0)
+                        *   return %r0;
+                        */
+                       "cmp x0, #0\n"
+                       "bne 1f\n"
+
+                       /* In the child, now. Call "fn(arg)". */
+                       "ldp x1, x0, [sp], #16\n"
+                       "blr x1\n"
+
+                       /* Call _exit(%r0).  */
+                       "mov x8, %10\n"
+                       "svc 0x0\n"
+                     "1:\n"
+
+                       : "=r" (res)
+                       : "i"(-EINVAL),
+                         "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg),
+                         "r"(__ptid), "r"(__tls), "r"(__ctid),
+                         "i"(__NR_clone), "i"(__NR_exit)
+                       : "x30", "memory");
+  return res;
+}
 #endif  // defined(__x86_64__) && SANITIZER_LINUX
 
 #if SANITIZER_ANDROID
 #define PROP_VALUE_MAX 92
 extern "C" SANITIZER_WEAK_ATTRIBUTE int __system_property_get(const char *name,
                                                               char *value);
 void GetExtraActivationFlags(char *buf, uptr size) {
   CHECK(size > PROP_VALUE_MAX);

lib/sanitizer_common/sanitizer_linux_libcdep.cc

static uptr TlsPreTcbSize() {
   InitTlsSize();
   g_tls_size = (g_tls_size + kTlsPreTcbSize + kTlsAlign -1) & ~(kTlsAlign - 1);
   return kTlsPreTcbSize;
 }
 #endif
 
 void InitTlsSize() {
 #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
+// all current supported platforms have 16 bytes stack alignment
+  const size_t kStackAlign = 16;
   typedef void (*get_tls_func)(size_t*, size_t*) DL_INTERNAL_FUNCTION;
   get_tls_func get_tls;
   void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
   CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr));
   internal_memcpy(&get_tls, &get_tls_static_info_ptr,
                   sizeof(get_tls_static_info_ptr));
   CHECK_NE(get_tls, 0);
   size_t tls_size = 0;
   size_t tls_align = 0;
   get_tls(&tls_size, &tls_align);
-  g_tls_size = tls_size;
+  if (tls_align < kStackAlign)
+    tls_align = kStackAlign;
+  g_tls_size = RoundUpTo(tls_size, tls_align);
 #endif  // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
 }
 
-#if (defined(__x86_64__) || defined(__i386__) || defined(__mips__)) \
+#if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) \
+    || defined(__aarch64__)) \
     && SANITIZER_LINUX
 // sizeof(struct thread) from glibc.
 static atomic_uintptr_t kThreadDescriptorSize;
 
 uptr ThreadDescriptorSize() {
   uptr val = atomic_load(&kThreadDescriptorSize, memory_order_relaxed);
   if (val)
     return val;
#ifdef _CS_GNU_LIBC_VERSION
   }
 #endif
 #elif defined(__mips__)
   // TODO(sagarthakur): add more values as per different glibc versions.
   val = FIRST_32_SECOND_64(1152, 1776);
   if (val)
     atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
   return val;
+#elif defined(__aarch64__)
+  // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
+  val = 1776;
+  atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
+  return val;
 #endif
   return 0;
 }
 
 // The offset at which pointer to self is located in the thread descriptor.
 const uptr kThreadSelfOffset = FIRST_32_SECOND_64(8, 16);
 
 uptr ThreadSelfOffset() {
# elif defined(__mips__)
   // TCB and the size of pthread_descr.
   const uptr kTlsTcbOffset = 0x7000;
   uptr thread_pointer;
   asm volatile(".set push;\
                 .set mips64r2;\
                 rdhwr %0,$29;\
                 .set pop" : "=r" (thread_pointer));
   descr_addr = thread_pointer - kTlsTcbOffset - TlsPreTcbSize();
+# elif defined(__aarch64__)
+  descr_addr = reinterpret_cast<uptr>(__builtin_thread_pointer());
 # else
 #  error "unsupported CPU arch"
 # endif
   return descr_addr;
 }
 #endif  // (x86_64 || i386 || MIPS) && SANITIZER_LINUX
 
 #if SANITIZER_FREEBSD

 uptr ThreadSelf() {
   return (uptr)ThreadSelfSegbase()[2];
 }
 #endif  // SANITIZER_FREEBSD
 
 #if !SANITIZER_GO
 static void GetTls(uptr *addr, uptr *size) {
 #if SANITIZER_LINUX
-# if defined(__x86_64__) || defined(__i386__)
+# if defined(__x86_64__) || defined(__i386__) || defined(__aarch64__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
   *addr -= *size;
   *addr += ThreadDescriptorSize();
 # elif defined(__mips__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
 # else

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 //===-- sanitizer_stoptheworld_linux_libcdep.cc ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "sanitizer_platform.h"
-#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__))
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__) || \
+                        defined(__aarch64__))
 
 #include "sanitizer_stoptheworld.h"
 
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_atomic.h"
 
 #include <errno.h>
 #include <sched.h> // for CLONE_* definitions
 #include <stddef.h>
 #include <sys/prctl.h> // for PR_* definitions
 #include <sys/ptrace.h> // for PTRACE_* definitions
 #include <sys/types.h> // for pid_t
+#include <sys/uio.h> // for iovec
+#include <elf.h> // for NT_PRSTATUS
 #if SANITIZER_ANDROID && defined(__arm__)
 # include <linux/user.h>  // for pt_regs
 #else
 # include <sys/user.h>  // for user_regs_struct
 #endif
 #include <sys/wait.h> // for signal-related stuff
 
 #ifdef sa_handler

 #elif defined(__powerpc__) || defined(__powerpc64__)
 typedef pt_regs regs_struct;
 #define REG_SP gpr[PT_R1]
 
 #elif defined(__mips__)
 typedef struct user regs_struct;
 #define REG_SP regs[EF_REG29]
 
+#elif defined(__aarch64__)
+typedef struct user_pt_regs regs_struct;
+#define REG_SP sp
+#define ARCH_IOVEC_FOR_GETREGSET
+
 #else
 #error "Unsupported architecture"
 #endif // SANITIZER_ANDROID && defined(__arm__)
 
 int SuspendedThreadsList::GetRegistersAndSP(uptr index,
                                             uptr *buffer,
                                             uptr *sp) const {
   pid_t tid = GetThreadID(index);
   regs_struct regs;
   int pterrno;
-  if (internal_iserror(internal_ptrace(PTRACE_GETREGS, tid, NULL, &regs),
-                       &pterrno)) {
+#ifdef ARCH_IOVEC_FOR_GETREGSET
+  struct iovec regset_io;
+  regset_io.iov_base = &regs;
+  regset_io.iov_len = sizeof(regs_struct);
+  bool isErr = internal_iserror(internal_ptrace(PTRACE_GETREGSET, tid,
+                                (void*)NT_PRSTATUS, (void*)&regset_io),
+                                &pterrno);
+#else
+  bool isErr = internal_iserror(internal_ptrace(PTRACE_GETREGS, tid, NULL,
+                                &regs), &pterrno);
+#endif
+  if (isErr) {
     VReport(1, "Could not get registers from thread %d (errno %d).\n", tid,
             pterrno);
     return -1;
   }
 
   *sp = regs.REG_SP;
   internal_memcpy(buffer, &regs, sizeof(regs));
   return 0;
 }
 
 uptr SuspendedThreadsList::RegisterCount() {
   return sizeof(regs_struct) / sizeof(uptr);
 }
 }  // namespace __sanitizer
 
-#endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__))
+#endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__)
+        // || defined(__aarch64__)

lib/tsan/rtl/tsan_interceptors.cc

 };
 #else
 struct ucontext_t {
   // The size is determined by looking at sizeof of real ucontext_t on linux.
   u64 opaque[936 / sizeof(u64) + 1];
 };
 #endif
 
+#if defined(__x86_64__) || defined(__mips__)
+#define PTHREAD_ABI_BASE  "GLIBC_2.3.2"
+#elif defined(__aarch64__)
+#define PTHREAD_ABI_BASE  "GLIBC_2.17"
+#endif
+
 extern "C" int pthread_attr_init(void *attr);
 extern "C" int pthread_attr_destroy(void *attr);
 DECLARE_REAL(int, pthread_attr_getdetachstate, void *, void *)
 extern "C" int pthread_attr_setstacksize(void *attr, uptr stacksize);
 extern "C" int pthread_key_create(unsigned *key, void (*destructor)(void* v));
 extern "C" int pthread_setspecific(unsigned key, const void *v);
 DECLARE_REAL(int, pthread_mutexattr_gettype, void *, void *)
 extern "C" int pthread_yield();
#endif
   TSAN_INTERCEPT(strcpy);  // NOLINT
   TSAN_INTERCEPT(strncpy);
   TSAN_INTERCEPT(strdup);
 
   TSAN_INTERCEPT(pthread_create);
   TSAN_INTERCEPT(pthread_join);
   TSAN_INTERCEPT(pthread_detach);
 
-  TSAN_INTERCEPT_VER(pthread_cond_init, "GLIBC_2.3.2");
-  TSAN_INTERCEPT_VER(pthread_cond_signal, "GLIBC_2.3.2");
-  TSAN_INTERCEPT_VER(pthread_cond_broadcast, "GLIBC_2.3.2");
-  TSAN_INTERCEPT_VER(pthread_cond_wait, "GLIBC_2.3.2");
-  TSAN_INTERCEPT_VER(pthread_cond_timedwait, "GLIBC_2.3.2");
-  TSAN_INTERCEPT_VER(pthread_cond_destroy, "GLIBC_2.3.2");
+  TSAN_INTERCEPT_VER(pthread_cond_init, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_signal, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_broadcast, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_wait, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_timedwait, PTHREAD_ABI_BASE);
+  TSAN_INTERCEPT_VER(pthread_cond_destroy, PTHREAD_ABI_BASE);
 
   TSAN_INTERCEPT(pthread_mutex_init);
   TSAN_INTERCEPT(pthread_mutex_destroy);
   TSAN_INTERCEPT(pthread_mutex_trylock);
   TSAN_INTERCEPT(pthread_mutex_timedlock);
 
   TSAN_INTERCEPT(pthread_spin_init);
   TSAN_INTERCEPT(pthread_spin_destroy);

lib/tsan/rtl/tsan_platform.h

 const uptr kHeapMemEnd    = 0xff00000000ull;
 const uptr kLoAppMemBeg   = 0x0100000000ull;
 const uptr kLoAppMemEnd   = 0x0200000000ull;
 const uptr kHiAppMemBeg   = 0xff80000000ull;
 const uptr kHiAppMemEnd   = 0xffffffffffull;
 const uptr kAppMemMsk     = 0xfc00000000ull;
 const uptr kAppMemXor     = 0x0400000000ull;
 const uptr kVdsoBeg       = 0xfffff00000ull;
+#elif defined(__aarch64__)
+/*
+C/C++ on linux/aarch64 (39-bit VMA)
+0000 4000 00 - 0200 0000 00: main binary
[phone] - 4000 0000 00: shadow memory
[phone] - 5000 0000 00: metainfo
[phone] - 6000 0000 00: -
[phone] - 6200 0000 00: traces
[phone] - 7d00 0000 00: -
+7d00 0000 00 - 7e00 0000 00: heap
+7e00 0000 00 - 7fff ffff ff: modules and main thread stack
+*/
+const uptr kLoAppMemBeg   = 0x0000400000ull;
+const uptr kLoAppMemEnd   = 0x0200000000ull;
+const uptr kShadowBeg     = 0x2000000000ull;
+const uptr kShadowEnd     = 0x4000000000ull;
+const uptr kMetaShadowBeg = 0x4000000000ull;
+const uptr kMetaShadowEnd = 0x5000000000ull;
+const uptr kTraceMemBeg   = 0x6000000000ull;
+const uptr kTraceMemEnd   = 0x6200000000ull;
+const uptr kHeapMemBeg    = 0x7d00000000ull;
+const uptr kHeapMemEnd    = 0x7e00000000ull;
+const uptr kHiAppMemBeg   = 0x7e00000000ull;
+const uptr kHiAppMemEnd   = 0x7fffffffffull;
+const uptr kAppMemMsk     = 0x7800000000ull;
+const uptr kAppMemXor     = 0x0800000000ull;
+const uptr kVdsoBeg       = 0x7f00000000ull;
 #endif
 
 ALWAYS_INLINE
 bool IsAppMem(uptr mem) {
   return (mem >= kHeapMemBeg && mem < kHeapMemEnd) ||
          (mem >= kLoAppMemBeg && mem < kLoAppMemEnd) ||
          (mem >= kHiAppMemBeg && mem < kHiAppMemEnd);
 }

lib/tsan/rtl/tsan_platform_linux.cc

void InitializeShadowMemory() {
   // we see 20% memory usage reduction without huge pages for this range.
   // FIXME: don't use constants here.
 #if defined(__x86_64__)
   const uptr kMadviseRangeBeg  = 0x7f0000000000ull;
   const uptr kMadviseRangeSize = 0x010000000000ull;
 #elif defined(__mips64)
   const uptr kMadviseRangeBeg  = 0xff00000000ull;
   const uptr kMadviseRangeSize = 0x0100000000ull;
+#elif defined(__aarch64__)
+  const uptr kMadviseRangeBeg  = 0x7e00000000ull;
+  const uptr kMadviseRangeSize = 0x0100000000ull;
 #endif
   NoHugePagesInRegion(MemToShadow(kMadviseRangeBeg),
                       kMadviseRangeSize * kShadowMultiplier);
   // Meta shadow is compressing and we don't flush it,
   // so it makes sense to mark it as NOHUGEPAGE to not over-allocate memory.
   // On one program it reduces memory consumption from 5GB to 2.5GB.
   NoHugePagesInRegion(kMetaShadowBeg, kMetaShadowEnd - kMetaShadowBeg);
   if (common_flags()->use_madv_dontdump)

lib/tsan/rtl/tsan_rtl.h

 #if SANITIZER_WORDSIZE != 64
 # error "ThreadSanitizer is supported only on 64-bit platforms"
 #endif
 
 namespace __tsan {
 
 #ifndef SANITIZER_GO
 struct MapUnmapCallback;
-#ifdef __mips64
+#if defined(__mips64) || defined(__aarch64__)
 static const uptr kAllocatorSpace = 0;
 static const uptr kAllocatorSize = SANITIZER_MMAP_RANGE_SIZE;
 static const uptr kAllocatorRegionSizeLog = 20;
 static const uptr kAllocatorNumRegions =
     kAllocatorSize >> kAllocatorRegionSizeLog;
 typedef TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
     MapUnmapCallback> ByteMap;
 typedef SizeClassAllocator32<kAllocatorSpace, kAllocatorSize, 0,

lib/tsan/tests/rtl/tsan_posix.cc

TEST(Posix, ThreadSpecificDtors) {
   EXPECT_EQ(pthread_join(th[0], 0), 0);
   EXPECT_EQ(pthread_create(&th[2], 0, dtors_thread, k[2]), 0);
   EXPECT_EQ(pthread_join(th[1], 0), 0);
   EXPECT_EQ(pthread_join(th[2], 0), 0);
   EXPECT_EQ(pthread_key_delete(key), 0);
   EXPECT_EQ(6, cnt);
 }
 
+#ifndef __aarch64__
 static __thread int local_var;
 
 static void *local_thread(void *p) {
   __tsan_write1(&local_var);
   __tsan_write1(&p);
   if (p == 0)
     return 0;
   const int kThreads = 4;
   pthread_t th[kThreads];
   for (int i = 0; i < kThreads; i++)
     EXPECT_EQ(pthread_create(&th[i], 0, local_thread,
               (void*)((long)p - 1)), 0);  // NOLINT
   for (int i = 0; i < kThreads; i++)
     EXPECT_EQ(pthread_join(th[i], 0), 0);
   return 0;
 }
+#endif
 
 TEST(Posix, ThreadLocalAccesses) {
+// The test is failing with high thread count for aarch64.
+// TODO(azanella): track down the issue and re-enable the test.
+#ifndef __aarch64__
   local_thread((void*)2);
+#endif
 }
 
 struct CondContext {
   pthread_mutex_t m;
   pthread_cond_t c;
   int data;
 };
 

test/tsan/ignore_lib0.cc

 // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib0.so
 // RUN: %clangxx_tsan -O1 %s -L%T -lignore_lib0 -o %t
 // RUN: echo running w/o suppressions:
 // RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOSUPP
 // RUN: echo running with suppressions:
 // RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} TSAN_OPTIONS="$TSAN_OPTIONS suppressions='%s.supp'" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
 
 // Tests that interceptors coming from a library specified in called_from_lib
 // suppression are ignored.
 
+// Some aarch64 kernels do not support non executable write pages
+// XFAIL: aarch64
+
 #ifndef LIB
 
 extern "C" void libfunc();
 
 int main() {
   libfunc();
 }
 

test/tsan/ignore_lib1.cc

 // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib1.so
 // RUN: %clangxx_tsan -O1 %s -o %t
 // RUN: echo running w/o suppressions:
 // RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOSUPP
 // RUN: echo running with suppressions:
 // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions='%s.supp'" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
 
 // Tests that interceptors coming from a dynamically loaded library specified
 // in called_from_lib suppression are ignored.
 
+// XFAIL: aarch64
+
 #ifndef LIB
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 #include <libgen.h>
 #include <string>

test/tsan/ignore_lib3.cc

 // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib3.so
 // RUN: %clangxx_tsan -O1 %s -o %t
 // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions='%s.supp'" %deflake %run %t | FileCheck %s
 
 // Tests that unloading of a library matched against called_from_lib suppression
 // causes program crash (this is not supported).
 
+// Some aarch64 kernels do not support non executable write pages
+// XFAIL: aarch64
+
 #ifndef LIB
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 #include <libgen.h>
 #include <string>

test/tsan/longjmp.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 
-// Longjmp assembly has not been implemented for mips64 yet
+// Longjmp assembly has not been implemented for mips64 or aarch64 yet
 // XFAIL: mips64
+// XFAIL: aarch64
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 
 int foo(jmp_buf env) {
   longjmp(env, 42);
 }

test/tsan/longjmp2.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 
-// Longjmp assembly has not been implemented for mips64 yet
+// Longjmp assembly has not been implemented for mips64 or aarch64 yet
 // XFAIL: mips64
+// XFAIL: aarch64
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 
 int foo(sigjmp_buf env) {
   printf("env=%p\n", env);
   siglongjmp(env, 42);

test/tsan/longjmp3.cc

 // RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 
-// Longjmp assembly has not been implemented for mips64 yet
+// Longjmp assembly has not been implemented for mips64 or aarch64 yet
 // XFAIL: mips64
+// XFAIL: aarch64
 
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 
 void bar(jmp_buf env) {
   volatile int x = 42;

test/tsan/longjmp4.cc

 // RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 
-// Longjmp assembly has not been implemented for mips64 yet
+// Longjmp assembly has not been implemented for mips64 or aarch64 yet
 // XFAIL: mips64
+// XFAIL: aarch64
 
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 #include <string.h>
 
 void bar(jmp_buf env) {

test/tsan/map32bit.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
 #include "test.h"
 #include <stdint.h>
 #include <errno.h>
 #include <sys/mman.h>
 
 // Test for issue:
 // https://code.google.com/p/thread-sanitizer/issues/detail?id=5
 
 // MAP_32BIT flag for mmap is supported only for x86_64.
 // XFAIL: mips64
+// XFAIL: aarch64
 
 void *Thread(void *ptr) {
   *(int*)ptr = 42;
   barrier_wait(&barrier);
   return 0;
 }
 
 int main() {

test/tsan/mmap_large.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include <stdint.h>
 #include <stdio.h>
 #include <errno.h>
 #include <sys/mman.h>
 
 #if defined(__FreeBSD__)
 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
 // that, it was never implemented.  So just define it to zero.
 #undef  MAP_NORESERVE
 #define MAP_NORESERVE 0
 #endif
 
 int main() {
 #ifdef __x86_64__
   const size_t kLog2Size = 39;
-#elif defined(__mips64)
+#elif defined(__mips64) || defined(__aarch64__)
   const size_t kLog2Size = 32;
 #endif
   const uintptr_t kLocation = 0x40ULL << kLog2Size;
   void *p = mmap(
       reinterpret_cast<void*>(kLocation),
       1ULL << kLog2Size,
       PROT_READ|PROT_WRITE,
       MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE,
       -1, 0);
   fprintf(stderr, "DONE %p %d\n", p, errno);
   return p == MAP_FAILED;
 }
 
 // CHECK: DONE

test/tsan/signal_longjmp.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 // Test case for longjumping out of signal handler:
 // https://code.google.com/p/thread-sanitizer/issues/detail?id=75
 
-// Longjmp assembly has not been implemented for mips64 yet
+// Longjmp assembly has not been implemented for mips64 or aarch64 yet
 // XFAIL: mips64
+// XFAIL: aarch64
 
 #include <setjmp.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/mman.h>
 
 sigjmp_buf fault_jmp;

test/tsan/test.h

 // Default instance of the barrier, but a test can declare more manually.
 pthread_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);
-#elif defined(__mips64)
+#elif defined(__mips64) || defined(__aarch64__)
   fprintf(stderr, "0x%010lx", (unsigned long) address);
 #endif
 }