tsan: don't print __tsan_atomic* functions in report stacks

[dvyukov]

Summary

Currently tsan_atomic* functions do FuncEntry/Exit using caller PC
and then use current PC (pointing to tsan_atomic* itself) during
memory access handling. As the result the top function in reports
involving atomics is __tsan_atomic* and the next frame points to user code.

Remove FuncEntry/Exit in atomic functions and use caller PC
during memory access handling. This removes __tsan_atomic*
from the top of report stacks, so that they point right to user code.

The motivation for this is performance.
Some atomic operations are very hot (mostly loads),
so removing FuncEntry/Exit is beneficial.
This also reduces thread trace consumption (1 event instead of 3).

tsan_atomic* at the top of the stack is not necessary
and does not add any new information. We already say
"atomic write of size 4", "tsan_atomic32_store" does not add
anything new.

It also makes reports consistent between atomic and non-atomic
accesses. For normal accesses we say "previous write" and point
to user code; for atomics we say "previous atomic write" and now
also point to user code.

[vitalybuka]

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

488

SCOPED part is misleading now.

[dvyukov]

renamed SCOPED_ATOMIC to ATOMIC_IMPL

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

488

renamed SCOPED_ATOMIC to ATOMIC_IMPL
(and removed /**/)

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

static morder convert_morder(morder mo) {
   // HLE is an optimization, and we pretend that elision always fails.
   // MEMMODEL_SYNC is used when lowering __sync_ atomics,
   // since we use __sync_ atomics for actual atomic operations,
   // we can safely ignore it as well. It also subtly affects semantics,
   // but we don't model the difference.
   return (morder)(mo & 0x7fff);
 }
 
-#define SCOPED_ATOMIC(func, ...) \
-    ThreadState *const thr = cur_thread(); \
-    if (UNLIKELY(thr->ignore_sync || thr->ignore_interceptors)) { \
-      ProcessPendingSignals(thr); \
-      return NoTsanAtomic##func(__VA_ARGS__); \
-    } \
-    const uptr callpc = (uptr)__builtin_return_address(0); \
-    uptr pc = StackTrace::GetCurrentPc(); \
-    mo = convert_morder(mo); \
-    ScopedAtomic sa(thr, callpc, a, mo, __func__); \
-    return Atomic##func(thr, pc, __VA_ARGS__); \
+#  define SCOPED_ATOMIC(func, ...)                              \
+    ThreadState *const thr = cur_thread();                      \
+    ProcessPendingSignals(thr);                                 \
+    if (UNLIKELY(thr->ignore_sync || thr->ignore_interceptors)) \
+      return NoTsanAtomic##func(__VA_ARGS__);                   \
+    mo = convert_morder(mo);                                    \
+    return Atomic##func(thr, GET_CALLER_PC(), __VA_ARGS__);     \
     /**/
 
-class ScopedAtomic {
- public:
-  ScopedAtomic(ThreadState *thr, uptr pc, const volatile void *a,
-               morder mo, const char *func)
-      : thr_(thr) {
-    FuncEntry(thr_, pc);
-    DPrintf("#%d: %s(%p, %d)\n", thr_->tid, func, a, mo);
-  }
-  ~ScopedAtomic() {
-    ProcessPendingSignals(thr_);
-    FuncExit(thr_);
-  }
- private:
-  ThreadState *thr_;
-};
-
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 a8 __tsan_atomic8_load(const volatile a8 *a, morder mo) {
   SCOPED_ATOMIC(Load, a, mo);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 a16 __tsan_atomic16_load(const volatile a16 *a, morder mo) {

 a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v,
     morder mo, morder fmo) {
   SCOPED_ATOMIC(CAS, a, c, v, mo, fmo);
 }
 #endif
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_atomic_thread_fence(morder mo) {
-  char* a = 0;
   SCOPED_ATOMIC(Fence, mo);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_atomic_signal_fence(morder mo) {
 }
 }  // extern "C"
 

compiler-rt/test/tsan/atomic_free3.cpp

 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write
 // CHECK:     #0 operator delete
 // CHECK:     #1 main
 
 // CHECK:   Previous atomic write
-// CHECK:     #0 __tsan_atomic32_store
-// CHECK:     #1 Thread
+// CHECK:     #0 Thread

compiler-rt/test/tsan/atomic_stack.cpp

int main() {
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Atomic write of size 4
-// CHECK:     #0 __tsan_atomic32_fetch_add
-// CHECK:     #1 Thread1
+// CHECK:     #0 Thread1