[XRay] fix more -Wformat warnings

[dim]

Summary

Building xray with recent clang on a 64-bit system results in a number
of -Wformat warnings:

compiler-rt/lib/xray/xray_allocator.h:70:11: warning: format specifies type 'int' but the argument has type '__sanitizer::uptr' (aka 'unsigned long') [-Wformat]
          RoundedSize, B);
          ^~~~~~~~~~~
compiler-rt/lib/xray/xray_allocator.h:119:11: warning: format specifies type 'int' but the argument has type '__sanitizer::uptr' (aka 'unsigned long') [-Wformat]
          RoundedSize, B);
          ^~~~~~~~~~~

Since __sanitizer::uptr has the same size as size_t, these can be
fixed by using the printf specifier %zu.

compiler-rt/lib/xray/xray_basic_logging.cpp:348:46: warning: format specifies type 'int' but the argument has type '__sanitizer::tid_t' (aka 'unsigned long long') [-Wformat]
      Report("Cleaned up log for TID: %d\n", GetTid());
                                      ~~     ^~~~~~~~
                                      %llu
compiler-rt/lib/xray/xray_basic_logging.cpp:353:62: warning: format specifies type 'int' but the argument has type '__sanitizer::tid_t' (aka 'unsigned long long') [-Wformat]
      Report("Skipping buffer for TID: %d; Offset = %llu\n", GetTid(),
                                       ~~                    ^~~~~~~~
                                       %llu

Since __sanitizer::tid_t is effectively declared as `unsigned long
long`, these can be fixed by using the printf specifier %llu.

compiler-rt/lib/xray/xray_basic_logging.cpp:354:14: warning: format specifies type 'unsigned long long' but the argument has type 'size_t' (aka 'unsigned long') [-Wformat]
             TLD.BufferOffset);
             ^~~~~~~~~~~~~~~~

Since BufferOffset is declared as size_t, this one can be fixed by
using %zu as a printf specifier.

compiler-rt/lib/xray/xray_interface.cpp:172:50: warning: format specifies type 'int' but the argument has type 'uint64_t' (aka 'unsigned long') [-Wformat]
    Report("Unsupported sled kind '%d' @%04x\n", Sled.Address, int(Sled.Kind));
                                   ~~            ^~~~~~~~~~~~
                                   %lu

Since `xray::SledEntry::Address is declared as uint64_t, this one
can be fixed by using PRIu64, and adding <cinttypes>.

compiler-rt/lib/xray/xray_interface.cpp:308:62: warning: format specifies type 'long long' but the argument has type 'size_t' (aka 'unsigned long') [-Wformat]
    Report("System page size is not a power of two: %lld\n", PageSize);
                                                    ~~~~     ^~~~~~~~
                                                    %zu
compiler-rt/lib/xray/xray_interface.cpp:359:64: warning: format specifies type 'long long' but the argument has type 'size_t' (aka 'unsigned long') [-Wformat]
    Report("Provided page size is not a power of two: %lld\n", PageSize);
                                                      ~~~~     ^~~~~~~~
                                                      %zu

Since PageSize is declared as size_t, these can be fixed by using
%zu as a printf specifier.

[MaskRay]

compiler-rt/lib/xray/xray_allocator.h

69

Drop trailing dot while updating messages. https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

[dim]

Drop trailing dots from report messages.

[dim]

Squash commits because arc tricked me.

[vitalybuka]

compiler-rt/lib/xray/xray_interface.cpp

172

%llu

[dim]

compiler-rt/lib/xray/xray_interface.cpp

172

This can only be done by adding a cast, as Sled.Address is uint64_t. There's a cast here anyway, so maybe another one's OK?

[vitalybuka]

compiler-rt/lib/xray/xray_interface.cpp

172

I see.
PRIu64 is OK.

compiler-rt/lib/xray/xray_allocator.h

#if SANITIZER_FUCHSIA
   }
   return reinterpret_cast<T *>(B);
 #else
   uptr B = internal_mmap(NULL, RoundedSize, PROT_READ | PROT_WRITE,
                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   int ErrNo = 0;
   if (UNLIKELY(internal_iserror(B, &ErrNo))) {
     if (Verbosity())
-      Report(
-          "XRay Profiling: Failed to allocate memory of size %d; Error = %d.\n",
+      Report("XRay Profiling: Failed to allocate memory of size %zu; Error = "
+             "%zu\n",
              RoundedSize, B);
     return nullptr;
   }
 #endif
   return reinterpret_cast<T *>(B);
 }
 
 template <class T> void deallocate(T *B) XRAY_NEVER_INSTRUMENT {
   if (B == nullptr)
if (Status != ZX_OK) {
     return nullptr;
   }
 #else
   uptr B = internal_mmap(NULL, RoundedSize, PROT_READ | PROT_WRITE,
                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   int ErrNo = 0;
   if (UNLIKELY(internal_iserror(B, &ErrNo))) {
     if (Verbosity())
-      Report(
-          "XRay Profiling: Failed to allocate memory of size %d; Error = %d.\n",
+      Report("XRay Profiling: Failed to allocate memory of size %zu; Error = "
+             "%zu\n",
              RoundedSize, B);
     return nullptr;
   }
 #endif
   return reinterpret_cast<T *>(B);
 }
 
 template <class T> void deallocateBuffer(T *B, size_t S) XRAY_NEVER_INSTRUMENT {
   if (B == nullptr)
private:
   SpinMutex Mutex{};
 
   void *Alloc() XRAY_NEVER_INSTRUMENT {
     SpinMutexLock Lock(&Mutex);
     if (UNLIKELY(BackingStore == nullptr)) {
       BackingStore = allocateBuffer(MaxMemory);
       if (BackingStore == nullptr) {
         if (Verbosity())
-          Report("XRay Profiling: Failed to allocate memory for allocator.\n");
+          Report("XRay Profiling: Failed to allocate memory for allocator\n");
         return nullptr;
       }
 
       AlignedNextBlock = BackingStore;
 
       // Ensure that NextBlock is aligned appropriately.
       auto BackingStoreNum = reinterpret_cast<uintptr_t>(BackingStore);
       auto AlignedNextBlockNum = nearest_boundary(
           reinterpret_cast<uintptr_t>(AlignedNextBlock), kCacheLineSize);
       if (diff(AlignedNextBlockNum, BackingStoreNum) > ptrdiff_t(MaxMemory)) {
         deallocateBuffer(BackingStore, MaxMemory);
         AlignedNextBlock = BackingStore = nullptr;
         if (Verbosity())
           Report("XRay Profiling: Cannot obtain enough memory from "
-                 "preallocated region.\n");
+                 "preallocated region\n");
         return nullptr;
       }
 
       AlignedNextBlock = reinterpret_cast<unsigned char *>(AlignedNextBlockNum);
 
       // Assert that AlignedNextBlock is cache-line aligned.
       DCHECK_EQ(reinterpret_cast<uintptr_t>(AlignedNextBlock) % kCacheLineSize,
                 0);

compiler-rt/lib/xray/xray_basic_logging.cpp

static void TLDDestructor(void *P) XRAY_NEVER_INSTRUMENT {
   ThreadLocalData &TLD = *reinterpret_cast<ThreadLocalData *>(P);
   auto ExitGuard = at_scope_exit([&TLD] {
     // Clean up dynamic resources.
     if (TLD.InMemoryBuffer)
       InternalFree(TLD.InMemoryBuffer);
     if (TLD.ShadowStack)
       InternalFree(TLD.ShadowStack);
     if (Verbosity())
-      Report("Cleaned up log for TID: %d\n", GetTid());
+      Report("Cleaned up log for TID: %llu\n", GetTid());
   });
 
   if (TLD.LogWriter == nullptr || TLD.BufferOffset == 0) {
     if (Verbosity())
-      Report("Skipping buffer for TID: %d; Offset = %llu\n", GetTid(),
+      Report("Skipping buffer for TID: %llu; Offset = %zu\n", GetTid(),
              TLD.BufferOffset);
     return;
   }
 
   {
     SpinMutexLock L(&LogMutex);
     TLD.LogWriter->WriteAll(reinterpret_cast<char *>(TLD.InMemoryBuffer),
                             reinterpret_cast<char *>(TLD.InMemoryBuffer) +

compiler-rt/lib/xray/xray_interface.cpp

 //===-- xray_interface.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 // Implementation of the API functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "xray_interface_internal.h"
 
-#include <cstdint>
+#include <cinttypes>
 #include <cstdio>
 #include <errno.h>
 #include <limits>
 #include <string.h>
 #include <sys/mman.h>
 
 #if SANITIZER_FUCHSIA
 #include <zircon/process.h>
case XRayEntryType::LOG_ARGS_ENTRY:
     break;
   case XRayEntryType::CUSTOM_EVENT:
     Success = patchCustomEvent(Enable, FuncId, Sled);
     break;
   case XRayEntryType::TYPED_EVENT:
     Success = patchTypedEvent(Enable, FuncId, Sled);
     break;
   default:
-    Report("Unsupported sled kind '%d' @%04x\n", Sled.Address, int(Sled.Kind));
+    Report("Unsupported sled kind '%" PRIu64 "' @%04x\n", Sled.Address,
+           int(Sled.Kind));
     return false;
   }
   return Success;
 }
 
 const XRayFunctionSledIndex
 findFunctionSleds(int32_t FuncId,
                   const XRaySledMap &InstrMap) XRAY_NEVER_INSTRUMENT {
for (std::size_t I = 0; I < InstrMap.Entries; I++) {
     if (Sled.address() > MaxSled->address())
       MaxSled = &Sled;
   }
 
   const size_t PageSize = flags()->xray_page_size_override > 0
                               ? flags()->xray_page_size_override
                               : GetPageSizeCached();
   if ((PageSize == 0) || ((PageSize & (PageSize - 1)) != 0)) {
-    Report("System page size is not a power of two: %lld\n", PageSize);
+    Report("System page size is not a power of two: %zu\n", PageSize);
     return XRayPatchingStatus::FAILED;
   }
 
   void *PageAlignedAddr =
       reinterpret_cast<void *>(MinSled->address() & ~(PageSize - 1));
   size_t MProtectLen =
       (MaxSled->address() - reinterpret_cast<uptr>(PageAlignedAddr)) +
       cSledLength;
if (FuncId <= 0 || static_cast<size_t>(FuncId) > InstrMap.Functions) {
     Report("Invalid function id provided: %d\n", FuncId);
     return XRayPatchingStatus::FAILED;
   }
 
   const size_t PageSize = flags()->xray_page_size_override > 0
                               ? flags()->xray_page_size_override
                               : GetPageSizeCached();
   if ((PageSize == 0) || ((PageSize & (PageSize - 1)) != 0)) {
-    Report("Provided page size is not a power of two: %lld\n", PageSize);
+    Report("Provided page size is not a power of two: %zu\n", PageSize);
     return XRayPatchingStatus::FAILED;
   }
 
   // Here we compute the minimum sled and maximum sled associated with a
   // particular function ID.
   auto SledRange = InstrMap.SledsIndex ? InstrMap.SledsIndex[FuncId - 1]
                                        : findFunctionSleds(FuncId, InstrMap);
   auto *f = SledRange.Begin;