scudo: Fix various test failures, mostly on 32-bit.

[cryptoad]

compiler-rt/lib/scudo/standalone/size_class_map.h

27

Isn't that still true?

[pcc]

compiler-rt/lib/scudo/standalone/size_class_map.h

27

Yes and we're now checking it in the derived classes since this class doesn't know the value of MaxSize.

compiler-rt/lib/scudo/standalone/size_class_map.h

inline uptr scaledLog2(uptr Size, uptr ZeroLog, uptr LogBits) {
   const uptr L = getMostSignificantSetBitIndex(Size);
   const uptr LBits = (Size >> (L - LogBits)) - (1 << LogBits);
   const uptr HBits = (L - ZeroLog) << LogBits;
   return LBits + HBits;
 }
 
 template <typename Config> struct SizeClassMapBase {
   static u32 getMaxCachedHint(uptr Size) {
-    DCHECK_LE(Size, (1UL << Config::MaxSizeLog) + Chunk::getHeaderSize());
     DCHECK_NE(Size, 0);
     u32 N;
     // Force a 32-bit division if the template parameters allow for it.
     if (Config::MaxBytesCachedLog > 31 || Config::MaxSizeLog > 31)
       N = static_cast<u32>((1UL << Config::MaxBytesCachedLog) / Size);
     else
       N = (1U << Config::MaxBytesCachedLog) / static_cast<u32>(Size);
     return Max(1U, Min(Config::MaxNumCachedHint, N));
static uptr getClassIdBySize(uptr Size) {
     if (Size <= SizeDelta + (1 << Config::MinSizeLog))
       return 1;
     Size -= SizeDelta;
     DCHECK_LE(Size, MaxSize);
     if (Size <= MidSize)
       return (Size + MinSize - 1) >> Config::MinSizeLog;
     return MidClass + 1 + scaledLog2(Size - 1, Config::MidSizeLog, S);
   }
+
+  static u32 getMaxCachedHint(uptr Size) {
+    DCHECK_LE(Size, MaxSize);
+    return Base::getMaxCachedHint(Size);
+  }
 };
 
 template <typename Config>
 class TableSizeClassMap : public SizeClassMapBase<Config> {
+  typedef SizeClassMapBase<Config> Base;
+
   static const u8 S = Config::NumBits - 1;
   static const uptr M = (1UL << S) - 1;
   static const uptr ClassesSize =
       sizeof(Config::Classes) / sizeof(Config::Classes[0]);
 
   struct SizeTable {
     constexpr SizeTable() {
       uptr Pos = 1 << Config::MidSizeLog;
if (Size <= Config::Classes[0])
       return 1;
     Size -= Config::SizeDelta;
     DCHECK_LE(Size, MaxSize);
     if (Size <= (1 << Config::MidSizeLog))
       return ((Size - 1) >> Config::MinSizeLog) + 1;
     return Table.Tab[scaledLog2(Size - 1, Config::MidSizeLog, S)];
   }
 
-  static void print() {}
-  static void validate() {}
+  static u32 getMaxCachedHint(uptr Size) {
+    DCHECK_LE(Size, MaxSize);
+    return Base::getMaxCachedHint(Size);
+  }
 };
 
 struct AndroidSizeClassConfig {
 #if SCUDO_WORDSIZE == 64U
   // Measured using a system_server profile.
   static const uptr NumBits = 7;
   static const uptr MinSizeLog = 4;
   static const uptr MidSizeLog = 6;

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

 // To achieve this, we allocate a chunk for which the backing block will be
 // aligned on a page, then run the malloc_iterate on both the pages that the
 // block is a boundary for. It must only be seen once by the callback function.
 TEST(ScudoWrappersCTest, MallocIterateBoundary) {
   const size_t PageSize = sysconf(_SC_PAGESIZE);
   const size_t BlockDelta = FIRST_32_SECOND_64(8U, 16U);
   const size_t SpecialSize = PageSize - BlockDelta;
 
-  void *P = malloc(SpecialSize);
+  // We aren't guaranteed that any size class is exactly a page wide. So we need
+  // to keep making allocations until we succeed.
+  //
+  // With a 16-byte block alignment and 4096-byte page size, each allocation has
+  // a probability of (1 - (16/4096)) of failing to meet the alignment
+  // requirements, and the probability of failing 65536 times is
+  // (1 - (16/4096))^65536 < 10^-112. So if we still haven't succeeded after
+  // 65536 tries, give up.
+  uintptr_t Block;
+  void *P = nullptr;
+  for (unsigned I = 0; I != 65536; ++I) {
+    void *PrevP = P;
+    P = malloc(SpecialSize);
     EXPECT_NE(P, nullptr);
+    *reinterpret_cast<void **>(P) = PrevP;
     BoundaryP = reinterpret_cast<uintptr_t>(P);
-  const uintptr_t Block = BoundaryP - BlockDelta;
+    Block = BoundaryP - BlockDelta;
+    if ((Block & (PageSize - 1)) == 0U)
+      break;
+  }
   EXPECT_EQ((Block & (PageSize - 1)), 0U);
 
   Count = 0U;
   malloc_disable();
   malloc_iterate(Block - PageSize, PageSize, callback, nullptr);
   malloc_iterate(Block, PageSize, callback, nullptr);
   malloc_enable();
   EXPECT_EQ(Count, 1U);
 
+  while (P) {
+    void *NextP = *reinterpret_cast<void **>(P);
     free(P);
+    P = NextP;
+  }
 }
 
 // We expect heap operations within a disable/enable scope to deadlock.
 TEST(ScudoWrappersCTest, MallocDisableDeadlock) {
   EXPECT_DEATH(
       {
         void *P = malloc(Size);
         EXPECT_NE(P, nullptr);