[PowerPC][tsan] Update tsan to handle changed memory layouts in newer kernels

[seurer]

Summary

[PowerPC][tsan] Update tsan to handle changed memory layouts in newer kernels

In more recent Linux kernels with 47 bit VMAs the layout of virtual memory
for powerpc64 changed causing the thread sanitizer to not work properly. This
patch adds support for 47 bit VMA kernels for powerpc64.

Tested on several 4.x and 3.x kernel releases.

[seurer]

lib/tsan/rtl/tsan_platform.h

345

Ugh! I missed changing that comment to "47 bits". I will fix it before checking in.

[nemanjai]

Committed in r318044.

lib/tsan/rtl/tsan_platform.h

struct Mapping46 {
   static const uptr kLoAppMemEnd   = 0x010000000000ull;
   static const uptr kHiAppMemBeg   = 0x3e8000000000ull;
   static const uptr kHiAppMemEnd   = 0x400000000000ull; // 46 bits
   static const uptr kAppMemMsk     = 0x3c0000000000ull;
   static const uptr kAppMemXor     = 0x020000000000ull;
   static const uptr kVdsoBeg       = 0x7800000000000000ull;
 };
 
+/*
+C/C++ on linux/powerpc64 (47-bit VMA)
+0000 0000 1000 - 0100 0000 0000: main binary
+0100 0000 0000 - 0200 0000 0000: -
+0100 0000 0000 - 1000 0000 0000: shadow
[phone] - 1000 0000 0000: -
[phone] - 2000 0000 0000: metainfo (memory blocks and sync objects)
[phone] - 2000 0000 0000: -
[phone] - 2200 0000 0000: traces
[phone] - 7d00 0000 0000: -
+7d00 0000 0000 - 7e00 0000 0000: heap
+7e00 0000 0000 - 7e80 0000 0000: -
+7e80 0000 0000 - 8000 0000 0000: modules and main thread stack
+*/
+struct Mapping47 {
+  static const uptr kMetaShadowBeg = 0x100000000000ull;
+  static const uptr kMetaShadowEnd = 0x200000000000ull;
+  static const uptr kTraceMemBeg   = 0x200000000000ull;
+  static const uptr kTraceMemEnd   = 0x220000000000ull;
+  static const uptr kShadowBeg     = 0x010000000000ull;
+  static const uptr kShadowEnd     = 0x100000000000ull;
+  static const uptr kHeapMemBeg    = 0x7d0000000000ull;
+  static const uptr kHeapMemEnd    = 0x7e0000000000ull;
+  static const uptr kLoAppMemBeg   = 0x000000001000ull;
+  static const uptr kLoAppMemEnd   = 0x010000000000ull;
+  static const uptr kHiAppMemBeg   = 0x7e8000000000ull;
+  static const uptr kHiAppMemEnd   = 0x800000000000ull; // 46 bits
+  static const uptr kAppMemMsk     = 0x7c0000000000ull;
+  static const uptr kAppMemXor     = 0x020000000000ull;
+  static const uptr kVdsoBeg       = 0x7800000000000000ull;
+};
+
 // Indicates the runtime will define the memory regions at runtime.
 #define TSAN_RUNTIME_VMA 1
 #endif
 
 #elif SANITIZER_GO && !SANITIZER_WINDOWS
 
 /* Go on linux, darwin and freebsd
 0000 0000 1000 - 0000 1000 0000: executable
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return MappingImpl<Mapping39, Type>();
     case 42: return MappingImpl<Mapping42, Type>();
     case 48: return MappingImpl<Mapping48, Type>();
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return MappingImpl<Mapping44, Type>();
-  else
-    return MappingImpl<Mapping46, Type>();
+  switch (vmaSize) {
+    case 44: return MappingImpl<Mapping44, Type>();
+    case 46: return MappingImpl<Mapping46, Type>();
+    case 47: return MappingImpl<Mapping47, Type>();
+  }
   DCHECK(0);
+  return 0;
 #else
   return MappingImpl<Mapping, Type>();
 #endif
 }
 
 #if !SANITIZER_GO
 ALWAYS_INLINE
 uptr LoAppMemBeg(void) {
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return IsAppMemImpl<Mapping39>(mem);
     case 42: return IsAppMemImpl<Mapping42>(mem);
     case 48: return IsAppMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return IsAppMemImpl<Mapping44>(mem);
-  else
-    return IsAppMemImpl<Mapping46>(mem);
+  switch (vmaSize) {
+    case 44: return IsAppMemImpl<Mapping44>(mem);
+    case 46: return IsAppMemImpl<Mapping46>(mem);
+    case 47: return IsAppMemImpl<Mapping47>(mem);
+  }
   DCHECK(0);
+  return false;
 #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) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return IsShadowMemImpl<Mapping39>(mem);
     case 42: return IsShadowMemImpl<Mapping42>(mem);
     case 48: return IsShadowMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return IsShadowMemImpl<Mapping44>(mem);
-  else
-    return IsShadowMemImpl<Mapping46>(mem);
+  switch (vmaSize) {
+    case 44: return IsShadowMemImpl<Mapping44>(mem);
+    case 46: return IsShadowMemImpl<Mapping46>(mem);
+    case 47: return IsShadowMemImpl<Mapping47>(mem);
+  }
   DCHECK(0);
+  return false;
 #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) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return IsMetaMemImpl<Mapping39>(mem);
     case 42: return IsMetaMemImpl<Mapping42>(mem);
     case 48: return IsMetaMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return IsMetaMemImpl<Mapping44>(mem);
-  else
-    return IsMetaMemImpl<Mapping46>(mem);
+  switch (vmaSize) {
+    case 44: return IsMetaMemImpl<Mapping44>(mem);
+    case 46: return IsMetaMemImpl<Mapping46>(mem);
+    case 47: return IsMetaMemImpl<Mapping47>(mem);
+  }
   DCHECK(0);
+  return false;
 #else
   return IsMetaMemImpl<Mapping>(mem);
 #endif
 }
 
 
 template<typename Mapping>
 uptr MemToShadowImpl(uptr x) {
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return MemToShadowImpl<Mapping39>(x);
     case 42: return MemToShadowImpl<Mapping42>(x);
     case 48: return MemToShadowImpl<Mapping48>(x);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return MemToShadowImpl<Mapping44>(x);
-  else
-    return MemToShadowImpl<Mapping46>(x);
+  switch (vmaSize) {
+    case 44: return MemToShadowImpl<Mapping44>(x);
+    case 46: return MemToShadowImpl<Mapping46>(x);
+    case 47: return MemToShadowImpl<Mapping47>(x);
+  }
   DCHECK(0);
+  return 0;
 #else
   return MemToShadowImpl<Mapping>(x);
 #endif
 }
 
 
 template<typename Mapping>
 u32 *MemToMetaImpl(uptr x) {
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return MemToMetaImpl<Mapping39>(x);
     case 42: return MemToMetaImpl<Mapping42>(x);
     case 48: return MemToMetaImpl<Mapping48>(x);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return MemToMetaImpl<Mapping44>(x);
-  else
-    return MemToMetaImpl<Mapping46>(x);
+  switch (vmaSize) {
+    case 44: return MemToMetaImpl<Mapping44>(x);
+    case 46: return MemToMetaImpl<Mapping46>(x);
+    case 47: return MemToMetaImpl<Mapping47>(x);
+  }
   DCHECK(0);
+  return 0;
 #else
   return MemToMetaImpl<Mapping>(x);
 #endif
 }
 
 
 template<typename Mapping>
 uptr ShadowToMemImpl(uptr s) {
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return ShadowToMemImpl<Mapping39>(s);
     case 42: return ShadowToMemImpl<Mapping42>(s);
     case 48: return ShadowToMemImpl<Mapping48>(s);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return ShadowToMemImpl<Mapping44>(s);
-  else
-    return ShadowToMemImpl<Mapping46>(s);
+  switch (vmaSize) {
+    case 44: return ShadowToMemImpl<Mapping44>(s);
+    case 46: return ShadowToMemImpl<Mapping46>(s);
+    case 47: return ShadowToMemImpl<Mapping47>(s);
+  }
   DCHECK(0);
+  return 0;
 #else
   return ShadowToMemImpl<Mapping>(s);
 #endif
 }
 
 
 
 // The additional page is to catch shadow stack overflow as paging fault.
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return GetThreadTraceImpl<Mapping39>(tid);
     case 42: return GetThreadTraceImpl<Mapping42>(tid);
     case 48: return GetThreadTraceImpl<Mapping48>(tid);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return GetThreadTraceImpl<Mapping44>(tid);
-  else
-    return GetThreadTraceImpl<Mapping46>(tid);
+  switch (vmaSize) {
+    case 44: return GetThreadTraceImpl<Mapping44>(tid);
+    case 46: return GetThreadTraceImpl<Mapping46>(tid);
+    case 47: return GetThreadTraceImpl<Mapping47>(tid);
+  }
   DCHECK(0);
+  return 0;
 #else
   return GetThreadTraceImpl<Mapping>(tid);
 #endif
 }
 
 
 template<typename Mapping>
 uptr GetThreadTraceHeaderImpl(int tid) {
#if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
     case 39: return GetThreadTraceHeaderImpl<Mapping39>(tid);
     case 42: return GetThreadTraceHeaderImpl<Mapping42>(tid);
     case 48: return GetThreadTraceHeaderImpl<Mapping48>(tid);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
-  if (vmaSize == 44)
-    return GetThreadTraceHeaderImpl<Mapping44>(tid);
-  else
-    return GetThreadTraceHeaderImpl<Mapping46>(tid);
+  switch (vmaSize) {
+    case 44: return GetThreadTraceHeaderImpl<Mapping44>(tid);
+    case 46: return GetThreadTraceHeaderImpl<Mapping46>(tid);
+    case 47: return GetThreadTraceHeaderImpl<Mapping47>(tid);
+  }
   DCHECK(0);
+  return 0;
 #else
   return GetThreadTraceHeaderImpl<Mapping>(tid);
 #endif
 }
 
 void InitializePlatform();
 void InitializePlatformEarly();
 void CheckAndProtect();