[scudo] Use DefaultSizeClassMap for 32-bit

[cryptoad]

Summary

With the recent changes to the Secondary, we use less bits for UnusedBytes,
which allows us in return to increase the bits used for Offset. That means
that we can use a Primary SizeClassMap allowing for a larger maximum size.

[alekseyshl]

LGTM

compiler-rt/trunk/lib/scudo/scudo_allocator.h

 // using functions such as GetBlockBegin, that is fairly costly. Our first
 // implementation used the MetaData as well, which offers the advantage of
 // being stored away from the chunk itself, but accessing it was costly as
 // well. The header will be atomically loaded and stored using the 16-byte
 // primitives offered by the platform (likely requires cmpxchg16b support).
 typedef u64 PackedHeader;
 struct UnpackedHeader {
   u64 Checksum    : 16;
-  u64 UnusedBytes : 24; // Needed for reallocation purposes.
+  u64 UnusedBytes : 20; // Needed for reallocation purposes.
   u64 State       : 2;  // available, allocated, or quarantined
   u64 AllocType   : 2;  // malloc, new, new[], or memalign
-  u64 Offset      : 12; // Offset from the beginning of the backend
+  u64 Offset      : 16; // Offset from the beginning of the backend
                         // allocation to the beginning of the chunk itself,
                         // in multiples of MinAlignment. See comment about
                         // its maximum value and test in init().
   u64 Salt        : 8;
 };
 
 typedef std::atomic<PackedHeader> AtomicPackedHeader;
 COMPILER_CHECK(sizeof(UnpackedHeader) == sizeof(PackedHeader));

compiler-rt/trunk/lib/scudo/scudo_allocator.cpp

 // version of Scudo slightly less toughened.
 static const uptr RegionSizeLog = 20;
 static const uptr NumRegions = SANITIZER_MMAP_RANGE_SIZE >> RegionSizeLog;
 # if SANITIZER_WORDSIZE == 32
 typedef FlatByteMap<NumRegions> ByteMap;
 # elif SANITIZER_WORDSIZE == 64
 typedef TwoLevelByteMap<(NumRegions >> 12), 1 << 12> ByteMap;
 # endif  // SANITIZER_WORDSIZE
-typedef SizeClassMap<3, 4, 8, 16, 64, 14> SizeClassMap;
+typedef DefaultSizeClassMap SizeClassMap;
 typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, 0, SizeClassMap,
     RegionSizeLog, ByteMap> PrimaryAllocator;
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef ScudoLargeMmapAllocator SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache, SecondaryAllocator>
   ScudoAllocator;
void init(const AllocatorOptions &Options) {
     uptr MaxOffset = (MaxPrimaryAlignment - AlignedChunkHeaderSize) >>
         MinAlignmentLog;
     Header.Offset = MaxOffset;
     if (Header.Offset != MaxOffset) {
       dieWithMessage("ERROR: the maximum possible offset doesn't fit in the "
                      "header\n");
     }
     // Verify that we can fit the maximum amount of unused bytes in the header.
-    // The worst case scenario would be when allocating 1 byte on a MaxAlignment
-    // alignment. Since the combined allocator currently rounds the size up to
-    // the alignment before passing it to the secondary, we end up with
-    // MaxAlignment - 1 extra bytes.
-    uptr MaxUnusedBytes = MaxAlignment - 1;
+    // Given that the Secondary fits the allocation to a page, the worst case
+    // scenario happens in the Primary. It will depend on the second to last
+    // and last class sizes, as well as the dynamic base for the Primary. The
+    // following is an over-approximation that works for our needs.
+    uptr MaxUnusedBytes = SizeClassMap::kMaxSize - 1 - AlignedChunkHeaderSize;
     Header.UnusedBytes = MaxUnusedBytes;
     if (Header.UnusedBytes != MaxUnusedBytes) {
       dieWithMessage("ERROR: the maximum possible unused bytes doesn't fit in "
                      "the header\n");
     }
 
     DeallocationTypeMismatch = Options.DeallocationTypeMismatch;
     DeleteSizeMismatch = Options.DeleteSizeMismatch;