NFC: Reuse allocator params

compiler-rt/lib/msan/msan_allocator.cc

void OnUnmap(uptr p, uptr size) const {
     ReleaseMemoryPagesToOS(shadow_p, shadow_p + size);
     if (__msan_get_track_origins()) {
       uptr origin_p = MEM_TO_ORIGIN(p);
       ReleaseMemoryPagesToOS(origin_p, origin_p + size);
     }
   }
 };
 
+struct DefaultMsanAllocatorParams : public DefaultAllocatorParams {
+  static const uptr kMetadataSize = sizeof(Metadata);
+  using MapUnmapCallback = MsanMapUnmapCallback;
+  using AddressSpaceView = LocalAddressSpaceView;
+};
+
 #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;
 
-struct AP32 {
+struct AP32 : public DefaultMsanAllocatorParams {
   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;
-  typedef MsanMapUnmapCallback MapUnmapCallback;
-  using PtrArray = DefaultLargeMmapAllocatorPtrArray;
-  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.
+struct AP64 : public DefaultMsanAllocatorParams {
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = 0x40000000000;  // 4T.
-  static const uptr kMetadataSize = sizeof(Metadata);
   typedef DefaultSizeClassMap SizeClassMap;
-  typedef MsanMapUnmapCallback MapUnmapCallback;
-  using PtrArray = DefaultLargeMmapAllocatorPtrArray;
-  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.
+struct AP64 : public DefaultMsanAllocatorParams {
   static const uptr kSpaceBeg = 0x300000000000;
   static const uptr kSpaceSize = 0x020000000000;  // 2T.
-  static const uptr kMetadataSize = sizeof(Metadata);
   typedef DefaultSizeClassMap SizeClassMap;
-  typedef MsanMapUnmapCallback MapUnmapCallback;
-  using PtrArray = DefaultLargeMmapAllocatorPtrArray;
-  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;
 
-struct AP32 {
+struct AP32 : public DefaultMsanAllocatorParams {
   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;
-  typedef MsanMapUnmapCallback MapUnmapCallback;
-  using PtrArray = DefaultLargeMmapAllocatorPtrArray;
-  static const uptr kFlags = 0;
 };
 typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #endif
 typedef CombinedAllocator<PrimaryAllocator> Allocator;
 typedef Allocator::AllocatorCache AllocatorCache;
 
 static Allocator allocator;
 static AllocatorCache fallback_allocator_cache;

compiler-rt/lib/sanitizer_common/sanitizer_allocator_combined.h

 //===-- sanitizer_allocator_combined.h --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Part of the Sanitizer Allocator.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
+struct DefaultAllocatorParams {
+  using PtrArray = DefaultLargeMmapAllocatorPtrArray;
+  static const uptr kFlags = 0;
+};
+
 // This class implements a complete memory allocator by using two
 // internal allocators:
 // PrimaryAllocator is efficient, but may not allocate some sizes (alignments).
 //  When allocating 2^x bytes it should return 2^x aligned chunk.
 // PrimaryAllocator is used via a local AllocatorCache.
 // SecondaryAllocator can allocate anything, but is not efficient.
 template <class PrimaryAllocator>
 class CombinedAllocator {