tsan: don't use caller/current PC in Java interfaces

[dvyukov]

Summary

Caller PC is plain harmful as native caller PC has nothing to do with Java code.
Current PC is not particularly useful and may be somewhat confusing for Java users
as it makes top frame to point to some magical __tsan function.
But obtaining and using these PCs adds runtime cost for every java event.
Remove these PCs. Rely only on official Java frames.
It makes execution faster, code simpler and reports better.

Depends on D106956.

[vitalybuka]

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

62

why do we have this?

[dvyukov]

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

62

It help to avoid irregularity related to "\" at the end of multi-line macro lines. With "/**/" all lines end with "\", so one can reorder/remove/add lines without introducing build breakages and logical errors.

[vitalybuka]

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

62

Looks unnecessary. That's the case of slight sacrifice of readability to small optimization rare editing.

[dvyukov]

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

62

I've sent https://reviews.llvm.org/D106982 to address this

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

struct JavaContext {
   const uptr heap_size;
 
   JavaContext(jptr heap_begin, jptr heap_size)
       : heap_begin(heap_begin)
       , heap_size(heap_size) {
   }
 };
 
-class ScopedJavaFunc {
- public:
-  ScopedJavaFunc(ThreadState *thr, uptr pc)
-      : thr_(thr) {
-    Initialize(thr_);
-    FuncEntry(thr, pc);
-  }
-
-  ~ScopedJavaFunc() {
-    FuncExit(thr_);
-    // FIXME(dvyukov): process pending signals.
-  }
-
- 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) \
+#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); \
+  (void)thr;                       \
   /**/
 
 void __tsan_java_init(jptr heap_begin, jptr heap_size) {
   SCOPED_JAVA_FUNC(__tsan_java_init);
   DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size);
   CHECK_EQ(jctx, 0);
   CHECK_GT(heap_begin, 0);
   CHECK_GT(heap_size, 0);
   CHECK_EQ(heap_begin % kHeapAlignment, 0);
void __tsan_java_alloc(jptr ptr, jptr size) {
   DPrintf("#%d: java_alloc(%p, %p)\n", thr->tid, ptr, size);
   CHECK_NE(jctx, 0);
   CHECK_NE(size, 0);
   CHECK_EQ(ptr % kHeapAlignment, 0);
   CHECK_EQ(size % kHeapAlignment, 0);
   CHECK_GE(ptr, jctx->heap_begin);
   CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
 
-  OnUserAlloc(thr, pc, ptr, size, false);
+  OnUserAlloc(thr, 0, ptr, size, false);
 }
 
 void __tsan_java_free(jptr ptr, jptr size) {
   SCOPED_JAVA_FUNC(__tsan_java_free);
   DPrintf("#%d: java_free(%p, %p)\n", thr->tid, ptr, size);
   CHECK_NE(jctx, 0);
   CHECK_NE(size, 0);
   CHECK_EQ(ptr % kHeapAlignment, 0);

 
 void __tsan_java_mutex_lock(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_mutex_lock);
   DPrintf("#%d: java_mutex_lock(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  MutexPostLock(thr, pc, addr, MutexFlagLinkerInit | MutexFlagWriteReentrant |
+  MutexPostLock(thr, 0, addr,
+                MutexFlagLinkerInit | MutexFlagWriteReentrant |
                     MutexFlagDoPreLockOnPostLock);
 }
 
 void __tsan_java_mutex_unlock(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock);
   DPrintf("#%d: java_mutex_unlock(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  MutexUnlock(thr, pc, addr);
+  MutexUnlock(thr, 0, addr);
 }
 
 void __tsan_java_mutex_read_lock(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_mutex_read_lock);
   DPrintf("#%d: java_mutex_read_lock(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  MutexPostReadLock(thr, pc, addr, MutexFlagLinkerInit |
-      MutexFlagWriteReentrant | MutexFlagDoPreLockOnPostLock);
+  MutexPostReadLock(thr, 0, addr,
+                    MutexFlagLinkerInit | MutexFlagWriteReentrant |
+                        MutexFlagDoPreLockOnPostLock);
 }
 
 void __tsan_java_mutex_read_unlock(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_mutex_read_unlock);
   DPrintf("#%d: java_mutex_read_unlock(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  MutexReadUnlock(thr, pc, addr);
+  MutexReadUnlock(thr, 0, addr);
 }
 
 void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
   SCOPED_JAVA_FUNC(__tsan_java_mutex_lock_rec);
   DPrintf("#%d: java_mutex_lock_rec(%p, %d)\n", thr->tid, addr, rec);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
   CHECK_GT(rec, 0);
 
-  MutexPostLock(thr, pc, addr, MutexFlagLinkerInit | MutexFlagWriteReentrant |
-      MutexFlagDoPreLockOnPostLock | MutexFlagRecursiveLock, rec);
+  MutexPostLock(thr, 0, addr,
+                MutexFlagLinkerInit | MutexFlagWriteReentrant |
+                    MutexFlagDoPreLockOnPostLock | MutexFlagRecursiveLock,
+                rec);
 }
 
 int __tsan_java_mutex_unlock_rec(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock_rec);
   DPrintf("#%d: java_mutex_unlock_rec(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  return MutexUnlock(thr, pc, addr, MutexFlagRecursiveUnlock);
+  return MutexUnlock(thr, 0, addr, MutexFlagRecursiveUnlock);
 }
 
 void __tsan_java_acquire(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_acquire);
   DPrintf("#%d: java_acquire(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  Acquire(thr, caller_pc, addr);
+  Acquire(thr, 0, addr);
 }
 
 void __tsan_java_release(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_release);
   DPrintf("#%d: java_release(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  Release(thr, caller_pc, addr);
+  Release(thr, 0, addr);
 }
 
 void __tsan_java_release_store(jptr addr) {
   SCOPED_JAVA_FUNC(__tsan_java_release);
   DPrintf("#%d: java_release_store(%p)\n", thr->tid, addr);
   CHECK_NE(jctx, 0);
   CHECK_GE(addr, jctx->heap_begin);
   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
 
-  ReleaseStore(thr, caller_pc, addr);
+  ReleaseStore(thr, 0, addr);
 }

compiler-rt/test/tsan/java_symbolization.cpp

 // 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:     #0 Allocer1 Alloc.java:11:222
+// CHECK:     #1 Allocer2 Alloc.java:33:444
+// On Linux/glibc #2 is __libc_start_main, but can be something else elsewhere.
+// CHECK:     #2
 // CHECK: DONE