tsan: fix debug format strings

[dvyukov]

Summary

Some of the DPrintf's currently produce -Wformat warnings if enabled.
Fix these format strings.

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 static void syscall_access_range(uptr pc, uptr p, uptr s, bool write) {
   TSAN_SYSCALL();
   MemoryAccessRange(thr, pc, p, s, write);
 }
 
 static USED void syscall_acquire(uptr pc, uptr addr) {
   TSAN_SYSCALL();
   Acquire(thr, pc, addr);
-  DPrintf("syscall_acquire(%p)\n", addr);
+  DPrintf("syscall_acquire(0x%zx))\n", addr);
 }
 
 static USED void syscall_release(uptr pc, uptr addr) {
   TSAN_SYSCALL();
-  DPrintf("syscall_release(%p)\n", addr);
+  DPrintf("syscall_release(0x%zx)\n", addr);
   Release(thr, pc, addr);
 }
 
 static void syscall_fd_close(uptr pc, int fd) {
   TSAN_SYSCALL();
   FdClose(thr, pc, fd);
 }
 
 static USED void syscall_fd_acquire(uptr pc, int fd) {
   TSAN_SYSCALL();
   FdAcquire(thr, pc, fd);
-  DPrintf("syscall_fd_acquire(%p)\n", fd);
+  DPrintf("syscall_fd_acquire(%d)\n", fd);
 }
 
 static USED void syscall_fd_release(uptr pc, int fd) {
   TSAN_SYSCALL();
-  DPrintf("syscall_fd_release(%p)\n", fd);
+  DPrintf("syscall_fd_release(%d)\n", fd);
   FdRelease(thr, pc, fd);
 }
 
 static void syscall_pre_fork(uptr pc) { ForkBefore(cur_thread(), pc); }
 
 static void syscall_post_fork(uptr pc, int pid) {
   ThreadState *thr = cur_thread();
   if (pid == 0) {

compiler-rt/lib/tsan/rtl/tsan_interface_java.cpp

 
 #define JAVA_FUNC_ENTER(func)      \
   ThreadState *thr = cur_thread(); \
   (void)thr;
 
 void __tsan_java_init(jptr heap_begin, jptr heap_size) {
   JAVA_FUNC_ENTER(__tsan_java_init);
   Initialize(thr);
-  DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size);
+  DPrintf("#%d: java_init(0x%zx, 0x%zx)\n", thr->tid, heap_begin, heap_size);
   DCHECK_EQ(jctx, 0);
   DCHECK_GT(heap_begin, 0);
   DCHECK_GT(heap_size, 0);
   DCHECK_EQ(heap_begin % kHeapAlignment, 0);
   DCHECK_EQ(heap_size % kHeapAlignment, 0);
   DCHECK_LT(heap_begin, heap_begin + heap_size);
   jctx = new(jctx_buf) JavaContext(heap_begin, heap_size);
 }
 
 int  __tsan_java_fini() {
   JAVA_FUNC_ENTER(__tsan_java_fini);
   DPrintf("#%d: java_fini()\n", thr->tid);
   DCHECK_NE(jctx, 0);
   // FIXME(dvyukov): this does not call atexit() callbacks.
   int status = Finalize(thr);
   DPrintf("#%d: java_fini() = %d\n", thr->tid, status);
   return status;
 }
 
 void __tsan_java_alloc(jptr ptr, jptr size) {
   JAVA_FUNC_ENTER(__tsan_java_alloc);
-  DPrintf("#%d: java_alloc(%p, %p)\n", thr->tid, ptr, size);
+  DPrintf("#%d: java_alloc(0x%zx, 0x%zx)\n", thr->tid, ptr, size);
   DCHECK_NE(jctx, 0);
   DCHECK_NE(size, 0);
   DCHECK_EQ(ptr % kHeapAlignment, 0);
   DCHECK_EQ(size % kHeapAlignment, 0);
   DCHECK_GE(ptr, jctx->heap_begin);
   DCHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
 
   OnUserAlloc(thr, 0, ptr, size, false);
 }
 
 void __tsan_java_free(jptr ptr, jptr size) {
   JAVA_FUNC_ENTER(__tsan_java_free);
-  DPrintf("#%d: java_free(%p, %p)\n", thr->tid, ptr, size);
+  DPrintf("#%d: java_free(0x%zx, 0x%zx)\n", thr->tid, ptr, size);
   DCHECK_NE(jctx, 0);
   DCHECK_NE(size, 0);
   DCHECK_EQ(ptr % kHeapAlignment, 0);
   DCHECK_EQ(size % kHeapAlignment, 0);
   DCHECK_GE(ptr, jctx->heap_begin);
   DCHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
 
   ctx->metamap.FreeRange(thr->proc(), ptr, size);
 }
 
 void __tsan_java_move(jptr src, jptr dst, jptr size) {
   JAVA_FUNC_ENTER(__tsan_java_move);
-  DPrintf("#%d: java_move(%p, %p, %p)\n", thr->tid, src, dst, size);
+  DPrintf("#%d: java_move(0x%zx, 0x%zx, 0x%zx)\n", thr->tid, src, dst, size);
   DCHECK_NE(jctx, 0);
   DCHECK_NE(size, 0);
   DCHECK_EQ(src % kHeapAlignment, 0);
   DCHECK_EQ(dst % kHeapAlignment, 0);
   DCHECK_EQ(size % kHeapAlignment, 0);
   DCHECK_GE(src, jctx->heap_begin);
   DCHECK_LE(src + size, jctx->heap_begin + jctx->heap_size);
   DCHECK_GE(dst, jctx->heap_begin);
void __tsan_java_move(jptr src, jptr dst, jptr size) {
   for (; s != send; s += inc, d += inc) {
     *d = *s;
     *s = 0;
   }
 }
 
 jptr __tsan_java_find(jptr *from_ptr, jptr to) {
   JAVA_FUNC_ENTER(__tsan_java_find);
-  DPrintf("#%d: java_find(&%p, %p)\n", *from_ptr, to);
+  DPrintf("#%d: java_find(&0x%zx, 0x%zx)\n", thr->tid, *from_ptr, to);
   DCHECK_EQ((*from_ptr) % kHeapAlignment, 0);
   DCHECK_EQ(to % kHeapAlignment, 0);
   DCHECK_GE(*from_ptr, jctx->heap_begin);
   DCHECK_LE(to, jctx->heap_begin + jctx->heap_size);
   for (uptr from = *from_ptr; from < to; from += kHeapAlignment) {
     MBlock *b = ctx->metamap.GetBlock(from);
     if (b) {
       *from_ptr = from;
       return b->siz;
     }
   }
   return 0;
 }
 
 void __tsan_java_finalize() {
   JAVA_FUNC_ENTER(__tsan_java_finalize);
   DPrintf("#%d: java_finalize()\n", thr->tid);
   AcquireGlobal(thr);
 }
 
 void __tsan_java_mutex_lock(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_mutex_lock);
-  DPrintf("#%d: java_mutex_lock(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_mutex_lock(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   MutexPostLock(thr, 0, addr,
                 MutexFlagLinkerInit | MutexFlagWriteReentrant |
                     MutexFlagDoPreLockOnPostLock);
 }
 
 void __tsan_java_mutex_unlock(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_mutex_unlock);
-  DPrintf("#%d: java_mutex_unlock(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_mutex_unlock(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   MutexUnlock(thr, 0, addr);
 }
 
 void __tsan_java_mutex_read_lock(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_mutex_read_lock);
-  DPrintf("#%d: java_mutex_read_lock(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_mutex_read_lock(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   MutexPostReadLock(thr, 0, addr,
                     MutexFlagLinkerInit | MutexFlagWriteReentrant |
                         MutexFlagDoPreLockOnPostLock);
 }
 
 void __tsan_java_mutex_read_unlock(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_mutex_read_unlock);
-  DPrintf("#%d: java_mutex_read_unlock(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_mutex_read_unlock(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   MutexReadUnlock(thr, 0, addr);
 }
 
 void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
   JAVA_FUNC_ENTER(__tsan_java_mutex_lock_rec);
-  DPrintf("#%d: java_mutex_lock_rec(%p, %d)\n", thr->tid, addr, rec);
+  DPrintf("#%d: java_mutex_lock_rec(0x%zx, %d)\n", thr->tid, addr, rec);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
   DCHECK_GT(rec, 0);
 
   MutexPostLock(thr, 0, addr,
                 MutexFlagLinkerInit | MutexFlagWriteReentrant |
                     MutexFlagDoPreLockOnPostLock | MutexFlagRecursiveLock,
                 rec);
 }
 
 int __tsan_java_mutex_unlock_rec(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_mutex_unlock_rec);
-  DPrintf("#%d: java_mutex_unlock_rec(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_mutex_unlock_rec(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   return MutexUnlock(thr, 0, addr, MutexFlagRecursiveUnlock);
 }
 
 void __tsan_java_acquire(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_acquire);
-  DPrintf("#%d: java_acquire(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_acquire(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   Acquire(thr, 0, addr);
 }
 
 void __tsan_java_release(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_release);
-  DPrintf("#%d: java_release(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_release(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   Release(thr, 0, addr);
 }
 
 void __tsan_java_release_store(jptr addr) {
   JAVA_FUNC_ENTER(__tsan_java_release);
-  DPrintf("#%d: java_release_store(%p)\n", thr->tid, addr);
+  DPrintf("#%d: java_release_store(0x%zx)\n", thr->tid, addr);
   DCHECK_NE(jctx, 0);
   DCHECK_GE(addr, jctx->heap_begin);
   DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
   ReleaseStore(thr, 0, addr);
 }

compiler-rt/lib/tsan/rtl/tsan_mman.cpp

if (AllocatorMayReturnNull())
       return SetErrnoOnNull(nullptr);
     GET_STACK_TRACE_FATAL(thr, pc);
     ReportReallocArrayOverflow(size, n, &stack);
   }
   return user_realloc(thr, pc, p, size * n);
 }
 
 void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write) {
-  DPrintf("#%d: alloc(%zu) = %p\n", thr->tid, sz, p);
+  DPrintf("#%d: alloc(%zu) = 0x%zx\n", thr->tid, sz, p);
   ctx->metamap.AllocBlock(thr, pc, p, sz);
   if (write && thr->ignore_reads_and_writes == 0)
     MemoryRangeImitateWrite(thr, pc, (uptr)p, sz);
   else
     MemoryResetRange(thr, pc, (uptr)p, sz);
 }
 
 void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write) {
   CHECK_NE(p, (void*)0);
   uptr sz = ctx->metamap.FreeBlock(thr->proc(), p);
-  DPrintf("#%d: free(%p, %zu)\n", thr->tid, p, sz);
+  DPrintf("#%d: free(0x%zx, %zu)\n", thr->tid, p, sz);
   if (write && thr->ignore_reads_and_writes == 0)
     MemoryRangeFreed(thr, pc, (uptr)p, sz);
 }
 
 void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
   // FIXME: Handle "shrinking" more efficiently,
   // it seems that some software actually does this.
   if (!p)

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

if (!MmapFixedSuperNoReserve(meta_begin, meta_end - meta_begin,
       Die();
     mapped_meta_end = meta_end;
   }
   VPrintf(2, "mapped meta shadow for (0x%zx-0x%zx) at (0x%zx-0x%zx)\n", addr,
           addr + size, meta_begin, meta_end);
 }
 
 void MapThreadTrace(uptr addr, uptr size, const char *name) {
-  DPrintf("#0: Mapping trace at %p-%p(0x%zx)\n", addr, addr + size, size);
+  DPrintf("#0: Mapping trace at 0x%zx-0x%zx(0x%zx)\n", addr, addr + size, size);
   CHECK_GE(addr, TraceMemBeg());
   CHECK_LE(addr + size, TraceMemEnd());
   CHECK_EQ(addr, addr & ~((64 << 10) - 1));  // windows wants 64K alignment
   if (!MmapFixedSuperNoReserve(addr, size, name)) {
     Printf("FATAL: ThreadSanitizer can not mmap thread trace (0x%zx/0x%zx)\n",
            addr, size);
     Die();
   }

compiler-rt/lib/tsan/rtl/tsan_rtl_mutex.cpp

static void UpdateSleepClockCallback(ThreadContextBase *tctx_base, void *arg) {
   ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base);
   u64 epoch = tctx->epoch1;
   if (tctx->status == ThreadStatusRunning)
     epoch = tctx->thr->fast_state.epoch();
   thr->last_sleep_clock.set(&thr->proc()->clock_cache, tctx->tid, epoch);
 }
 
 void AfterSleep(ThreadState *thr, uptr pc) {
-  DPrintf("#%d: AfterSleep %zx\n", thr->tid);
+  DPrintf("#%d: AfterSleep\n", thr->tid);
   if (thr->ignore_sync)
     return;
   thr->last_sleep_stack_id = CurrentStackId(thr, pc);
   ThreadRegistryLock l(&ctx->thread_registry);
   ctx->thread_registry.RunCallbackForEachThreadLocked(UpdateSleepClockCallback,
                                                       thr);
 }
 #endif

compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp

 // and tag for that event. If there are multiple such events, it returns
 // the last one. Returns false if the event is not present in the trace.
 bool RestoreStack(Tid tid, EventType type, Sid sid, Epoch epoch, uptr addr,
                   uptr size, AccessType typ, VarSizeStackTrace *pstk,
                   MutexSet *pmset, uptr *ptag) {
   // This function restores stack trace and mutex set for the thread/epoch.
   // It does so by getting stack trace and mutex set at the beginning of
   // trace part, and then replaying the trace till the given epoch.
-  DPrintf2("RestoreStack: tid=%u sid=%u@%u addr=0x%zx/%zu typ=%x\n", tid, sid,
-           epoch, addr, size, typ);
+  DPrintf2("RestoreStack: tid=%u sid=%u@%u addr=0x%zx/%zu typ=%x\n", tid,
+           static_cast<int>(sid), static_cast<int>(epoch), addr, size,
+           static_cast<int>(typ));
   ctx->slot_mtx.CheckLocked();  // needed to prevent trace part recycling
   ctx->thread_registry.CheckLocked();
   ThreadContext *tctx =
       static_cast<ThreadContext *>(ctx->thread_registry.GetThreadLocked(tid));
   Trace *trace = &tctx->trace;
   // Snapshot first/last parts and the current position in the last part.
   TracePart *first_part;
   TracePart *last_part;
TraceReplay(
               evp->_ == 0)  // NopEvent
             return;
           auto *ev = reinterpret_cast<EventAccess *>(evp);
           uptr ev_addr = RestoreAddr(ev->addr);
           uptr ev_size = 1 << ev->size_log;
           uptr ev_pc =
               prev_pc + ev->pc_delta - (1 << (EventAccess::kPCBits - 1));
           prev_pc = ev_pc;
-          DPrintf2("  Access: pc=0x%zx addr=0x%llx/%llu type=%llu/%llu\n",
-                   ev_pc, ev_addr, ev_size, ev->is_read, ev->is_atomic);
+          DPrintf2("  Access: pc=0x%zx addr=0x%zx/%zu type=%u/%u\n", ev_pc,
+                   ev_addr, ev_size, ev->is_read, ev->is_atomic);
           if (match && type == EventType::kAccessExt &&
               IsWithinAccess(addr, size, ev_addr, ev_size) &&
               is_read == ev->is_read && is_atomic == ev->is_atomic && !is_free)
             RestoreStackMatch(pstk, pmset, &stack, &mset, ev_pc, &found);
           return;
         }
         if (evp->is_func) {
           auto *ev = reinterpret_cast<EventFunc *>(evp);
           if (ev->pc) {
-            DPrintf2("  FuncEnter: pc=0x%zx\n", ev->pc);
+            DPrintf2("  FuncEnter: pc=0x%llx\n", ev->pc);
             stack.PushBack(ev->pc);
           } else {
             DPrintf2("  FuncExit\n");
             CHECK(stack.Size());
             stack.PopBack();
           }
           return;
         }
         switch (evp->type) {
           case EventType::kAccessExt: {
             auto *ev = reinterpret_cast<EventAccessExt *>(evp);
             uptr ev_addr = RestoreAddr(ev->addr);
             uptr ev_size = 1 << ev->size_log;
             prev_pc = ev->pc;
-            DPrintf2("  AccessExt: pc=0x%zx addr=0x%llx/%llu type=%llu/%llu\n",
+            DPrintf2("  AccessExt: pc=0x%llx addr=0x%zx/%zu type=%u/%u\n",
                      ev->pc, ev_addr, ev_size, ev->is_read, ev->is_atomic);
             if (match && type == EventType::kAccessExt &&
                 IsWithinAccess(addr, size, ev_addr, ev_size) &&
                 is_read == ev->is_read && is_atomic == ev->is_atomic &&
                 !is_free)
               RestoreStackMatch(pstk, pmset, &stack, &mset, ev->pc, &found);
             break;
           }
           case EventType::kAccessRange: {
             auto *ev = reinterpret_cast<EventAccessRange *>(evp);
             uptr ev_addr = RestoreAddr(ev->addr);
             uptr ev_size =
                 (ev->size_hi << EventAccessRange::kSizeLoBits) + ev->size_lo;
             uptr ev_pc = RestoreAddr(ev->pc);
             prev_pc = ev_pc;
-            DPrintf2("  Range: pc=0x%zx addr=0x%llx/%llu type=%llu/%llu\n",
-                     ev_pc, ev_addr, ev_size, ev->is_read, ev->is_free);
+            DPrintf2("  Range: pc=0x%zx addr=0x%zx/%zu type=%u/%u\n", ev_pc,
+                     ev_addr, ev_size, ev->is_read, ev->is_free);
             if (match && type == EventType::kAccessExt &&
                 IsWithinAccess(addr, size, ev_addr, ev_size) &&
                 is_read == ev->is_read && !is_atomic && is_free == ev->is_free)
               RestoreStackMatch(pstk, pmset, &stack, &mset, ev_pc, &found);
             break;
           }
           case EventType::kLock:
             FALLTHROUGH;
           case EventType::kRLock: {
             auto *ev = reinterpret_cast<EventLock *>(evp);
             bool is_write = ev->type == EventType::kLock;
             uptr ev_addr = RestoreAddr(ev->addr);
             uptr ev_pc = RestoreAddr(ev->pc);
             StackID stack_id =
                 (ev->stack_hi << EventLock::kStackIDLoBits) + ev->stack_lo;
-            DPrintf2("  Lock: pc=0x%zx addr=0x%llx stack=%u write=%d\n", ev_pc,
+            DPrintf2("  Lock: pc=0x%zx addr=0x%zx stack=%u write=%d\n", ev_pc,
                      ev_addr, stack_id, is_write);
             mset.AddAddr(ev_addr, stack_id, is_write);
             // Events with ev_pc == 0 are written to the beginning of trace
             // part as initial mutex set (are not real).
             if (match && type == EventType::kLock && addr == ev_addr && ev_pc)
               RestoreStackMatch(pstk, pmset, &stack, &mset, ev_pc, &found);
             break;
           }
           case EventType::kUnlock: {
             auto *ev = reinterpret_cast<EventUnlock *>(evp);
             uptr ev_addr = RestoreAddr(ev->addr);
-            DPrintf2("  Unlock: addr=0x%llx\n", ev_addr);
+            DPrintf2("  Unlock: addr=0x%zx\n", ev_addr);
             mset.DelAddr(ev_addr);
             break;
           }
           case EventType::kTime:
             // TraceReplay already extracted sid/epoch from it,
             // nothing else to do here.
             break;
         }