[scudo] Clean up tests.

[cferris]

Summary

Modify the tests so that all clang warnings can be turned up to high.

Fix all places flagged by -Wconversion.

Fix a few unused variables not marked with UNUSED.

For the memtag testing, only compile some tests for 64 bit since
compiling them on 32 bit leads to warnings/errors. All of the tests
are already skipped on 32 bit OSes, so this will not affect any
real tests.

[cferris]

clang format.

[Chia-hungDuan]

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

219–221

Just curious, how did it work without std:: previously? Called to the C rand() function?

[cferris]

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

219–221

I'm guessing it just used the normal rand which is functionally the same as std::rand.

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

void ScudoCombinedTest<Config>::BasicTest(scudo::uptr SizeLog) {
   auto *Allocator = this->Allocator.get();
 
   // This allocates and deallocates a bunch of chunks, with a wide range of
   // sizes and alignments, with a focus on sizes that could trigger weird
   // behaviors (plus or minus a small delta of a power of two for example).
   for (scudo::uptr AlignLog = MinAlignLog; AlignLog <= 16U; AlignLog++) {
     const scudo::uptr Align = 1U << AlignLog;
     for (scudo::sptr Delta = -32; Delta <= 32; Delta++) {
-      if (static_cast<scudo::sptr>(1U << SizeLog) + Delta < 0)
+      if ((1LL << SizeLog) + Delta < 0)
         continue;
-      const scudo::uptr Size = (1U << SizeLog) + Delta;
+      const scudo::uptr Size =
+          static_cast<scudo::uptr>((1LL << SizeLog) + Delta);
       void *P = Allocator->allocate(Size, Origin, Align);
       EXPECT_NE(P, nullptr);
       EXPECT_TRUE(Allocator->isOwned(P));
       EXPECT_TRUE(scudo::isAligned(reinterpret_cast<scudo::uptr>(P), Align));
       EXPECT_LE(Size, Allocator->getUsableSize(P));
       memset(P, 0xaa, Size);
       checkMemoryTaggingMaybe(Allocator, P, Size, Align);
       Allocator->deallocate(P, Origin, Size);
SCUDO_TYPED_TEST(ScudoCombinedDeathTest, ReallocateSame) {
   // the same block size, but that should be the case for MaxSize - 64 with our
   // default class size maps.
   constexpr scudo::uptr ReallocSize =
       TypeParam::Primary::SizeClassMap::MaxSize - 64;
   void *P = Allocator->allocate(ReallocSize, Origin);
   const char Marker = 0xab;
   memset(P, Marker, ReallocSize);
   for (scudo::sptr Delta = -32; Delta < 32; Delta += 8) {
-    const scudo::uptr NewSize = ReallocSize + Delta;
+    const scudo::uptr NewSize =
+        static_cast<scudo::uptr>(static_cast<scudo::sptr>(ReallocSize) + Delta);
     void *NewP = Allocator->reallocate(P, NewSize);
     EXPECT_EQ(NewP, P);
     for (scudo::uptr I = 0; I < ReallocSize - 32; I++)
       EXPECT_EQ((reinterpret_cast<char *>(NewP))[I], Marker);
     checkMemoryTaggingMaybe(Allocator, NewP, NewSize, 0);
   }
   Allocator->deallocate(P, Origin);
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, IterateOverChunks) {
   auto *Allocator = this->Allocator.get();
   // Allocates a bunch of chunks, then iterate over all the chunks, ensuring
   // they are the ones we allocated. This requires the allocator to not have any
   // other allocated chunk at this point (eg: won't work with the Quarantine).
   // FIXME: Make it work with UseQuarantine and tagging enabled. Internals of
   // iterateOverChunks reads header by tagged and non-tagger pointers so one of
   // them will fail.
   if (!UseQuarantine) {
     std::vector<void *> V;
     for (scudo::uptr I = 0; I < 64U; I++)
       V.push_back(Allocator->allocate(
-          rand() % (TypeParam::Primary::SizeClassMap::MaxSize / 2U), Origin));
+          static_cast<scudo::uptr>(std::rand()) %
+              (TypeParam::Primary::SizeClassMap::MaxSize / 2U),
+          Origin));
     Allocator->disable();
     Allocator->iterateOverChunks(
         0U, static_cast<scudo::uptr>(SCUDO_MMAP_RANGE_SIZE - 1),
-        [](uintptr_t Base, size_t Size, void *Arg) {
+        [](uintptr_t Base, UNUSED size_t Size, void *Arg) {
           std::vector<void *> *V = reinterpret_cast<std::vector<void *> *>(Arg);
           void *P = reinterpret_cast<void *>(Base);
           EXPECT_NE(std::find(V->begin(), V->end(), P), V->end());
         },
         reinterpret_cast<void *>(&V));
     Allocator->enable();
     for (auto P : V)
       Allocator->deallocate(P, Origin);

 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, CacheDrain) NO_THREAD_SAFETY_ANALYSIS {
   auto *Allocator = this->Allocator.get();
 
   std::vector<void *> V;
   for (scudo::uptr I = 0; I < 64U; I++)
     V.push_back(Allocator->allocate(
-        rand() % (TypeParam::Primary::SizeClassMap::MaxSize / 2U), Origin));
+        static_cast<scudo::uptr>(std::rand()) %
+            (TypeParam::Primary::SizeClassMap::MaxSize / 2U),
+        Origin));
   for (auto P : V)
     Allocator->deallocate(P, Origin);
 
   bool UnlockRequired;
   auto *TSD = Allocator->getTSDRegistry()->getTSDAndLock(&UnlockRequired);
   EXPECT_TRUE(!TSD->getCache().isEmpty());
   TSD->getCache().drain();
   EXPECT_TRUE(TSD->getCache().isEmpty());
   if (UnlockRequired)
     TSD->unlock();
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, ForceCacheDrain) NO_THREAD_SAFETY_ANALYSIS {
   auto *Allocator = this->Allocator.get();
 
   std::vector<void *> V;
   for (scudo::uptr I = 0; I < 64U; I++)
     V.push_back(Allocator->allocate(
-        rand() % (TypeParam::Primary::SizeClassMap::MaxSize / 2U), Origin));
+        static_cast<scudo::uptr>(std::rand()) %
+            (TypeParam::Primary::SizeClassMap::MaxSize / 2U),
+        Origin));
   for (auto P : V)
     Allocator->deallocate(P, Origin);
 
   // `ForceAll` will also drain the caches.
   Allocator->releaseToOS(scudo::ReleaseToOS::ForceAll);
 
   bool UnlockRequired;
   auto *TSD = Allocator->getTSDRegistry()->getTSDAndLock(&UnlockRequired);
for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     Threads[I] = std::thread([&]() {
       {
         std::unique_lock<std::mutex> Lock(Mutex);
         while (!Ready)
           Cv.wait(Lock);
       }
       std::vector<std::pair<void *, scudo::uptr>> V;
       for (scudo::uptr I = 0; I < 256U; I++) {
-        const scudo::uptr Size = std::rand() % 4096U;
+        const scudo::uptr Size = static_cast<scudo::uptr>(std::rand()) % 4096U;
         void *P = Allocator->allocate(Size, Origin);
         // A region could have ran out of memory, resulting in a null P.
         if (P)
           V.push_back(std::make_pair(P, Size));
       }
 
       // Try to interleave pushBlocks(), popBatch() and releaseToOS().
       Allocator->releaseToOS(scudo::ReleaseToOS::Force);
SCUDO_TYPED_TEST(ScudoCombinedTest, DisableMemInit) {
   Allocator->setOption(scudo::Option::ThreadDisableMemInit, 0);
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, ReallocateInPlaceStress) {
   auto *Allocator = this->Allocator.get();
 
   // Regression test: make realloc-in-place happen at the very right end of a
   // mapped region.
-  constexpr int nPtrs = 10000;
-  for (int i = 1; i < 32; ++i) {
+  constexpr size_t nPtrs = 10000;
+  for (scudo::uptr i = 1; i < 32; ++i) {
     scudo::uptr Size = 16 * i - 1;
     std::vector<void *> Ptrs;
-    for (int i = 0; i < nPtrs; ++i) {
+    for (size_t i = 0; i < nPtrs; ++i) {
       void *P = Allocator->allocate(Size, Origin);
       P = Allocator->reallocate(P, Size + 1);
       Ptrs.push_back(P);
     }
 
-    for (int i = 0; i < nPtrs; ++i)
+    for (size_t i = 0; i < nPtrs; ++i)
       Allocator->deallocate(Ptrs[i], Origin);
   }
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, RingBufferSize) {
   auto *Allocator = this->Allocator.get();
   auto Size = Allocator->getRingBufferSize();
   if (Size > 0)

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

 using MemtagDeathTest = MemtagTest;
 
 TEST_F(MemtagTest, ArchMemoryTagGranuleSize) {
   EXPECT_GT(archMemoryTagGranuleSize(), 1u);
   EXPECT_TRUE(isPowerOfTwo(archMemoryTagGranuleSize()));
 }
 
 TEST_F(MemtagTest, ExtractTag) {
+// The test is already skipped on anything other than 64 bit. But
+// compiling on 32 bit leads to warnings/errors, so skip compiling the test.
+#if defined(__LP64__)
   uptr Tags = 0;
   // Try all value for the top byte and check the tags values are in the
   // expected range.
   for (u64 Top = 0; Top < 0x100; ++Top)
     Tags = Tags | (1u << extractTag(Addr | (Top << 56)));
   EXPECT_EQ(0xffffull, Tags);
+#endif
 }
 
 TEST_F(MemtagDeathTest, AddFixedTag) {
   for (uptr Tag = 0; Tag < 0x10; ++Tag)
     EXPECT_EQ(Tag, extractTag(addFixedTag(Addr, Tag)));
   if (SCUDO_DEBUG) {
     EXPECT_DEATH(addFixedTag(Addr, 16), "");
     EXPECT_DEATH(addFixedTag(~Addr, 0), "");
for (uptr SrcTag = 0; SrcTag < 0x10; ++SrcTag) {
     uptr Tags = 0;
     for (uptr I = 0; I < 100000; ++I)
       Tags = Tags | (1u << extractTag(selectRandomTag(Ptr, 0)));
     EXPECT_EQ(0xfffeull, Tags);
   }
 }
 
 TEST_F(MemtagTest, SelectRandomTagWithMask) {
+// The test is already skipped on anything other than 64 bit. But
+// compiling on 32 bit leads to warnings/errors, so skip compiling the test.
+#if defined(__LP64__)
   for (uptr j = 0; j < 32; ++j) {
     for (uptr i = 0; i < 1000; ++i)
       EXPECT_NE(j, extractTag(selectRandomTag(Addr, 1ull << j)));
   }
+#endif
 }
 
 TEST_F(MemtagDeathTest, SKIP_NO_DEBUG(LoadStoreTagUnaligned)) {
   for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     if (P % archMemoryTagGranuleSize() == 0)
       continue;
     EXPECT_DEATH(loadTag(P), "");
     EXPECT_DEATH(storeTag(P), "");
for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     uptr Tagged = addFixedTag(P, 5);
     if (Tagged % archMemoryTagGranuleSize() == 0)
       continue;
     EXPECT_DEATH(storeTags(Tagged, Tagged), "");
   }
 }
 
 TEST_F(MemtagTest, StoreTags) {
+// The test is already skipped on anything other than 64 bit. But
+// compiling on 32 bit leads to warnings/errors, so skip compiling the test.
+#if defined(__LP64__)
   const uptr MaxTaggedSize = 4 * archMemoryTagGranuleSize();
   for (uptr Size = 0; Size <= MaxTaggedSize; ++Size) {
     uptr NoTagBegin = Addr + archMemoryTagGranuleSize();
     uptr NoTagEnd = NoTagBegin + Size;
 
     u8 Tag = 5;
 
     uptr TaggedBegin = addFixedTag(NoTagBegin, Tag);
for (uptr Size = 0; Size <= MaxTaggedSize; ++Size) {
     }
 
     // Untagged right granule.
     EXPECT_EQ(LoadPtr, loadTag(LoadPtr));
 
     // Reset tags without using StoreTags.
     MemMap.releasePagesToOS(Addr, BufferSize);
   }
+#endif
 }
 
 } // namespace scudo
 
 #endif

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

 SCUDO_TYPED_TEST(ScudoPrimaryTest, PrimaryIterate) {
   using Primary = TestAllocator<TypeParam, scudo::DefaultSizeClassMap>;
   std::unique_ptr<Primary> Allocator(new Primary);
   Allocator->init(/*ReleaseToOsInterval=*/-1);
   typename Primary::CacheT Cache;
   Cache.init(nullptr, Allocator.get());
   std::vector<std::pair<scudo::uptr, void *>> V;
   for (scudo::uptr I = 0; I < 64U; I++) {
-    const scudo::uptr Size = std::rand() % Primary::SizeClassMap::MaxSize;
+    const scudo::uptr Size =
+        static_cast<scudo::uptr>(std::rand()) % Primary::SizeClassMap::MaxSize;
     const scudo::uptr ClassId = Primary::SizeClassMap::getClassIdBySize(Size);
     void *P = Cache.allocate(ClassId);
     V.push_back(std::make_pair(ClassId, P));
   }
   scudo::uptr Found = 0;
   auto Lambda = [&V, &Found](scudo::uptr Block) {
     for (const auto &Pair : V) {
       if (Pair.second == reinterpret_cast<void *>(Block))
Threads[I] = std::thread([&]() {
       Cache.init(nullptr, Allocator.get());
       std::vector<std::pair<scudo::uptr, void *>> V;
       {
         std::unique_lock<std::mutex> Lock(Mutex);
         while (!Ready)
           Cv.wait(Lock);
       }
       for (scudo::uptr I = 0; I < 256U; I++) {
-        const scudo::uptr Size =
-            std::rand() % Primary::SizeClassMap::MaxSize / 4;
+        const scudo::uptr Size = static_cast<scudo::uptr>(std::rand()) %
+                                 Primary::SizeClassMap::MaxSize / 4;
         const scudo::uptr ClassId =
             Primary::SizeClassMap::getClassIdBySize(Size);
         void *P = Cache.allocate(ClassId);
         if (P)
           V.push_back(std::make_pair(ClassId, P));
       }
 
       // Try to interleave pushBlocks(), popBatch() and releaseToOS().

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

for (auto TestCase : TestCases) {
     StringRangeRecorder Recorder;
     RangeTracker Tracker(Recorder);
     for (scudo::uptr I = 0; TestCase[I] != 0; I++)
       Tracker.processNextPage(TestCase[I] == 'x');
     Tracker.finish();
     // Strip trailing '.'-pages before comparing the results as they are not
     // going to be reported to range_recorder anyway.
     const char *LastX = strrchr(TestCase, 'x');
-    std::string Expected(TestCase,
-                         LastX == nullptr ? 0 : (LastX - TestCase + 1));
+    std::string Expected(
+        TestCase,
+        LastX == nullptr ? 0U : static_cast<size_t>(LastX - TestCase + 1));
     EXPECT_STREQ(Expected.c_str(), Recorder.ReportedPages.c_str());
   }
 }
 
 class ReleasedPagesRecorder {
 public:
   ReleasedPagesRecorder() = default;
   explicit ReleasedPagesRecorder(scudo::uptr Base) : Base(Base) {}

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

 TEST_F(MapAllocatorTest, SecondaryCombinations) {
   constexpr scudo::uptr MinAlign = FIRST_32_SECOND_64(8, 16);
   constexpr scudo::uptr HeaderSize = scudo::roundUp(8, MinAlign);
   for (scudo::uptr SizeLog = 0; SizeLog <= 20; SizeLog++) {
     for (scudo::uptr AlignLog = FIRST_32_SECOND_64(3, 4); AlignLog <= 16;
          AlignLog++) {
       const scudo::uptr Align = 1U << AlignLog;
       for (scudo::sptr Delta = -128; Delta <= 128; Delta += 8) {
-        if (static_cast<scudo::sptr>(1U << SizeLog) + Delta <= 0)
+        if ((1LL << SizeLog) + Delta <= 0)
           continue;
-        const scudo::uptr UserSize =
-            scudo::roundUp((1U << SizeLog) + Delta, MinAlign);
+        const scudo::uptr UserSize = scudo::roundUp(
+            static_cast<scudo::uptr>((1LL << SizeLog) + Delta), MinAlign);
         const scudo::uptr Size =
             HeaderSize + UserSize + (Align > MinAlign ? Align - HeaderSize : 0);
         void *P = Allocator->allocate(Options, Size, Align);
         EXPECT_NE(P, nullptr);
         void *AlignedP = reinterpret_cast<void *>(
             scudo::roundUp(reinterpret_cast<scudo::uptr>(P), Align));
         memset(AlignedP, 0xff, UserSize);
         Allocator->deallocate(Options, P);
       }
     }
   }
   scudo::ScopedString Str;
   Allocator->getStats(&Str);
   Str.output();
 }
 
 TEST_F(MapAllocatorTest, SecondaryIterate) {
   std::vector<void *> V;
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   for (scudo::uptr I = 0; I < 32U; I++)
-    V.push_back(Allocator->allocate(Options, (std::rand() % 16) * PageSize));
+    V.push_back(Allocator->allocate(
+        Options, (static_cast<scudo::uptr>(std::rand()) % 16U) * PageSize));
   auto Lambda = [&V](scudo::uptr Block) {
     EXPECT_NE(std::find(V.begin(), V.end(), reinterpret_cast<void *>(Block)),
               V.end());
   };
   Allocator->disable();
   Allocator->iterateOverBlocks(Lambda);
   Allocator->enable();
   while (!V.empty()) {
void performAllocations() {
     const scudo::uptr PageSize = scudo::getPageSizeCached();
     {
       std::unique_lock<std::mutex> Lock(Mutex);
       while (!Ready)
         Cv.wait(Lock);
     }
     for (scudo::uptr I = 0; I < 128U; I++) {
       // Deallocate 75% of the blocks.
-      const bool Deallocate = (rand() & 3) != 0;
-      void *P = Allocator->allocate(Options, (std::rand() % 16) * PageSize);
+      const bool Deallocate = (std::rand() & 3) != 0;
+      void *P = Allocator->allocate(
+          Options, (static_cast<scudo::uptr>(std::rand()) % 16U) * PageSize);
       if (Deallocate)
         Allocator->deallocate(Options, P);
       else
         V.push_back(P);
     }
     while (!V.empty()) {
       Allocator->deallocate(Options, V.back());
       V.pop_back();

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

public:
   void init() {
     // This should only be called once by the registry.
     EXPECT_FALSE(Initialized);
     Initialized = true;
   }
 
   void unmapTestOnly() { TSDRegistry.unmapTestOnly(this); }
   void initCache(CacheT *Cache) { *Cache = {}; }
-  void commitBack(scudo::TSD<MockAllocator> *TSD) {}
+  void commitBack(UNUSED scudo::TSD<MockAllocator> *TSD) {}
   TSDRegistryT *getTSDRegistry() { return &TSDRegistry; }
   void callPostInitCallback() {}
 
   bool isInitialized() { return Initialized; }
 
   void *operator new(size_t Size) {
     void *P = nullptr;
     EXPECT_EQ(0, posix_memalign(&P, alignof(ThisT), Size));

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

if (SCUDO_ANDROID) {
     EXPECT_EQ(mallopt(M_CACHE_SIZE_MAX, 1024 * 1024 * 2), 1);
     EXPECT_EQ(mallopt(M_TSDS_COUNT_MAX, 10), 1);
   }
 }
 #endif
 
 TEST(ScudoWrappersCTest, OtherAlloc) {
 #if HAVE_PVALLOC
-  const size_t PageSize = sysconf(_SC_PAGESIZE);
+  const size_t PageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
 
   void *P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   EXPECT_LE(PageSize, malloc_usable_size(P));
   free(P);
 
   EXPECT_EQ(pvalloc(SIZE_MAX), nullptr);
TEST(ScudoWrappersCTest, MallInfo2) {
   MI = mallinfo2();
   EXPECT_GE(MI.fordblks, Free + BypassQuarantineSize);
 }
 #endif
 
 static uintptr_t BoundaryP;
 static size_t Count;
 
-static void callback(uintptr_t Base, size_t Size, void *Arg) {
+static void callback(uintptr_t Base, UNUSED size_t Size, UNUSED void *Arg) {
   if (scudo::archSupportsMemoryTagging()) {
     Base = scudo::untagPointer(Base);
     BoundaryP = scudo::untagPointer(BoundaryP);
   }
   if (Base == BoundaryP)
     Count++;
 }
 
 // Verify that a block located on an iteration boundary is not mis-accounted.
 // 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 PageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
 #if SCUDO_ANDROID
   // Android uses a 16 byte alignment for both 32 bit and 64 bit.
   const size_t BlockDelta = 16U;
 #else
   const size_t BlockDelta = FIRST_32_SECOND_64(8U, 16U);
 #endif
   const size_t SpecialSize = PageSize - BlockDelta;
 
EXPECT_DEATH(
       },
       "");
 }
 
 static pthread_mutex_t Mutex;
 static pthread_cond_t Conditional = PTHREAD_COND_INITIALIZER;
 static bool Ready;
 
-static void *enableMalloc(void *Unused) {
+static void *enableMalloc(UNUSED void *Unused) {
   // Initialize the allocator for this thread.
   void *P = malloc(Size);
   EXPECT_NE(P, nullptr);
   memset(P, 0x42, Size);
   free(P);
 
   // Signal the main thread we are ready.
   pthread_mutex_lock(&Mutex);

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

 static void stressNew() {
   std::vector<uintptr_t *> V;
   {
     std::unique_lock<std::mutex> Lock(Mutex);
     while (!Ready)
       Cv.wait(Lock);
   }
   for (size_t I = 0; I < 256U; I++) {
-    const size_t N = std::rand() % 128U;
+    const size_t N = static_cast<size_t>(std::rand()) % 128U;
     uintptr_t *P = new uintptr_t[N];
     if (P) {
       memset(P, 0x42, sizeof(uintptr_t) * N);
       V.push_back(P);
     }
   }
   while (!V.empty()) {
     delete[] V.back();