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

 //===-- sanitizer_allocator_primary64.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Part of the Sanitizer Allocator.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 template<class SizeClassAllocator> struct SizeClassAllocator64LocalCache;
 
 // SizeClassAllocator64 -- allocator for 64-bit address space.
 // The template parameter Params is a class containing the actual parameters.
 //
 // Space: a portion of address space of kSpaceSize bytes starting at SpaceBeg.

 
 template <typename Allocator>
 class MemoryMapper {
  public:
   typedef typename Allocator::CompactPtrT CompactPtrT;
 
   explicit MemoryMapper(const Allocator &allocator) : allocator_(allocator) {}
 
   bool GetAndResetStats(uptr &ranges, uptr &bytes) {
     ranges = released_ranges_count_;
     released_ranges_count_ = 0;
     bytes = released_bytes_;
     released_bytes_ = 0;
     return ranges != 0;
   }
 
   u64 *MapPackedCounterArrayBuffer(uptr count) {
     buffer_.clear();
     buffer_.resize(count);
     return buffer_.data();
   }
 
   // Releases [from, to) range of pages back to OS.
   void ReleasePageRangeToOS(uptr class_id, CompactPtrT from, CompactPtrT to) {
     const uptr region_base = allocator_.GetRegionBeginBySizeClass(class_id);
     const uptr from_page = allocator_.CompactPtrToPointer(region_base, from);
     const uptr to_page = allocator_.CompactPtrToPointer(region_base, to);
     ReleaseMemoryPagesToOS(from_page, to_page);
     released_ranges_count_++;
     released_bytes_ += to_page - from_page;
   }
 
  private:
   const Allocator &allocator_;
   uptr released_ranges_count_ = 0;
   uptr released_bytes_ = 0;
   InternalMmapVector<u64> buffer_;
 };
 
 template <class Params>
 class SizeClassAllocator64 {
  public:
   using AddressSpaceView = typename Params::AddressSpaceView;
   static const uptr kSpaceBeg = Params::kSpaceBeg;
   static const uptr kSpaceSize = Params::kSpaceSize;
   static const uptr kMetadataSize = Params::kMetadataSize;
   typedef typename Params::SizeClassMap SizeClassMap;
   typedef typename Params::MapUnmapCallback MapUnmapCallback;
 
   static const bool kRandomShuffleChunks =
       Params::kFlags & SizeClassAllocator64FlagMasks::kRandomShuffleChunks;
 
   typedef SizeClassAllocator64<Params> ThisT;
   typedef SizeClassAllocator64LocalCache<ThisT> AllocatorCache;
   typedef MemoryMapper<ThisT> MemoryMapperT;
 
   // When we know the size class (the region base) we can represent a pointer
   // as a 4-byte integer (offset from the region start shifted right by 4).
   typedef u32 CompactPtrT;
   static const uptr kCompactPtrScale = 4;
   CompactPtrT PointerToCompactPtr(uptr base, uptr ptr) const {
     return static_cast<CompactPtrT>((ptr - base) >> kCompactPtrScale);
   }
   uptr CompactPtrToPointer(uptr base, CompactPtrT ptr32) const {
     return base + (static_cast<uptr>(ptr32) << kCompactPtrScale);
   }
 
   // If heap_start is nonzero, assumes kSpaceSize bytes are already mapped R/W
   // at heap_start and places the heap there.  This mode requires kSpaceBeg ==
#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

enum {
     CIMT_FILE
   } type;
   union {
     FileMetadata file;
   };
 };
 
 #if SI_POSIX
 typedef AddrHashMap<CommonInterceptorMetadata, 31051> MetadataHashMap;
 
 static MetadataHashMap *interceptor_metadata_map;
 
 UNUSED static void SetInterceptorMetadata(__sanitizer_FILE *addr,
                                           const FileMetadata &file) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr);
   CHECK(h.created());
   h->type = CommonInterceptorMetadata::CIMT_FILE;
   h->file = file;
 }
 
 UNUSED static const FileMetadata *GetInterceptorMetadata(
     __sanitizer_FILE *addr) {

 
 UNUSED static void DeleteInterceptorMetadata(void *addr) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr, true);
   CHECK(h.exists());
 }
 #endif  // SI_POSIX
 
 #if SANITIZER_INTERCEPT_STRLEN
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
   // Sometimes strlen is called prior to InitializeCommonInterceptors,
   // in which case the REAL(strlen) typically used in
   // COMMON_INTERCEPTOR_ENTER will fail.  We use internal_strlen here
   // to handle that.
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strlen(s);
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strlen, s);
   SIZE_T result = REAL(strlen)(s);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, result + 1);
   return result;
 }
 #define INIT_STRLEN COMMON_INTERCEPT_FUNCTION(strlen)
 #else
 #define INIT_STRLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNLEN
 INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strnlen, s, maxlen);
   SIZE_T length = REAL(strnlen)(s, maxlen);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, Min(length + 1, maxlen));
   return length;
 }
 #define INIT_STRNLEN COMMON_INTERCEPT_FUNCTION(strnlen)
 #else
 #define INIT_STRNLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNDUP
 INTERCEPTOR(char*, strndup, const char *s, uptr size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
 #define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
 #else
 #define INIT_STRNDUP
 #endif // SANITIZER_INTERCEPT_STRNDUP
 
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

 // and http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html
 // with a few common GNU extensions.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdarg.h>
 
 static const char *parse_number(const char *p, int *out) {
   *out = internal_atoll(p);
   while (*p >= '0' && *p <= '9')
     ++p;
   return p;
 }
 
 static const char *maybe_parse_param_index(const char *p, int *out) {
   // n$
   if (*p >= '0' && *p <= '9') {
     int number;
     const char *q = parse_number(p, &number);
     CHECK(q);
     if (*q == '$') {
       *out = number;
       p = q + 1;
     }
   }
 
   // Otherwise, do not change p. This will be re-parsed later as the field
   // width.
   return p;
 }
 
 static bool char_is_one_of(char c, const char *s) {
   return !!internal_strchr(s, c);
 }
 
 static const char *maybe_parse_length_modifier(const char *p, char ll[2]) {
   if (char_is_one_of(*p, "jztLq")) {
     ll[0] = *p;
     ++p;
   } else if (*p == 'h') {
     ll[0] = 'h';
case 'h':
       return lengthModifier[1] == 'h' ? sizeof(char) : sizeof(short);
     case 'l':
       return lengthModifier[1] == 'l' ? sizeof(long long) : sizeof(long);
     case 'q':
       return sizeof(long long);
     case 'L':
       return sizeof(long long);
     case 'j':
       return sizeof(INTMAX_T);
     case 'z':
       return sizeof(SIZE_T);
     case 't':
       return sizeof(PTRDIFF_T);
     case 0:
       return sizeof(int);
     default:
       return FSS_INVALID;
     }
   }
 
   if (format_is_float_conv(convSpecifier)) {

 };
 
 // Parse scanf format string. If a valid directive in encountered, it is
 // returned in dir. This function returns the pointer to the first
 // unprocessed character, or 0 in case of error.
 // In case of the end-of-string, a pointer to the closing \0 is returned.
 static const char *scanf_parse_next(const char *p, bool allowGnuMalloc,
                                     ScanfDirective *dir) {
   internal_memset(dir, 0, sizeof(*dir));
   dir->argIdx = -1;
 
   while (*p) {
     if (*p != '%') {
       ++p;
       continue;
     }
     dir->begin = p;
     ++p;
     // %%
     if (*p == '%') {
       ++p;
       continue;
     }
     if (*p == '\0') {
       return nullptr;
     }
     // %n$
     p = maybe_parse_param_index(p, &dir->argIdx);
     CHECK(p);
     // *
     if (*p == '*') {
       dir->suppressed = true;
       ++p;
     }
     // Field width
     if (*p >= '0' && *p <= '9') {
       p = parse_number(p, &dir->fieldWidth);
       CHECK(p);
       if (dir->fieldWidth <= 0)  // Width if at all must be non-zero
         return nullptr;
     }
     // m
     if (*p == 'm') {
       dir->allocate = true;
       ++p;
     }
static int scanf_get_value_size(ScanfDirective *dir) {
   return format_get_value_size(dir->convSpecifier, dir->lengthModifier, false);
 }
 
 // Common part of *scanf interceptors.
 // Process format string and va_list, and report all store ranges.
 // Stops when "consuming" n_inputs input items.
 static void scanf_common(void *ctx, int n_inputs, bool allowGnuMalloc,
                          const char *format, va_list aq) {
   CHECK_GT(n_inputs, 0);
   const char *p = format;
 
   COMMON_INTERCEPTOR_READ_RANGE(ctx, format, internal_strlen(format) + 1);
 
   while (*p) {
     ScanfDirective dir;
     p = scanf_parse_next(p, allowGnuMalloc, &dir);
     if (!p)
       break;
     if (dir.convSpecifier == 0) {
       // This can only happen at the end of the format string.
       CHECK_EQ(*p, 0);
       break;
     }
     // Here the directive is valid. Do what it says.
     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) {
       size = internal_strlen((const char *)argp) + 1;
     } else if (size == FSS_WCSLEN) {
       // FIXME: actually use wcslen() to calculate it.
       size = 0;
     }
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, argp, size);
     // For %ms/%mc, write the allocated output buffer as well.
     if (dir.allocate) {
       char *buf = *(char **)argp;
       if (buf)
         COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, internal_strlen(buf) + 1);
     }
   }
 }
 
 #if SANITIZER_INTERCEPT_PRINTF
 
 struct PrintfDirective {
   int fieldWidth;
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

 //===-- sanitizer_common_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 <algorithm>
 
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_file.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_platform.h"
 

 }
 
 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();