tsan: print alloc stack for Java objects

[dvyukov]

Summary

We maintain information about Java allocations,
but for some reason never printed it in reports.
Print it.

[vitalybuka]

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

67

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

 
  private:
   ThreadState *thr_;
 };
 
 static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1];
 static JavaContext *jctx;
 
+MBlock *JavaHeapBlock(uptr addr, uptr *start) {
+  if (!jctx || addr < jctx->heap_begin ||
+      addr >= jctx->heap_begin + jctx->heap_size)
+    return nullptr;
+  for (uptr p = RoundDown(addr, kMetaShadowCell); p >= jctx->heap_begin;
+       p -= kMetaShadowCell) {
+    MBlock *b = ctx->metamap.GetBlock(p);
+    if (!b)
+      continue;
+    if (p + b->siz <= addr)
+      return nullptr;
+    *start = p;
+    return b;
+  }
+  return nullptr;
+}
+
 }  // namespace __tsan
 
 #define SCOPED_JAVA_FUNC(func) \
   ThreadState *thr = cur_thread(); \
   const uptr caller_pc = GET_CALLER_PC(); \
   const uptr pc = StackTrace::GetCurrentPc(); \
   (void)pc; \
   ScopedJavaFunc scoped(thr, caller_pc); \

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

 #else
 # define DPrintf2(...)
 #endif
 
 u32 CurrentStackId(ThreadState *thr, uptr pc);
 ReportStack *SymbolizeStackId(u32 stack_id);
 void PrintCurrentStack(ThreadState *thr, uptr pc);
 void PrintCurrentStackSlow(uptr pc);  // uses libunwind
+MBlock *JavaHeapBlock(uptr addr, uptr *start);
 
 void Initialize(ThreadState *thr);
 void MaybeSpawnBackgroundThread();
 int Finalize(ThreadState *thr);
 
 void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write);
 void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write);
 

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

if (FdLocation(addr, &fd, &creat_tid, &creat_stack)) {
     loc->stack = SymbolizeStackId(creat_stack);
     rep_->locs.PushBack(loc);
     ThreadContext *tctx = FindThreadByUidLocked(creat_tid);
     if (tctx)
       AddThread(tctx);
     return;
   }
   MBlock *b = 0;
+  uptr block_begin = 0;
   Allocator *a = allocator();
   if (a->PointerIsMine((void*)addr)) {
-    void *block_begin = a->GetBlockBegin((void*)addr);
+    block_begin = (uptr)a->GetBlockBegin((void *)addr);
     if (block_begin)
-      b = ctx->metamap.GetBlock((uptr)block_begin);
+      b = ctx->metamap.GetBlock(block_begin);
   }
+  if (!b)
+    b = JavaHeapBlock(addr, &block_begin);
   if (b != 0) {
     ThreadContext *tctx = FindThreadByTidLocked(b->tid);
     ReportLocation *loc = ReportLocation::New(ReportLocationHeap);
     loc->heap_chunk_start = (uptr)allocator()->GetBlockBegin((void *)addr);
     loc->heap_chunk_size = b->siz;
     loc->external_tag = b->tag;
     loc->tid = tctx ? tctx->tid : b->tid;
     loc->stack = SymbolizeStackId(b->stk);

compiler-rt/test/tsan/java.h

 void __tsan_java_mutex_lock_rec(jptr addr, int rec);
 int  __tsan_java_mutex_unlock_rec(jptr addr);
 int  __tsan_java_acquire(jptr addr);
 int  __tsan_java_release(jptr addr);
 int  __tsan_java_release_store(jptr addr);
 
 void __tsan_read1_pc(jptr addr, jptr pc);
 void __tsan_write1_pc(jptr addr, jptr pc);
+void __tsan_func_entry(jptr pc);
+void __tsan_func_exit();
 }
 
 const jptr kExternalPCBit = 1ULL << 60;

compiler-rt/test/tsan/java_symbolization.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "java.h"
 #include <memory.h>
 
 extern "C" void __tsan_symbolize_external_ex(
     jptr pc, void (*add_frame)(void *, const char *, const char *, int, int),
     void *ctx) {
   if (pc == (1234 | kExternalPCBit)) {
     add_frame(ctx, "MyInnerFunc", "MyInnerFile.java", 1234, 56);
     add_frame(ctx, "MyOuterFunc", "MyOuterFile.java", 4321, 65);
   }
+  if (pc == (2345 | kExternalPCBit)) {
+    add_frame(ctx, "Caller1", "CallerFile.java", 111, 22);
+    add_frame(ctx, "Caller2", "CallerFile.java", 333, 44);
+  }
+  if (pc == (3456 | kExternalPCBit)) {
+    add_frame(ctx, "Allocer1", "Alloc.java", 11, 222);
+    add_frame(ctx, "Allocer2", "Alloc.java", 33, 444);
+  }
 }
 
 void *Thread(void *p) {
   barrier_wait(&barrier);
-  __tsan_write1_pc((jptr)p, 1234 | kExternalPCBit);
+  __tsan_func_entry(2345 | kExternalPCBit);
+  __tsan_write1_pc((jptr)p + 16, 1234 | kExternalPCBit);
+  __tsan_func_exit();
   return 0;
 }
 
+jptr const kHeapSize = 64 * 1024;
+jptr java_heap[kHeapSize];
+
 int main() {
   barrier_init(&barrier, 2);
-  int const kHeapSize = 1024 * 1024;
-  jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
+  jptr jheap = (jptr)java_heap;
   __tsan_java_init(jheap, kHeapSize);
-  const int kBlockSize = 16;
+  const int kBlockSize = 32;
+  __tsan_func_entry(3456 | kExternalPCBit);
   __tsan_java_alloc(jheap, kBlockSize);
+  __tsan_func_exit();
   pthread_t th;
   pthread_create(&th, 0, Thread, (void*)jheap);
-  __tsan_write1_pc((jptr)jheap, 1234 | kExternalPCBit);
+  __tsan_func_entry(2345 | kExternalPCBit);
+  __tsan_write1_pc(jheap + 16, 1234 | kExternalPCBit);
+  __tsan_func_exit();
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(jheap, kBlockSize);
   fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write
+// CHECK:     #0 MyInnerFunc MyInnerFile.java:1234:56
+// CHECK:     #1 MyOuterFunc MyOuterFile.java:4321:65
+// CHECK:     #2 Caller1 CallerFile.java:111:22
+// CHECK:     #3 Caller2 CallerFile.java:333:44
+// CHECK-NOT: #4
+// CHECK:   Previous write
 // CHECK:     #0 MyInnerFunc MyInnerFile.java:1234:56
 // CHECK:     #1 MyOuterFunc MyOuterFile.java:4321:65
+// CHECK:     #2 Caller1 CallerFile.java:111:22
+// CHECK:     #3 Caller2 CallerFile.java:333:44
+// On Linux/glibc #4 is __libc_start_main, but can be something else elsewhere.
+// CHECK:     #4
+// CHECK:   Location is heap block of size 32 at {{.*}} allocated by main thread:
+// CHECK:     #0 __tsan_java_alloc
+// CHECK:     #1 main
+// CHECK:     #2 Allocer1 Alloc.java:11:222
+// CHECK:     #3 Allocer2 Alloc.java:33:444
+// On Linux/glibc #4 is __libc_start_main, but can be something else elsewhere.
+// CHECK:     #4
 // CHECK: DONE