[tsan] Support aarch64 for Android.

[eugenis]

lib/tsan/rtl/tsan_platform.h

129

Is there a reason you are not using the generic aarch64/linux mappings below?
For ASan/aarch64/android, I've noticed that ART requires a first 4GB mapping, which seems incompatible with this layout.

[yabinc]

lib/tsan/rtl/tsan_platform.h

129

The Android mapping is different from Mapping39 in kLoAppMemBeg-kLoAppMemEnd. Because
android links all executables as shared libraries.
Thanks for reminding. I didn't notice that. I will check it out after my vacation.

[eugenis]

lib/tsan/rtl/tsan_platform.h

129

You mean PIE?
That linux mapping does not support PIE!
Well it could be a kernel version thing - at some point they moved PIE executable mappings from 0x7f.. to 0x55...

I've added a comment to http://reviews.llvm.org/D14199.

I don't mind going ahead with this one and figuring out if we want to unify the mappings later.

[yabinc]

lib/tsan/rtl/tsan_platform.h

129

Yes, I mean PIE. It might be related to kernel version, or architecture. I am not sure.

[zatrazz]

lib/tsan/rtl/tsan_platform.h

129

As I commented on the aarch64-linux TSAN mapping unification discussion [1] I did check the tests with -fpic -pie build and I saw no issue. I checked on a recent kernel (3.19) and on this configuration the PIE addresses for TSAN builds are se on 0x7f.. range.

I will check for 42-bits if TSAN tests fail with PIE build.

[1] http://reviews.llvm.org/D14199

[zatrazz]

lib/tsan/rtl/tsan_platform.h

129

My first analysis was flawed and PIE flags was not really being used when building the binaries. I rechecked on both 39 and 42 bits VMA and indeed current mapping scheme for aarch64-linux does not support PIE configurations. I have created the revision [1] to fix this issue.

I am not sure if this will work for aarch64-android.

[1] http://reviews.llvm.org/D15447

[yabinc]

It works. Thanks!

lib/tsan/rtl/tsan_platform.h

struct Mapping {
   static const uptr kLoAppMemEnd   = 0x0200000000ull;
   static const uptr kHiAppMemBeg   = 0xff80000000ull;
   static const uptr kHiAppMemEnd   = 0xffffffffffull;
   static const uptr kAppMemMsk     = 0xfc00000000ull;
   static const uptr kAppMemXor     = 0x0400000000ull;
   static const uptr kVdsoBeg       = 0xfffff00000ull;
 };
 #elif defined(__aarch64__)
+#if SANITIZER_ANDROID
+/*
+C/C++ on android/aarch64 (39-bit VMA)
+On Android, the executable file is shared library, so it is loaded
+to address space near TASK_SIZE*2/3. Vdso area is not guaranteed
+to be higher than stack, so disable it.
[phone] - 4000 0000 00: shadow memory
[phone] - 5000 0000 00: metainfo
[phone] - 5500 0000 00: -
[phone] - 5700 0000 00: main binary
[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
+*/
+struct Mapping {
+  static const uptr kShadowBeg     = 0x2000000000ull;
+  static const uptr kShadowEnd     = 0x4000000000ull;
+  static const uptr kMetaShadowBeg = 0x4000000000ull;
+  static const uptr kMetaShadowEnd = 0x5000000000ull;
+  static const uptr kLoAppMemBeg   = 0x5500000000ull;
+  static const uptr kLoAppMemEnd   = 0x5700000000ull;
+  static const uptr kTraceMemBeg   = 0x6000000000ull;
+  static const uptr kTraceMemEnd   = 0x6200000000ull;
+  static const uptr kHeapMemBeg    = 0x7d00000000ull;
+  static const uptr kHeapMemEnd    = 0x7e00000000ull;
+  static const uptr kHiAppMemBeg   = 0x7e00000000ull;
+  static const uptr kHiAppMemEnd   = 0x8000000000ull;
+  static const uptr kVdsoBeg       = 0x8000000000ull;
+  static const uptr kLoAppMemAdd   = 0x0300000000ull;
+  static const uptr kLoAppMemMsk   = 0x5000000000ull;
+  static const uptr kHiAppMemMsk   = 0x7000000000ull;
+};
+
+#else
+
 // AArch64 supports multiple VMA which leads to multiple address transformation
 // functions.  To support these multiple VMAS transformations and mappings TSAN
 // runtime for AArch64 uses an external memory read (vmaSize) to select which
 // mapping to use.  Although slower, it make a same instrumented binary run on
 // multiple kernels.
 
 /*
 C/C++ on linux/aarch64 (39-bit VMA)
struct Mapping42 {
   static const uptr kHiAppMemEnd   = 0x3ffffffffffull;
   static const uptr kAppMemMsk     = 0x3c000000000ull;
   static const uptr kAppMemXor     = 0x04000000000ull;
   static const uptr kVdsoBeg       = 0x37f00000000ull;
 };
 
 // Indicates the runtime will define the memory regions at runtime.
 #define TSAN_RUNTIME_VMA 1
-#endif
+#endif  // SANITIZER_ANDROID
+#endif  // defined(__aarch64__)
 
 #elif defined(SANITIZER_GO) && !SANITIZER_WINDOWS
 
 /* Go on linux, darwin and freebsd
 0000 0000 1000 - 0000 1000 0000: executable
 0000 1000 0000 - 00c0 0000 0000: -
 00c0 0000 0000 - 00e0 0000 0000: heap
 00e0 0000 0000 - 2000 0000 0000: -
#endif
     case MAPPING_META_SHADOW_END: return Mapping::kMetaShadowEnd;
     case MAPPING_TRACE_BEG: return Mapping::kTraceMemBeg;
     case MAPPING_TRACE_END: return Mapping::kTraceMemEnd;
   }
 }
 
 template<int Type>
 uptr MappingArchImpl(void) {
-#ifdef __aarch64__
+#if defined(__aarch64__) && !SANITIZER_ANDROID
   if (vmaSize == 39)
     return MappingImpl<Mapping39, Type>();
   else
     return MappingImpl<Mapping42, Type>();
   DCHECK(0);
 #else
   return MappingImpl<Mapping, Type>();
 #endif
return (mem >= Mapping::kHeapMemBeg && mem < Mapping::kHeapMemEnd) ||
          (mem >= Mapping::kHiAppMemBeg && mem < Mapping::kHiAppMemEnd);
 #else
   return mem >= Mapping::kAppMemBeg && mem < Mapping::kAppMemEnd;
 #endif
 }
 
 ALWAYS_INLINE
 bool IsAppMem(uptr mem) {
-#ifdef __aarch64__
+#if defined(__aarch64__) && !SANITIZER_ANDROID
   if (vmaSize == 39)
     return IsAppMemImpl<Mapping39>(mem);
   else
     return IsAppMemImpl<Mapping42>(mem);
   DCHECK(0);
 #else
   return IsAppMemImpl<Mapping>(mem);
 #endif
 }
 
 
 template<typename Mapping>
 bool IsShadowMemImpl(uptr mem) {
   return mem >= Mapping::kShadowBeg && mem <= Mapping::kShadowEnd;
 }
 
 ALWAYS_INLINE
 bool IsShadowMem(uptr mem) {
-#ifdef __aarch64__
+#if defined(__aarch64__) && !SANITIZER_ANDROID
   if (vmaSize == 39)
     return IsShadowMemImpl<Mapping39>(mem);
   else
     return IsShadowMemImpl<Mapping42>(mem);
   DCHECK(0);
 #else
   return IsShadowMemImpl<Mapping>(mem);
 #endif
 }
 
 
 template<typename Mapping>
 bool IsMetaMemImpl(uptr mem) {
   return mem >= Mapping::kMetaShadowBeg && mem <= Mapping::kMetaShadowEnd;
 }
 
 ALWAYS_INLINE
 bool IsMetaMem(uptr mem) {
-#ifdef __aarch64__
+#if defined(__aarch64__) && !SANITIZER_ANDROID
   if (vmaSize == 39)
     return IsMetaMemImpl<Mapping39>(mem);
   else
     return IsMetaMemImpl<Mapping42>(mem);
   DCHECK(0);
 #else
   return IsMetaMemImpl<Mapping>(mem);
 #endif
 }
 
 
 template<typename Mapping>
 uptr MemToShadowImpl(uptr x) {
   DCHECK(IsAppMem(x));
 #ifndef SANITIZER_GO
   return (((x) & ~(Mapping::kAppMemMsk | (kShadowCell - 1)))
       ^ Mapping::kAppMemXor) * kShadowCnt;
 #else
   return ((x & ~(kShadowCell - 1)) * kShadowCnt) | Mapping::kShadowBeg;
 #endif
 }
 
+template<typename Mapping>
+uptr MemToShadowAndroidImpl(uptr x) {
+  DCHECK(IsAppMem(x));
+  if (x <= Mapping::kLoAppMemEnd)
+    return ((x & ~(Mapping::kLoAppMemMsk | (kShadowCell - 1)))
+        + Mapping::kLoAppMemAdd) * kShadowCnt;
+  else
+    return ((x & ~(Mapping::kHiAppMemMsk | (kShadowCell - 1)))) * kShadowCnt;
+}
+
 ALWAYS_INLINE
 uptr MemToShadow(uptr x) {
 #ifdef __aarch64__
+#if SANITIZER_ANDROID
+  return MemToShadowAndroidImpl<Mapping>(x);
+#else
   if (vmaSize == 39)
     return MemToShadowImpl<Mapping39>(x);
   else
     return MemToShadowImpl<Mapping42>(x);
   DCHECK(0);
+#endif  // SANITIZER_ANDROID
 #else
   return MemToShadowImpl<Mapping>(x);
 #endif
 }
 
 
 template<typename Mapping>
 u32 *MemToMetaImpl(uptr x) {
   DCHECK(IsAppMem(x));
 #ifndef SANITIZER_GO
   return (u32*)(((((x) & ~(Mapping::kAppMemMsk | (kMetaShadowCell - 1)))
         ^ Mapping::kAppMemXor) / kMetaShadowCell * kMetaShadowSize)
           | Mapping::kMetaShadowBeg);
 #else
   return (u32*)(((x & ~(kMetaShadowCell - 1)) / \
       kMetaShadowCell * kMetaShadowSize) | Mapping::kMetaShadowBeg);
 #endif
 }
 
+template<typename Mapping>
+u32 *MemToMetaAndroidImpl(uptr x) {
+  DCHECK(IsAppMem(x));
+  if (x <= Mapping::kLoAppMemEnd)
+    return (u32*)((((x & ~(Mapping::kLoAppMemMsk | (kMetaShadowCell - 1)))
+        + Mapping::kLoAppMemAdd) / kMetaShadowCell * kMetaShadowSize)
+          | Mapping::kMetaShadowBeg);
+  else
+    return (u32*)(((x & ~(Mapping::kHiAppMemMsk | (kMetaShadowCell - 1)))
+        / kMetaShadowCell * kMetaShadowSize) | Mapping::kMetaShadowBeg);
+}
+
 ALWAYS_INLINE
 u32 *MemToMeta(uptr x) {
 #ifdef __aarch64__
+#if SANITIZER_ANDROID
+  return MemToMetaAndroidImpl<Mapping>(x);
+#else
   if (vmaSize == 39)
     return MemToMetaImpl<Mapping39>(x);
   else
     return MemToMetaImpl<Mapping42>(x);
   DCHECK(0);
+#endif  // SANITIZER_ANDROID
 #else
   return MemToMetaImpl<Mapping>(x);
 #endif
 }
 
 
 template<typename Mapping>
 uptr ShadowToMemImpl(uptr s) {
# ifndef SANITIZER_WINDOWS
   return (s & ~Mapping::kShadowBeg) / kShadowCnt;
 # else
   // FIXME(dvyukov): this is most likely wrong as the mapping is not bijection.
   return (s - Mapping::kShadowBeg) / kShadowCnt;
 # endif // SANITIZER_WINDOWS
 #endif
 }
 
+template<typename Mapping>
+uptr ShadowToMemAndroidImpl(uptr s) {
+  DCHECK(IsShadowMem(s));
+  if (s <= MemToShadow(Mapping::kLoAppMemEnd))
+    return ((s / kShadowCnt) - Mapping::kLoAppMemAdd) | Mapping::kLoAppMemMsk;
+  else
+    return ((s / kShadowCnt)) | Mapping::kHiAppMemMsk;
+}
+
 ALWAYS_INLINE
 uptr ShadowToMem(uptr s) {
 #ifdef __aarch64__
+#if SANITIZER_ANDROID
+  return ShadowToMemAndroidImpl<Mapping>(s);
+#else
   if (vmaSize == 39)
     return ShadowToMemImpl<Mapping39>(s);
   else
     return ShadowToMemImpl<Mapping42>(s);
   DCHECK(0);
+#endif  // SANITIZER_ANDROID
 #else
   return ShadowToMemImpl<Mapping>(s);
 #endif
 }
 
 
 
 // The additional page is to catch shadow stack overflow as paging fault.
 // Windows wants 64K alignment for mmaps.
 const uptr kTotalTraceSize = (kTraceSize * sizeof(Event) + sizeof(Trace)
     + (64 << 10) + (64 << 10) - 1) & ~((64 << 10) - 1);
 
 template<typename Mapping>
 uptr GetThreadTraceImpl(int tid) {
   uptr p = Mapping::kTraceMemBeg + (uptr)tid * kTotalTraceSize;
   DCHECK_LT(p, Mapping::kTraceMemEnd);
   return p;
 }
 
 ALWAYS_INLINE
 uptr GetThreadTrace(int tid) {
-#ifdef __aarch64__
+#if defined(__aarch64__) && !SANITIZER_ANDROID
   if (vmaSize == 39)
     return GetThreadTraceImpl<Mapping39>(tid);
   else
     return GetThreadTraceImpl<Mapping42>(tid);
   DCHECK(0);
 #else
   return GetThreadTraceImpl<Mapping>(tid);
 #endif
 }
 
 
 template<typename Mapping>
 uptr GetThreadTraceHeaderImpl(int tid) {
   uptr p = Mapping::kTraceMemBeg + (uptr)tid * kTotalTraceSize
       + kTraceSize * sizeof(Event);
   DCHECK_LT(p, Mapping::kTraceMemEnd);
   return p;
 }
 
 ALWAYS_INLINE
 uptr GetThreadTraceHeader(int tid) {
-#ifdef __aarch64__
+#if defined(__aarch64__) && !SANITIZER_ANDROID
   if (vmaSize == 39)
     return GetThreadTraceHeaderImpl<Mapping39>(tid);
   else
     return GetThreadTraceHeaderImpl<Mapping42>(tid);
   DCHECK(0);
 #else
   return GetThreadTraceHeaderImpl<Mapping>(tid);
 #endif

lib/tsan/rtl/tsan_platform_posix.cc

void InitializeShadowMemory() {
   // 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__)
+#if SANITIZER_ANDROID
+  const uptr kMadviseRangeBeg = 0x7d00000000ull;
+  const uptr kMadviseRangeSize = 0x0300000000ull;
+#else
   uptr kMadviseRangeBeg = 0;
   uptr kMadviseRangeSize = 0;
   if (vmaSize == 39) {
     kMadviseRangeBeg  = 0x7d00000000ull;
     kMadviseRangeSize = 0x0300000000ull;
   } else if (vmaSize == 42) {
     kMadviseRangeBeg  = 0x3f000000000ull;
     kMadviseRangeSize = 0x01000000000ull;
   } else {
     DCHECK(0);
   }
+#endif  // SANITIZER_ANDROID
 #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(MetaShadowBeg(), MetaShadowEnd() - MetaShadowBeg());
   if (common_flags()->use_madv_dontdump)
while (proc_maps.Next(&p, &end, 0, 0, 0, &prot)) {
     if (prot == 0)  // Zero page or mprotected.
       continue;
     if (p >= VdsoBeg())  // vdso
       break;
     Printf("FATAL: ThreadSanitizer: unexpected memory mapping %p-%p\n", p, end);
     Die();
   }
 
+#if defined(__aarch64__) && SANITIZER_ANDROID
+  ProtectRange(MetaShadowEnd(), LoAppMemBeg());
+  ProtectRange(LoAppMemEnd(), TraceMemBeg());
+#else
   ProtectRange(LoAppMemEnd(), ShadowBeg());
-  ProtectRange(ShadowEnd(), MetaShadowBeg());
   ProtectRange(MetaShadowEnd(), TraceMemBeg());
+#endif
+  ProtectRange(ShadowEnd(), MetaShadowBeg());
   // Memory for traces is mapped lazily in MapThreadTrace.
   // Protect the whole range for now, so that user does not map something here.
   ProtectRange(TraceMemBeg(), TraceMemEnd());
   ProtectRange(TraceMemEnd(), HeapMemBeg());
   ProtectRange(HeapEnd(), HiAppMemBeg());
 }
 #endif
 
 }  // namespace __tsan
 
 #endif  // SANITIZER_POSIX