[vm, compiler] Get the full Dart stack in TSAN reports.

Call __tsan_func_entry/__tsan_func_exit in functions that use __tsan_read/__tsan_write or call other functions. Call __tsan_func_exit once per frame when unwinding for exceptions. Do so only in AOT, since TSAN won't be able to symbolize JIT functions anyway.

TEST=ci
Bug: #61352
Cq-Include-Trybots: luci.dart.try:vm-tsan-linux-release-arm64-try,vm-tsan-linux-release-x64-try
Change-Id: Ie52c978c25664d78b834e9b72ecf7eb2a12cc2ba
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/444181
Reviewed-by: Alexander Aprelev <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

runtime/platform/thread_sanitizer.h

@@ -35,6 +35,8 @@ extern "C" void __tsan_write2(void* addr);
 extern "C" void __tsan_write4(void* addr);
 extern "C" void __tsan_write8(void* addr);
 extern "C" void __tsan_write16(void* addr);
+extern "C" void __tsan_func_entry(void* pc);
+extern "C" void __tsan_func_exit();
 #else
 #define NO_SANITIZE_THREAD
 #endif

runtime/tests/vm/dart/tsan/array_data_race_test.dart

@@ -83,6 +83,6 @@ main(List<String> arguments) {
   Expect.notEquals(0, result.exitCode);
   Expect.contains("ThreadSanitizer: data race", result.stderr);
   Expect.contains("of size 8", result.stderr);
-  Expect.contains("List.[]=", result.stderr);
-  Expect.contains("_Array.[]", result.stderr);
+  Expect.contains("dataRaceFromMain", result.stderr);
+  Expect.contains("dataRaceFromChild", result.stderr);
 }

runtime/tests/vm/dart/tsan/field_data_race_test.dart

@@ -40,8 +40,20 @@ dataRaceFromChild() {
   }
 }
 
+@pragma("vm:never-inline")
+dataRaceFromMainCaller() => dataRaceFromMain();
+
+@pragma("vm:never-inline")
+dataRaceFromMainCallerCaller() => dataRaceFromMainCaller();
+
+@pragma("vm:never-inline")
+dataRaceFromChildCaller() => dataRaceFromChild();
+
+@pragma("vm:never-inline")
+dataRaceFromChildCallerCaller() => dataRaceFromChildCaller();
+
 child(_) {
-  dataRaceFromChild();
+  dataRaceFromChildCallerCaller();
 }
 
 final nativeLib = dlopenPlatformSpecific('ffi_test_functions');
@@ -65,7 +77,7 @@ main(List<String> arguments) {
     unsafeSetSharedTo(getRootLibraryUrl(), "box", Box());
     print(box); // side effect initialization
     Isolate.spawn(child, null);
-    dataRaceFromMain();
+    dataRaceFromMainCallerCaller();
     return;
   }
 
@@ -87,5 +99,9 @@ main(List<String> arguments) {
   Expect.contains("ThreadSanitizer: data race", result.stderr);
   Expect.contains("of size 8", result.stderr);
   Expect.contains("dataRaceFromMain", result.stderr);
+  Expect.contains("dataRaceFromMainCaller", result.stderr);
+  Expect.contains("dataRaceFromMainCallerCaller", result.stderr);
   Expect.contains("dataRaceFromChild", result.stderr);
+  Expect.contains("dataRaceFromChildCaller", result.stderr);
+  Expect.contains("dataRaceFromChildCallerCaller", result.stderr);
 }

runtime/vm/compiler/assembler/assembler_arm.cc

@@ -3273,7 +3273,8 @@ void Assembler::EmitEntryFrameVerification(Register scratch) {
 }
 
 void Assembler::CallRuntime(const RuntimeEntry& entry,
-                            intptr_t argument_count) {
+                            intptr_t argument_count,
+                            bool tsan_enter_exit) {
   ASSERT(!entry.is_leaf());
   // Argument count is not checked here, but in the runtime entry for a more
   // informative error message.

runtime/vm/compiler/assembler/assembler_arm.h

@@ -430,6 +430,10 @@ class Assembler : public AssemblerBase {
   void StoreMemoryValue(Register src, Register base, int32_t offset) {
     StoreToOffset(src, base, offset);
   }
+
+  void TsanFuncEntry(bool preserve_registers = true) { UNREACHABLE(); }
+  void TsanFuncExit(bool preserve_registers = true) { UNREACHABLE(); }
+
   void LoadAcquire(Register dst,
                    const Address& address,
                    OperandSize size = kFourBytes) override {
@@ -1464,7 +1468,9 @@ class Assembler : public AssemblerBase {
   void EmitEntryFrameVerification(Register scratch);
 
   // For non-leaf runtime calls. For leaf runtime calls, use LeafRuntimeScope,
-  void CallRuntime(const RuntimeEntry& entry, intptr_t argument_count);
+  void CallRuntime(const RuntimeEntry& entry,
+                   intptr_t argument_count,
+                   bool tsan_enter_exit = true);
 
   // Set up a Dart frame on entry with a frame pointer and PC information to
   // enable easy access to the RawInstruction object of code corresponding

runtime/vm/compiler/assembler/assembler_arm64.cc

@@ -403,6 +403,22 @@ void Assembler::TsanWrite(Register addr, intptr_t size) {
   }
 }
 
+void Assembler::TsanFuncEntry(bool preserve_registers) {
+  Comment("TsanFuncEntry");
+  LeafRuntimeScope rt(this, /*frame_size=*/0, preserve_registers);
+  ldr(R0, Address(FP, target::frame_layout.saved_caller_fp_from_fp *
+                          target::kWordSize));
+  ldr(R0, Address(R0, target::frame_layout.saved_caller_pc_from_fp *
+                          target::kWordSize));
+  rt.Call(kTsanFuncEntryRuntimeEntry, /*argument_count=*/1);
+}
+
+void Assembler::TsanFuncExit(bool preserve_registers) {
+  Comment("TsanFuncExit");
+  LeafRuntimeScope rt(this, /*frame_size=*/0, preserve_registers);
+  rt.Call(kTsanFuncExitRuntimeEntry, /*argument_count=*/0);
+}
+
 static int CountLeadingZeros(uint64_t value, int width) {
   if (width == 64) return Utils::CountLeadingZeros64(value);
   if (width == 32) return Utils::CountLeadingZeros32(value);
@@ -1830,13 +1846,22 @@ void Assembler::VerifyNotInGenerated(Register scratch) {
 }
 
 void Assembler::CallRuntime(const RuntimeEntry& entry,
-                            intptr_t argument_count) {
+                            intptr_t argument_count,
+                            bool tsan_enter_exit) {
   ASSERT(!entry.is_leaf());
   // Argument count is not checked here, but in the runtime entry for a more
   // informative error message.
+  if (FLAG_target_thread_sanitizer && FLAG_precompiled_mode &&
+      tsan_enter_exit) {
+    TsanFuncEntry(/*preserve_registers=*/false);
+  }
   ldr(R5, compiler::Address(THR, entry.OffsetFromThread()));
   LoadImmediate(R4, argument_count);
   Call(Address(THR, target::Thread::call_to_runtime_entry_point_offset()));
+  if (FLAG_target_thread_sanitizer && FLAG_precompiled_mode &&
+      tsan_enter_exit) {
+    TsanFuncExit(/*preserve_registers=*/false);
+  }
 }
 
 // FPU: Only the bottom 64-bits of v8-v15 are preserved by the caller. The upper

runtime/vm/compiler/assembler/assembler_arm64.h

@@ -506,6 +506,8 @@ class Assembler : public AssemblerBase {
   void TsanStoreRelease(Register src, Register addr, OperandSize size);
   void TsanRead(Register addr, intptr_t size);
   void TsanWrite(Register addr, intptr_t size);
+  void TsanFuncEntry(bool preserve_registers = true);
+  void TsanFuncExit(bool preserve_registers = true);
 
   void LoadAcquire(Register dst,
                    const Address& address,
@@ -2141,7 +2143,9 @@ class Assembler : public AssemblerBase {
   void LeaveDartFrame();
 
   // For non-leaf runtime calls. For leaf runtime calls, use LeafRuntimeScope,
-  void CallRuntime(const RuntimeEntry& entry, intptr_t argument_count);
+  void CallRuntime(const RuntimeEntry& entry,
+                   intptr_t argument_count,
+                   bool tsan_enter_exit = true);
 
   // Set up a stub frame so that the stack traversal code can easily identify
   // a stub frame.

runtime/vm/compiler/assembler/assembler_ia32.cc

@@ -2607,7 +2607,8 @@ static const Register volatile_cpu_registers[kNumberOfVolatileCpuRegisters] = {
     EAX, ECX, EDX};
 
 void Assembler::CallRuntime(const RuntimeEntry& entry,
-                            intptr_t argument_count) {
+                            intptr_t argument_count,
+                            bool tsan_enter_exit) {
   ASSERT(!entry.is_leaf());
   // Argument count is not checked here, but in the runtime entry for a more
   // informative error message.

runtime/vm/compiler/assembler/assembler_ia32.h

@@ -668,6 +668,9 @@ class Assembler : public AssemblerBase {
     }
   }
 
+  void TsanFuncEntry(bool preserve_registers = true) { UNREACHABLE(); }
+  void TsanFuncExit(bool preserve_registers = true) { UNREACHABLE(); }
+
   void LoadAcquire(Register dst,
                    const Address& address,
                    OperandSize size = kFourBytes) override {
@@ -906,7 +909,9 @@ class Assembler : public AssemblerBase {
   void ExitFullSafepoint(Register scratch);
 
   // For non-leaf runtime calls. For leaf runtime calls, use LeafRuntimeScope,
-  void CallRuntime(const RuntimeEntry& entry, intptr_t argument_count);
+  void CallRuntime(const RuntimeEntry& entry,
+                   intptr_t argument_count,
+                   bool tsan_enter_exit = true);
 
   void Call(const Code& code,
             bool movable_target = false,

runtime/vm/compiler/assembler/assembler_riscv.cc

@@ -3222,6 +3222,22 @@ void Assembler::TsanWrite(Register addr, intptr_t size) {
   }
 }
 
+void Assembler::TsanFuncEntry(bool preserve_registers) {
+  Comment("TsanFuncEntry");
+  LeafRuntimeScope rt(this, /*frame_size=*/0, preserve_registers);
+  lx(A0, Address(FP, target::frame_layout.saved_caller_fp_from_fp *
+                         target::kWordSize));
+  lx(A0, Address(A0, target::frame_layout.saved_caller_pc_from_fp *
+                         target::kWordSize));
+  rt.Call(kTsanFuncEntryRuntimeEntry, /*argument_count=*/1);
+}
+
+void Assembler::TsanFuncExit(bool preserve_registers) {
+  Comment("TsanFuncExit");
+  LeafRuntimeScope rt(this, /*frame_size=*/0, preserve_registers);
+  rt.Call(kTsanFuncExitRuntimeEntry, /*argument_count=*/0);
+}
+
 void Assembler::LoadAcquire(Register dst,
                             const Address& address,
                             OperandSize size) {
@@ -4854,13 +4870,22 @@ void Assembler::LeaveDartFrame(intptr_t fp_sp_dist) {
 }
 
 void Assembler::CallRuntime(const RuntimeEntry& entry,
-                            intptr_t argument_count) {
+                            intptr_t argument_count,
+                            bool tsan_enter_exit) {
   ASSERT(!entry.is_leaf());
   // Argument count is not checked here, but in the runtime entry for a more
   // informative error message.
+  if (FLAG_target_thread_sanitizer && FLAG_precompiled_mode &&
+      tsan_enter_exit) {
+    TsanFuncEntry(/*preserve_registers=*/false);
+  }
   lx(T5, compiler::Address(THR, entry.OffsetFromThread()));
   li(T4, argument_count);
   Call(Address(THR, target::Thread::call_to_runtime_entry_point_offset()));
+  if (FLAG_target_thread_sanitizer && FLAG_precompiled_mode &&
+      tsan_enter_exit) {
+    TsanFuncExit(/*preserve_registers=*/false);
+  }
 }
 
 static const RegisterSet kRuntimeCallSavedRegisters(kDartVolatileCpuRegs,