tsan: remove TSAN_MID_APP_RANGE macro

[dvyukov]

Summary

First, the define conflicts with definition/testing of all mappings,
since it's not a global property anymore. Second, macros/ifdefs are bad.
Define kMidAppMemBeg/End to 0 to denote that there is no "mid" range instead.

Depends on D107736.

[melver]

Subject: s/remote/remove/

[dvyukov]

fixed typo in commit description

[dvyukov]

Subject: s/remote/remove/

done

[dvyukov]

changed SelectMapping to use template Arg and rebased

compiler-rt/lib/tsan/rtl/tsan_platform.h

struct MappingAppleAarch64 {
   static const uptr kMetaShadowEnd = 0x0e00000000ull;
   static const uptr kTraceMemBeg   = 0x0f00000000ull;
   static const uptr kTraceMemEnd   = 0x0fc0000000ull;
   static const uptr kHiAppMemBeg   = 0x0fc0000000ull;
   static const uptr kHiAppMemEnd   = 0x0fc0000000ull;
   static const uptr kAppMemMsk     =          0x0ull;
   static const uptr kAppMemXor     =          0x0ull;
   static const uptr kVdsoBeg       = 0x7000000000000000ull;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
 };
 
 /*
 C/C++ on linux/aarch64 (39-bit VMA)
 0000 0010 00 - 0100 0000 00: main binary
 0100 0000 00 - 0800 0000 00: -
 0800 0000 00 - 2000 0000 00: shadow memory
 2000 0000 00 - 3100 0000 00: -
struct MappingPPC64_44 {
   static const uptr kLoAppMemEnd   = 0x000100000000ull;
   static const uptr kHeapMemBeg    = 0x0f0000000000ull;
   static const uptr kHeapMemEnd    = 0x0f5000000000ull;
   static const uptr kHiAppMemBeg   = 0x0f6000000000ull;
   static const uptr kHiAppMemEnd   = 0x100000000000ull; // 44 bits
   static const uptr kAppMemMsk     = 0x0f0000000000ull;
   static const uptr kAppMemXor     = 0x002100000000ull;
   static const uptr kVdsoBeg       = 0x3c0000000000000ull;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
 };
 
 /*
 C/C++ on linux/powerpc64 (46-bit VMA)
 0000 0000 1000 - 0100 0000 0000: main binary
 0100 0000 0000 - 0200 0000 0000: -
 0100 0000 0000 - 1000 0000 0000: shadow
 1000 0000 0000 - 1000 0000 0000: -
struct MappingPPC64_46 {
   static const uptr kHeapMemEnd    = 0x3e0000000000ull;
   static const uptr kLoAppMemBeg   = 0x000000001000ull;
   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;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
 };
 
 /*
 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
 1000 0000 0000 - 1000 0000 0000: -
struct MappingPPC64_47 {
   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; // 47 bits
   static const uptr kAppMemMsk     = 0x7c0000000000ull;
   static const uptr kAppMemXor     = 0x020000000000ull;
   static const uptr kVdsoBeg       = 0x7800000000000000ull;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
 };
 
 /*
 C/C++ on linux/s390x
 While the kernel provides a 64-bit address space, we have to restrict ourselves
 to 48 bits due to how e.g. SyncVar::GetId() works.
 0000 0000 1000 - 0e00 0000 0000: binary, modules, stacks - 14 TiB
 0e00 0000 0000 - 4000 0000 0000: -
struct MappingS390x {
   static const uptr kHeapMemEnd    = 0xc00000000000ull;
   static const uptr kLoAppMemBeg   = 0x000000001000ull;
   static const uptr kLoAppMemEnd   = 0x0e0000000000ull;
   static const uptr kHiAppMemBeg   = 0xc00000004000ull;
   static const uptr kHiAppMemEnd   = 0xc00000004000ull;
   static const uptr kAppMemMsk     = 0xb00000000000ull;
   static const uptr kAppMemXor     = 0x100000000000ull;
   static const uptr kVdsoBeg       = 0xfffffffff000ull;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
 };
 
 /* Go on linux, darwin and freebsd on x86_64
 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: -
 2000 0000 0000 - 2380 0000 0000: shadow

 #else
 #  define HAS_48_BIT_ADDRESS_SPACE 0
 #endif
 
 #if !SANITIZER_GO
 
 #  if HAS_48_BIT_ADDRESS_SPACE
 typedef Mapping48AddressSpace Mapping;
-#    define TSAN_MID_APP_RANGE 1
 #  elif defined(__mips64)
 typedef MappingMips64_40 Mapping40;
-#    define TSAN_MID_APP_RANGE 1
 #    define TSAN_RUNTIME_VMA 1
 #  elif defined(__aarch64__) && defined(__APPLE__)
 typedef MappingAppleAarch64 Mapping;
 #  elif defined(__aarch64__) && !defined(__APPLE__)
 // 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.
 typedef MappingAarch64_39 Mapping39;
 typedef MappingAarch64_42 Mapping42;
 typedef MappingAarch64_48 Mapping48;
 // Indicates the runtime will define the memory regions at runtime.
 #    define TSAN_RUNTIME_VMA 1
 // Indicates that mapping defines a mid range memory segment.
-#    define TSAN_MID_APP_RANGE 1
 #  elif defined(__powerpc64__)
 // PPC64 supports multiple VMA which leads to multiple address transformation
 // functions.  To support these multiple VMAS transformations and mappings TSAN
 // runtime for PPC64 uses an external memory read (vmaSize) to select which
 // mapping to use.  Although slower, it make a same instrumented binary run on
 // multiple kernels.
 typedef MappingPPC64_44 Mapping44;
 typedef MappingPPC64_46 Mapping46;

 #endif
 }
 
 enum MappingType {
   MAPPING_LO_APP_BEG,
   MAPPING_LO_APP_END,
   MAPPING_HI_APP_BEG,
   MAPPING_HI_APP_END,
-#ifdef TSAN_MID_APP_RANGE
   MAPPING_MID_APP_BEG,
   MAPPING_MID_APP_END,
-#endif
   MAPPING_HEAP_BEG,
   MAPPING_HEAP_END,
   MAPPING_APP_BEG,
   MAPPING_APP_END,
   MAPPING_SHADOW_BEG,
   MAPPING_SHADOW_END,
   MAPPING_META_SHADOW_BEG,
   MAPPING_META_SHADOW_END,
   MAPPING_TRACE_BEG,
   MAPPING_TRACE_END,
   MAPPING_VDSO_BEG,
 };
 
 struct MappingField {
   template <typename Mapping>
   static uptr Apply(MappingType type) {
     switch (type) {
 #if !SANITIZER_GO
     case MAPPING_LO_APP_BEG: return Mapping::kLoAppMemBeg;
     case MAPPING_LO_APP_END: return Mapping::kLoAppMemEnd;
-# ifdef TSAN_MID_APP_RANGE
     case MAPPING_MID_APP_BEG: return Mapping::kMidAppMemBeg;
     case MAPPING_MID_APP_END: return Mapping::kMidAppMemEnd;
-# endif
     case MAPPING_HI_APP_BEG: return Mapping::kHiAppMemBeg;
     case MAPPING_HI_APP_END: return Mapping::kHiAppMemEnd;
     case MAPPING_HEAP_BEG: return Mapping::kHeapMemBeg;
     case MAPPING_HEAP_END: return Mapping::kHeapMemEnd;
     case MAPPING_VDSO_BEG: return Mapping::kVdsoBeg;
 #else
     case MAPPING_APP_BEG: return Mapping::kAppMemBeg;
     case MAPPING_APP_END: return Mapping::kAppMemEnd;

 uptr LoAppMemBeg(void) {
   return SelectMapping<MappingField>(MAPPING_LO_APP_BEG);
 }
 ALWAYS_INLINE
 uptr LoAppMemEnd(void) {
   return SelectMapping<MappingField>(MAPPING_LO_APP_END);
 }
 
-#ifdef TSAN_MID_APP_RANGE
 ALWAYS_INLINE
 uptr MidAppMemBeg(void) {
   return SelectMapping<MappingField>(MAPPING_MID_APP_BEG);
 }
 ALWAYS_INLINE
 uptr MidAppMemEnd(void) {
   return SelectMapping<MappingField>(MAPPING_MID_APP_END);
 }
-#endif
 
 ALWAYS_INLINE
 uptr HeapMemBeg(void) { return SelectMapping<MappingField>(MAPPING_HEAP_BEG); }
 ALWAYS_INLINE
 uptr HeapMemEnd(void) { return SelectMapping<MappingField>(MAPPING_HEAP_END); }
 
 ALWAYS_INLINE
 uptr HiAppMemBeg(void) {

 ALWAYS_INLINE
 uptr AppMemEnd(void) { return SelectMapping<MappingField>(MAPPING_APP_END); }
 
 #endif
 
 static inline
 bool GetUserRegion(int i, uptr *start, uptr *end) {
   switch (i) {
-  default:
-    return false;
 #if !SANITIZER_GO
   case 0:
     *start = LoAppMemBeg();
     *end = LoAppMemEnd();
     return true;
   case 1:
     *start = HiAppMemBeg();
     *end = HiAppMemEnd();
     return true;
   case 2:
     *start = HeapMemBeg();
     *end = HeapMemEnd();
     return true;
-# ifdef TSAN_MID_APP_RANGE
   case 3:
+    if (MidAppMemBeg()) {
       *start = MidAppMemBeg();
       *end = MidAppMemEnd();
       return true;
-# endif
+    }
+    FALLTHROUGH;
 #else
   case 0:
     *start = AppMemBeg();
     *end = AppMemEnd();
     return true;
 #endif
+  default:
+    return false;
   }
 }
 
 ALWAYS_INLINE
 uptr ShadowBeg(void) { return SelectMapping<MappingField>(MAPPING_SHADOW_BEG); }
 ALWAYS_INLINE
 uptr ShadowEnd(void) { return SelectMapping<MappingField>(MAPPING_SHADOW_END); }
 
uptr TraceMemEnd(void) {
   return SelectMapping<MappingField>(MAPPING_TRACE_END);
 }
 
 struct IsAppMemImpl {
   template <typename Mapping>
   static bool Apply(uptr mem) {
 #if !SANITIZER_GO
   return (mem >= Mapping::kHeapMemBeg && mem < Mapping::kHeapMemEnd) ||
-# ifdef TSAN_MID_APP_RANGE
          (mem >= Mapping::kMidAppMemBeg && mem < Mapping::kMidAppMemEnd) ||
-# endif
          (mem >= Mapping::kLoAppMemBeg && mem < Mapping::kLoAppMemEnd) ||
          (mem >= Mapping::kHiAppMemBeg && mem < Mapping::kHiAppMemEnd);
 #else
   return mem >= Mapping::kAppMemBeg && mem < Mapping::kAppMemEnd;
 #endif
   }
 };
 
#if !SANITIZER_GO
   // an easy way to restore the original app address. But the mapping is a
   // bijection, so we try to restore the address as belonging to low/mid/high
   // range consecutively and see if shadow->app->shadow mapping gives us the
   // same address.
   uptr p = (sp / kShadowCnt) ^ Mapping::kAppMemXor;
   if (p >= Mapping::kLoAppMemBeg && p < Mapping::kLoAppMemEnd &&
       MemToShadowImpl::Apply<Mapping>(p) == sp)
     return p;
-# ifdef TSAN_MID_APP_RANGE
+  if (Mapping::kMidAppMemBeg) {
     p = ((sp / kShadowCnt) ^ Mapping::kAppMemXor) +
         (Mapping::kMidAppMemBeg & Mapping::kAppMemMsk);
     if (p >= Mapping::kMidAppMemBeg && p < Mapping::kMidAppMemEnd &&
         MemToShadowImpl::Apply<Mapping>(p) == sp)
       return p;
-# endif
+  }
   return ((sp / kShadowCnt) ^ Mapping::kAppMemXor) | Mapping::kAppMemMsk;
 #else  // #if !SANITIZER_GO
 # ifndef SANITIZER_WINDOWS
   return (sp & ~Mapping::kShadowBeg) / kShadowCnt;
 # else
   return (sp - Mapping::kShadowBeg) / kShadowCnt;
 # endif // SANITIZER_WINDOWS
 #endif

compiler-rt/lib/tsan/rtl/tsan_platform_posix.cpp

 
 #if defined(__aarch64__) && defined(__APPLE__) && !HAS_48_BIT_ADDRESS_SPACE
   ProtectRange(HeapMemEnd(), ShadowBeg());
   ProtectRange(ShadowEnd(), MetaShadowBeg());
   ProtectRange(MetaShadowEnd(), TraceMemBeg());
 #else
   ProtectRange(LoAppMemEnd(), ShadowBeg());
   ProtectRange(ShadowEnd(), MetaShadowBeg());
-#ifdef TSAN_MID_APP_RANGE
+  if (MidAppMemBeg()) {
     ProtectRange(MetaShadowEnd(), MidAppMemBeg());
     ProtectRange(MidAppMemEnd(), TraceMemBeg());
-#else
+  } else {
     ProtectRange(MetaShadowEnd(), TraceMemBeg());
-#endif
+  }
   // 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
 
 #if defined(__s390x__)