[scudo] Fix various compiler warnings, minor bugs, remove unused header files

[ddcc]

Summary

Tested using a standalone build. Suppress or rename variables to avoid compiler warnings, remove duplicate string.h include already contained in common.h, fix some checks against undefined macros, avoid unmapping around the zero page, modify testing assertions to have matching type due to lack of type promotion during template substitution, use capture-by-reference in lambdas.

[vitalybuka]

This patch is essentially squash of unrelated fixes.
It would be nice to see this as a set of small incremental patches according to https://llvm.org/docs/DeveloperPolicy.html#incremental-development

[hctim]

As a side note, "vanilla" scudo (i.e. the non-standalone variant) is basically on hospice support. I tried to delete it about a year ago and failed to migrate some of the testing dependencies.

I'd like to get back to deleting it at some point in the future.

[ddcc]

Ok, I've split this up and will close it.

compiler-rt/lib/scudo/standalone/checksum.cpp

 //===-- checksum.cpp --------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "checksum.h"
 #include "atomic_helpers.h"
+#include "chunk.h"
 
 #if defined(__x86_64__) || defined(__i386__)
 #include <cpuid.h>
 #elif defined(__arm__) || defined(__aarch64__)
 #if SCUDO_FUCHSIA
 #include <zircon/features.h>
 #include <zircon/syscalls.h>
 #else

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

void storeDeallocationStackMaybe(Options Options, void *Ptr, u8 PrevTag,
     u32 DeallocationTid = getThreadID();
 
     storeRingBufferEntry(addFixedTag(untagPointer(Ptr), PrevTag),
                          AllocationTrace, AllocationTid, Size,
                          DeallocationTrace, DeallocationTid);
   }
 
   static const size_t NumErrorReports =
-      sizeof(((scudo_error_info *)0)->reports) /
-      sizeof(((scudo_error_info *)0)->reports[0]);
+      sizeof(((scudo_error_info *)nullptr)->reports) /
+      sizeof(((scudo_error_info *)nullptr)->reports[0]);
 
   static void getInlineErrorInfo(struct scudo_error_info *ErrorInfo,
                                  size_t &NextErrorReport, uintptr_t FaultAddr,
                                  const StackDepot *Depot,
                                  const char *RegionInfoPtr, const char *Memory,
                                  const char *MemoryTags, uintptr_t MemoryAddr,
                                  size_t MemorySize, size_t MinDistance,
                                  size_t MaxDistance) {

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

for (u8 I = 0; I < Count; I++)
     __asm__ __volatile__("yield");
 #endif
   __asm__ __volatile__("" ::: "memory");
 }
 
 // Platform specific functions.
 
 extern uptr PageSizeCached;
+uptr getPageSize();
 uptr getPageSizeSlow();
 inline uptr getPageSizeCached() {
   // Bionic uses a hardcoded value.
   if (SCUDO_ANDROID)
     return 4096U;
   if (LIKELY(PageSizeCached))
     return PageSizeCached;
   return getPageSizeSlow();

compiler-rt/lib/scudo/standalone/flags_parser.cpp

 //===-- flags_parser.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flags_parser.h"
 #include "common.h"
 #include "report.h"
 
 #include <stdlib.h>
-#include <string.h>
 
 namespace scudo {
 
 class UnknownFlagsRegistry {
   static const u32 MaxUnknownFlags = 16;
   const char *UnknownFlagsNames[MaxUnknownFlags];
   u32 NumberOfUnknownFlags;
 

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

 inline uptr untagPointer(uptr Ptr) { return Ptr & ((1ULL << 56) - 1); }
 
 inline uint8_t extractTag(uptr Ptr) { return (Ptr >> 56) & 0xf; }
 
 #else
 
 inline constexpr bool archSupportsMemoryTagging() { return false; }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmissing-noreturn"
 inline uptr archMemoryTagGranuleSize() {
   UNREACHABLE("memory tagging not supported");
 }
 
 inline uptr untagPointer(uptr Ptr) {
   (void)Ptr;
   UNREACHABLE("memory tagging not supported");
 }
 
 inline uint8_t extractTag(uptr Ptr) {
   (void)Ptr;
   UNREACHABLE("memory tagging not supported");
 }
+#pragma clang diagnostic pop
 
 #endif
 
 #if __clang_major__ >= 12 && defined(__aarch64__)
 
 #if SCUDO_LINUX
 
 inline bool systemSupportsMemoryTagging() {
prctl(PR_SET_TAGGED_ADDR_CTRL,
         PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC | (0xfffe << PR_MTE_TAG_SHIFT),
         0, 0, 0);
 }
 
 #else // !SCUDO_LINUX
 
 inline bool systemSupportsMemoryTagging() { return false; }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmissing-noreturn"
 inline bool systemDetectsMemoryTagFaultsTestOnly() {
   UNREACHABLE("memory tagging not supported");
 }
 
 inline void enableSystemMemoryTaggingTestOnly() {
   UNREACHABLE("memory tagging not supported");
 }
+#pragma clang diagnostic pop
 
 #endif // SCUDO_LINUX
 
 class ScopedDisableMemoryTagChecks {
   uptr PrevTCO;
 
 public:
   ScopedDisableMemoryTagChecks() {
__asm__ __volatile__(
       : "+r"(TaggedPtr)
       :
       : "memory");
   return TaggedPtr;
 }
 
 #else
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmissing-noreturn"
 inline bool systemSupportsMemoryTagging() {
   UNREACHABLE("memory tagging not supported");
 }
 
 inline bool systemDetectsMemoryTagFaultsTestOnly() {
   UNREACHABLE("memory tagging not supported");
 }
 
inline void storeTag(uptr Ptr) {
   (void)Ptr;
   UNREACHABLE("memory tagging not supported");
 }
 
 inline uptr loadTag(uptr Ptr) {
   (void)Ptr;
   UNREACHABLE("memory tagging not supported");
 }
+#pragma clang diagnostic pop
 
 #endif
 
 inline void setRandomTag(void *Ptr, uptr Size, uptr ExcludeMask,
                          uptr *TaggedBegin, uptr *TaggedEnd) {
   *TaggedBegin = selectRandomTag(reinterpret_cast<uptr>(Ptr), ExcludeMask);
   *TaggedEnd = storeTags(*TaggedBegin, *TaggedBegin + Size);
 }

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

 //===-- mutex.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_MUTEX_H_
 #define SCUDO_MUTEX_H_
 
 #include "atomic_helpers.h"
 #include "common.h"
 
-#include <string.h>
-
 #if SCUDO_FUCHSIA
 #include <lib/sync/mutex.h> // for sync_mutex_t
 #endif
 
 namespace scudo {
 
 class HybridMutex {
 public:

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

 #endif
 
 #if defined(__TRUSTY__)
 #define SCUDO_TRUSTY 1
 #else
 #define SCUDO_TRUSTY 0
 #endif
 
-#if __LP64__
+#if defined(__LP64__)
 #define SCUDO_WORDSIZE 64U
 #else
 #define SCUDO_WORDSIZE 32U
 #endif
 
 #if SCUDO_WORDSIZE == 64U
 #define FIRST_32_SECOND_64(a, b) (b)
 #else

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

void init(s32 ReleaseToOsInterval) {
     setOption(Option::ReleaseInterval, static_cast<sptr>(ReleaseToOsInterval));
   }
 
   void unmapTestOnly() {
     for (uptr I = 0; I < NumClasses; I++) {
       RegionInfo *Region = getRegionInfo(I);
       *Region = {};
     }
+    if (PrimaryBase)
       unmap(reinterpret_cast<void *>(PrimaryBase), PrimarySize, UNMAP_ALL, &Data);
     PrimaryBase = 0U;
   }
 
   TransferBatch *popBatch(CacheT *C, uptr ClassId) {
     DCHECK_LT(ClassId, NumClasses);
     RegionInfo *Region = getRegionInfo(ClassId);
     ScopedLock L(Region->Mutex);
     TransferBatch *B = Region->FreeList.front();

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

struct QuarantineBatch {
   // With the following count, a batch (and the header that protects it) occupy
   // 4096 bytes on 32-bit platforms, and 8192 bytes on 64-bit.
   static const u32 MaxCount = 1019;
   QuarantineBatch *Next;
   uptr Size;
   u32 Count;
   void *Batch[MaxCount];
 
-  void init(void *Ptr, uptr Size) {
+  void init(void *Ptr, uptr Sz) {
     Count = 1;
     Batch[0] = Ptr;
-    this->Size = Size + sizeof(QuarantineBatch); // Account for the Batch Size.
+    this->Size = Sz + sizeof(QuarantineBatch); // Account for the Batch Size.
   }
 
   // The total size of quarantined nodes recorded in this batch.
   uptr getQuarantinedSize() const { return Size - sizeof(QuarantineBatch); }
 
-  void push_back(void *Ptr, uptr Size) {
+  void push_back(void *Ptr, uptr Sz) {
     DCHECK_LT(Count, MaxCount);
     Batch[Count++] = Ptr;
-    this->Size += Size;
+    this->Size += Sz;
   }
 
   bool canMerge(const QuarantineBatch *const From) const {
     return Count + From->Count <= MaxCount;
   }
 
   void merge(QuarantineBatch *const From) {
     DCHECK_LE(Count + From->Count, MaxCount);

 public:
   void init() { DCHECK_EQ(atomic_load_relaxed(&Size), 0U); }
 
   // Total memory used, including internal accounting.
   uptr getSize() const { return atomic_load_relaxed(&Size); }
   // Memory used for internal accounting.
   uptr getOverheadSize() const { return List.size() * sizeof(QuarantineBatch); }
 
-  void enqueue(Callback Cb, void *Ptr, uptr Size) {
+  void enqueue(Callback Cb, void *Ptr, uptr Sz) {
     if (List.empty() || List.back()->Count == QuarantineBatch::MaxCount) {
       QuarantineBatch *B =
           reinterpret_cast<QuarantineBatch *>(Cb.allocate(sizeof(*B)));
       DCHECK(B);
-      B->init(Ptr, Size);
+      B->init(Ptr, Sz);
       enqueueBatch(B);
     } else {
-      List.back()->push_back(Ptr, Size);
-      addToSize(Size);
+      List.back()->push_back(Ptr, Sz);
+      addToSize(Sz);
     }
   }
 
   void transfer(QuarantineCache *From) {
     List.append_back(&From->List);
     addToSize(From->getSize());
     atomic_store_relaxed(&From->Size, 0);
   }
private:
   // Read-only data.
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex CacheMutex;
   CacheT Cache;
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex RecycleMutex;
   atomic_uptr MinSize = {};
   atomic_uptr MaxSize = {};
   alignas(SCUDO_CACHE_LINE_SIZE) atomic_uptr MaxCacheSize = {};
 
-  void NOINLINE recycle(uptr MinSize, Callback Cb) {
+  void NOINLINE recycle(uptr MinSz, Callback Cb) {
     CacheT Tmp;
     Tmp.init();
     {
       ScopedLock L(CacheMutex);
       // Go over the batches and merge partially filled ones to
       // save some memory, otherwise batches themselves (since the memory used
       // by them is counted against quarantine limit) can overcome the actual
       // user's quarantined chunks, which diminishes the purpose of the
       // quarantine.
       const uptr CacheSize = Cache.getSize();
       const uptr OverheadSize = Cache.getOverheadSize();
       DCHECK_GE(CacheSize, OverheadSize);
       // Do the merge only when overhead exceeds this predefined limit (might
       // require some tuning). It saves us merge attempt when the batch list
       // quarantine is unlikely to contain batches suitable for merge.
       constexpr uptr OverheadThresholdPercents = 100;
       if (CacheSize > OverheadSize &&
           OverheadSize * (100 + OverheadThresholdPercents) >
               CacheSize * OverheadThresholdPercents) {
         Cache.mergeBatches(&Tmp);
       }
       // Extract enough chunks from the quarantine to get below the max
       // quarantine size and leave some leeway for the newly quarantined chunks.
-      while (Cache.getSize() > MinSize)
+      while (Cache.getSize() > MinSz)
         Tmp.enqueueBatch(Cache.dequeueBatch());
     }
     RecycleMutex.unlock();
     doRecycle(&Tmp, Cb);
   }
 
   void NOINLINE doRecycle(CacheT *C, Callback Cb) {
     while (QuarantineBatch *B = C->dequeueBatch()) {

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

 #include "common.h"
 #include "list.h"
 #include "mutex.h"
 
 namespace scudo {
 
 class ReleaseRecorder {
 public:
-  ReleaseRecorder(uptr Base, MapPlatformData *Data = nullptr)
-      : Base(Base), Data(Data) {}
+  ReleaseRecorder(uptr _Base, MapPlatformData *_Data = nullptr)
+      : Base(_Base), Data(_Data) {}
 
   uptr getReleasedRangesCount() const { return ReleasedRangesCount; }
 
   uptr getReleasedBytes() const { return ReleasedBytes; }
 
   uptr getBase() const { return Base; }
 
   // Releases [From, To) range of pages back to OS.
private:
   uptr *Buffer;
 
   static HybridMutex Mutex;
   static uptr StaticBuffer[StaticBufferCount];
 };
 
 template <class ReleaseRecorderT> class FreePagesRangeTracker {
 public:
-  explicit FreePagesRangeTracker(ReleaseRecorderT *Recorder)
-      : Recorder(Recorder), PageSizeLog(getLog2(getPageSizeCached())) {}
+  explicit FreePagesRangeTracker(ReleaseRecorderT *_Recorder)
+      : Recorder(_Recorder), PageSizeLog(getLog2(getPageSizeCached())) {}
 
   void processNextPage(bool Freed) {
     if (Freed) {
       if (!InRange) {
         CurrentRangeStatePage = CurrentPage;
         InRange = true;
       }
     } else {

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

uptr HeaderPos;
           continue;
         Found = true;
         Entry = Entries[I];
         Entries[I].CommitBase = 0;
         break;
       }
     }
     if (Found) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wconditional-uninitialized"
       *H = reinterpret_cast<LargeBlock::Header *>(
           LargeBlock::addHeaderTag<Config>(HeaderPos));
+#pragma clang diagnostic pop
       *Zeroed = Entry.Time == 0;
       if (useMemoryTagging<Config>(Options))
         setMemoryPermission(Entry.CommitBase, Entry.CommitSize, 0, &Entry.Data);
       uptr NewBlockBegin = reinterpret_cast<uptr>(*H + 1);
       if (useMemoryTagging<Config>(Options)) {
         if (*Zeroed)
           storeTags(LargeBlock::addHeaderTag<Config>(Entry.CommitBase),
                     NewBlockBegin);
private:
   u32 QuarantinePos = 0;
   atomic_u32 MaxEntriesCount = {};
   atomic_uptr MaxEntrySize = {};
   u64 OldestTime = 0;
   u32 IsFullEvents = 0;
   atomic_s32 ReleaseToOsIntervalMs = {};
 
   CachedBlock Entries[Config::SecondaryCacheEntriesArraySize] = {};
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wzero-length-array"
   CachedBlock Quarantine[Config::SecondaryCacheQuarantineSize] = {};
+#pragma clang diagnostic pop
 };
 
 template <typename Config> class MapAllocator {
 public:
   void init(GlobalStats *S, s32 ReleaseToOsInterval = -1) {
     DCHECK_EQ(AllocatedBytes, 0U);
     DCHECK_EQ(FreedBytes, 0U);
     Cache.init(ReleaseToOsInterval);
template <typename F> void iterateOverBlocks(F Callback) const {
     for (const auto &H : InUseBlocks) {
       uptr Ptr = reinterpret_cast<uptr>(&H) + LargeBlock::getHeaderSize();
       if (allocatorSupportsMemoryTagging<Config>())
         Ptr = untagPointer(Ptr);
       Callback(Ptr);
     }
   }
 
-  uptr canCache(uptr Size) { return Cache.canCache(Size); }
+  bool canCache(uptr Size) { return Cache.canCache(Size); }
 
   bool setOption(Option O, sptr Value) { return Cache.setOption(O, Value); }
 
   void releaseToOS() { Cache.releaseToOS(); }
 
   void disableMemoryTagging() { Cache.disableMemoryTagging(); }
 
   void unmapTestOnly() { Cache.unmapTestOnly(); }

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

Buffer.append(
         SCMap::getClassIdBySize(S));
     TotalCached += Cached;
     PrevS = S;
   }
   Buffer.append("Total Cached: %zu\n", TotalCached);
   Buffer.output();
 }
 
-template <typename SCMap> static void validateMap() {
+template <typename SCMap> static UNUSED void validateMap() {
   for (uptr C = 0; C < SCMap::NumClasses; C++) {
     if (C == SCMap::BatchClassId)
       continue;
     const uptr S = SCMap::getSizeByClassId(C);
     CHECK_NE(S, 0U);
     CHECK_EQ(SCMap::getClassIdBySize(S), C);
     if (C < SCMap::LargestClassId)
       CHECK_EQ(SCMap::getClassIdBySize(S + 1), C + 1);

compiler-rt/lib/scudo/standalone/string_utils.cpp

 //===-- string_utils.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "string_utils.h"
 #include "common.h"
 
 #include <stdarg.h>
-#include <string.h>
 
 namespace scudo {
 
 static int appendChar(char **Buffer, const char *BufferEnd, char C) {
   if (*Buffer < BufferEnd) {
     **Buffer = C;
     (*Buffer)++;
   }

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

 //===-- bytemap_test.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "bytemap.h"
 
-#include <pthread.h>
-#include <string.h>
-
 template <typename T> void testMap(T &Map, scudo::uptr Size) {
   Map.init();
   for (scudo::uptr I = 0; I < Size; I += 7)
     Map.set(I, (I % 100) + 1);
   for (scudo::uptr J = 0; J < Size; J++) {
     if (J % 7)
       EXPECT_EQ(Map[J], 0);
     else

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

 //===-- checksum_test.cpp ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "checksum.h"
 
 #include <string.h>
 
-scudo::u16 computeSoftwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
+static scudo::u16 computeSoftwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
                                           scudo::uptr ArraySize) {
   scudo::u16 Checksum = static_cast<scudo::u16>(Seed & 0xffff);
   for (scudo::uptr I = 0; I < ArraySize; I++)
     Checksum = scudo::computeBSDChecksum(Checksum, Array[I]);
   return Checksum;
 }
 
-scudo::u16 computeHardwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
+static scudo::u16 computeHardwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
                                           scudo::uptr ArraySize) {
   scudo::u32 Crc = Seed;
   for (scudo::uptr I = 0; I < ArraySize; I++)
     Crc = scudo::computeHardwareCRC32(Crc, Array[I]);
   return static_cast<scudo::u16>((Crc & 0xffff) ^ (Crc >> 16));
 }
 
 typedef scudo::u16 (*ComputeChecksum)(scudo::u32, scudo::uptr *, scudo::uptr);
 
 // This verifies that flipping bits in the data being checksummed produces a
 // different checksum. We do not use random data to avoid flakyness.
-template <ComputeChecksum F> void verifyChecksumFunctionBitFlip() {
+template <ComputeChecksum F> static void verifyChecksumFunctionBitFlip() {
   scudo::uptr Array[sizeof(scudo::u64) / sizeof(scudo::uptr)];
   const scudo::uptr ArraySize = ARRAY_SIZE(Array);
   memset(Array, 0xaa, sizeof(Array));
   const scudo::u32 Seed = 0x41424343U;
   const scudo::u16 Reference = F(Seed, Array, ArraySize);
   scudo::u8 IdenticalChecksums = 0;
   for (scudo::uptr I = 0; I < ArraySize; I++) {
     for (scudo::uptr J = 0; J < SCUDO_WORDSIZE; J++) {

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

void *P = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Block) +
                                      HeaderSize);
   scudo::Chunk::storeHeader(Cookie, P, &OldHeader);
   memset(P, 'A', Size);
   scudo::Chunk::UnpackedHeader NewHeader = OldHeader;
   NewHeader.State = scudo::Chunk::State::Quarantined;
   scudo::Chunk::compareExchangeHeader(Cookie, P, &NewHeader, &OldHeader);
   NewHeader = {};
   EXPECT_TRUE(scudo::Chunk::isValid(Cookie, P, &NewHeader));
-  EXPECT_EQ(NewHeader.State, scudo::Chunk::State::Quarantined);
+  EXPECT_EQ(NewHeader.State,
+            static_cast<scudo::u8>(scudo::Chunk::State::Quarantined));
   EXPECT_FALSE(scudo::Chunk::isValid(InvalidCookie, P, &NewHeader));
   free(Block);
 }
 
 TEST(ScudoChunkDeathTest, CorruptHeader) {
   initChecksum();
   const scudo::uptr Size = 0x100U;
   scudo::Chunk::UnpackedHeader Header = {};

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

 #define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidSvelteConfig)                    \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, DefaultConfig)                          \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidConfig)
 #endif
 
 #define SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TYPE)                             \
   using FIXTURE##NAME##_##TYPE = FIXTURE##NAME<scudo::TYPE>;                   \
-  TEST_F(FIXTURE##NAME##_##TYPE, NAME) { Run(); }
+  TEST_F(FIXTURE##NAME##_##TYPE, NAME) { FIXTURE##NAME<scudo::TYPE>::Run(); }
 
 #define SCUDO_TYPED_TEST(FIXTURE, NAME)                                        \
   template <class TypeParam>                                                   \
   struct FIXTURE##NAME : public FIXTURE<TypeParam> {                           \
     void Run();                                                                \
   };                                                                           \
   SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                                    \
   template <class TypeParam> void FIXTURE##NAME<TypeParam>::Run()
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, IsOwned) {
   auto *Allocator = this->Allocator.get();
   static scudo::u8 StaticBuffer[scudo::Chunk::getHeaderSize() + 1];
   EXPECT_FALSE(
       Allocator->isOwned(&StaticBuffer[scudo::Chunk::getHeaderSize()]));
 
   scudo::u8 StackBuffer[scudo::Chunk::getHeaderSize() + 1];
   for (scudo::uptr I = 0; I < sizeof(StackBuffer); I++)
     StackBuffer[I] = 0x42U;
   EXPECT_FALSE(Allocator->isOwned(&StackBuffer[scudo::Chunk::getHeaderSize()]));
   for (scudo::uptr I = 0; I < sizeof(StackBuffer); I++)
-    EXPECT_EQ(StackBuffer[I], 0x42U);
+    EXPECT_EQ(StackBuffer[I], static_cast<scudo::u8>(0x42U));
 }
 
 template <class Config>
 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
SCUDO_TYPED_TEST(ScudoCombinedTest, ZeroContents) {
 
   // Ensure that specifying ZeroContents returns a zero'd out block.
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
       const scudo::uptr Size = (1U << SizeLog) + Delta * 128U;
       void *P = Allocator->allocate(Size, Origin, 1U << MinAlignLog, true);
       EXPECT_NE(P, nullptr);
       for (scudo::uptr I = 0; I < Size; I++)
-        ASSERT_EQ((reinterpret_cast<char *>(P))[I], 0);
+        ASSERT_EQ((reinterpret_cast<char *>(P))[I], static_cast<char>(0));
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, ZeroFill) {
   auto *Allocator = this->Allocator.get();
 
   // Ensure that specifying ZeroFill returns a zero'd out block.
   Allocator->setFillContents(scudo::ZeroFill);
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
       const scudo::uptr Size = (1U << SizeLog) + Delta * 128U;
       void *P = Allocator->allocate(Size, Origin, 1U << MinAlignLog, false);
       EXPECT_NE(P, nullptr);
       for (scudo::uptr I = 0; I < Size; I++)
-        ASSERT_EQ((reinterpret_cast<char *>(P))[I], 0);
+        ASSERT_EQ((reinterpret_cast<char *>(P))[I], static_cast<char>(0));
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, PatternOrZeroFill) {
   auto *Allocator = this->Allocator.get();
for (scudo::uptr I = 0; I <= MaxNumberOfChunks; I++) {
       else
         V.push_back(P);
     }
     while (!V.empty()) {
       Allocator->deallocate(V.back(), Origin);
       V.pop_back();
     }
   }
-  EXPECT_EQ(FailedAllocationsCount, 0U);
+  EXPECT_EQ(FailedAllocationsCount, 0UL);
 }
 
 // Ensure that releaseToOS can be called prior to any other allocator
 // operation without issue.
 SCUDO_TYPED_TEST(ScudoCombinedTest, ReleaseToOS) {
   auto *Allocator = this->Allocator.get();
   Allocator->releaseToOS();
 }
for (scudo::uptr ClassId = 1U; ClassId <= SizeClassMap::LargestClassId;
     }
     EXPECT_TRUE(Found);
   }
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, DisableMemInit) {
   auto *Allocator = this->Allocator.get();
 
-  std::vector<void *> Ptrs(65536, nullptr);
+  std::vector<void *> Ptrs(65536);
 
   Allocator->setOption(scudo::Option::ThreadDisableMemInit, 1);
 
   constexpr scudo::uptr MinAlignLog = FIRST_32_SECOND_64(3U, 4U);
 
   // Test that if mem-init is disabled on a thread, calloc should still work as
   // expected. This is tricky to ensure when MTE is enabled, so this test tries
   // to exercise the relevant code on our MTE path.
for (unsigned I = 0; I != Ptrs.size(); ++I) {
       Ptrs[I] = Allocator->allocate(Size - 8, Origin);
       memset(Ptrs[I], 0xbb, Size - 8);
     }
     for (unsigned I = 0; I != Ptrs.size(); ++I)
       Allocator->deallocate(Ptrs[I], Origin, Size - 8);
     for (unsigned I = 0; I != Ptrs.size(); ++I) {
       Ptrs[I] = Allocator->allocate(Size, Origin, 1U << MinAlignLog, true);
       for (scudo::uptr J = 0; J < Size; ++J)
-        ASSERT_EQ((reinterpret_cast<char *>(Ptrs[I]))[J], 0);
+        ASSERT_EQ((reinterpret_cast<char *>(Ptrs[I]))[J], static_cast<char>(0));
     }
   }
 
   Allocator->setOption(scudo::Option::ThreadDisableMemInit, 0);
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, ReallocateInPlaceStress) {
   auto *Allocator = this->Allocator.get();

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

TEST(ScudoCommonTest, Zeros) {
 
   MapPlatformData Data = {};
   uptr *P = reinterpret_cast<uptr *>(map(nullptr, Size, "Zeros", 0, &Data));
   const ptrdiff_t N = Size / sizeof(*P);
   ASSERT_NE(nullptr, P);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
   memset(P, 1, Size);
-  EXPECT_EQ(std::count(P, P + N, 0), 0);
+  EXPECT_EQ(std::count(P, P + N, 0), 0L);
 
   releasePagesToOS((uptr)P, 0, Size, &Data);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
   unmap(P, Size, 0, &Data);
 }
 
 } // namespace scudo

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

 //===-- flags_test.cpp ------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "flags.h"
 #include "flags_parser.h"
 
-#include <string.h>
-
 static const char FlagName[] = "flag_name";
 static const char FlagDesc[] = "flag description";
 
 template <typename T>
 static void testFlag(scudo::FlagType Type, T StartValue, const char *Env,
                      T FinalValue) {
   scudo::FlagParser Parser;
   T Flag = StartValue;

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

static void checkList(ListT *L, ListItem *I1, ListItem *I2 = nullptr,
   }
   EXPECT_TRUE(L->empty());
 }
 
 template <typename ListT> static void testListCommon(void) {
   ListT L;
   L.clear();
 
-  EXPECT_EQ(L.size(), 0U);
+  EXPECT_EQ(L.size(), 0UL);
   L.push_back(X);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.back(), X);
   EXPECT_EQ(L.front(), X);
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 
   L.push_front(X);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.back(), X);
   EXPECT_EQ(L.front(), X);
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 
   L.push_front(X);
   L.push_front(Y);
   L.push_front(Z);
-  EXPECT_EQ(L.size(), 3U);
+  EXPECT_EQ(L.size(), 3UL);
   EXPECT_EQ(L.front(), Z);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
 
   L.pop_front();
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), Y);
   EXPECT_EQ(L.back(), X);
   L.pop_front();
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 
   L.push_back(X);
   L.push_back(Y);
   L.push_back(Z);
-  EXPECT_EQ(L.size(), 3U);
+  EXPECT_EQ(L.size(), 3UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), Z);
   L.checkConsistency();
 
   L.pop_front();
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), Y);
   EXPECT_EQ(L.back(), Z);
   L.pop_front();
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 }
 
 TEST(ScudoListTest, LinkedListCommon) {
   testListCommon<SLList>();
   testListCommon<DLList>();
 }
 
 TEST(ScudoListTest, SinglyLinkedList) {
   SLList L;
   L.clear();
 
   L.push_back(X);
   L.push_back(Y);
   L.push_back(Z);
   L.extract(X, Y);
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), Z);
   L.checkConsistency();
   L.extract(X, Z);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.pop_front();
   EXPECT_TRUE(L.empty());
 
   SLList L1, L2;
   L1.clear();
TEST(ScudoListTest, SinglyLinkedList) {
   EXPECT_TRUE(L2.empty());
 
   L1.clear();
   L2.clear();
   L1.push_back(X);
   L1.append_back(&L2);
   EXPECT_EQ(L1.back(), X);
   EXPECT_EQ(L1.front(), X);
-  EXPECT_EQ(L1.size(), 1U);
+  EXPECT_EQ(L1.size(), 1UL);
 }
 
 TEST(ScudoListTest, DoublyLinkedList) {
   DLList L;
   L.clear();
 
   L.push_back(X);
   L.push_back(Y);
   L.push_back(Z);
   L.remove(Y);
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), Z);
   L.checkConsistency();
   L.remove(Z);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.pop_front();
   EXPECT_TRUE(L.empty());
 
   L.push_back(X);
   L.insert(Y, X);
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), Y);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.remove(Y);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.pop_front();
   EXPECT_TRUE(L.empty());
 }

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

 //===-- map_test.cpp --------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "common.h"
 
-#include <string.h>
 #include <unistd.h>
 
 static const char *MappingName = "scudo:test";
 
 TEST(ScudoMapTest, PageSize) {
   EXPECT_EQ(scudo::getPageSizeCached(),
-            static_cast<scudo::uptr>(getpagesize()));
+            static_cast<scudo::uptr>(sysconf(_SC_PAGESIZE)));
 }
 
 TEST(ScudoMapDeathTest, MapNoAccessUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
   scudo::MapPlatformData Data = {};
   void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &Data);
   EXPECT_NE(P, nullptr);
   EXPECT_DEATH(memset(P, 0xaa, Size), "");

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

TEST(MemtagBasicDeathTest, Unsupported) {
   EXPECT_DEATH(loadTag((uptr)0), "not supported");
 
   EXPECT_DEATH(setRandomTag(nullptr, 64, 0, nullptr, nullptr), "not supported");
   EXPECT_DEATH(untagPointer(nullptr), "not supported");
   EXPECT_DEATH(loadTag(nullptr), "not supported");
   EXPECT_DEATH(addFixedTag(nullptr, 0), "not supported");
 }
 
-class MemtagTest : public ::testing::Test {
+class MemtagTest : public Test {
 protected:
   void SetUp() override {
     if (!archSupportsMemoryTagging() || !systemDetectsMemoryTagFaultsTestOnly())
       GTEST_SKIP() << "Memory tagging is not supported";
 
     BufferSize = getPageSizeCached();
     Buffer = reinterpret_cast<u8 *>(
         map(nullptr, BufferSize, "MemtagTest", MAP_MEMTAG, &Data));
protected:
   MapPlatformData Data = {};
   u8 *Buffer = nullptr;
   uptr Addr = 0;
 };
 
 using MemtagDeathTest = MemtagTest;
 
 TEST_F(MemtagTest, ArchMemoryTagGranuleSize) {
-  EXPECT_GT(archMemoryTagGranuleSize(), 1u);
+  EXPECT_GT(archMemoryTagGranuleSize(), 1ul);
   EXPECT_TRUE(isPowerOfTwo(archMemoryTagGranuleSize()));
 }
 
 TEST_F(MemtagTest, ExtractTag) {
   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);
+  EXPECT_EQ(0xfffful, Tags);
 }
 
 TEST_F(MemtagDeathTest, AddFixedTag) {
-  for (uptr Tag = 0; Tag < 0x10; ++Tag)
+  for (uint8_t Tag = 0; Tag < 0x10; ++Tag)
     EXPECT_EQ(Tag, extractTag(addFixedTag(Addr, Tag)));
   if (SCUDO_DEBUG) {
     EXPECT_DEBUG_DEATH(addFixedTag(Addr, 16), "");
     EXPECT_DEBUG_DEATH(addFixedTag(~Addr, 0), "");
   }
 }
 
 TEST_F(MemtagTest, UntagPointer) {

 }
 
 TEST_F(MemtagTest, SelectRandomTag) {
   for (uptr SrcTag = 0; SrcTag < 0x10; ++SrcTag) {
     uptr Ptr = addFixedTag(Addr, SrcTag);
     uptr Tags = 0;
     for (uptr I = 0; I < 100000; ++I)
       Tags = Tags | (1u << extractTag(selectRandomTag(Ptr, 0)));
-    EXPECT_EQ(0xfffeull, Tags);
+    EXPECT_EQ(0xfffeul, Tags);
   }
 }
 
 TEST_F(MemtagTest, SelectRandomTagWithMask) {
-  for (uptr j = 0; j < 32; ++j) {
+  for (uint8_t j = 0; j < 32; ++j) {
     for (uptr i = 0; i < 1000; ++i)
       EXPECT_NE(j, extractTag(selectRandomTag(Addr, 1ull << j)));
   }
 }
 
 TEST_F(MemtagDeathTest, SKIP_NO_DEBUG(LoadStoreTagUnaligned)) {
   for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     if (P % archMemoryTagGranuleSize() == 0)

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

 //===-- mutex_test.cpp ------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "mutex.h"
 
 #include <pthread.h>
-#include <string.h>
 
 class TestData {
 public:
   explicit TestData(scudo::HybridMutex &M) : Mutex(M) {
     for (scudo::u32 I = 0; I < Size; I++)
       Data[I] = 0;
   }
 

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

 #define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig1)                            \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig2)                            \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig3)
 #endif
 
 #define SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TYPE)                             \
   using FIXTURE##NAME##_##TYPE = FIXTURE##NAME<TYPE>;                          \
-  TEST_F(FIXTURE##NAME##_##TYPE, NAME) { Run(); }
+  TEST_F(FIXTURE##NAME##_##TYPE, NAME) { FIXTURE##NAME<TYPE>::Run(); }
 
 #define SCUDO_TYPED_TEST(FIXTURE, NAME)                                        \
   template <class TypeParam>                                                   \
   struct FIXTURE##NAME : public FIXTURE<TypeParam> {                           \
     void Run();                                                                \
   };                                                                           \
   SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                                    \
   template <class TypeParam> void FIXTURE##NAME<TypeParam>::Run()
SCUDO_TYPED_TEST(ScudoPrimaryTest, PrimaryIterate) {
   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 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) {
+  auto Lambda = [&V, &Found](scudo::uptr Block) {
     for (const auto &Pair : V) {
       if (Pair.second == reinterpret_cast<void *>(Block))
         Found++;
     }
   };
   Allocator->disable();
   Allocator->iterateOverBlocks(Lambda);
   Allocator->enable();
SCUDO_TYPED_TEST(ScudoPrimaryTest, ReleaseToOS) {
   Cache.init(nullptr, Allocator.get());
   const scudo::uptr Size = scudo::getPageSizeCached() * 2;
   EXPECT_TRUE(Primary::canAllocate(Size));
   const scudo::uptr ClassId = Primary::SizeClassMap::getClassIdBySize(Size);
   void *P = Cache.allocate(ClassId);
   EXPECT_NE(P, nullptr);
   Cache.deallocate(ClassId, P);
   Cache.destroy(nullptr);
-  EXPECT_GT(Allocator->releaseToOS(), 0U);
+  EXPECT_GT(Allocator->releaseToOS(), 0UL);
 }

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

TEST(ScudoQuarantineTest, QuarantineBatchMerge) {
   // Verify the trivial case.
   scudo::QuarantineBatch Into;
   Into.init(FakePtr, 4UL);
   scudo::QuarantineBatch From;
   From.init(FakePtr, 8UL);
 
   Into.merge(&From);
 
-  EXPECT_EQ(Into.Count, 2UL);
+  EXPECT_EQ(Into.Count, 2U);
   EXPECT_EQ(Into.Batch[0], FakePtr);
   EXPECT_EQ(Into.Batch[1], FakePtr);
   EXPECT_EQ(Into.Size, 12UL + sizeof(scudo::QuarantineBatch));
   EXPECT_EQ(Into.getQuarantinedSize(), 12UL);
 
-  EXPECT_EQ(From.Count, 0UL);
+  EXPECT_EQ(From.Count, 0U);
   EXPECT_EQ(From.Size, sizeof(scudo::QuarantineBatch));
   EXPECT_EQ(From.getQuarantinedSize(), 0UL);
 
   // Merge the batch to the limit.
   for (scudo::uptr I = 2; I < scudo::QuarantineBatch::MaxCount; ++I)
     From.push_back(FakePtr, 8UL);
   EXPECT_TRUE(Into.Count + From.Count == scudo::QuarantineBatch::MaxCount);
   EXPECT_TRUE(Into.canMerge(&From));

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

 //===-- release_test.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "list.h"
 #include "release.h"
 #include "size_class_map.h"
 
-#include <string.h>
-
 #include <algorithm>
 #include <random>
 #include <set>
 
 TEST(ScudoReleaseTest, PackedCounterArray) {
   for (scudo::uptr I = 0; I < SCUDO_WORDSIZE; I++) {
     // Various valid counter's max values packed into one word.
     scudo::PackedCounterArray Counters2N(1U, 1U, 1UL << I);

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

TEST_F(MapAllocatorTest, SecondaryCombinations) {
   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));
-  auto Lambda = [V](scudo::uptr Block) {
+  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()) {
     Allocator->deallocate(Options, V.back());

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

 //===-- stats_test.cpp ------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "stats.h"
 
 TEST(ScudoStatsTest, LocalStats) {
   scudo::LocalStats LStats;
   LStats.init();
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(LStats.get(static_cast<scudo::StatType>(I)), 0U);
+    EXPECT_EQ(LStats.get(static_cast<scudo::StatType>(I)), 0UL);
   LStats.add(scudo::StatAllocated, 4096U);
-  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096U);
+  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096UL);
   LStats.sub(scudo::StatAllocated, 4096U);
-  EXPECT_EQ(LStats.get(scudo::StatAllocated), 0U);
+  EXPECT_EQ(LStats.get(scudo::StatAllocated), 0UL);
   LStats.set(scudo::StatAllocated, 4096U);
-  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096U);
+  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096UL);
 }
 
 TEST(ScudoStatsTest, GlobalStats) {
   scudo::GlobalStats GStats;
   GStats.init();
   scudo::uptr Counters[scudo::StatCount] = {};
   GStats.get(Counters);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(Counters[I], 0U);
+    EXPECT_EQ(Counters[I], 0UL);
   scudo::LocalStats LStats;
   LStats.init();
   GStats.link(&LStats);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    LStats.add(static_cast<scudo::StatType>(I), 4096U);
+    LStats.add(static_cast<scudo::StatType>(I), 4096UL);
   GStats.get(Counters);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(Counters[I], 4096U);
+    EXPECT_EQ(Counters[I], 4096UL);
   // Unlinking the local stats move numbers to the global stats.
   GStats.unlink(&LStats);
   GStats.get(Counters);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(Counters[I], 4096U);
+    EXPECT_EQ(Counters[I], 4096UL);
 }

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

for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     std::unique_lock<std::mutex> Lock(Mutex);
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
   // The initial number of TSDs we get will be the minimum of the default count
   // and the number of CPUs.
-  EXPECT_LE(Pointers.size(), 8U);
+  EXPECT_LE(Pointers.size(), 8UL);
   Pointers.clear();
   auto Registry = Allocator->getTSDRegistry();
   // Increase the number of TSDs to 16.
   Registry->setOption(scudo::Option::MaxTSDsCount, 16);
   Ready = false;
   for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     Threads[I] = std::thread(stressSharedRegistry, Allocator.get());
   {
     std::unique_lock<std::mutex> Lock(Mutex);
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
   // We should get 16 distinct TSDs back.
-  EXPECT_EQ(Pointers.size(), 16U);
+  EXPECT_EQ(Pointers.size(), 16UL);
 }

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

 //===-- vector_test.cpp -----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "vector.h"
 
 TEST(ScudoVectorTest, Basic) {
   scudo::Vector<int> V;
-  EXPECT_EQ(V.size(), 0U);
+  EXPECT_EQ(V.size(), 0UL);
   V.push_back(42);
-  EXPECT_EQ(V.size(), 1U);
+  EXPECT_EQ(V.size(), 1UL);
   EXPECT_EQ(V[0], 42);
   V.push_back(43);
-  EXPECT_EQ(V.size(), 2U);
+  EXPECT_EQ(V.size(), 2UL);
   EXPECT_EQ(V[0], 42);
   EXPECT_EQ(V[1], 43);
 }
 
 TEST(ScudoVectorTest, Stride) {
   scudo::Vector<scudo::uptr> V;
   for (scudo::uptr I = 0; I < 1000; I++) {
     V.push_back(I);
-    EXPECT_EQ(V.size(), I + 1U);
+    EXPECT_EQ(V.size(), I + 1UL);
     EXPECT_EQ(V[I], I);
   }
   for (scudo::uptr I = 0; I < 1000; I++)
     EXPECT_EQ(V[I], I);
 }
 
 TEST(ScudoVectorTest, ResizeReduction) {
   scudo::Vector<int> V;
   V.push_back(0);
   V.push_back(0);
-  EXPECT_EQ(V.size(), 2U);
+  EXPECT_EQ(V.size(), 2UL);
   V.resize(1);
-  EXPECT_EQ(V.size(), 1U);
+  EXPECT_EQ(V.size(), 1UL);
 }

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

 // freed (this depends on the size obviously) and the following free succeeds.
 
 static const size_t Size = 100U;
 
 TEST(ScudoWrappersCDeathTest, Malloc) {
   void *P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0UL);
 
   // An update to this warning in Clang now triggers in this line, but it's ok
   // because the check is expecting a bad pointer and should fail.
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
   EXPECT_DEATH(
#endif
   EXPECT_EQ(errno, ENOMEM);
 }
 
 TEST(ScudoWrappersCTest, Calloc) {
   void *P = calloc(1U, Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   for (size_t I = 0; I < Size; I++)
-    EXPECT_EQ((reinterpret_cast<uint8_t *>(P))[I], 0U);
+    EXPECT_EQ((reinterpret_cast<uint8_t *>(P))[I], static_cast<uint8_t>(0U));
   free(P);
 
   P = calloc(1U, 0U);
   EXPECT_NE(P, nullptr);
   free(P);
   P = calloc(0U, 1U);
   EXPECT_NE(P, nullptr);
   free(P);

 TEST(ScudoWrappersCTest, Memalign) {
   void *P;
   for (size_t I = FIRST_32_SECOND_64(2U, 3U); I <= 18U; I++) {
     const size_t Alignment = 1U << I;
 
     P = memalign(Alignment, Size);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
     free(P);
 
     P = nullptr;
     EXPECT_EQ(posix_memalign(&P, Alignment, Size), 0);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
     free(P);
   }
 
   EXPECT_EQ(memalign(4096U, SIZE_MAX), nullptr);
   EXPECT_EQ(posix_memalign(&P, 15U, Size), EINVAL);
   EXPECT_EQ(posix_memalign(&P, 4096U, SIZE_MAX), ENOMEM);
 
   // Android's memalign accepts non power-of-2 alignments, and 0.
   if (SCUDO_ANDROID) {
     for (size_t Alignment = 0U; Alignment <= 128U; Alignment++) {
       P = memalign(Alignment, 1024U);
       EXPECT_NE(P, nullptr);
       free(P);
     }
   }
 }
 
 TEST(ScudoWrappersCTest, AlignedAlloc) {
   const size_t Alignment = 4096U;
   void *P = aligned_alloc(Alignment, Alignment * 4U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Alignment * 4U, malloc_usable_size(P));
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
   free(P);
 
   errno = 0;
   P = aligned_alloc(Alignment, Size);
   EXPECT_EQ(P, nullptr);
   EXPECT_EQ(errno, EINVAL);
 }
 
TEST(ScudoWrappersCDeathTest, Realloc) {
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   memset(P, 0x42, Size);
 
   P = realloc(P, Size * 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size * 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size; I++)
-    EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+    EXPECT_EQ(static_cast<uint8_t>(0x42U), (reinterpret_cast<uint8_t *>(P))[I]);
 
   P = realloc(P, Size / 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size / 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size / 2U; I++)
-    EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+    EXPECT_EQ(static_cast<uint8_t>(0x42U), (reinterpret_cast<uint8_t *>(P))[I]);
   free(P);
 
   EXPECT_DEATH(P = realloc(P, Size), "");
 
   errno = 0;
   EXPECT_EQ(realloc(nullptr, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   errno = 0;
   EXPECT_EQ(realloc(P, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
   free(P);
 
   // Android allows realloc of memalign pointers.
   if (SCUDO_ANDROID) {
     const size_t Alignment = 1024U;
     P = memalign(Alignment, Size);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
     memset(P, 0x42, Size);
 
     P = realloc(P, Size * 2U);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size * 2U, malloc_usable_size(P));
     for (size_t I = 0; I < Size; I++)
-      EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+      EXPECT_EQ(static_cast<uint8_t>(0x42U), (reinterpret_cast<uint8_t *>(P))[I]);
     free(P);
   }
 }
 
 #if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallOpt) {
   errno = 0;
   EXPECT_EQ(mallopt(-1000, 1), 0);

 #endif
 
 TEST(ScudoWrappersCTest, OtherAlloc) {
 #if !SCUDO_FUCHSIA
   const size_t PageSize = sysconf(_SC_PAGESIZE);
 
   void *P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0UL);
   EXPECT_LE(PageSize, malloc_usable_size(P));
   free(P);
 
   EXPECT_EQ(pvalloc(SIZE_MAX), nullptr);
 
   P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0UL);
   free(P);
 #endif
 
   EXPECT_EQ(valloc(SIZE_MAX), nullptr);
 }
 
 #if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallInfo) {

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

 #define SCUDO_TSD_EXCLUSIVE_H_
 
 #include "tsd.h"
 
 namespace scudo {
 
 struct ThreadState {
   bool DisableMemInit : 1;
-  enum {
+  enum : unsigned {
     NotInitialized = 0,
     Initialized,
     TornDown,
   } InitState : 2;
 };
 
 template <class Allocator> void teardownThread(void *Ptr);
 
template <class Allocator> struct TSDRegistryExT {
   }
 
   void enable() {
     atomic_store(&Disabled, 0U, memory_order_release);
     FallbackTSD.unlock();
     Mutex.unlock();
   }
 
-  bool setOption(Option O, UNUSED sptr Value) {
+  bool setOption(Option O, sptr Value) {
     if (O == Option::ThreadDisableMemInit)
       State.DisableMemInit = Value;
     if (O == Option::MaxTSDsCount)
       return false;
     return true;
   }
 
   bool getDisableMemInit() { return State.DisableMemInit; }

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

 //===-- vector.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_VECTOR_H_
 #define SCUDO_VECTOR_H_
 
 #include "common.h"
 
-#include <string.h>
-
 namespace scudo {
 
 // A low-level vector based on map. May incur a significant memory overhead for
 // small vectors. The current implementation supports only POD types.
 template <typename T> class VectorNoCtor {
 public:
   constexpr void init(uptr InitialCapacity = 0) {
     Data = &LocalData[0];

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

 
 // Bionic's struct mallinfo consists of size_t (mallinfo(3) uses int).
 #if SCUDO_ANDROID
 typedef size_t __scudo_mallinfo_data_t;
 #else
 typedef int __scudo_mallinfo_data_t;
 #endif
 
+extern "C" void malloc_postinit();
+extern scudo::Allocator<scudo::Config, malloc_postinit> Allocator;
+
 struct __scudo_mallinfo {
   __scudo_mallinfo_data_t arena;
   __scudo_mallinfo_data_t ordblks;
   __scudo_mallinfo_data_t smblks;
   __scudo_mallinfo_data_t hblks;
   __scudo_mallinfo_data_t hblkhd;
   __scudo_mallinfo_data_t usmblks;
   __scudo_mallinfo_data_t fsmblks;

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

 inline bool checkPosixMemalignAlignment(uptr Alignment) {
   return Alignment == 0 || !isPowerOfTwo(Alignment) ||
          !isAligned(Alignment, sizeof(void *));
 }
 
 // Returns true if calloc(Size, N) overflows on Size*N calculation. Use a
 // builtin supported by recent clang & GCC if it exists, otherwise fallback to a
 // costly division.
-inline bool checkForCallocOverflow(uptr Size, uptr N, uptr *Product) {
-#if __has_builtin(__builtin_umull_overflow) && (SCUDO_WORDSIZE == 64U)
-  return __builtin_umull_overflow(Size, N, Product);
-#elif __has_builtin(__builtin_umul_overflow) && (SCUDO_WORDSIZE == 32U)
-  return __builtin_umul_overflow(Size, N, Product);
-#else
+template <typename T = scudo::uptr>
+inline bool checkForCallocOverflow(T Size, T N, T *Product) {
   *Product = Size * N;
   if (!Size)
     return false;
   return (*Product / Size) != N;
+}
+
+#if __has_builtin(__builtin_umull_overflow)
+template <>
+inline bool checkForCallocOverflow<unsigned long>(unsigned long Size,
+                                                  unsigned long N,
+                                                  unsigned long *Product) {
+  return __builtin_umull_overflow(Size, N, Product);
+}
 #endif
+
+#if __has_builtin(__builtin_umul_overflow)
+template <>
+inline bool checkForCallocOverflow<unsigned int>(unsigned int Size,
+                                                 unsigned int N,
+                                                 unsigned int *Product) {
+  return __builtin_umul_overflow(Size, N, Product);
 }
+#endif
 
 // Returns true if the size passed to pvalloc overflows when rounded to the next
 // multiple of PageSize.
 inline bool checkForPvallocOverflow(uptr Size, uptr PageSize) {
   return roundUpTo(Size, PageSize) < Size;
 }
 
 } // namespace scudo
 
 #endif // SCUDO_CHECKS_H_