tsan: deduplicate mapping selection

[dvyukov]

Summary

Currently we have mapping selection duplicated 9 times.
Deduplicate it. No functional changes.

Depends on D107734.

[melver]

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

599

If MappingType was moved above this function, then this could also use 'MappingType arg.?

664

The wrapping of Apply into MappingField is only required because of Result, right?

You could make SelectMapping have 'auto' return, then this wouldn't be needed.

666

Maybe I missed something, but why is this not using 'MappingType type'? Then the compiler would also check the switch for exhaustiveness.
Similarly all other Apply implementations.

[melver]

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

666

( And in case it is applicable, perhaps it's also an opportunity to switch to an 'enum class'. )

[dvyukov]

use auto as return type

[dvyukov]

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

599

This SelectMapping function is now generalized to call caller-passed function and it replaces _9_ different copy-pastes of the same code that were different by the called function.
Most of these functions accept uptr (addresses), only one version accepted MappingType. I could parametrize the arg type as typename Func::Arg but I decided it's not worth it.

664

Not only because of return type.
We want to parametrize SelectMapping with effectively a function template. I.e. pass a function that is itself parameterized by Mapping.
There are no function template template arguments, only classes can be template template arguments. The only way I know to do it is to wrap the function in a class, thus Func::Apply.

But using 'auto' for return type is indeed a good idea and it allows to get rid of Result typedef.
I've changed the code to use auto.

666

I've tried this one (the rest inherently want uptr arg type) and it gives me warnings (intentional) and an error (not intentional). I am not sure how to avoid the error w/o introducing another typedef for Func::Arg.

tsan_platform.h:667:13: warning: enumeration values 'MAPPING_APP_BEG' and 'MAPPING_APP_END' not handled in switch [-Wswitch]

switch (type) {
        ^

tsan_platform.h:637:10: error: no matching function for call to 'Apply'

return Func::template Apply<Mapping>(arg);
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~

tsan_platform.h:699:10: note: in instantiation of function template specialization 'tsan::SelectMapping<tsan::MappingField>' requested here

return SelectMapping<MappingField>(MAPPING_LO_APP_BEG);
       ^

tsan_platform.h:666:17: note: candidate function template not viable: no known conversion from 'sanitizer::uptr' (aka 'unsigned long') to 'tsan::MappingType' for 1st argument

static Result Apply(MappingType type) {

[dvyukov]

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

666

We can cast uptr to the enum _within_ the function to get warnings about missed switch cases.
Lemme do this separately because it will cause lots of rebase conflicts and also current we have litigate warnings about missed switch cases because of these #ifdef's.

[melver]

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

666

Re error: If it's just passing through the type to Apply then another 'typename Arg' on SelectMapping would be just as safe.

But re warnings, if intentional, then uptr is probably ok (or have a 'default:' but that defeats the the compiler checking things for us).

[dvyukov]

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

666

The warnings are semi-intentional. They actually should be fixed by subsequent commits that unify names and remove ifdefs.

What do you think re:
What do you think re casting 'uptr' to MappingType _within_ the function so that we still get warnings about missed switch cases; and introducing enum class; but keeping arg type as uptr?
But I would like to do it in a new commit on top of this series.

[dvyukov]

changed SelectMapping to use template Arg and rebased

[dvyukov]

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

666

I've changed SelectMapping arg to "template Arg" and used MappingType enum as arg here. PTAL.

[melver]

Glad it worked.

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

 #else
 #  error "Unknown platform"
 #endif
 
 #ifdef TSAN_RUNTIME_VMA
 extern uptr vmaSize;
 #endif
 
+template <typename Func, typename Arg>
+ALWAYS_INLINE auto SelectMapping(Arg arg) {
+#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
+  switch (vmaSize) {
+    case 39:
+      return Func::template Apply<Mapping39>(arg);
+    case 42:
+      return Func::template Apply<Mapping42>(arg);
+    case 48:
+      return Func::template Apply<Mapping48>(arg);
+  }
+  DCHECK(0);
+  return 0;
+#elif defined(__powerpc64__)
+  switch (vmaSize) {
+#  if !SANITIZER_GO
+    case 44:
+      return Func::template Apply<Mapping44>(arg);
+#  endif
+    case 46:
+      return Func::template Apply<Mapping46>(arg);
+    case 47:
+      return Func::template Apply<Mapping47>(arg);
+  }
+  DCHECK(0);
+  return 0;
+#elif defined(__mips64)
+  switch (vmaSize) {
+#  if !SANITIZER_GO
+    case 40:
+      return Func::template Apply<Mapping40>(arg);
+#  else
+    case 47:
+      return Func::template Apply<Mapping47>(arg);
+#  endif
+  }
+  DCHECK(0);
+  return 0;
+#else
+  return Func::template Apply<Mapping>(arg);
+#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,
 };
 
-template<typename Mapping, int Type>
-uptr MappingImpl(void) {
-  switch (Type) {
+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;
 #endif
     case MAPPING_SHADOW_BEG: return Mapping::kShadowBeg;
     case MAPPING_SHADOW_END: return Mapping::kShadowEnd;
     case MAPPING_META_SHADOW_BEG: return Mapping::kMetaShadowBeg;
     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) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return MappingImpl<Mapping44, Type>();
-#endif
-    case 46: return MappingImpl<Mapping46, Type>();
-    case 47: return MappingImpl<Mapping47, Type>();
-  }
+    default:
       DCHECK(0);
       return 0;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return MappingImpl<Mapping40, Type>();
-#else
-    case 47: return MappingImpl<Mapping47, Type>();
-#endif
     }
-  DCHECK(0);
-  return 0;
-#else
-  return MappingImpl<Mapping, Type>();
-#endif
   }
+};
 
 #if !SANITIZER_GO
 ALWAYS_INLINE
 uptr LoAppMemBeg(void) {
-  return MappingArchImpl<MAPPING_LO_APP_BEG>();
+  return SelectMapping<MappingField>(MAPPING_LO_APP_BEG);
 }
 ALWAYS_INLINE
 uptr LoAppMemEnd(void) {
-  return MappingArchImpl<MAPPING_LO_APP_END>();
+  return SelectMapping<MappingField>(MAPPING_LO_APP_END);
 }
 
 #ifdef TSAN_MID_APP_RANGE
 ALWAYS_INLINE
 uptr MidAppMemBeg(void) {
-  return MappingArchImpl<MAPPING_MID_APP_BEG>();
+  return SelectMapping<MappingField>(MAPPING_MID_APP_BEG);
 }
 ALWAYS_INLINE
 uptr MidAppMemEnd(void) {
-  return MappingArchImpl<MAPPING_MID_APP_END>();
+  return SelectMapping<MappingField>(MAPPING_MID_APP_END);
 }
 #endif
 
 ALWAYS_INLINE
-uptr HeapMemBeg(void) {
-  return MappingArchImpl<MAPPING_HEAP_BEG>();
-}
+uptr HeapMemBeg(void) { return SelectMapping<MappingField>(MAPPING_HEAP_BEG); }
 ALWAYS_INLINE
-uptr HeapMemEnd(void) {
-  return MappingArchImpl<MAPPING_HEAP_END>();
-}
+uptr HeapMemEnd(void) { return SelectMapping<MappingField>(MAPPING_HEAP_END); }
 
 ALWAYS_INLINE
 uptr HiAppMemBeg(void) {
-  return MappingArchImpl<MAPPING_HI_APP_BEG>();
+  return SelectMapping<MappingField>(MAPPING_HI_APP_BEG);
 }
 ALWAYS_INLINE
 uptr HiAppMemEnd(void) {
-  return MappingArchImpl<MAPPING_HI_APP_END>();
+  return SelectMapping<MappingField>(MAPPING_HI_APP_END);
 }
 
 ALWAYS_INLINE
-uptr VdsoBeg(void) {
-  return MappingArchImpl<MAPPING_VDSO_BEG>();
-}
+uptr VdsoBeg(void) { return SelectMapping<MappingField>(MAPPING_VDSO_BEG); }
 
 #else
 
 ALWAYS_INLINE
-uptr AppMemBeg(void) {
-  return MappingArchImpl<MAPPING_APP_BEG>();
-}
+uptr AppMemBeg(void) { return SelectMapping<MappingField>(MAPPING_APP_BEG); }
 ALWAYS_INLINE
-uptr AppMemEnd(void) {
-  return MappingArchImpl<MAPPING_APP_END>();
-}
+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;
case 0:
     *start = AppMemBeg();
     *end = AppMemEnd();
     return true;
 #endif
   }
 }
 
 ALWAYS_INLINE
-uptr ShadowBeg(void) {
-  return MappingArchImpl<MAPPING_SHADOW_BEG>();
-}
+uptr ShadowBeg(void) { return SelectMapping<MappingField>(MAPPING_SHADOW_BEG); }
 ALWAYS_INLINE
-uptr ShadowEnd(void) {
-  return MappingArchImpl<MAPPING_SHADOW_END>();
-}
+uptr ShadowEnd(void) { return SelectMapping<MappingField>(MAPPING_SHADOW_END); }
 
 ALWAYS_INLINE
 uptr MetaShadowBeg(void) {
-  return MappingArchImpl<MAPPING_META_SHADOW_BEG>();
+  return SelectMapping<MappingField>(MAPPING_META_SHADOW_BEG);
 }
 ALWAYS_INLINE
 uptr MetaShadowEnd(void) {
-  return MappingArchImpl<MAPPING_META_SHADOW_END>();
+  return SelectMapping<MappingField>(MAPPING_META_SHADOW_END);
 }
 
 ALWAYS_INLINE
 uptr TraceMemBeg(void) {
-  return MappingArchImpl<MAPPING_TRACE_BEG>();
+  return SelectMapping<MappingField>(MAPPING_TRACE_BEG);
 }
 ALWAYS_INLINE
 uptr TraceMemEnd(void) {
-  return MappingArchImpl<MAPPING_TRACE_END>();
+  return SelectMapping<MappingField>(MAPPING_TRACE_END);
 }
 
-
-template<typename Mapping>
-bool IsAppMemImpl(uptr mem) {
+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
   }
+};
 
 ALWAYS_INLINE
-bool IsAppMem(uptr mem) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return IsAppMemImpl<Mapping44>(mem);
-#endif
-    case 46: return IsAppMemImpl<Mapping46>(mem);
-    case 47: return IsAppMemImpl<Mapping47>(mem);
-  }
-  DCHECK(0);
-  return false;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return IsAppMemImpl<Mapping40>(mem);
-#else
-    case 47: return IsAppMemImpl<Mapping47>(mem);
-#endif
-  }
-  DCHECK(0);
-  return false;
-#else
-  return IsAppMemImpl<Mapping>(mem);
-#endif
-}
-
+bool IsAppMem(uptr mem) { return SelectMapping<IsAppMemImpl>(mem); }
 
-template<typename Mapping>
-bool IsShadowMemImpl(uptr mem) {
+struct IsShadowMemImpl {
+  template <typename Mapping>
+  static bool Apply(uptr mem) {
     return mem >= Mapping::kShadowBeg && mem <= Mapping::kShadowEnd;
   }
+};
 
 ALWAYS_INLINE
 bool IsShadowMem(RawShadow *p) {
-  uptr mem = reinterpret_cast<uptr>(p);
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return IsShadowMemImpl<Mapping44>(mem);
-#endif
-    case 46: return IsShadowMemImpl<Mapping46>(mem);
-    case 47: return IsShadowMemImpl<Mapping47>(mem);
-  }
-  DCHECK(0);
-  return false;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return IsShadowMemImpl<Mapping40>(mem);
-#else
-    case 47: return IsShadowMemImpl<Mapping47>(mem);
-#endif
-  }
-  DCHECK(0);
-  return false;
-#else
-  return IsShadowMemImpl<Mapping>(mem);
-#endif
+  return SelectMapping<IsShadowMemImpl>(reinterpret_cast<uptr>(p));
 }
 
-template<typename Mapping>
-bool IsMetaMemImpl(uptr mem) {
+struct IsMetaMemImpl {
+  template <typename Mapping>
+  static bool Apply(uptr mem) {
     return mem >= Mapping::kMetaShadowBeg && mem <= Mapping::kMetaShadowEnd;
   }
+};
 
 ALWAYS_INLINE
 bool IsMetaMem(const u32 *p) {
-  uptr mem = reinterpret_cast<uptr>(p);
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return IsMetaMemImpl<Mapping44>(mem);
-#endif
-    case 46: return IsMetaMemImpl<Mapping46>(mem);
-    case 47: return IsMetaMemImpl<Mapping47>(mem);
-  }
-  DCHECK(0);
-  return false;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return IsMetaMemImpl<Mapping40>(mem);
-#else
-    case 47: return IsMetaMemImpl<Mapping47>(mem);
-#endif
-  }
-  DCHECK(0);
-  return false;
-#else
-  return IsMetaMemImpl<Mapping>(mem);
-#endif
+  return SelectMapping<IsMetaMemImpl>(reinterpret_cast<uptr>(p));
 }
 
+struct MemToShadowImpl {
   template <typename Mapping>
-uptr MemToShadowRaw(uptr x) {
-  DCHECK(IsAppMem(x));
+  static uptr Apply(uptr x) {
+    DCHECK(IsAppMemImpl::Apply<Mapping>(x));
 #if !SANITIZER_GO
-  return (((x) & ~(Mapping::kAppMemMsk | (kShadowCell - 1)))
-      ^ Mapping::kAppMemXor) * kShadowCnt;
+    return (((x) & ~(Mapping::kAppMemMsk | (kShadowCell - 1))) ^
+            Mapping::kAppMemXor) *
+           kShadowCnt;
 #else
 # ifndef SANITIZER_WINDOWS
     return ((x & ~(kShadowCell - 1)) * kShadowCnt) | Mapping::kShadowBeg;
 # else
     return ((x & ~(kShadowCell - 1)) * kShadowCnt) + Mapping::kShadowBeg;
 # endif
 #endif
   }
-
-template <typename Mapping>
-RawShadow *MemToShadowImpl(uptr x) {
-  return reinterpret_cast<RawShadow *>(MemToShadowRaw<Mapping>(x));
-}
+};
 
 ALWAYS_INLINE
 RawShadow *MemToShadow(uptr x) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  switch (vmaSize) {
-    case 39: return MemToShadowImpl<Mapping39>(x);
-    case 42: return MemToShadowImpl<Mapping42>(x);
-    case 48: return MemToShadowImpl<Mapping48>(x);
-  }
-  DCHECK(0);
-  return nullptr;
-#elif defined(__powerpc64__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return MemToShadowImpl<Mapping44>(x);
-#endif
-    case 46: return MemToShadowImpl<Mapping46>(x);
-    case 47: return MemToShadowImpl<Mapping47>(x);
-  }
-  DCHECK(0);
-  return nullptr;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return MemToShadowImpl<Mapping40>(x);
-#else
-    case 47: return MemToShadowImpl<Mapping47>(x);
-#endif
-  }
-  DCHECK(0);
-  return nullptr;
-#else
-  return MemToShadowImpl<Mapping>(x);
-#endif
+  return reinterpret_cast<RawShadow *>(SelectMapping<MemToShadowImpl>(x));
 }
 
-template<typename Mapping>
-u32 *MemToMetaImpl(uptr x) {
-  DCHECK(IsAppMem(x));
+struct MemToMetaImpl {
+  template <typename Mapping>
+  static u32 *Apply(uptr x) {
+    DCHECK(IsAppMemImpl::Apply<Mapping>(x));
 #if !SANITIZER_GO
   return (u32*)(((((x) & ~(Mapping::kAppMemMsk | (kMetaShadowCell - 1)))) /
       kMetaShadowCell * kMetaShadowSize) | Mapping::kMetaShadowBeg);
 #else
 # ifndef SANITIZER_WINDOWS
   return (u32*)(((x & ~(kMetaShadowCell - 1)) / \
       kMetaShadowCell * kMetaShadowSize) | Mapping::kMetaShadowBeg);
 # else
   return (u32*)(((x & ~(kMetaShadowCell - 1)) / \
       kMetaShadowCell * kMetaShadowSize) + Mapping::kMetaShadowBeg);
 # endif
 #endif
   }
+};
 
 ALWAYS_INLINE
-u32 *MemToMeta(uptr x) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return MemToMetaImpl<Mapping44>(x);
-#endif
-    case 46: return MemToMetaImpl<Mapping46>(x);
-    case 47: return MemToMetaImpl<Mapping47>(x);
-  }
-  DCHECK(0);
-  return 0;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return MemToMetaImpl<Mapping40>(x);
-#else
-    case 47: return MemToMetaImpl<Mapping47>(x);
-#endif
-  }
-  DCHECK(0);
-  return 0;
-#else
-  return MemToMetaImpl<Mapping>(x);
-#endif
-}
+u32 *MemToMeta(uptr x) { return SelectMapping<MemToMetaImpl>(x); }
 
+struct ShadowToMemImpl {
   template <typename Mapping>
-uptr ShadowToMemImpl(RawShadow *s) {
-  DCHECK(IsShadowMem(s));
-  uptr sp = reinterpret_cast<uptr>(s);
+  static uptr Apply(uptr sp) {
+    DCHECK(IsShadowMemImpl::Apply<Mapping>(sp));
 #if !SANITIZER_GO
   // The shadow mapping is non-linear and we've lost some bits, so we don't have
   // 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 &&
-      MemToShadow(p) == s)
+      MemToShadowImpl::Apply<Mapping>(p) == sp)
     return p;
 # ifdef TSAN_MID_APP_RANGE
   p = ((sp / kShadowCnt) ^ Mapping::kAppMemXor) +
       (Mapping::kMidAppMemBeg & Mapping::kAppMemMsk);
   if (p >= Mapping::kMidAppMemBeg && p < Mapping::kMidAppMemEnd &&
-      MemToShadow(p) == s)
+      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
   }
+};
 
 ALWAYS_INLINE
 uptr ShadowToMem(RawShadow *s) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return ShadowToMemImpl<Mapping44>(s);
-#endif
-    case 46: return ShadowToMemImpl<Mapping46>(s);
-    case 47: return ShadowToMemImpl<Mapping47>(s);
-  }
-  DCHECK(0);
-  return 0;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return ShadowToMemImpl<Mapping40>(s);
-#else
-    case 47: return ShadowToMemImpl<Mapping47>(s);
-#endif
-  }
-  DCHECK(0);
-  return 0;
-#else
-  return ShadowToMemImpl<Mapping>(s);
-#endif
+  return SelectMapping<ShadowToMemImpl>(reinterpret_cast<uptr>(s));
 }
 
 // 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;
+struct GetThreadTraceImpl {
+  template <typename Mapping>
+  static uptr Apply(uptr tid) {
+    uptr p = Mapping::kTraceMemBeg + tid * kTotalTraceSize;
     DCHECK_LT(p, Mapping::kTraceMemEnd);
     return p;
   }
+};
 
 ALWAYS_INLINE
-uptr GetThreadTrace(int tid) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return GetThreadTraceImpl<Mapping44>(tid);
-#endif
-    case 46: return GetThreadTraceImpl<Mapping46>(tid);
-    case 47: return GetThreadTraceImpl<Mapping47>(tid);
-  }
-  DCHECK(0);
-  return 0;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return GetThreadTraceImpl<Mapping40>(tid);
-#else
-    case 47: return GetThreadTraceImpl<Mapping47>(tid);
-#endif
-  }
-  DCHECK(0);
-  return 0;
-#else
-  return GetThreadTraceImpl<Mapping>(tid);
-#endif
-}
-
+uptr GetThreadTrace(int tid) { return SelectMapping<GetThreadTraceImpl>(tid); }
 
-template<typename Mapping>
-uptr GetThreadTraceHeaderImpl(int tid) {
-  uptr p = Mapping::kTraceMemBeg + (uptr)tid * kTotalTraceSize
-      + kTraceSize * sizeof(Event);
+struct GetThreadTraceHeaderImpl {
+  template <typename Mapping>
+  static uptr Apply(uptr tid) {
+    uptr p = Mapping::kTraceMemBeg + tid * kTotalTraceSize +
+             kTraceSize * sizeof(Event);
     DCHECK_LT(p, Mapping::kTraceMemEnd);
     return p;
   }
+};
 
 ALWAYS_INLINE
 uptr GetThreadTraceHeader(int tid) {
-#if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
-  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__)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 44: return GetThreadTraceHeaderImpl<Mapping44>(tid);
-#endif
-    case 46: return GetThreadTraceHeaderImpl<Mapping46>(tid);
-    case 47: return GetThreadTraceHeaderImpl<Mapping47>(tid);
-  }
-  DCHECK(0);
-  return 0;
-#elif defined(__mips64)
-  switch (vmaSize) {
-#if !SANITIZER_GO
-    case 40: return GetThreadTraceHeaderImpl<Mapping40>(tid);
-#else
-    case 47: return GetThreadTraceHeaderImpl<Mapping47>(tid);
-#endif
-  }
-  DCHECK(0);
-  return 0;
-#else
-  return GetThreadTraceHeaderImpl<Mapping>(tid);
-#endif
+  return SelectMapping<GetThreadTraceHeaderImpl>(tid);
 }
 
 void InitializePlatform();
 void InitializePlatformEarly();
 void CheckAndProtect();
 void InitializeShadowMemoryPlatform();
 void FlushShadowMemory();
 void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive);