[Sanitizer] Rework BufferedStackTrace::Unwind (part 1)

[yln]

Summary

In a previous revision (https://reviews.llvm.org/D58156) I fixed a few
failing tests on Darwin involving stack printing.

The underlying issue has to do with stack unwinding. We have the notion
of a slow and a fast unwinder. Linux has both, on Darwin only the fast
unwinder is available.

Considering this, the current API is hard to use correctly.

BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
                           uptr stack_top, uptr stack_bottom,
                           bool request_fast_unwind)

The only thing the slow unwinder needs to work is pc. It can also take
an optional context. The fast unwinder additionally requires
bp,stack_top, stack_bottom. The context is not applicable to the
fast unwinder.

The semantics of request_fast_unwind is really only a "request" to use
the fast unwinder. On platforms that only support one kind of unwinder
it is essentially ignored.

This means that code like below doesn't work on Darwin.

bool fast = common_flags()->fast_unwind_on_fatal;
if (fast)
  GetThreadStackTopAndBottom(..., &top, &bottom);

stack.Unwind(..., top, bottom, fast);
// May use fast unwinder, but top and bottom haven't been provided.

// Even the following is broken
stack.Unwind(..., 0, 0, false);

The function StackTrace::WillUseFastUnwind was introduced to remedy
this. In my last patch, I applied it some places that caused test
failures. This patch adds a few more calls.

However, ultimately BufferedStackTrace::Unwind is not a good API. (I
guess it just grew more complex over time.) It tries to hide which
unwinder is used, but to use it correctly the caller needs to be aware
which unwinder is going to be used. Its set of parameters is the union
of required arguments of both unwinders.

This patch removes Unwind and directly calls the fast or slow unwind
functions. This change (part 1) is purely mechanical. In a follow-up I
want to try to cleanup the call sites. Maybe it is possible to hide most
of the details behind yet another macro.

rdar://problem/48177534

[yln]

ninja check-sanitizer passes on my Mac and Linux VM (Ubuntu 18). I would appreciate if someone can test this on their Windows machine!

[vitalybuka]

compiler-rt/lib/ubsan/ubsan_diag_standalone.cc

25

Would be nice to have separate NFC patch for stuff like removing _sanitizer::

31

Could you also make another NFC patch for:
Unwind(... bool) -> FastUnwind/SlowUnwind

34

SlowUnwindStack -> just SlowUnwind
Word Stack is redundant there at it's a member of the StackTrace

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

61

Another patch is here...
Please extract tiny patches for whatever the rest of the patch irrelevant.

[yln]

As requested, I will split this up into smaller patches.
First one is here: https://reviews.llvm.org/D58550

compiler-rt/lib/asan/asan_stack.h

 
 // Get the stack trace with the given pc and bp.
 // The pc will be in the position 0 of the resulting stack trace.
 // The bp may refer to the current frame or to the caller's frame.
 ALWAYS_INLINE
 void GetStackTrace(BufferedStackTrace *stack, uptr max_depth, uptr pc, uptr bp,
                    void *context, bool fast) {
 #if SANITIZER_WINDOWS
-  stack->Unwind(max_depth, pc, bp, context, 0, 0, fast);
+  stack->SlowUnwindStack(pc, max_depth);
 #else
   AsanThread *t;
   stack->size = 0;
   if (LIKELY(asan_inited)) {
     if ((t = GetCurrentThread()) && !t->isUnwinding()) {
       uptr stack_top = t->stack_top();
       uptr stack_bottom = t->stack_bottom();
       ScopedUnwinding unwind_scope(t);
       if (!SANITIZER_MIPS || IsValidFrame(bp, stack_top, stack_bottom)) {
-        stack->Unwind(max_depth, pc, bp, context, stack_top, stack_bottom,
-                      fast);
+        if (StackTrace::WillUseFastUnwind(fast) && stack_top != 0)
+          stack->FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
+        else
+          stack->SlowUnwindStack(pc, max_depth);
       }
     } else if (!t && !fast) {
       /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
-      stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
+      stack->SlowUnwindStack(pc, max_depth);
     }
   }
 #endif // SANITIZER_WINDOWS
 }
 
 } // namespace __asan
 
 // NOTE: A Rule of thumb is to retrieve stack trace in the interceptors
GetStackTrace(&stack, max_size, StackTrace::GetCurrentPc(),  \
                   GET_CURRENT_FRAME(), 0, fast);                 \
   }
 
 #define GET_STACK_TRACE_FATAL(pc, bp)              \
   BufferedStackTrace stack;                        \
   GetStackTrace(&stack, kStackTraceMax, pc, bp, 0, \
                 common_flags()->fast_unwind_on_fatal)
 
-#define GET_STACK_TRACE_SIGNAL(sig)                                        \
-  BufferedStackTrace stack;                                                \
-  GetStackTrace(&stack, kStackTraceMax, (sig).pc, (sig).bp, (sig).context, \
-                common_flags()->fast_unwind_on_fatal)
-
 #define GET_STACK_TRACE_FATAL_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_CHECK_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_check)
 
 #define GET_STACK_TRACE_THREAD                                    \
   GET_STACK_TRACE(kStackTraceMax, true)

compiler-rt/lib/hwasan/hwasan.cc

void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
   if (!t) {
     // the thread is still being created.
     stack->size = 0;
     return;
   }
   if (!StackTrace::WillUseFastUnwind(request_fast_unwind)) {
     // Block reports from our interceptors during _Unwind_Backtrace.
     SymbolizerScope sym_scope;
-    return stack->Unwind(max_s, pc, bp, context, 0, 0, request_fast_unwind);
+    return stack->SlowUnwindStack(pc, context, max_s);
   }
-  stack->Unwind(max_s, pc, bp, context, t->stack_top(), t->stack_bottom(),
-                request_fast_unwind);
+  stack->FastUnwindStack(pc, bp, t->stack_top(), t->stack_bottom(), max_s);
 }
 
 static void HWAsanCheckFailed(const char *file, int line, const char *cond,
                               u64 v1, u64 v2) {
   Report("HWAddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
          line, cond, (uptr)v1, (uptr)v2);
   PRINT_CURRENT_STACK_CHECK();
   Die();

compiler-rt/lib/lsan/lsan.h

void GetStackTrace(__sanitizer::BufferedStackTrace *stack,
   uptr stack_top = 0, stack_bottom = 0;
   ThreadContext *t;
   if (__sanitizer::StackTrace::WillUseFastUnwind(fast) &&
       (t = CurrentThreadContext())) {
     stack_top = t->stack_end();
     stack_bottom = t->stack_begin();
   }
   if (!SANITIZER_MIPS || IsValidFrame(bp, stack_top, stack_bottom)) {
-    stack->Unwind(max_depth, pc, bp, context, stack_top, stack_bottom, fast);
+    if (StackTrace::WillUseFastUnwind(fast) && stack_top != 0)
+      stack->FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
+    else
+      stack->SlowUnwindStack(pc, context, max_depth);
   }
 }
 
 }  // namespace __lsan
 
 extern bool lsan_inited;
 extern bool lsan_init_is_running;
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __lsan_init();

compiler-rt/lib/msan/msan.cc

 }
 
 void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
                    void *context, bool request_fast_unwind) {
   MsanThread *t = GetCurrentThread();
   if (!t || !StackTrace::WillUseFastUnwind(request_fast_unwind)) {
     // Block reports from our interceptors during _Unwind_Backtrace.
     SymbolizerScope sym_scope;
-    return stack->Unwind(max_s, pc, bp, context, 0, 0, request_fast_unwind);
+    return stack->SlowUnwindStack(pc, max_s);
   }
-  stack->Unwind(max_s, pc, bp, context, t->stack_top(), t->stack_bottom(),
-                request_fast_unwind);
+  stack->FastUnwindStack(pc, bp, t->stack_top(), t->stack_bottom(), max_s);
 }
 
 void PrintWarning(uptr pc, uptr bp) {
   PrintWarningWithOrigin(pc, bp, __msan_origin_tls);
 }
 
 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin) {
   if (msan_expect_umr) {

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

struct StackTrace {
   StackTrace(const uptr *trace, u32 size) : trace(trace), size(size), tag(0) {}
   StackTrace(const uptr *trace, u32 size, u32 tag)
       : trace(trace), size(size), tag(tag) {}
 
   // Prints a symbolized stacktrace, followed by an empty line.
   void Print() const;
 
   static bool WillUseFastUnwind(bool request_fast_unwind) {
+    static_assert(SANITIZER_CAN_FAST_UNWIND || SANITIZER_CAN_SLOW_UNWIND,
+                  "Neither fast nor slow unwinder is supported");
     if (!SANITIZER_CAN_FAST_UNWIND)
       return false;
-    else if (!SANITIZER_CAN_SLOW_UNWIND)
+    if (!SANITIZER_CAN_SLOW_UNWIND)
       return true;
     return request_fast_unwind;
   }
 
   static uptr GetCurrentPc();
   static inline uptr GetPreviousInstructionPc(uptr pc);
   static uptr GetNextInstructionPc(uptr pc);
   typedef bool (*SymbolizeCallback)(const void *pc, char *out_buffer,

 // StackTrace that owns the buffer used to store the addresses.
 struct BufferedStackTrace : public StackTrace {
   uptr trace_buffer[kStackTraceMax];
   uptr top_frame_bp;  // Optional bp of a top frame.
 
   BufferedStackTrace() : StackTrace(trace_buffer, 0), top_frame_bp(0) {}
 
   void Init(const uptr *pcs, uptr cnt, uptr extra_top_pc = 0);
-  void Unwind(u32 max_depth, uptr pc, uptr bp, void *context, uptr stack_top,
-              uptr stack_bottom, bool request_fast_unwind);
+
+  void FastUnwindStack(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom,
+                       u32 max_depth);
+  void SlowUnwindStack(uptr pc, void *context, u32 max_depth) {
+    CHECK_GE(max_depth, 2);
+    if (context)
+      SlowUnwindStackWithContext(pc, context, max_depth);
+    else
+      SlowUnwindStack(pc, max_depth);
+  }
+
+  void SlowUnwindStack(uptr pc, u32 max_depth);
+  void SlowUnwindStackWithContext(uptr pc, void *context, u32 max_depth);
 
   void Reset() {
     *static_cast<StackTrace *>(this) = StackTrace(trace_buffer, 0);
     top_frame_bp = 0;
   }
 
  private:
-  void FastUnwindStack(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom,
-                       u32 max_depth);
-  void SlowUnwindStack(uptr pc, u32 max_depth);
-  void SlowUnwindStackWithContext(uptr pc, void *context,
-                                  u32 max_depth);
   void PopStackFrames(uptr count);
   uptr LocatePcInTrace(uptr pc);
 
   BufferedStackTrace(const BufferedStackTrace &) = delete;
   void operator=(const BufferedStackTrace &) = delete;
 };
 
 // Check if given pointer points into allocated stack area.

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cc

void BufferedStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
   size = cnt + !!extra_top_pc;
   CHECK_LE(size, kStackTraceMax);
   internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
   if (extra_top_pc)
     trace_buffer[cnt] = extra_top_pc;
   top_frame_bp = 0;
 }
 
+// TODO(yln): Remove and replace call sites with macro (#ifdef).
+// Temporarily define symbols so we can link on all platforms/architectures.
+#if !SANITIZER_CAN_SLOW_UNWIND
+void BufferedStackTrace::SlowUnwindStack(uptr, u32) {
+  UNIMPLEMENTED();
+}
+void BufferedStackTrace::SlowUnwindStackWithContext(uptr, void *, u32) {
+  UNIMPLEMENTED();
+}
+#endif
+
 // Sparc implemention is in its own file.
 #if !defined(__sparc__)
 
 // In GCC on ARM bp points to saved lr, not fp, so we should check the next
 // cell in stack to be a saved frame pointer. GetCanonicFrame returns the
 // pointer to saved frame pointer in any case.
 static inline uhwptr *GetCanonicFrame(uptr bp,
                                       uptr stack_top,
                                       uptr stack_bottom) {
-  CHECK_GT(stack_top, stack_bottom);
 #ifdef __arm__
   if (!IsValidFrame(bp, stack_top, stack_bottom)) return 0;
   uhwptr *bp_prev = (uhwptr *)bp;
   if (IsValidFrame((uptr)bp_prev[0], stack_top, stack_bottom)) return bp_prev;
   // The next frame pointer does not look right. This could be a GCC frame, step
   // back by 1 word and try again.
   if (IsValidFrame((uptr)bp_prev[-1], stack_top, stack_bottom))
     return bp_prev - 1;
   // Nope, this does not look right either. This means the frame after next does
   // not have a valid frame pointer, but we can still extract the caller PC.
   // Unfortunately, there is no way to decide between GCC and LLVM frame
   // layouts. Assume LLVM.
   return bp_prev;
 #else
   return (uhwptr*)bp;
 #endif
 }
 
 void BufferedStackTrace::FastUnwindStack(uptr pc, uptr bp, uptr stack_top,
                                          uptr stack_bottom, u32 max_depth) {
-  const uptr kPageSize = GetPageSizeCached();
+  CHECK_NE(stack_bottom, 0);
+  CHECK_GT(stack_top, stack_bottom);
   CHECK_GE(max_depth, 2);
+  const uptr kPageSize = GetPageSizeCached();
   trace_buffer[0] = pc;
   size = 1;
   if (stack_top < 4096) return;  // Sanity check for stack top.
   uhwptr *frame = GetCanonicFrame(bp, stack_top, stack_bottom);
   // Lowest possible address that makes sense as the next frame pointer.
   // Goes up as we walk the stack.
   uptr bottom = stack_bottom;
   // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

for (uptr i = 0; i < size && trace[i]; i++) {
     frames->ClearAll();
   }
   // Always print a trailing empty line after stack trace.
   Printf("\n");
   if (dedup_token.length())
     Printf("DEDUP_TOKEN: %s\n", dedup_token.data());
 }
 
-void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
-                                uptr stack_top, uptr stack_bottom,
-                                bool request_fast_unwind) {
-  top_frame_bp = (max_depth > 0) ? bp : 0;
-  // Avoid doing any work for small max_depth.
-  if (max_depth == 0) {
-    size = 0;
-    return;
-  }
-  if (max_depth == 1) {
-    size = 1;
-    trace_buffer[0] = pc;
-    return;
-  }
-  if (!WillUseFastUnwind(request_fast_unwind)) {
-#if SANITIZER_CAN_SLOW_UNWIND
-    if (context)
-      SlowUnwindStackWithContext(pc, context, max_depth);
-    else
-      SlowUnwindStack(pc, max_depth);
-#else
-    UNREACHABLE("slow unwind requested but not available");
-#endif
-  } else {
-    FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
-  }
-}
-
 static int GetModuleAndOffsetForPc(uptr pc, char *module_name,
                                    uptr module_name_len, uptr *pc_offset) {
   const char *found_module_name = nullptr;
   bool ok = Symbolizer::GetOrInit()->GetModuleNameAndOffsetForPC(
       pc, &found_module_name, pc_offset);
 
   if (!ok) return false;
 

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_sparc.cc

 
 #include "sanitizer_common.h"
 #include "sanitizer_stacktrace.h"
 
 namespace __sanitizer {
 
 void BufferedStackTrace::FastUnwindStack(uptr pc, uptr bp, uptr stack_top,
                                          uptr stack_bottom, u32 max_depth) {
-  const uptr kPageSize = GetPageSizeCached();
+  CHECK_NE(stack_bottom, 0);
+  CHECK_GT(stack_top, stack_bottom);
   CHECK_GE(max_depth, 2);
+  const uptr kPageSize = GetPageSizeCached();
   trace_buffer[0] = pc;
   size = 1;
   if (stack_top < 4096) return;  // Sanity check for stack top.
   // Flush register windows to memory
   asm volatile("ta 3" ::: "memory");
   uhwptr *frame = (uhwptr*)bp;
   // Lowest possible address that makes sense as the next frame pointer.
   // Goes up as we walk the stack.

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cc

void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
   // unless there is only 1 frame in the stack trace (1 frame is always better
   // than 0!).
   PopStackFrames(Min(to_pop, static_cast<uptr>(1)));
   trace_buffer[0] = pc;
 }
 
 void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
                                                     u32 max_depth) {
-  CHECK_NE(context, nullptr);
+  CHECK(context);
+  CHECK_GE(max_depth, 2);
   UNREACHABLE("signal context doesn't exist");
 }
 #endif  // SANITIZER_CAN_SLOW_UNWIND
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SYMBOLIZER_MARKUP

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cc

#if SANITIZER_POSIX && (!SANITIZER_GO && !SANITIZER_ANDROID)
   InternalMmapVector<BufferedStackTrace> stack_buffer(1);
   BufferedStackTrace *stack = stack_buffer.data();
   stack->Reset();
   uptr top = 0;
   uptr bottom = 0;
   GET_CALLER_PC_BP_SP;
   (void)sp;
   bool fast = common_flags()->fast_unwind_on_fatal;
-  if (fast)
+  if (StackTrace::WillUseFastUnwind(fast))
     GetThreadStackTopAndBottom(false, &top, &bottom);
-  stack->Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, fast);
+  if (StackTrace::WillUseFastUnwind(fast))
+    stack->FastUnwindStack(pc, bp, top, bottom, kStackTraceMax);
+  else
+    stack->SlowUnwindStack(pc, kStackTraceMax);
 
   Printf("%s", d.Warning());
   Report("WARNING: %s: writable-executable page usage\n", SanitizerToolName);
   Printf("%s", d.Default());
 
   stack->Print();
   ReportErrorSummary("w-and-x-usage", stack);
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
   if (to_pop == 0 && size > 1)
     to_pop = 1;
   PopStackFrames(to_pop);
   trace_buffer[0] = pc;
 }
 
 void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
                                                     u32 max_depth) {
+  CHECK(context);
   CHECK_GE(max_depth, 2);
   if (!unwind_backtrace_signal_arch) {
     SlowUnwindStack(pc, max_depth);
     return;
   }
 
   void *map = acquire_my_map_info_list();
   CHECK(map);

compiler-rt/lib/sanitizer_common/sanitizer_unwind_win.cc

void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
 
   // Skip the RTL frames by searching for the PC in the stacktrace.
   uptr pc_location = LocatePcInTrace(pc);
   PopStackFrames(pc_location);
 }
 
 void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
   u32 max_depth) {
+  CHECK(context);
+  CHECK_GE(max_depth, 2);
   CONTEXT ctx = *(CONTEXT *)context;
   STACKFRAME64 stack_frame;
   memset(&stack_frame, 0, sizeof(stack_frame));
 
   InitializeDbgHelpIfNeeded();
 
   size = 0;
 #if defined(_WIN64)

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cc

 
 class FastUnwindTest : public ::testing::Test {
  protected:
   virtual void SetUp();
   virtual void TearDown();
   bool TryFastUnwind(uptr max_depth) {
     if (!StackTrace::WillUseFastUnwind(true))
       return false;
-    trace.Unwind(max_depth, start_pc, (uptr)&fake_stack[0], 0, fake_top,
-                 fake_bottom, true);
+    trace.FastUnwindStack(start_pc, (uptr)&fake_stack[0], fake_top,
+                 fake_bottom, max_depth);
     return true;
   }
 
   void *mapping;
   uhwptr *fake_stack;
   const uptr fake_stack_size = 10;
   uhwptr start_pc;
   uhwptr fake_top;
TEST_F(FastUnwindTest, MisalignedFramePointer) {
   // Should get all on-stack retaddrs up to the 4th slot and start_pc.
   EXPECT_EQ(4U, trace.size);
   EXPECT_EQ(start_pc, trace.trace[0]);
   for (uptr i = 1; i < 4U; i++) {
     EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
   }
 }
 
-TEST_F(FastUnwindTest, OneFrameStackTrace) {
-  if (!TryFastUnwind(1))
-    return;
-  EXPECT_EQ(1U, trace.size);
-  EXPECT_EQ(start_pc, trace.trace[0]);
-  EXPECT_EQ((uhwptr)&fake_stack[0], trace.top_frame_bp);
-}
-
-TEST_F(FastUnwindTest, ZeroFramesStackTrace) {
-  if (!TryFastUnwind(0))
-    return;
-  EXPECT_EQ(0U, trace.size);
-  EXPECT_EQ(0U, trace.top_frame_bp);
-}
-
 TEST_F(FastUnwindTest, FPBelowPrevFP) {
   // The next FP points to unreadable memory inside the stack limits, but below
   // current FP.
   fake_stack[0] = (uhwptr)&fake_stack[-50];
   fake_stack[1] = PC(1);
   if (!TryFastUnwind(3))
     return;
   EXPECT_EQ(2U, trace.size);
TEST_F(FastUnwindTest, CloseToZeroFrame) {
   // The stack should be truncated at the NULL pointer (and not include it).
   EXPECT_EQ(3U, trace.size);
   EXPECT_EQ(start_pc, trace.trace[0]);
   for (uptr i = 1; i < 3U; i++) {
     EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
   }
 }
 
-TEST(SlowUnwindTest, ShortStackTrace) {
-  if (StackTrace::WillUseFastUnwind(false))
-    return;
-  BufferedStackTrace stack;
-  uptr pc = StackTrace::GetCurrentPc();
-  uptr bp = GET_CURRENT_FRAME();
-  stack.Unwind(0, pc, bp, 0, 0, 0, false);
-  EXPECT_EQ(0U, stack.size);
-  EXPECT_EQ(0U, stack.top_frame_bp);
-  stack.Unwind(1, pc, bp, 0, 0, 0, false);
-  EXPECT_EQ(1U, stack.size);
-  EXPECT_EQ(pc, stack.trace[0]);
-  EXPECT_EQ(bp, stack.top_frame_bp);
-}
-
 }  // namespace __sanitizer

compiler-rt/lib/tsan/dd/dd_rtl.cc

 
 namespace __dsan {
 
 static Context *ctx;
 
 static u32 CurrentStackTrace(Thread *thr, uptr skip) {
   BufferedStackTrace stack;
   thr->ignore_interceptors = true;
-  stack.Unwind(1000, 0, 0, 0, 0, 0, false);
+  stack.SlowUnwindStack(0, 1000);
   thr->ignore_interceptors = false;
   if (stack.size <= skip)
     return 0;
   return StackDepotPut(StackTrace(stack.trace + skip, stack.size - skip));
 }
 
 static void PrintStackTrace(Thread *thr, u32 stk) {
   StackTrace stack = StackDepotGet(stk);

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

 }
 
 #if !SANITIZER_GO
 static void OnStackUnwind(const SignalContext &sig, const void *,
                           BufferedStackTrace *stack) {
   uptr top = 0;
   uptr bottom = 0;
   bool fast = common_flags()->fast_unwind_on_fatal;
-  if (fast) GetThreadStackTopAndBottom(false, &top, &bottom);
-  stack->Unwind(kStackTraceMax, sig.pc, sig.bp, sig.context, top, bottom, fast);
+  if (StackTrace::WillUseFastUnwind(fast))
+    GetThreadStackTopAndBottom(false, &top, &bottom);
+  if (StackTrace::WillUseFastUnwind(fast))
+    stack->FastUnwindStack(sig.pc, sig.bp, top, bottom, kStackTraceMax);
+  else
+    stack->SlowUnwindStack(sig.pc, sig.context, kStackTraceMax);
 }
 
 static void TsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   HandleDeadlySignal(siginfo, context, GetTid(), &OnStackUnwind, nullptr);
 }
 #endif
 
 void Initialize(ThreadState *thr) {

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

#if !SANITIZER_GO
   uptr bottom = 0;
   if (__sanitizer::StackTrace::WillUseFastUnwind(false)) {
     bp = GET_CURRENT_FRAME();
     __sanitizer::GetThreadStackTopAndBottom(false, &top, &bottom);
   }
   BufferedStackTrace *ptrace =
       new(internal_alloc(MBlockStackTrace, sizeof(BufferedStackTrace)))
           BufferedStackTrace();
-  ptrace->Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, false);
+  if (StackTrace::WillUseFastUnwind(false))
+    ptrace->FastUnwindStack(pc, bp, top, bottom, kStackTraceMax);
+  else
+    ptrace->SlowUnwindStack(pc, kStackTraceMax);
   for (uptr i = 0; i < ptrace->size / 2; i++) {
     uptr tmp = ptrace->trace_buffer[i];
     ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1];
     ptrace->trace_buffer[ptrace->size - i - 1] = tmp;
   }
   PrintStack(SymbolizeStack(*ptrace));
 #endif
 }

compiler-rt/lib/ubsan/ubsan_diag.cc

 #include <stdio.h>
 
 using namespace __ubsan;
 
 void __ubsan::GetStackTrace(BufferedStackTrace *stack, uptr max_depth, uptr pc,
                             uptr bp, void *context, bool fast) {
   uptr top = 0;
   uptr bottom = 0;
-  if (fast)
+  if (StackTrace::WillUseFastUnwind(fast))
     GetThreadStackTopAndBottom(false, &top, &bottom);
-  stack->Unwind(max_depth, pc, bp, context, top, bottom, fast);
+  if (StackTrace::WillUseFastUnwind(fast))
+    stack->FastUnwindStack(pc, bp, top, bottom, max_depth);
+  else
+    stack->SlowUnwindStack(pc, context, max_depth);
 }
 
 static void MaybePrintStackTrace(uptr pc, uptr bp) {
   // We assume that flags are already parsed, as UBSan runtime
   // will definitely be called when we print the first diagnostics message.
   if (!flags()->print_stacktrace)
     return;
 

compiler-rt/lib/ubsan/ubsan_diag_standalone.cc

 using namespace __ubsan;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   uptr top = 0;
   uptr bottom = 0;
   bool request_fast_unwind = common_flags()->fast_unwind_on_fatal;
-  if (__sanitizer::StackTrace::WillUseFastUnwind(request_fast_unwind))
-    __sanitizer::GetThreadStackTopAndBottom(false, &top, &bottom);
+  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
+    GetThreadStackTopAndBottom(false, &top, &bottom);
 
   GET_CURRENT_PC_BP_SP;
   (void)sp;
   BufferedStackTrace stack;
-  stack.Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom,
-               request_fast_unwind);
+  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
+    stack.FastUnwindStack(pc, bp, top, bottom, kStackTraceMax);
+  else
+    stack.SlowUnwindStack(pc, kStackTraceMax);
   stack.Print();
 }
 } // extern "C"
 
 #endif  // CAN_SANITIZE_UB

compiler-rt/test/sanitizer_common/TestCases/Posix/dedup_token_length_test.cc

 // Test dedup_token_length
 // RUN: %clangxx -O0 %s -o %t
 // RUN: env %tool_options='abort_on_error=0'                       not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK0 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=0' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK0 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=1' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK1 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=2' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK2 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=3' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK3 --match-full-lines
 
 // REQUIRES: stable-runtime
 
 // XFAIL: netbsd && !asan
 
-// FIXME(dliew): Make this test work with other sanitizers
-// XFAIL: darwin && (tsan || ubsan)
+// FIXME(dliew): Make this test work with TSan
+// XFAIL: darwin && tsan
 
 volatile int *null = 0;
 
 namespace Xyz {
   template<class A, class B> void Abc() {
     *null = 0;
   }
 }