[scudo] Correct format string specifiers

[cryptoad]

Summary

Following D108014, address the -Wformat issues.

[cryptoad]

So this turned out to be a little more complicated for 32-b.
The 'z' format specifier expects a size_t which is defined
as a unsigned int on 32-b Linux platforms, while our
scudo::uptr are defined a unsigned long. So zu wasn't
an appropriate specifier on 32-b platforms for a uptr.

This introduces a 'l' format specifier that we didn't previously
have, and replaces 'z' with 'l' for all uptr format strings.

[vitalybuka]

it's probably copied from sanitizer_common
I thing it should match uintptr_t like here 45138f788c9b3c4ac5d9ae4479841c411c15190e

[vitalybuka]

Actually scudo already #include <stdint.h>, so maybe define uptr as uintptr_t ?

[cryptoad]

Redoing this the way Vitaly suggested.

compiler-rt/lib/scudo/standalone/CMakeLists.txt

 add_compiler_rt_component(scudo_standalone)
 
 include_directories(../.. include)
 
 set(SCUDO_CFLAGS)
 
 list(APPEND SCUDO_CFLAGS
   -Werror=conversion
   -Wall
   -g
   -nostdinc++)
 
-# Too many existing bugs, needs cleanup.
-append_list_if(COMPILER_RT_HAS_WNO_FORMAT -Wno-format SCUDO_CFLAGS)
-
 # Remove -stdlib= which is unused when passing -nostdinc++.
 string(REGEX REPLACE "-stdlib=[a-zA-Z+]*" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 
 append_list_if(COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden SCUDO_CFLAGS)
 
 append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SCUDO_CFLAGS)
 
 append_list_if(COMPILER_RT_HAS_WNO_PEDANTIC -Wno-pedantic SCUDO_CFLAGS)

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

 }
 
 // Fatal internal map() or unmap() error (potentially OOM related).
 void NORETURN dieOnMapUnmapError(uptr SizeIfOOM) {
   char Error[128] = "Scudo ERROR: internal map or unmap failure\n";
   if (SizeIfOOM) {
     formatString(
         Error, sizeof(Error),
-        "Scudo ERROR: internal map failure (NO MEMORY) requesting %zuKB\n",
+        "Scudo ERROR: internal map failure (NO MEMORY) requesting %luKB\n",
         SizeIfOOM >> 10);
   }
   outputRaw(Error);
   setAbortMessage(Error);
   die();
 }
 
 } // namespace scudo

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

void getStats(ScopedString *Str) {
     uptr PoppedBlocks = 0;
     uptr PushedBlocks = 0;
     for (uptr I = 0; I < NumClasses; I++) {
       SizeClassInfo *Sci = getSizeClassInfo(I);
       TotalMapped += Sci->AllocatedUser;
       PoppedBlocks += Sci->Stats.PoppedBlocks;
       PushedBlocks += Sci->Stats.PushedBlocks;
     }
-    Str->append("Stats: SizeClassAllocator32: %zuM mapped in %zu allocations; "
-                "remains %zu\n",
+    Str->append("Stats: SizeClassAllocator32: %luM mapped in %lu allocations; "
+                "remains %lu\n",
                 TotalMapped >> 20, PoppedBlocks, PoppedBlocks - PushedBlocks);
     for (uptr I = 0; I < NumClasses; I++)
       getStats(Str, I, 0);
   }
 
   bool setOption(Option O, sptr Value) {
     if (O == Option::ReleaseInterval) {
       const s32 Interval = Max(
private:
   }
 
   void getStats(ScopedString *Str, uptr ClassId, uptr Rss) {
     SizeClassInfo *Sci = getSizeClassInfo(ClassId);
     if (Sci->AllocatedUser == 0)
       return;
     const uptr InUse = Sci->Stats.PoppedBlocks - Sci->Stats.PushedBlocks;
     const uptr AvailableChunks = Sci->AllocatedUser / getSizeByClassId(ClassId);
-    Str->append("  %02zu (%6zu): mapped: %6zuK popped: %7zu pushed: %7zu "
-                "inuse: %6zu avail: %6zu rss: %6zuK releases: %6zu\n",
+    Str->append("  %02lu (%6lu): mapped: %6luK popped: %7lu pushed: %7lu "
+                "inuse: %6lu avail: %6lu rss: %6luK releases: %6lu\n",
                 ClassId, getSizeByClassId(ClassId), Sci->AllocatedUser >> 10,
                 Sci->Stats.PoppedBlocks, Sci->Stats.PushedBlocks, InUse,
                 AvailableChunks, Rss >> 10, Sci->ReleaseInfo.RangesReleased);
   }
 
   NOINLINE uptr releaseToOSMaybe(SizeClassInfo *Sci, uptr ClassId,
                                  bool Force = false) {
     const uptr BlockSize = getSizeByClassId(ClassId);

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

void getStats(ScopedString *Str) {
     uptr PushedBlocks = 0;
     for (uptr I = 0; I < NumClasses; I++) {
       RegionInfo *Region = getRegionInfo(I);
       if (Region->MappedUser)
         TotalMapped += Region->MappedUser;
       PoppedBlocks += Region->Stats.PoppedBlocks;
       PushedBlocks += Region->Stats.PushedBlocks;
     }
-    Str->append("Stats: SizeClassAllocator64: %zuM mapped (%zuM rss) in %zu "
-                "allocations; remains %zu\n",
-                TotalMapped >> 20, 0, PoppedBlocks,
+    Str->append("Stats: SizeClassAllocator64: %luM mapped (%uM rss) in %lu "
+                "allocations; remains %lu\n",
+                TotalMapped >> 20, 0U, PoppedBlocks,
                 PoppedBlocks - PushedBlocks);
 
     for (uptr I = 0; I < NumClasses; I++)
       getStats(Str, I, 0);
   }
 
   bool setOption(Option O, sptr Value) {
     if (O == Option::ReleaseInterval) {
if (TotalUserBytes > MappedUser) {
           roundUpTo(TotalUserBytes - MappedUser, MapSizeIncrement);
       const uptr RegionBase = RegionBeg - getRegionBaseByClassId(ClassId);
       if (UNLIKELY(RegionBase + MappedUser + MapSize > RegionSize)) {
         if (!Region->Exhausted) {
           Region->Exhausted = true;
           ScopedString Str;
           getStats(&Str);
           Str.append(
-              "Scudo OOM: The process has exhausted %zuM for size class %zu.\n",
+              "Scudo OOM: The process has exhausted %luM for size class %lu.\n",
               RegionSize >> 20, Size);
           Str.output();
         }
         return nullptr;
       }
       if (MappedUser == 0)
         Region->Data = Data;
       if (UNLIKELY(!map(
private:
   }
 
   void getStats(ScopedString *Str, uptr ClassId, uptr Rss) {
     RegionInfo *Region = getRegionInfo(ClassId);
     if (Region->MappedUser == 0)
       return;
     const uptr InUse = Region->Stats.PoppedBlocks - Region->Stats.PushedBlocks;
     const uptr TotalChunks = Region->AllocatedUser / getSizeByClassId(ClassId);
-    Str->append("%s %02zu (%6zu): mapped: %6zuK popped: %7zu pushed: %7zu "
-                "inuse: %6zu total: %6zu rss: %6zuK releases: %6zu last "
-                "released: %6zuK region: 0x%zx (0x%zx)\n",
+    Str->append("%s %02lu (%6lu): mapped: %6luK popped: %7lu pushed: %7lu "
+                "inuse: %6lu total: %6lu rss: %6luK releases: %6lu last "
+                "released: %6luK region: 0x%lx (0x%lx)\n",
                 Region->Exhausted ? "F" : " ", ClassId,
                 getSizeByClassId(ClassId), Region->MappedUser >> 10,
                 Region->Stats.PoppedBlocks, Region->Stats.PushedBlocks, InUse,
                 TotalChunks, Rss >> 10, Region->ReleaseInfo.RangesReleased,
                 Region->ReleaseInfo.LastReleasedBytes >> 10, Region->RegionBeg,
                 getRegionBaseByClassId(ClassId));
   }
 

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

const uptr ChunksUsagePercent =
             ? 0
             : TotalQuarantineChunks * 100 / QuarantineChunksCapacity;
     const uptr TotalQuarantinedBytes = TotalBytes - TotalOverheadBytes;
     const uptr MemoryOverheadPercent =
         (TotalQuarantinedBytes == 0)
             ? 0
             : TotalOverheadBytes * 100 / TotalQuarantinedBytes;
     Str->append(
-        "Stats: Quarantine: batches: %zu; bytes: %zu (user: %zu); chunks: %zu "
-        "(capacity: %zu); %zu%% chunks used; %zu%% memory overhead\n",
+        "Stats: Quarantine: batches: %lu; bytes: %lu (user: %lu); chunks: %lu "
+        "(capacity: %lu); %lu%% chunks used; %lu%% memory overhead\n",
         BatchCount, TotalBytes, TotalQuarantinedBytes, TotalQuarantineChunks,
         QuarantineChunksCapacity, ChunksUsagePercent, MemoryOverheadPercent);
   }
 
 private:
   SinglyLinkedList<QuarantineBatch> List;
   atomic_uptr Size = {};
 
void NOINLINE drainAndRecycle(CacheT *C, Callback Cb) {
     }
     RecycleMutex.lock();
     recycle(0, Cb);
   }
 
   void getStats(ScopedString *Str) const {
     // It assumes that the world is stopped, just as the allocator's printStats.
     Cache.getStats(Str);
-    Str->append("Quarantine limits: global: %zuK; thread local: %zuK\n",
+    Str->append("Quarantine limits: global: %luK; thread local: %luK\n",
                 getMaxSize() >> 10, getCacheSize() >> 10);
   }
 
   void disable() {
     // RecycleMutex must be locked 1st since we grab CacheMutex within recycle.
     RecycleMutex.lock();
     CacheMutex.lock();
   }

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

void NORETURN reportSanityCheckError(const char *Field) {
   ScopedErrorReport Report;
   Report.append("maximum possible %s doesn't fit in header\n", Field);
 }
 
 // We enforce a maximum alignment, to keep fields smaller and generally prevent
 // integer overflows, or unexpected corner cases.
 void NORETURN reportAlignmentTooBig(uptr Alignment, uptr MaxAlignment) {
   ScopedErrorReport Report;
-  Report.append("invalid allocation alignment: %zu exceeds maximum supported "
-                "alignment of %zu\n",
+  Report.append("invalid allocation alignment: %lu exceeds maximum supported "
+                "alignment of %lu\n",
                 Alignment, MaxAlignment);
 }
 
 // See above, we also enforce a maximum size.
 void NORETURN reportAllocationSizeTooBig(uptr UserSize, uptr TotalSize,
                                          uptr MaxSize) {
   ScopedErrorReport Report;
-  Report.append("requested allocation size %zu (%zu after adjustments) exceeds "
-                "maximum supported size of %zu\n",
+  Report.append("requested allocation size %lu (%lu after adjustments) exceeds "
+                "maximum supported size of %lu\n",
                 UserSize, TotalSize, MaxSize);
 }
 
 void NORETURN reportOutOfMemory(uptr RequestedSize) {
   ScopedErrorReport Report;
-  Report.append("out of memory trying to allocate %zu bytes\n", RequestedSize);
+  Report.append("out of memory trying to allocate %lu bytes\n", RequestedSize);
 }
 
 static const char *stringifyAction(AllocatorAction Action) {
   switch (Action) {
   case AllocatorAction::Recycling:
     return "recycling";
   case AllocatorAction::Deallocating:
     return "deallocating";

 }
 
 // The size specified to the delete operator does not match the one that was
 // passed to new when allocating the chunk.
 void NORETURN reportDeleteSizeMismatch(void *Ptr, uptr Size,
                                        uptr ExpectedSize) {
   ScopedErrorReport Report;
   Report.append(
-      "invalid sized delete when deallocating address %p (%zu vs %zu)\n", Ptr,
+      "invalid sized delete when deallocating address %p (%lu vs %lu)\n", Ptr,
       Size, ExpectedSize);
 }
 
 void NORETURN reportAlignmentNotPowerOfTwo(uptr Alignment) {
   ScopedErrorReport Report;
   Report.append(
-      "invalid allocation alignment: %zu, alignment must be a power of two\n",
+      "invalid allocation alignment: %lu, alignment must be a power of two\n",
       Alignment);
 }
 
 void NORETURN reportCallocOverflow(uptr Count, uptr Size) {
   ScopedErrorReport Report;
-  Report.append("calloc parameters overflow: count * size (%zu * %zu) cannot "
+  Report.append("calloc parameters overflow: count * size (%lu * %lu) cannot "
                 "be represented with type size_t\n",
                 Count, Size);
 }
 
 void NORETURN reportInvalidPosixMemalignAlignment(uptr Alignment) {
   ScopedErrorReport Report;
   Report.append(
-      "invalid alignment requested in posix_memalign: %zu, alignment must be a "
+      "invalid alignment requested in posix_memalign: %lu, alignment must be a "
       "power of two and a multiple of sizeof(void *) == %zu\n",
       Alignment, sizeof(void *));
 }
 
 void NORETURN reportPvallocOverflow(uptr Size) {
   ScopedErrorReport Report;
-  Report.append("pvalloc parameters overflow: size %zu rounded up to system "
-                "page size %zu cannot be represented in type size_t\n",
+  Report.append("pvalloc parameters overflow: size %lu rounded up to system "
+                "page size %lu cannot be represented in type size_t\n",
                 Size, getPageSizeCached());
 }
 
 void NORETURN reportInvalidAlignedAllocAlignment(uptr Alignment, uptr Size) {
   ScopedErrorReport Report;
-  Report.append("invalid alignment requested in aligned_alloc: %zu, alignment "
-                "must be a power of two and the requested size %zu must be a "
+  Report.append("invalid alignment requested in aligned_alloc: %lu, alignment "
+                "must be a power of two and the requested size %lu must be a "
                 "multiple of alignment\n",
                 Alignment, Size);
 }
 
 } // namespace scudo

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

const uptr CommitSize = H->CommitSize;
     Stats.sub(StatAllocated, CommitSize);
     Stats.sub(StatMapped, H->MapSize);
   }
   Cache.store(Options, H);
 }
 
 template <typename Config>
 void MapAllocator<Config>::getStats(ScopedString *Str) const {
-  Str->append(
-      "Stats: MapAllocator: allocated %zu times (%zuK), freed %zu times "
-      "(%zuK), remains %zu (%zuK) max %zuM\n",
-      NumberOfAllocs, AllocatedBytes >> 10, NumberOfFrees, FreedBytes >> 10,
-      NumberOfAllocs - NumberOfFrees, (AllocatedBytes - FreedBytes) >> 10,
-      LargestSize >> 20);
+  Str->append("Stats: MapAllocator: allocated %u times (%luK), freed %u times "
+              "(%luK), remains %u (%luK) max %luM\n",
+              NumberOfAllocs, AllocatedBytes >> 10, NumberOfFrees,
+              FreedBytes >> 10, NumberOfAllocs - NumberOfFrees,
+              (AllocatedBytes - FreedBytes) >> 10, LargestSize >> 20);
 }
 
 } // namespace scudo
 
 #endif // SCUDO_SECONDARY_H_

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

for (uptr I = 0; I < SCMap::NumClasses; I++) {
     if (I == SCMap::BatchClassId)
       continue;
     const uptr S = SCMap::getSizeByClassId(I);
     const uptr D = S - PrevS;
     const uptr P = PrevS ? (D * 100 / PrevS) : 0;
     const uptr L = S ? getMostSignificantSetBitIndex(S) : 0;
     const uptr Cached = SCMap::getMaxCachedHint(S) * S;
     Buffer.append(
-        "C%02zu => S: %zu diff: +%zu %02zu%% L %zu Cached: %zu %zu; id %zu\n",
-        I, S, D, P, L, SCMap::getMaxCachedHint(S), Cached,
+        "C%02lu => S: %lu diff: +%lu %02lu%% L %lu Cached: %u %lu; id %lu\n", I,
+        S, D, P, L, SCMap::getMaxCachedHint(S), Cached,
         SCMap::getClassIdBySize(S));
     TotalCached += Cached;
     PrevS = S;
   }
-  Buffer.append("Total Cached: %zu\n", TotalCached);
+  Buffer.append("Total Cached: %lu\n", TotalCached);
   Buffer.output();
 }
 
 template <typename SCMap> static void validateMap() {
   for (uptr C = 0; C < SCMap::NumClasses; C++) {
     if (C == SCMap::BatchClassId)
       continue;
     const uptr S = SCMap::getSizeByClassId(C);

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

Res += appendUnsigned(Buffer, BufferEnd, ptr_value, 16,
                         SCUDO_POINTER_FORMAT_LENGTH, /*PadWithZero=*/true,
                         /*Upper=*/false);
   return Res;
 }
 
 static int formatString(char *Buffer, uptr BufferLength, const char *Format,
                         va_list Args) {
   static const char *PrintfFormatsHelp =
-      "Supported formatString formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
+      "Supported formatString formats: %([0-9]*)?(z|l|ll)?{d,u,x,X}; %p; "
       "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
   RAW_CHECK(Format);
   RAW_CHECK(BufferLength > 0);
   const char *BufferEnd = &Buffer[BufferLength - 1];
   const char *Cur = Format;
   int Res = 0;
   for (; *Cur; Cur++) {
     if (*Cur != '%') {
for (; *Cur; Cur++) {
     const bool HavePrecision = (Cur[0] == '.' && Cur[1] == '*');
     int Precision = -1;
     if (HavePrecision) {
       Cur += 2;
       Precision = va_arg(Args, int);
     }
     const bool HaveZ = (*Cur == 'z');
     Cur += HaveZ;
-    const bool HaveLL = !HaveZ && (Cur[0] == 'l' && Cur[1] == 'l');
+    const bool HaveL = !HaveZ && (Cur[0] == 'l' && Cur[1] != 'l');
+    Cur += HaveL;
+    const bool HaveLL = !HaveZ && !HaveL && (Cur[0] == 'l' && Cur[1] == 'l');
     Cur += HaveLL * 2;
     s64 DVal;
     u64 UVal;
-    const bool HaveLength = HaveZ || HaveLL;
+    const bool HaveLength = HaveZ || HaveL || HaveLL;
     const bool HaveFlags = HaveWidth || HaveLength;
     // At the moment only %s supports precision and left-justification.
     CHECK(!((Precision >= 0 || LeftJustified) && *Cur != 's'));
     switch (*Cur) {
     case 'd': {
-      DVal = HaveLL  ? va_arg(Args, s64)
-             : HaveZ ? va_arg(Args, sptr)
+      DVal = HaveLL             ? va_arg(Args, s64)
+             : (HaveZ || HaveL) ? va_arg(Args, sptr)
                                 : va_arg(Args, int);
       Res += appendSignedDecimal(&Buffer, BufferEnd, DVal, Width, PadWithZero);
       break;
     }
     case 'u':
     case 'x':
     case 'X': {
-      UVal = HaveLL  ? va_arg(Args, u64)
-             : HaveZ ? va_arg(Args, uptr)
+      UVal = HaveLL             ? va_arg(Args, u64)
+             : (HaveZ || HaveL) ? va_arg(Args, uptr)
                                 : va_arg(Args, unsigned);
       const bool Upper = (*Cur == 'X');
       Res += appendUnsigned(&Buffer, BufferEnd, UVal, (*Cur == 'u') ? 10 : 16,
                             Width, PadWithZero, Upper);
       break;
     }
     case 'p': {
       RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp);
       Res += appendPointer(&Buffer, BufferEnd, va_arg(Args, uptr));

compiler-rt/lib/scudo/standalone/tests/CMakeLists.txt

set(SCUDO_UNITTEST_CFLAGS
   -I${COMPILER_RT_SOURCE_DIR}/lib/scudo/standalone
   -I${COMPILER_RT_SOURCE_DIR}/lib/scudo/standalone/include
   -DGTEST_HAS_RTTI=0
   -g
   # Extra flags for the C++ tests
   # TODO(kostyak): find a way to make -fsized-deallocation work
   -Wno-mismatched-new-delete)
 
-# Too many existing bugs, needs cleanup.
-append_list_if(COMPILER_RT_HAS_WNO_FORMAT -Wno-format SCUDO_UNITTEST_CFLAGS)
-
 if(COMPILER_RT_DEBUG)
   list(APPEND SCUDO_UNITTEST_CFLAGS -DSCUDO_DEBUG=1)
 endif()
 
 if(ANDROID)
   list(APPEND SCUDO_UNITTEST_CFLAGS -fno-emulated-tls)
 endif()
 

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

 TEST(ScudoStringsTest, Constructor) {
   scudo::ScopedString Str;
   EXPECT_EQ(0ul, Str.length());
   EXPECT_EQ('\0', *Str.data());
 }
 
 TEST(ScudoStringsTest, Basic) {
   scudo::ScopedString Str;
-  Str.append("a%db%zdc%ue%zuf%xh%zxq%pe%sr", static_cast<int>(-1),
+  Str.append("a%db%ldc%ue%luf%xh%lxq%pe%sr", static_cast<int>(-1),
              static_cast<scudo::uptr>(-2), static_cast<unsigned>(-4),
              static_cast<scudo::uptr>(5), static_cast<unsigned>(10),
              static_cast<scudo::uptr>(11), reinterpret_cast<void *>(0x123),
              "_string_");
   EXPECT_EQ(Str.length(), strlen(Str.data()));
 
   std::string expectedString = "a-1b-2c4294967292e5fahbq0x";
   expectedString += std::string(SCUDO_POINTER_FORMAT_LENGTH - 3, '0');