sanitizer_common: fix format strings

[dvyukov]

Summary

Fix existing -Wformat warnings.

Depends on D107979.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_libignore.cpp

108

It would be nice if we have consistency with pointers. As is we mix %p and 0x%zx but the produce different output.
Unfortunately we already have a lot of both.

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

17

clang-tidy: error: 'algorithm' file not found [clang-diagnostic-error] ?

[dvyukov]

fix parent revision

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_libignore.cpp

108

Agree. It would be nice if we could teach compilers that uptr for '%p' is fine. But I did not find any ways to affect this checking.
Overall I tried to preserve %p in user reports, but for internal/debug output I just fixed the format strings (reinterpret_cast<void*> is too verbose).

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

17

I don't know what to do with this. I've seen a number of similar warnings in test files (in all test files?). I think there is some issue in clang-tidy setup for tests. But I don't know how to fix and it's at least unrelated to this change.

[quinnp]

Hi, I think this patch broke some PowerPC bots.
For example:

• clang-ppc64le-linux-lnt
• clang-ppc64le-linux-multistage
• sanitizer-ppc64le-linux

[dvyukov]

In D107980#2944608, @quinnp wrote:

Hi, I think this patch broke some PowerPC bots.
For example:

• clang-ppc64le-linux-lnt
• clang-ppc64le-linux-multistage
• sanitizer-ppc64le-linux

I've sent https://reviews.llvm.org/D108066 to fix this.
Turns out we don't have %l, that was somewhat surprising (no way to properly print longs).
Thanks for the report

[bjope]

I'm seeing build failures like this in downstream builders:

bin/clang++ --target=i386-unknown-linux-gnu  -D_DEBUG -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/repo/llvm/compiler-rt/lib/gwp_asan/.. -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -Werror -std=c++14 -Wno-unused-parameter -O3 -DNDEBUG    -fPIC -fno-builtin -fno-exceptions -fomit-frame-pointer -funwind-tables -fno-stack-protector -fno-sanitize=safe-stack -fvisibility=hidden -fno-lto -Wthread-safety -Wthread-safety-reference -Wthread-safety-beta -O3 -gline-tables-only -Wno-gnu -Wno-variadic-macros -Wno-c99-extensions -Wno-format-pedantic -nostdinc++ -fno-rtti -fno-exceptions -nostdinc++ -pthread -fno-omit-frame-pointer -fPIC -fPIC -fno-builtin -fno-exceptions -fomit-frame-pointer -funwind-tables -fno-stack-protector -fno-sanitize=safe-stack -fvisibility=hidden -fno-lto -Wthread-safety -Wthread-safety-reference -Wthread-safety-beta -O3 -gline-tables-only -Wno-gnu -Wno-variadic-macros -Wno-c99-extensions -Wno-format-pedantic -nostdinc++ -UNDEBUG -MD -MT compiler-rt/lib/gwp_asan/CMakeFiles/RTGwpAsanBacktraceSanitizerCommon.i386.dir/optional/backtrace_sanitizer_common.cpp.o -MF compiler-rt/lib/gwp_asan/CMakeFiles/RTGwpAsanBacktraceSanitizerCommon.i386.dir/optional/backtrace_sanitizer_common.cpp.o.d -o compiler-rt/lib/gwp_asan/CMakeFiles/RTGwpAsanBacktraceSanitizerCommon.i386.dir/optional/backtrace_sanitizer_common.cpp.o -c /repo/llvm/compiler-rt/lib/gwp_asan/optional/backtrace_sanitizer_common.cpp
In file included from /repo/llvm/compiler-rt/lib/gwp_asan/optional/backtrace_sanitizer_common.cpp:17:
/repo/llvm/compiler-rt/lib/gwp_asan/../sanitizer_common/sanitizer_flag_parser.h:141:76: error: format specifies type 'size_t' (aka 'unsigned int') but the argument has type 'unsigned long' [-Werror,-Wformat]
  uptr num_symbols_should_write = internal_snprintf(buffer, size, "0x%zx", *t_);
                                                                     ~~~   ^~~
                                                                     %lx
1 error generated.

[dvyukov]

Hi Bjorn,
I've mailed D108105 which should fix all 32-bit warnings.
Thanks for reporting.

[bjope]

In D107980#2946153, @dvyukov wrote:

Hi Bjorn,
I've mailed D108105 which should fix all 32-bit warnings.
Thanks for reporting.

I've noticed that the problem resolved itself later. I think that maybe this patch fixed it: https://reviews.llvm.org/rG45138f788c9b3c4ac5d9ae4479841c411c15190e

[dvyukov]

In D107980#2946168, @bjope wrote:

In D107980#2946153, @dvyukov wrote:

Hi Bjorn,
I've mailed D108105 which should fix all 32-bit warnings.
Thanks for reporting.

I've noticed that the problem resolved itself later. I think that maybe this patch fixed it: https://reviews.llvm.org/rG45138f788c9b3c4ac5d9ae4479841c411c15190e

Ah, right, it should fix it as well. Did not notice it.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

#endif
   void PrintStats(uptr class_id, uptr rss) {
     RegionInfo *region = GetRegionInfo(class_id);
     if (region->mapped_user == 0) return;
     uptr in_use = region->stats.n_allocated - region->stats.n_freed;
     uptr avail_chunks = region->allocated_user / ClassIdToSize(class_id);
     Printf(
         "%s %02zd (%6zd): mapped: %6zdK allocs: %7zd frees: %7zd inuse: %6zd "
         "num_freed_chunks %7zd avail: %6zd rss: %6zdK releases: %6zd "
-        "last released: %6zdK region: 0x%zx\n",
+        "last released: %6lldK region: 0x%zx\n",
         region->exhausted ? "F" : " ", class_id, ClassIdToSize(class_id),
         region->mapped_user >> 10, region->stats.n_allocated,
         region->stats.n_freed, in_use, region->num_freed_chunks, avail_chunks,
         rss >> 10, region->rtoi.num_releases,
         region->rtoi.last_released_bytes >> 10,
         SpaceBeg() + kRegionSize * class_id);
   }
 

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

INTERCEPTOR(int, ioctl, int d, unsigned long request, ...) {
 
   // Although request is unsigned long, the rest of the interceptor uses it
   // as just "unsigned" to save space, because we know that all values fit in
   // "unsigned" - they are compile-time constants.
 
   const ioctl_desc *desc = ioctl_lookup(request);
   ioctl_desc decoded_desc;
   if (!desc) {
-    VPrintf(2, "Decoding unknown ioctl 0x%x\n", request);
+    VPrintf(2, "Decoding unknown ioctl 0x%lx\n", request);
     if (!ioctl_decode(request, &decoded_desc))
-      Printf("WARNING: failed decoding unknown ioctl 0x%x\n", request);
+      Printf("WARNING: failed decoding unknown ioctl 0x%lx\n", request);
     else
       desc = &decoded_desc;
   }
 
   if (desc) ioctl_common_pre(ctx, desc, d, request, arg);
   int res = REAL(ioctl)(d, request, arg);
   // FIXME: some ioctls have different return values for success and failure.
   if (desc && res != -1) ioctl_common_post(ctx, desc, res, d, request, arg);

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc

while (*p) {
     if (dir.argIdx != -1) {
       // Unsupported.
       break;
     }
     if (dir.suppressed)
       continue;
     int size = scanf_get_value_size(&dir);
     if (size == FSS_INVALID) {
-      Report("%s: WARNING: unexpected format specifier in scanf interceptor: ",
-             SanitizerToolName, "%.*s\n", dir.end - dir.begin, dir.begin);
+      Report("%s: WARNING: unexpected format specifier in scanf interceptor: %.*s\n",
+             SanitizerToolName, static_cast<int>(dir.end - dir.begin), dir.begin);
       break;
     }
     void *argp = va_arg(aq, void *);
     if (dir.convSpecifier != 'n')
       --n_inputs;
     if (n_inputs < 0)
       break;
     if (size == FSS_STRLEN) {
if (format_is_float_conv(convSpecifier)) {                     \
       case 12:                                                     \
         va_arg(*aq, long double);                                  \
         break;                                                     \
       case 16:                                                     \
         va_arg(*aq, long double);                                  \
         break;                                                     \
       default:                                                     \
         Report("WARNING: unexpected floating-point arg size"       \
-               " in printf interceptor: %d\n", size);              \
+               " in printf interceptor: %zu\n", static_cast<uptr>(size));             \
         return;                                                    \
       }                                                            \
     } else {                                                       \
       switch (size) {                                              \
       case 1:                                                      \
       case 2:                                                      \
       case 4:                                                      \
         va_arg(*aq, u32);                                          \
         break;                                                     \
       case 8:                                                      \
         va_arg(*aq, u64);                                          \
         break;                                                     \
       default:                                                     \
         Report("WARNING: unexpected arg size"                      \
-               " in printf interceptor: %d\n", size);              \
+               " in printf interceptor: %zu\n", static_cast<uptr>(size));             \
         return;                                                    \
       }                                                            \
     }                                                              \
   } while (0)
 
 // Common part of *printf interceptors.
 // Process format string and va_list, and report all load ranges.
 static void printf_common(void *ctx, const char *format, va_list aq) {
if (dir.convSpecifier == 'm')
       continue;
     int size = printf_get_value_size(&dir);
     if (size == FSS_INVALID) {
       static int ReportedOnce;
       if (!ReportedOnce++)
         Report(
             "%s: WARNING: unexpected format specifier in printf "
             "interceptor: %.*s (reported once per process)\n",
-            SanitizerToolName, dir.end - dir.begin, dir.begin);
+            SanitizerToolName, static_cast<int>(dir.end - dir.begin), dir.begin);
       break;
     }
     if (dir.convSpecifier == 'n') {
       void *argp = va_arg(aq, void *);
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, argp, size);
       continue;
     } else if (size == FSS_STRLEN) {
       if (void *argp = va_arg(aq, void *)) {

compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp

static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
   uptr last_base = 0;
   uptr module_start_idx = 0;
 
   for (uptr i = 0; i < len; ++i) {
     const uptr pc = pcs[i];
     if (!pc) continue;
 
     if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
-      Printf("ERROR: unknown pc 0x%x (may happen if dlclose is used)\n", pc);
+      Printf("ERROR: unknown pc 0x%zx (may happen if dlclose is used)\n", pc);
       continue;
     }
     uptr module_base = pc - pcs[i];
 
     if (module_base != last_base || !module_found) {
       if (module_found) {
         WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
                             i - module_start_idx);

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h

inline bool FlagHandler<uptr>::Parse(const char *value) {
   *t_ = internal_simple_strtoll(value, &value_end, 10);
   bool ok = *value_end == 0;
   if (!ok) Printf("ERROR: Invalid value for uptr option: '%s'\n", value);
   return ok;
 }
 
 template <>
 inline bool FlagHandler<uptr>::Format(char *buffer, uptr size) {
-  uptr num_symbols_should_write = internal_snprintf(buffer, size, "%p", *t_);
+  uptr num_symbols_should_write = internal_snprintf(buffer, size, "0x%zx", *t_);
   return num_symbols_should_write < size;
 }
 
 template <>
 inline bool FlagHandler<s64>::Parse(const char *value) {
   const char *value_end;
   *t_ = internal_simple_strtoll(value, &value_end, 10);
   bool ok = *value_end == 0;

compiler-rt/lib/sanitizer_common/sanitizer_libignore.cpp

 namespace __sanitizer {
 
 LibIgnore::LibIgnore(LinkerInitialized) {
 }
 
 void LibIgnore::AddIgnoredLibrary(const char *name_templ) {
   Lock lock(&mutex_);
   if (count_ >= kMaxLibs) {
-    Report("%s: too many ignored libraries (max: %d)\n", SanitizerToolName,
+    Report("%s: too many ignored libraries (max: %lu)\n", SanitizerToolName,
            kMaxLibs);
     Die();
   }
   Lib *lib = &libs_[count_++];
   lib->templ = internal_strdup(name_templ);
   lib->name = nullptr;
   lib->real_name = nullptr;
   lib->loaded = false;
if (track_instrumented_libs_) {
     for (const auto &mod : modules) {
       if (!mod.instrumented())
         continue;
       for (const auto &range : mod.ranges()) {
         if (!range.executable)
           continue;
         if (IsPcInstrumented(range.beg) && IsPcInstrumented(range.end - 1))
           continue;
-        VReport(1, "Adding instrumented range %p-%p from library '%s'\n",
+        VReport(1, "Adding instrumented range 0x%zx-0x%zx from library '%s'\n",
                 range.beg, range.end, mod.full_name());
         const uptr idx =
             atomic_load(&instrumented_ranges_count_, memory_order_relaxed);
         CHECK_LT(idx, ARRAY_SIZE(instrumented_code_ranges_));
         instrumented_code_ranges_[idx].begin = range.beg;
         instrumented_code_ranges_[idx].end = range.end;
         atomic_store(&instrumented_ranges_count_, idx + 1,
                      memory_order_release);

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

private:
   void ExtendDedupToken(SymbolizedStack *stack) {
     if (!dedup_token_)
       return;
 
     if (dedup_frames_-- > 0) {
       if (dedup_token_->length())
         dedup_token_->append("--");
       if (stack->info.function != nullptr)
-        dedup_token_->append(stack->info.function);
+        dedup_token_->append("%s", stack->info.function);
     }
   }
 
   const char *stack_trace_fmt_;
   const char frame_delimiter_;
   int dedup_frames_ = common_flags()->dedup_token_length;
   uptr frame_num_ = 0;
   InternalScopedString *output_;

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

for (const char *p = format; *p != '\0'; p++) {
     }
     p++;
     switch (*p) {
     case '%':
       buffer->append("%%");
       break;
     // Frame number and all fields of AddressInfo structure.
     case 'n':
-      buffer->append("%zu", frame_no);
+      buffer->append("%u", frame_no);
       break;
     case 'p':
       buffer->append("0x%zx", address);
       break;
     case 'm':
       buffer->append("%s", StripPathPrefix(info->module, strip_path_prefix));
       break;
     case 'o':
case 'M':
         // Always strip the module name for %M.
         RenderModuleLocation(buffer, StripModuleName(info->module),
                              info->module_offset, info->module_arch, "");
       } else {
         buffer->append("(%p)", (void *)address);
       }
       break;
     default:
-      Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
-             *p);
+      Report("Unsupported specifier in stack frame format: %c (%p)!\n", *p, p);
       Die();
     }
   }
 }
 
 bool RenderNeedsSymbolization(const char *format) {
   if (0 == internal_strcmp(format, "DEFAULT"))
     format = kDefaultFormat;
for (const char *p = format; *p != '\0'; p++) {
     switch (*p) {
       case '%':
         buffer->append("%%");
         break;
       case 's':
         buffer->append("%s", StripPathPrefix(DI->file, strip_path_prefix));
         break;
       case 'l':
-        buffer->append("%d", DI->line);
+        buffer->append("%zu", DI->line);
         break;
       case 'g':
         buffer->append("%s", DI->name);
         break;
       default:
-        Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
-               *p);
+        Report("Unsupported specifier in stack frame format: %c (%p)!\n", *p,
+               p);
         Die();
     }
   }
 }
 
 #endif  // !SANITIZER_SYMBOLIZER_MARKUP
 
 void RenderSourceLocation(InternalScopedString *buffer, const char *file,

compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cpp

 
 // Make sure we properly destroy the DTLS objects:
 // this counter should never get too large.
 static atomic_uintptr_t number_of_live_dtls;
 
 static const uptr kDestroyedThread = -1;
 
 static void DTLS_Deallocate(DTLS::DTVBlock *block) {
-  VReport(2, "__tls_get_addr: DTLS_Deallocate %p %zd\n", block);
+  VReport(2, "__tls_get_addr: DTLS_Deallocate %p\n", block);
   UnmapOrDie(block, sizeof(DTLS::DTVBlock));
   atomic_fetch_sub(&number_of_live_dtls, 1, memory_order_relaxed);
 }
 
 static DTLS::DTVBlock *DTLS_NextBlock(atomic_uintptr_t *cur) {
   uptr v = atomic_load(cur, memory_order_acquire);
   if (v == kDestroyedThread)
     return nullptr;
DTLS::DTV *DTLS_on_tls_get_addr(void *arg_void, void *res,
   if (!common_flags()->intercept_tls_get_addr) return 0;
   TlsGetAddrParam *arg = reinterpret_cast<TlsGetAddrParam *>(arg_void);
   uptr dso_id = arg->dso_id;
   DTLS::DTV *dtv = DTLS_Find(dso_id);
   if (!dtv || dtv->beg)
     return 0;
   uptr tls_size = 0;
   uptr tls_beg = reinterpret_cast<uptr>(res) - arg->offset - kDtvOffset;
-  VReport(2, "__tls_get_addr: %p {%p,%p} => %p; tls_beg: %p; sp: %p "
-             "num_live_dtls %zd\n",
+  VReport(2,
+          "__tls_get_addr: %p {0x%zx,0x%zx} => %p; tls_beg: 0x%zx; sp: %p "
           arg, arg->dso_id, arg->offset, res, tls_beg, &tls_beg,
           atomic_load(&number_of_live_dtls, memory_order_relaxed));
   if (dtls.last_memalign_ptr == tls_beg) {
     tls_size = dtls.last_memalign_size;
-    VReport(2, "__tls_get_addr: glibc <=2.18 suspected; tls={%p,%p}\n",
+    VReport(2, "__tls_get_addr: glibc <=2.18 suspected; tls={0x%zx,0x%zx}\n",
             tls_beg, tls_size);
   } else if (tls_beg >= static_tls_begin && tls_beg < static_tls_end) {
     // This is the static TLS block which was initialized / unpoisoned at thread
     // creation.
-    VReport(2, "__tls_get_addr: static tls: %p\n", tls_beg);
+    VReport(2, "__tls_get_addr: static tls: 0x%zx\n", tls_beg);
     tls_size = 0;
   } else if ((tls_beg % 4096) == sizeof(Glibc_2_19_tls_header)) {
     // We may want to check gnu_get_libc_version().
     Glibc_2_19_tls_header *header = (Glibc_2_19_tls_header *)tls_beg - 1;
     tls_size = header->size;
     tls_beg = header->start;
-    VReport(2, "__tls_get_addr: glibc >=2.19 suspected; tls={%p %p}\n",
+    VReport(2, "__tls_get_addr: glibc >=2.19 suspected; tls={0x%zx 0x%zx}\n",
             tls_beg, tls_size);
   } else {
     VReport(2, "__tls_get_addr: Can't guess glibc version\n");
     // This may happen inside the DTOR of main thread, so just ignore it.
     tls_size = 0;
   }
   dtv->beg = tls_beg;
   dtv->size = tls_size;
   return dtv;
 }
 
 void DTLS_on_libc_memalign(void *ptr, uptr size) {
   if (!common_flags()->intercept_tls_get_addr) return;
-  VReport(2, "DTLS_on_libc_memalign: %p %p\n", ptr, size);
+  VReport(2, "DTLS_on_libc_memalign: %p 0x%zx\n", ptr, size);
   dtls.last_memalign_ptr = reinterpret_cast<uptr>(ptr);
   dtls.last_memalign_size = size;
 }
 
 DTLS *DTLS_Get() { return &dtls; }
 
 bool DTLSInDestruction(DTLS *dtls) {
   return atomic_load(&dtls->dtv_block, memory_order_relaxed) ==

compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp

 }
 
 TEST(SanitizerCommon, InternalScopedStringLarge) {
   InternalScopedString str;
   std::string expected;
   for (int i = 0; i < 1000; ++i) {
     std::string append(i, 'a' + i % 26);
     expected += append;
-    str.append(append.c_str());
+    str.append("%s", append.c_str());
     EXPECT_EQ(expected, str.data());
   }
 }
 
 TEST(SanitizerCommon, InternalScopedStringLargeFormat) {
   InternalScopedString str;
   std::string expected;
   for (int i = 0; i < 1000; ++i) {

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

 //===-- sanitizer_stacktrace_test.cpp -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_stacktrace.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <string>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 
 using testing::ContainsRegex;
struct Local {
     static NOINLINE void Test() {
       const uptr pcs[] = {
           (uptr)&Local::Test,
           GET_CURRENT_PC(),
           StackTrace::GetCurrentPc(),
           StackTrace::GetCurrentPc(),
       };
       for (uptr i = 0; i < ARRAY_SIZE(pcs); i++)
-        Printf("pc%zu: %p\n", i, pcs[i]);
+        Printf("pc%zu: 0x%zx\n", i, pcs[i]);
       for (uptr i = 1; i < ARRAY_SIZE(pcs); i++) {
         EXPECT_GT(pcs[i], pcs[0]);
         EXPECT_LT(pcs[i], pcs[0] + 1000);
         for (uptr j = 0; j < i; j++) EXPECT_NE(pcs[i], pcs[j]);
       }
     }
   };
   Local::Test();