Introduce `AddressSpaceView` template parameter to `SizeClassAllocator32`, `FlatByteMap`, and `TwoLevelByteMap`.

[delcypher]

Summary

This is a follow up patch to r346956 for the SizeClassAllocator32
allocator.

This patch makes AddressSpaceView a template parameter both to the
ByteMap implementations, AP32 implementations and is used in
SizeClassAllocator32. The actual changes to ByteMap implementations
and SizeClassAllocator32 are very simple. However the patch is large
because it requires changing all the AP32 definitions, and users of
those definitions.

Note that the reason for not making LocalAddressSpaceView the default
template parameter for the various templates is because that would
require all users to add empty braces (i.e. PrimaryAllocator<> instead
of PrimaryAllocator to instantiate). To avoid this we create a
template version with a T suffix (e.g. PrimaryAllocatorT) and then
create an alias that has the previous type name (e.g.
PrimaryAllocator) that instantiates with LocalAddressSpaceView (e.g.
PrimaryAllocatorT<LocalAddressSpaceView>).

In order to check that template is instantiated in the correct a way a
static_assert(...) has been added that checks that the
AddressSpaceView type used by Params::ByteMap::AddressSpaceView matches
the Params::AddressSpaceView. This uses the new sanitizer_type_traits.h
header.

rdar://problem/45284065

[kubamracek]

The patch is quite big. I've added a couple suggestions how to reduce it to make it easier to review.

lib/sanitizer_common/sanitizer_allocator_bytemap.h

18

Is this necessary? FlatByteMap isn't doing any dereferences besides reading it's own fields.

81

Avoid reformatting code we don't need to change.

lib/sanitizer_common/sanitizer_allocator_internal.h

50

Can we unify the naming convention of adding "T" and "Ty" suffix to types? Do we need both?

63

Avoid reformatting code we don't need to change.

lib/sanitizer_common/sanitizer_allocator_primary32.h

243–247

This looks like an optimization. Can we remove it from the patch?

lib/sanitizer_common/sanitizer_type_traits.h

36–40 ↗

(On Diff #175280)

This (sanitizer_type_traits.h, the test file and the static_assert) can be moved to a separate patch.

[delcypher]

lib/sanitizer_common/sanitizer_allocator_bytemap.h

18

It is necessary for this implementation. This is because SizeClassAllocator32 contains a static_assert that checks that Params::ByteMap::AddressSpaceView is the same type as the Params::AddressSpaceView.
In order for this to work all ByteMap implementations need to expose the AddressSpaceView type.

This patch currently does this to ensure that the AddressSpaceView type is consistent everywhere.

There is a way to avoid the static_assert by making AP32::ByteMap be a templated type (i.e. not a concrete type like FlatByteMap<..., LocalAddressSpaceView>) and instead be a type that takes a single AddressSpaceView template argument. Then inside SizeClassAllocator32 the allocator would need to fill in the AddressSpaceView argument. I.e. replace

typedef typename Params::ByteMap ByteMap;

with

using ByteMap = Params::ByteMap<Params::AddressSpaceView>;

This still requires that FlatByteMap still take an AddressSpaceView template parameter, even though it isn't really used because all ByteMap implementations need to accept the same template parameters.

81

I could fix this but please note this is just clang-format doing its thing. Surely we want to clang-format all our patches?

lib/sanitizer_common/sanitizer_allocator_internal.h

50

Sure they can be unified. However before I go for a mass rename, do we want a different name? The T suffix was a placeholder for until I came up with a better name. Given that these types always take a single template parameter that is an AddressSpaceView make the suffix should reflect that. For example we could make the suffix be ASVT (Address Space View Type) rather than T. What do you think?

lib/sanitizer_common/sanitizer_allocator_primary32.h

243–247

I can. It is more than just an optimization. It's also there for clarity. Previously it was not obvious that doing possible_regions[region] gives you a class id.

lib/sanitizer_common/sanitizer_type_traits.h

36–40 ↗

(On Diff #175280)

Sure. I'll try to do this.

[delcypher]

lib/sanitizer_common/sanitizer_type_traits.h

36–40 ↗

(On Diff #175280)

Okay I've split this out into https://reviews.llvm.org/D54951 . I'll update this patch shortly.

[delcypher]

Remove sanitize_type_traits from this patch and put in https://reviews.llvm.org/D54951

[delcypher]

Try again.

[kubamracek]

The patch is quite big. I've added a couple suggestions how to reduce it to make it easier to review.

lib/sanitizer_common/sanitizer_allocator.h

25

Also remove.

lib/sanitizer_common/sanitizer_allocator_primary32.h

112–114

Also remove.

[kubamracek]

Please make this patch independent on the other (type_traits).

[delcypher]

Remove some unnecessary formatting changes.

[delcypher]

Replace typedef with using for consistency.

[delcypher]

Remove tweak in ForEachChunk(...).

[delcypher]

In D54904#1309831, @kubamracek wrote:

Please make this patch independent on the other (type_traits).

Is this really necessary? Without the static_assert it really isn't obvious why ByteMap::AddressSpaceView exists.

[delcypher]

• Use ASVT (Address Space View Template) as a suffix on types that takes AddressSpaceView as a single template parameter (apart from AP32 and AP64 to avoid making the name longer).
• Remove static_assert and related header file. I'll put that in another patch.

[delcypher]

lib/sanitizer_common/sanitizer_allocator_internal.h

50

@kubamracek I went with ASVT as the suffix for types that take a single AddressSpaceView template parameter. The only place I didn't make the change is the actually allocator parameter struct type names (e.g. AP32) so that the name is kept short.

[delcypher]

@kcc ping.

[kcc]

Kostya, Vitaly,
I'd like to hear your opinion.
Primarily, from the maintainability POV: how much does this (and the following) patch reduce our ability to maintain and modify the code.

[vitalybuka]

LGTM
but PrimaryAllocatorASVT is unused here, should we expect patches with PrimaryAllocatorASVT?

[cryptoad]

LGTM

[delcypher]

In D54904#1325056, @vitalybuka wrote:

LGTM
but PrimaryAllocatorASVT is unused here, should we expect patches with PrimaryAllocatorASVT?

@vitalybuka
Yes there will be patches that will use PrimaryAllocatorASVT. However I should note that we actually only need to support the AddressSpaceView template parameter not being LocalAddressSpaceView for ASan and LSan. For the other sanitizer allocators (e.g. TSan) would could have slightly simpler code that just hard codes using LocalAddressSpaceView rather than making it possible at compile time to change this. I didn't do this because I wanted to make the change uniformly to all the sanitizers. If you'd prefer that I make the changes to all the other sanitizers (i.e. not ASan and LSan) in a different way (i.e. hardcode LocalAddressSpaceView) then please let me know and I'll redo this patch.

[vitalybuka]

And for where ever it's going to be used, would be nice to have at least draft/WIP patch in the stack to see how this is going to be used

[delcypher]

Only make AP32 templated for ASan and LSan. For other allocator AP32 types just hardcode LocalAddressSpaceView. Also put type_traits stuff back in.

[delcypher]

@cryptoad @vitalybuka
Please take another look. I've updated the patch to use type_traits.h again and I've simplified AP32 for some of the sanitizers.

[delcypher]

In D54904#1326133, @vitalybuka wrote:

And for where ever it's going to be used, would be nice to have at least draft/WIP patch in the stack to see how this is going to be used

I've avoided doing this thus far for several reasons:

• Creating lots of patches further divides your team's limited review time.
• If changes are requested to patches low in the stack of patches, then this will likely require changes to many patches higher in stack, and possibly even a complete rethink of the approach. This rewriting can burn a lot of time so I prefer to rewrite just one or two patches at a time rather than a large patch set to avoid this.

I think this patch is much closer to something that your team will accept so I'll start creating more patches that tries to follow the style of this patch. I'll put these up for review today.

[delcypher]

@kcc @cryptoad @vitalybuka Is this patch okay to land now?

[vitalybuka]

LGTM

lib/asan/asan_allocator.h

struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kFlags = 0;
 };
 
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #else  // Fallback to SizeClassAllocator32.
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
-typedef FlatByteMap<kNumRegions> ByteMap;
+template <typename AddressSpaceView>
+using ByteMap = FlatByteMap<kNumRegions, AddressSpaceView>;
 # elif SANITIZER_WORDSIZE == 64
-typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+template <typename AddressSpaceView>
+using ByteMap = 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;
-  typedef __asan::ByteMap ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = __asan::ByteMap<AddressSpaceView>;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32> PrimaryAllocator;
+template <typename AddressSpaceView>
+using PrimaryAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView> >;
+using PrimaryAllocator = PrimaryAllocatorT<LocalAddressSpaceView>;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 static const uptr kNumberOfSizeClasses = SizeClassMap::kNumClasses;
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<AsanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
     SecondaryAllocator> AsanAllocator;
 

lib/hwasan/hwasan_allocator.h

void OnUnmap(uptr p, uptr size) const {
     // Make it accessible with zero-tagged pointer.
     TagMemory(p, size, 0);
   }
 };
 
 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 ByteMap = 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(Metadata);
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = __hwasan::kRegionSizeLog;
-  typedef __hwasan::ByteMap ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = __hwasan::ByteMap<AddressSpaceView>;
   typedef HwasanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32> PrimaryAllocator;
+template <typename AddressSpaceView>
+using PrimaryAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+using PrimaryAllocator = PrimaryAllocatorT<LocalAddressSpaceView>;
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<HwasanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
                           SecondaryAllocator> Allocator;
 
 
 void AllocatorSwallowThreadLocalCache(AllocatorCache *cache);
 

lib/lsan/lsan_allocator.h

 #endif
   u32 stack_trace_id;
 };
 
 #if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
     defined(__arm__)
 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 ByteMap = 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;
-  typedef __lsan::ByteMap ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = __lsan::ByteMap<AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32> PrimaryAllocator;
+template <typename AddressSpaceView>
+using PrimaryAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+using PrimaryAllocator = PrimaryAllocatorT<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

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 ByteMap =
+      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(Metadata);
     typedef __sanitizer::CompactSizeClassMap SizeClassMap;
     static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
-    typedef __msan::ByteMap ByteMap;
+    using AddressSpaceView = AddressSpaceViewTy;
+    using ByteMap = __msan::ByteMap<AddressSpaceView>;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
   };
-  typedef SizeClassAllocator32<AP32> PrimaryAllocator;
+  template <typename AddressSpaceView>
+  using PrimaryAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+  using PrimaryAllocator = PrimaryAllocatorT<LocalAddressSpaceView>;
 #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 kFlags = 0;
   };
 
   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 ByteMap =
+      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(Metadata);
     typedef __sanitizer::CompactSizeClassMap SizeClassMap;
     static const uptr kRegionSizeLog = __msan::kRegionSizeLog;
-    typedef __msan::ByteMap ByteMap;
+    using AddressSpaceView = AddressSpaceViewTy;
+    using ByteMap = __msan::ByteMap<AddressSpaceView>;
     typedef MsanMapUnmapCallback MapUnmapCallback;
     static const uptr kFlags = 0;
   };
-  typedef SizeClassAllocator32<AP32> PrimaryAllocator;
+  template <typename AddressSpaceViewTy>
+  using PrimaryAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+  using PrimaryAllocator = PrimaryAllocatorT<LocalAddressSpaceView>;
 #endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
                           SecondaryAllocator> Allocator;
 
 static Allocator allocator;
 static AllocatorCache fallback_allocator_cache;

lib/sanitizer_common/sanitizer_allocator.h

 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_lfstack.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_list.h"
 #include "sanitizer_local_address_space_view.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_procmaps.h"
+#include "sanitizer_type_traits.h"
 
 namespace __sanitizer {
 
 // Allows the tools to name their allocations appropriately.
 extern const char *PrimaryAllocatorName;
 extern const char *SecondaryAllocatorName;
 
 // Since flags are immutable and allocator behavior can be changed at runtime

lib/sanitizer_common/sanitizer_allocator_bytemap.h

 // Part of the Sanitizer Allocator.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 // Maps integers in rage [0, kSize) to u8 values.
-template<u64 kSize>
+template <u64 kSize, typename AddressSpaceViewTy = LocalAddressSpaceView>
 class FlatByteMap {
  public:
+  using AddressSpaceView = AddressSpaceViewTy;
   void Init() {
     internal_memset(map_, 0, sizeof(map_));
   }
 
   void set(uptr idx, u8 val) {
     CHECK_LT(idx, kSize);
     CHECK_EQ(0U, map_[idx]);
     map_[idx] = val;
   }
   u8 operator[] (uptr idx) {
     CHECK_LT(idx, kSize);
     // FIXME: CHECK may be too expensive here.
     return map_[idx];
   }
  private:
   u8 map_[kSize];
 };
 
 // TwoLevelByteMap maps integers in range [0, kSize1*kSize2) to u8 values.
 // It is implemented as a two-dimensional array: array of kSize1 pointers
 // to kSize2-byte arrays. The secondary arrays are mmaped on demand.
 // Each value is initially zero and can be set to something else only once.
 // Setting and getting values from multiple threads is safe w/o extra locking.
-template <u64 kSize1, u64 kSize2, class MapUnmapCallback = NoOpMapUnmapCallback>
+template <u64 kSize1, u64 kSize2,
+          typename AddressSpaceViewTy = LocalAddressSpaceView,
+          class MapUnmapCallback = NoOpMapUnmapCallback>
 class TwoLevelByteMap {
  public:
+  using AddressSpaceView = AddressSpaceViewTy;
   void Init() {
     internal_memset(map1_, 0, sizeof(map1_));
     mu_.Init();
   }
 
   void TestOnlyUnmap() {
     for (uptr i = 0; i < kSize1; i++) {
       u8 *p = Get(i);
void set(uptr idx, u8 val) {
     CHECK_EQ(0U, map2[idx % kSize2]);
     map2[idx % kSize2] = val;
   }
 
   u8 operator[] (uptr idx) const {
     CHECK_LT(idx, kSize1 * kSize2);
     u8 *map2 = Get(idx / kSize2);
     if (!map2) return 0;
-    return map2[idx % kSize2];
+    auto value_ptr = AddressSpaceView::Load(&map2[idx % kSize2]);
+    return *value_ptr;
   }
 
  private:
   u8 *Get(uptr idx) const {
     CHECK_LT(idx, kSize1);
     return reinterpret_cast<u8 *>(
         atomic_load(&map1_[idx], memory_order_acquire));
   }

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 ByteMap = FlatByteMap<kInternalAllocatorNumRegions, AddressSpaceView>;
 #else
-typedef TwoLevelByteMap<(kInternalAllocatorNumRegions >> 12), 1 << 12> ByteMap;
+template <typename AddressSpaceView>
+using ByteMap = TwoLevelByteMap<(kInternalAllocatorNumRegions >> 12), 1 << 12,
+                                AddressSpaceView>;
 #endif
+template <typename AddressSpaceViewTy>
 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;
-  typedef __sanitizer::ByteMap ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = __sanitizer::ByteMap<AddressSpaceViewTy>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32> PrimaryInternalAllocator;
+template <typename AddressSpaceView>
+using PrimaryInternalAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+using PrimaryInternalAllocator =
+    PrimaryInternalAllocatorT<LocalAddressSpaceView>;
 
 typedef SizeClassAllocatorLocalCache<PrimaryInternalAllocator>
     InternalAllocatorCache;
 
 typedef LargeMmapAllocator<NoOpMapUnmapCallback,
                            LargeMmapAllocatorPtrArrayStatic>
     SecondaryInternalAllocator;
 
 typedef CombinedAllocator<PrimaryInternalAllocator, InternalAllocatorCache,
                           SecondaryInternalAllocator> InternalAllocator;
 
 void *InternalAlloc(uptr size, InternalAllocatorCache *cache = nullptr,
                     uptr alignment = 0);
 void *InternalRealloc(void *p, uptr size,
                       InternalAllocatorCache *cache = nullptr);
 void *InternalCalloc(uptr countr, uptr size,
                      InternalAllocatorCache *cache = nullptr);
 void InternalFree(void *p, InternalAllocatorCache *cache = nullptr);
 InternalAllocator *internal_allocator();
 
 } // namespace __sanitizer
 
 #endif // SANITIZER_ALLOCATOR_INTERNAL_H

lib/sanitizer_common/sanitizer_allocator_primary32.h

enum {
     kRandomShuffleChunks = 1,
     kUseSeparateSizeClassForBatch = 2,
   };
 };
 
 template <class Params>
 class SizeClassAllocator32 {
  public:
+  using AddressSpaceView = typename Params::AddressSpaceView;
   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;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
static uptr ClassIdToSize(uptr class_id) {
     return (class_id == SizeClassMap::kBatchClassID) ?
         kBatchSize : SizeClassMap::Size(class_id);
   }
 
   typedef SizeClassAllocator32<Params> ThisT;
   typedef SizeClassAllocator32LocalCache<ThisT> AllocatorCache;
 
   void Init(s32 release_to_os_interval_ms) {
+    static_assert(
+        is_same<typename ByteMap::AddressSpaceView, AddressSpaceView>::value,
+        "AddressSpaceView type mismatch");
     possible_regions.Init();
     internal_memset(size_class_info_array, 0, sizeof(size_class_info_array));
   }
 
   s32 ReleaseToOSIntervalMs() const {
     return kReleaseToOSIntervalNever;
   }
 
void ForceUnlock() {
     for (int i = kNumClasses - 1; i >= 0; i--) {
       GetSizeClassInfo(i)->mutex.Unlock();
     }
   }
 
   // Iterate over all existing chunks.
   // The allocator must be locked when calling this function.
   void ForEachChunk(ForEachChunkCallback callback, void *arg) {
-    for (uptr region = 0; region < kNumPossibleRegions; region++)
-      if (possible_regions[region]) {
-        uptr chunk_size = ClassIdToSize(possible_regions[region]);
+    for (uptr region = 0; region < kNumPossibleRegions; region++) {
+      uptr class_id = possible_regions[region];
+      if (class_id) {
+        uptr chunk_size = ClassIdToSize(class_id);
         uptr max_chunks_in_region = kRegionSize / (chunk_size + kMetadataSize);
         uptr region_beg = region * kRegionSize;
         for (uptr chunk = region_beg;
              chunk < region_beg + max_chunks_in_region * chunk_size;
              chunk += chunk_size) {
           // Too slow: CHECK_EQ((void *)chunk, GetBlockBegin((void *)chunk));
           callback(chunk, arg);
         }
       }
     }
+  }
 
   void PrintStats() {}
 
   static uptr AdditionalSize() { return 0; }
 
   typedef SizeClassMap SizeClassMapT;
   static const uptr kNumClasses = SizeClassMap::kNumClasses;
 

lib/sanitizer_common/tests/sanitizer_allocator_test.cc

 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;
-  typedef FlatByteMap<kFlatByteMapSize> ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32Compact> Allocator32Compact;
+template <typename AddressSpaceView>
+using Allocator32CompactT = SizeClassAllocator32<AP32Compact<AddressSpaceView>>;
+using Allocator32Compact = Allocator32CompactT<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;
-  typedef FlatByteMap<kFlatByteMapSize> ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = FlatByteMap<kFlatByteMapSize, AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 };
-typedef SizeClassAllocator32<AP32SeparateBatches> Allocator32SeparateBatches;
+template <typename AddressSpaceView>
+using Allocator32SeparateBatchesT =
+    SizeClassAllocator32<AP32SeparateBatches<AddressSpaceView>>;
+using Allocator32SeparateBatches =
+    Allocator32SeparateBatchesT<LocalAddressSpaceView>;
 
 TEST(SanitizerCommon, SizeClassAllocator32SeparateBatches) {
   TestSizeClassAllocator<Allocator32SeparateBatches>();
 }
 
 template <class Allocator>
 void SizeClassAllocatorMetadataStress() {
   Allocator *a = new 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;
-  typedef FlatByteMap<kFlatByteMapSize> ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = 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();
if (j % 7)
       EXPECT_EQ(m[j], 0);
     else
       EXPECT_EQ(m[j], (j % 100) + 1);
   }
 
   m.TestOnlyUnmap();
 }
 
-
-typedef TwoLevelByteMap<1 << 12, 1 << 13, TestMapUnmapCallback> TestByteMap;
+template <typename AddressSpaceView>
+using TestByteMapT =
+    TwoLevelByteMap<1 << 12, 1 << 13, AddressSpaceView, TestMapUnmapCallback>;
+using TestByteMap = TestByteMapT<LocalAddressSpaceView>;
 
 struct TestByteMapParam {
   TestByteMap *m;
   size_t shard;
   size_t num_shards;
 };
 
 void *TwoLevelByteMapUserThread(void *param) {

lib/scudo/scudo_allocator.h

struct AP64 {
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
 };
 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 ByteMap = FlatByteMap<NumRegions, AddressSpaceView>;
 # elif SANITIZER_WORDSIZE == 64
-typedef TwoLevelByteMap<(NumRegions >> 12), 1 << 12> ByteMap;
+template <typename AddressSpaceView>
+using ByteMap = TwoLevelByteMap<(NumRegions >> 12), 1 << 12, AddressSpaceView>;
 # endif  // SANITIZER_WORDSIZE
-struct AP32 {
+template <typename AddressSpaceViewTy> 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;
-  typedef __scudo::ByteMap ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = __scudo::ByteMap<AddressSpaceView>;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags =
       SizeClassAllocator32FlagMasks::kRandomShuffleChunks |
       SizeClassAllocator32FlagMasks::kUseSeparateSizeClassForBatch;
 };
-typedef SizeClassAllocator32<AP32> PrimaryT;
+typedef SizeClassAllocator32<AP32<LocalAddressSpaceView>> PrimaryT;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 #include "scudo_allocator_secondary.h"
 #include "scudo_allocator_combined.h"
 
 typedef SizeClassAllocatorLocalCache<PrimaryT> AllocatorCacheT;
 typedef LargeMmapAllocator SecondaryT;
 typedef CombinedAllocator<PrimaryT, AllocatorCacheT, SecondaryT> BackendT;

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;
-typedef TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
-    MapUnmapCallback> ByteMap;
+template <typename AddressSpaceView>
+using ByteMap = TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
+                                AddressSpaceView, MapUnmapCallback>;
+template <typename AddressSpaceViewTy>
 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;
-  typedef __tsan::ByteMap ByteMap;
+  using AddressSpaceView = AddressSpaceViewTy;
+  using ByteMap = __tsan::ByteMap<AddressSpaceView>;
   typedef __tsan::MapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
-typedef SizeClassAllocator32<AP32> PrimaryAllocator;
+template <typename AddressSpaceView>
+using PrimaryAllocatorT = SizeClassAllocator32<AP32<AddressSpaceView>>;
+using PrimaryAllocator = PrimaryAllocatorT<LocalAddressSpaceView>;
 #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;