[NFC] Move `AddressSpaceView` out of `Params` for Size class allocators.

[delcypher]

Summary

Making Params a templated type and passing the AddressSpaceView
to the size class allocators was a design mistake. This patch instead
makes AddressSpaceView a separate template parameter and turns
Params::ByteMap into a templated alias Params::ByteMapASVT.
This gives us several wins.

• This change in design means it possible for the size class allocators can construct the type for their RemoteAddressSpaceView counter-part. Previously that was exceedingly difficult because the Params type the size class allocators received already had the AddressSpaceView type chosen.
• The AP32 and AP64 no longer need to be templated.
• AP64 declarations go back to being simple.
• The type of SizeClassAllocator32::ByteMap is now correct by construction (i.e. AP32 definitions can't pass in a ByteMap with the wrong AddressSpaceView).

The only downside to this patch is that it makes AP32 declarations
more complicated.

rdar://problem/45284065

[vitalybuka]

I still prefer D57279

[vitalybuka]

Removing stale patches from the "Ready to Review" list.

lib/asan/asan_allocator.h

 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x8000000000ULL;  // 500G
 typedef DefaultSizeClassMap SizeClassMap;
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 typedef DefaultSizeClassMap SizeClassMap;
 # endif
-template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef __asan::SizeClassMap SizeClassMap;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
 template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
+using PrimaryAllocatorASVT = SizeClassAllocator64<AP64, AddressSpaceView>;
 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
 #else  // Fallback to SizeClassAllocator32.
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
 template <typename AddressSpaceView>
 using ByteMapASVT = FlatByteMap<kNumRegions, AddressSpaceView>;
 # elif SANITIZER_WORDSIZE == 64
 template <typename AddressSpaceView>
 using ByteMapASVT =
     TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
 # endif
 typedef CompactSizeClassMap SizeClassMap;
-template <typename AddressSpaceViewTy>
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 16;
   typedef __asan::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = __asan::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = __asan::ByteMapASVT<AddressSpaceView>;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = __asan::ByteMapASVT<AddressSpaceView>;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView> >;
+using PrimaryAllocatorASVT = SizeClassAllocator32<AP32, AddressSpaceView>;
 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 static const uptr kNumberOfSizeClasses = SizeClassMap::kNumClasses;
 template <typename AddressSpaceView>
 using AllocatorCacheASVT =
     SizeClassAllocatorLocalCache<PrimaryAllocatorASVT<AddressSpaceView>>;
 using AllocatorCache = AllocatorCacheASVT<LocalAddressSpaceView>;

lib/lsan/lsan_allocator.h

 #if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
     defined(__arm__)
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
 template <typename AddressSpaceView>
 using ByteMapASVT =
     TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
 
-template <typename AddressSpaceViewTy>
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = sizeof(ChunkMetadata);
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = __lsan::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = __lsan::ByteMapASVT<AddressSpaceView>;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = __lsan::ByteMapASVT<AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+using PrimaryAllocatorASVT = SizeClassAllocator32<AP32, AddressSpaceView>;
 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
 #elif defined(__x86_64__) || defined(__powerpc64__)
 # if defined(__powerpc64__)
 const uptr kAllocatorSpace = 0xa0000000000ULL;
 const uptr kAllocatorSize  = 0x20000000000ULL;  // 2T.
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.
 # endif
-template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = sizeof(ChunkMetadata);
   typedef DefaultSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
 template <typename AddressSpaceView>
-using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
+using PrimaryAllocatorASVT = SizeClassAllocator64<AP64, AddressSpaceView>;
 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
 #endif
 
 template <typename AddressSpaceView>
 using AllocatorCacheASVT =
     SizeClassAllocatorLocalCache<PrimaryAllocatorASVT<AddressSpaceView>>;
 using AllocatorCache = AllocatorCacheASVT<LocalAddressSpaceView>;
 

lib/msan/msan_allocator.cc

void OnUnmap(uptr p, uptr size) const {
     }
   }
 };
 
 #if defined(__mips64)
   static const uptr kMaxAllowedMallocSize = 2UL << 30;
   static const uptr kRegionSizeLog = 20;
   static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
-  typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+  template <typename AddressSpaceView>
+  using ByteMapASVT =
+      TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
 
   struct AP32 {
     static const uptr kSpaceBeg = 0;
     static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef __sanitizer::CompactSizeClassMap SizeClassMap;
     static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
-    using AddressSpaceView = LocalAddressSpaceView;
-    using ByteMap = __msan::ByteMap;
+    template <typename AddressSpaceView>
+    using ByteMapASVT = __msan::ByteMapASVT<AddressSpaceView>;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
   };
   typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #elif defined(__x86_64__)
 #if SANITIZER_NETBSD || \
     (SANITIZER_LINUX && !defined(MSAN_LINUX_X86_64_OLD_MAPPING))
   static const uptr kAllocatorSpace = 0x700000000000ULL;
 #else
   static const uptr kAllocatorSpace = 0x600000000000ULL;
 #endif
   static const uptr kMaxAllowedMallocSize = 8UL << 30;
 
   struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
     static const uptr kSpaceBeg = kAllocatorSpace;
     static const uptr kSpaceSize = 0x40000000000; // 4T.
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef DefaultSizeClassMap SizeClassMap;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
-    using AddressSpaceView = LocalAddressSpaceView;
   };
 
   typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 
 #elif defined(__powerpc64__)
   static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
 
   struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
     static const uptr kSpaceBeg = 0x300000000000;
     static const uptr kSpaceSize = 0x020000000000; // 2T.
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef DefaultSizeClassMap SizeClassMap;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
-    using AddressSpaceView = LocalAddressSpaceView;
   };
 
   typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #elif defined(__aarch64__)
   static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
   static const uptr kRegionSizeLog = 20;
   static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
-  typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+  template <typename AddressSpaceView>
+  using ByteMapASVT =
+      TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>;
 
   struct AP32 {
     static const uptr kSpaceBeg = 0;
     static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
     static const uptr kMetadataSize = sizeof(Metadata);
     typedef __sanitizer::CompactSizeClassMap SizeClassMap;
     static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
-    using AddressSpaceView = LocalAddressSpaceView;
-    using ByteMap = __msan::ByteMap;
+    template <typename AddressSpaceView>
+    using ByteMapASVT = __msan::ByteMapASVT<AddressSpaceView>;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
   };
   typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,

lib/sanitizer_common/sanitizer_allocator_internal.h

 // FIXME: Check if we may use even more compact size class map for internal
 // purposes.
 typedef CompactSizeClassMap InternalSizeClassMap;
 
 static const uptr kInternalAllocatorRegionSizeLog = 20;
 static const uptr kInternalAllocatorNumRegions =
     SANITIZER_MMAP_RANGE_SIZE >> kInternalAllocatorRegionSizeLog;
 #if SANITIZER_WORDSIZE == 32
-typedef FlatByteMap<kInternalAllocatorNumRegions> ByteMap;
+template <typename AddressSpaceView>
+using ByteMapASVT = FlatByteMap<kInternalAllocatorNumRegions, AddressSpaceView>;
 #else
-typedef TwoLevelByteMap<(kInternalAllocatorNumRegions >> 12), 1 << 12> ByteMap;
+template <typename AddressSpaceView>
+using ByteMapASVT = TwoLevelByteMap<(kInternalAllocatorNumRegions >> 12),
+                                    1 << 12, AddressSpaceView>;
 #endif
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef InternalSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = kInternalAllocatorRegionSizeLog;
-  using AddressSpaceView = LocalAddressSpaceView;
-  using ByteMap = __sanitizer::ByteMap;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = __sanitizer::ByteMapASVT<AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32> PrimaryInternalAllocator;
+using PrimaryInternalAllocator = SizeClassAllocator32<AP32>;
 
 typedef SizeClassAllocatorLocalCache<PrimaryInternalAllocator>
     InternalAllocatorCache;
 
 typedef LargeMmapAllocator<NoOpMapUnmapCallback,
                            LargeMmapAllocatorPtrArrayStatic>
     SecondaryInternalAllocator;
 

lib/sanitizer_common/sanitizer_allocator_primary32.h

 
 struct SizeClassAllocator32FlagMasks {  //  Bit masks.
   enum {
     kRandomShuffleChunks = 1,
     kUseSeparateSizeClassForBatch = 2,
   };
 };
 
-template <class Params>
+template <class Params, typename AddressSpaceViewTy = LocalAddressSpaceView>
 class SizeClassAllocator32 {
  public:
-  using AddressSpaceView = typename Params::AddressSpaceView;
+  using AddressSpaceView = AddressSpaceViewTy;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const u64 kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = Params::kRegionSizeLog;
-  typedef typename Params::ByteMap ByteMap;
+  using ByteMap = typename Params::template ByteMapASVT<AddressSpaceView>;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
   static_assert(
       is_same<typename ByteMap::AddressSpaceView, AddressSpaceView>::value,
       "AddressSpaceView type mismatch");
 
   static const bool kRandomShuffleChunks = Params::kFlags &
       SizeClassAllocator32FlagMasks::kRandomShuffleChunks;

lib/sanitizer_common/sanitizer_allocator_primary64.h

 // UserChunk1 ... UserChunkN <gap> MetaChunkN ... MetaChunk1 FreeArray
 
 struct SizeClassAllocator64FlagMasks {  //  Bit masks.
   enum {
     kRandomShuffleChunks = 1,
   };
 };
 
-template <class Params>
+template <class Params, typename AddressSpaceViewTy = LocalAddressSpaceView>
 class SizeClassAllocator64 {
  public:
-  using AddressSpaceView = typename Params::AddressSpaceView;
+  using AddressSpaceView = AddressSpaceViewTy;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const uptr kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
   static const bool kRandomShuffleChunks =
       Params::kFlags & SizeClassAllocator64FlagMasks::kRandomShuffleChunks;

lib/sanitizer_common/tests/sanitizer_allocator_test.cc

 typedef VeryCompactSizeClassMap SizeClassMap;
 #else
 static const uptr kAllocatorSpace = 0x700000000000ULL;
 static const uptr kAllocatorSize  = 0x010000000000ULL;  // 1T.
 static const u64 kAddressSpaceSize = 1ULL << 47;
 typedef DefaultSizeClassMap SizeClassMap;
 #endif
 
-template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator Params. Short name for shorter demangled names..
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef ::SizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64Dyn {
   static const uptr kSpaceBeg = ~(uptr)0;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef ::SizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64Compact {
   static const uptr kSpaceBeg = ~(uptr)0;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef CompactSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64VeryCompact {
   static const uptr kSpaceBeg = ~(uptr)0;
   static const uptr kSpaceSize = 1ULL << 37;
   static const uptr kMetadataSize = 16;
   typedef VeryCompactSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
-template <typename AddressSpaceViewTy>
 struct AP64Dense {
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 16;
   typedef DenseSizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = AddressSpaceViewTy;
 };
 
 template <typename AddressSpaceView>
-using Allocator64ASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
+using Allocator64ASVT = SizeClassAllocator64<AP64, AddressSpaceView>;
 using Allocator64 = Allocator64ASVT<LocalAddressSpaceView>;
 
 template <typename AddressSpaceView>
-using Allocator64DynamicASVT = SizeClassAllocator64<AP64Dyn<AddressSpaceView>>;
+using Allocator64DynamicASVT = SizeClassAllocator64<AP64Dyn, AddressSpaceView>;
 using Allocator64Dynamic = Allocator64DynamicASVT<LocalAddressSpaceView>;
 
 template <typename AddressSpaceView>
 using Allocator64CompactASVT =
-    SizeClassAllocator64<AP64Compact<AddressSpaceView>>;
+    SizeClassAllocator64<AP64Compact, AddressSpaceView>;
 using Allocator64Compact = Allocator64CompactASVT<LocalAddressSpaceView>;
 
 template <typename AddressSpaceView>
 using Allocator64VeryCompactASVT =
-    SizeClassAllocator64<AP64VeryCompact<AddressSpaceView>>;
+    SizeClassAllocator64<AP64VeryCompact, AddressSpaceView>;
 using Allocator64VeryCompact =
     Allocator64VeryCompactASVT<LocalAddressSpaceView>;
 
 template <typename AddressSpaceView>
-using Allocator64DenseASVT = SizeClassAllocator64<AP64Dense<AddressSpaceView>>;
+using Allocator64DenseASVT = SizeClassAllocator64<AP64Dense, AddressSpaceView>;
 using Allocator64Dense = Allocator64DenseASVT<LocalAddressSpaceView>;
 
 #elif defined(__mips64)
 static const u64 kAddressSpaceSize = 1ULL << 40;
 #elif defined(__aarch64__)
 static const u64 kAddressSpaceSize = 1ULL << 39;
 #elif defined(__s390x__)
 static const u64 kAddressSpaceSize = 1ULL << 53;
 #elif defined(__s390__)
 static const u64 kAddressSpaceSize = 1ULL << 31;
 #else
 static const u64 kAddressSpaceSize = 1ULL << 32;
 #endif
 
 static const uptr kRegionSizeLog = FIRST_32_SECOND_64(20, 24);
 static const uptr kFlatByteMapSize = kAddressSpaceSize >> kRegionSizeLog;
 
-template <typename AddressSpaceViewTy>
 struct AP32Compact {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = kAddressSpaceSize;
   static const uptr kMetadataSize = 16;
   typedef CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = ::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 template <typename AddressSpaceView>
 using Allocator32CompactASVT =
-    SizeClassAllocator32<AP32Compact<AddressSpaceView>>;
+    SizeClassAllocator32<AP32Compact, AddressSpaceView>;
 using Allocator32Compact = Allocator32CompactASVT<LocalAddressSpaceView>;
 
 template <class SizeClassMap>
 void TestSizeClassMap() {
   typedef SizeClassMap SCMap;
   SCMap::Print();
   SCMap::Validate();
 }

 }
 #endif
 #endif
 
 TEST(SanitizerCommon, SizeClassAllocator32Compact) {
   TestSizeClassAllocator<Allocator32Compact>();
 }
 
-template <typename AddressSpaceViewTy>
 struct AP32SeparateBatches {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = kAddressSpaceSize;
   static const uptr kMetadataSize = 16;
   typedef DefaultSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = ::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 };
 template <typename AddressSpaceView>
 using Allocator32SeparateBatchesASVT =
-    SizeClassAllocator32<AP32SeparateBatches<AddressSpaceView>>;
+    SizeClassAllocator32<AP32SeparateBatches, AddressSpaceView>;
 using Allocator32SeparateBatches =
     Allocator32SeparateBatchesASVT<LocalAddressSpaceView>;
 
 TEST(SanitizerCommon, SizeClassAllocator32SeparateBatches) {
   TestSizeClassAllocator<Allocator32SeparateBatches>();
 }
 
 template <class Allocator>
TEST(SanitizerCommon, SizeClassAllocator64MapUnmapCallback) {
   EXPECT_EQ(TestMapUnmapCallback::map_count, 4);
   a->TestOnlyUnmap();
   EXPECT_EQ(TestMapUnmapCallback::unmap_count, 1);  // The whole thing.
   delete a;
 }
 #endif
 #endif
 
-template <typename AddressSpaceViewTy = LocalAddressSpaceView>
 struct AP32WithCallback {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = kAddressSpaceSize;
   static const uptr kMetadataSize = 16;
   typedef CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = ::kRegionSizeLog;
-  using AddressSpaceView = AddressSpaceViewTy;
-  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
   typedef TestMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 
 TEST(SanitizerCommon, SizeClassAllocator32MapUnmapCallback) {
   TestMapUnmapCallback::map_count = 0;
   TestMapUnmapCallback::unmap_count = 0;
-  typedef SizeClassAllocator32<AP32WithCallback<>> Allocator32WithCallBack;
+  typedef SizeClassAllocator32<AP32WithCallback> Allocator32WithCallBack;
   Allocator32WithCallBack *a = new Allocator32WithCallBack;
   a->Init(kReleaseToOSIntervalNever);
   EXPECT_EQ(TestMapUnmapCallback::map_count, 0);
   SizeClassAllocatorLocalCache<Allocator32WithCallBack>  cache;
   memset(&cache, 0, sizeof(cache));
   cache.Init(0);
   AllocatorStats stats;
   stats.Init();

lib/scudo/scudo_allocator.h

 struct AP64 {
   static const uptr kSpaceBeg = AllocatorSpace;
   static const uptr kSpaceSize = AllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef __scudo::SizeClassMap SizeClassMap;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
-  using AddressSpaceView = LocalAddressSpaceView;
 };
 typedef SizeClassAllocator64<AP64> PrimaryT;
 #else
 static const uptr NumRegions = SANITIZER_MMAP_RANGE_SIZE >> RegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
-typedef FlatByteMap<NumRegions> ByteMap;
+template <typename AddressSpaceView>
+using ByteMapASVT = FlatByteMap<NumRegions, AddressSpaceView>;
 # elif SANITIZER_WORDSIZE == 64
-typedef TwoLevelByteMap<(NumRegions >> 12), 1 << 12> ByteMap;
+template <typename AddressSpaceView>
+using ByteMapASVT =
+    TwoLevelByteMap<(NumRegions >> 12), 1 << 12, AddressSpaceView>;
 # endif  // SANITIZER_WORDSIZE
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef __scudo::SizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = RegionSizeLog;
-  using AddressSpaceView = LocalAddressSpaceView;
-  using ByteMap = __scudo::ByteMap;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = __scudo::ByteMapASVT<AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator32FlagMasks::kRandomShuffleChunks |
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 };
 typedef SizeClassAllocator32<AP32> PrimaryT;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 

lib/tsan/rtl/tsan_rtl.h

 namespace __tsan {
 
 #if !SANITIZER_GO
 struct MapUnmapCallback;
 #if defined(__mips64) || defined(__aarch64__) || defined(__powerpc__)
 static const uptr kAllocatorRegionSizeLog = 20;
 static const uptr kAllocatorNumRegions =
     SANITIZER_MMAP_RANGE_SIZE >> kAllocatorRegionSizeLog;
-using ByteMap = TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
-                                LocalAddressSpaceView, MapUnmapCallback>;
+template <typename AddressSpaceView>
+using ByteMapASVT = TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
+                                    AddressSpaceView, MapUnmapCallback>;
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = kAllocatorRegionSizeLog;
-  using AddressSpaceView = LocalAddressSpaceView;
-  using ByteMap = __tsan::ByteMap;
+  template <typename AddressSpaceView>
+  using ByteMapASVT = __tsan::ByteMapASVT<AddressSpaceView>;
   typedef __tsan::MapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #else
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = Mapping::kHeapMemBeg;
   static const uptr kSpaceSize = Mapping::kHeapMemEnd - Mapping::kHeapMemBeg;
   static const uptr kMetadataSize = 0;
   typedef DefaultSizeClassMap SizeClassMap;
   typedef __tsan::MapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
-  using AddressSpaceView = LocalAddressSpaceView;
 };
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<MapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
     SecondaryAllocator> Allocator;
 Allocator *allocator();