tsan: move shadow stack into ThreadState

[dvyukov]

Summary

Currently the shadow stack is located in the trace memory mapping.
The new tsan runtime will remove the trace memory mapping.
Move the shadow stack into ThreadState as a preparation step.

[nemanjai]

Either this patch or https://reviews.llvm.org/D110520 has broken almost all the PPC bots. Please revert and let us know how we can help you figure out what needs to be done to investigate/fix this on the PPC bots.

Bot failures:
https://lab.llvm.org/buildbot/#/builders/52/builds/10854
https://lab.llvm.org/buildbot/#/builders/100/builds/9308
https://lab.llvm.org/buildbot/#/builders/93/builds/5134
https://lab.llvm.org/buildbot/#/builders/76/builds/4004
https://lab.llvm.org/buildbot/#/builders/105/builds/15435
https://lab.llvm.org/buildbot/#/builders/121/builds/11854

[dvyukov]

In the failure logs I see:

92: ThreadSanitizer: CHECK failed: tsan_rtl.cpp:148 "((reinterpret_cast<uptr>(this) % 128)) == ((0))" (0x40, 0x0) (tid=90937)

So I think it's https://reviews.llvm.org/D110520 , I've sent https://reviews.llvm.org/D110629 that will hopefully fix the failures.
Thanks for reporting

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

struct ThreadState {
   int ignore_reads_and_writes;
   atomic_sint32_t pending_signals;
   int ignore_sync;
   int suppress_reports;
   // Go does not support ignores.
 #if !SANITIZER_GO
   IgnoreSet mop_ignore_set;
   IgnoreSet sync_ignore_set;
-#endif
-  // C/C++ uses fixed size shadow stack embed into Trace.
+  // C/C++ uses fixed size shadow stack.
+  uptr shadow_stack[kShadowStackSize];
+#else
   // Go uses malloc-allocated shadow stack with dynamic size.
   uptr *shadow_stack;
+#endif
   uptr *shadow_stack_end;
   uptr *shadow_stack_pos;
   RawShadow *racy_shadow_addr;
   RawShadow racy_state[2];
   MutexSet mset;
   ThreadClock clock;
 #if !SANITIZER_GO
   Vector<JmpBuf> jmp_bufs;

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

#endif
       stk_size(stk_size),
       tls_addr(tls_addr),
       tls_size(tls_size)
 #if !SANITIZER_GO
       ,
       last_sleep_clock(tid)
 #endif
 {
+#if !SANITIZER_GO
+  shadow_stack_pos = shadow_stack;
+  shadow_stack_end = shadow_stack + kShadowStackSize;
+#else
+  // Setup dynamic shadow stack.
+  const int kInitStackSize = 8;
+  shadow_stack = (uptr *)Alloc(kInitStackSize * sizeof(uptr));
+  shadow_stack_pos = shadow_stack;
+  shadow_stack_end = shadow_stack + kInitStackSize;
+#endif
 }
 
 #if !SANITIZER_GO
 void MemoryProfiler(u64 uptime) {
   if (ctx->memprof_fd == kInvalidFd)
     return;
   InternalMmapVector<char> buf(4096);
   WriteMemoryProfile(buf.data(), buf.size(), uptime);

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

void ThreadContext::OnStarted(void *arg) {
   thr = args->thr;
   // RoundUp so that one trace part does not contain events
   // from different threads.
   epoch0 = RoundUp(epoch1 + 1, kTracePartSize);
   epoch1 = (u64)-1;
   new (thr)
       ThreadState(ctx, tid, unique_id, epoch0, reuse_count, args->stk_addr,
                   args->stk_size, args->tls_addr, args->tls_size);
-#if !SANITIZER_GO
-  thr->shadow_stack = &ThreadTrace(thr->tid)->shadow_stack[0];
-  thr->shadow_stack_pos = thr->shadow_stack;
-  thr->shadow_stack_end = thr->shadow_stack + kShadowStackSize;
-#else
-  // Setup dynamic shadow stack.
-  const int kInitStackSize = 8;
-  thr->shadow_stack = (uptr *)Alloc(kInitStackSize * sizeof(uptr));
-  thr->shadow_stack_pos = thr->shadow_stack;
-  thr->shadow_stack_end = thr->shadow_stack + kInitStackSize;
-#endif
   if (common_flags()->detect_deadlocks)
     thr->dd_lt = ctx->dd->CreateLogicalThread(unique_id);
   thr->fast_state.SetHistorySize(flags()->history_size);
   // Commit switch to the new part of the trace.
   // TraceAddEvent will reset stack0/mset0 in the new part for us.
   TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
 
   thr->fast_synch_epoch = epoch0;

compiler-rt/lib/tsan/tests/unit/tsan_stack_test.cpp

 //===-- tsan_stack_test.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 //===----------------------------------------------------------------------===//
 #include "tsan_sync.h"
 #include "tsan_rtl.h"
 #include "gtest/gtest.h"
 #include <string.h>
 
 namespace __tsan {
 
 template <typename StackTraceTy>
 static void TestStackTrace(StackTraceTy *trace) {
   ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0, 0);
-  uptr stack[128];
-  thr.shadow_stack = &stack[0];
-  thr.shadow_stack_pos = &stack[0];
-  thr.shadow_stack_end = &stack[128];
 
   ObtainCurrentStack(&thr, 0, trace);
   EXPECT_EQ(0U, trace->size);
 
   ObtainCurrentStack(&thr, 42, trace);
   EXPECT_EQ(1U, trace->size);
   EXPECT_EQ(42U, trace->trace[0]);
 
static void TestStackTrace(StackTraceTy *trace) {
   EXPECT_EQ(100U, trace->trace[0]);
   EXPECT_EQ(101U, trace->trace[1]);
   EXPECT_EQ(42U, trace->trace[2]);
 }
 
 template<typename StackTraceTy>
 static void TestTrim(StackTraceTy *trace) {
   ThreadState thr(0, 0, 0, 0, 0, 0, 0, 0, 0);
-  const uptr kShadowStackSize = 2 * kStackTraceMax;
-  uptr stack[kShadowStackSize];
-  thr.shadow_stack = &stack[0];
-  thr.shadow_stack_pos = &stack[0];
-  thr.shadow_stack_end = &stack[kShadowStackSize];
 
-  for (uptr i = 0; i < kShadowStackSize; ++i)
+  for (uptr i = 0; i < 2 * kStackTraceMax; ++i)
     *thr.shadow_stack_pos++ = 100 + i;
 
   ObtainCurrentStack(&thr, 0, trace);
   EXPECT_EQ(kStackTraceMax, trace->size);
   for (uptr i = 0; i < kStackTraceMax; i++) {
     EXPECT_EQ(100 + kStackTraceMax + i, trace->trace[i]);
   }