[NFC][Sanitizer] Always use GetStackTrace to fill in stack

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 #define GET_CALLER_PC_BP \
   uptr bp = GET_CURRENT_FRAME();              \
   uptr pc = GET_CALLER_PC();
 
 // Use this macro if you want to print stack trace with the current
 // function in the top frame.
 #define GET_CURRENT_PC_BP_SP \
   uptr bp = GET_CURRENT_FRAME();              \
-  uptr pc = StackTrace::GetCurrentPc();   \
+  uptr pc = StackTrace::GetCurrentPc();       \
   uptr local_stack;                           \
   uptr sp = (uptr)&local_stack
 
+#define GET_CURRENT_PC_BP \
+  uptr bp = GET_CURRENT_FRAME();              \
+  uptr pc = StackTrace::GetCurrentPc();
+
 
 #endif  // SANITIZER_STACKTRACE_H

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cc

if ((prot & (PROT_WRITE | PROT_EXEC)) != (PROT_WRITE | PROT_EXEC))
     return;
 
   ScopedErrorReportLock l;
   SanitizerCommonDecorator d;
 
   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;
+
+  GET_CALLER_PC_BP;
   bool fast = common_flags()->fast_unwind_on_fatal;
-  if (StackTrace::WillUseFastUnwind(fast)) {
-    GetThreadStackTopAndBottom(false, &top, &bottom);
-    stack->Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, true);
-  } else
-    stack->Unwind(kStackTraceMax, pc, 0, nullptr, 0, 0, false);
+  GetStackTrace(stack, kStackTraceMax, pc, bp, nullptr, fast);
 
   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/tsan/rtl/tsan_rtl.cc

for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) {
       }
     }
   }
 }
 
 #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 (StackTrace::WillUseFastUnwind(fast)) {
-    GetThreadStackTopAndBottom(false, &top, &bottom);
-    stack->Unwind(kStackTraceMax, sig.pc, sig.bp, nullptr, top, bottom, true);
-  } else
-    stack->Unwind(kStackTraceMax, sig.pc, 0, sig.context, 0, 0, false);
+  GetStackTrace(stack, kStackTraceMax, sig.pc, sig.bp, sig.context, fast);
 }
 
 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

 // tail-call to PrintCurrentStackSlow breaks this assumption because
 // __sanitizer_print_stack_trace disappears after tail-call.
 // However, this solution is not reliable enough, please see dvyukov's comment
 // http://reviews.llvm.org/D19148#406208
 // Also see PR27280 comment 2 and 3 for breaking examples and analysis.
 ALWAYS_INLINE
 void PrintCurrentStackSlow(uptr pc) {
 #if !SANITIZER_GO
-  uptr bp = 0;
-  uptr top = 0;
-  uptr bottom = 0;
+  uptr bp = GET_CURRENT_FRAME();
   BufferedStackTrace *ptrace =
       new(internal_alloc(MBlockStackTrace, sizeof(BufferedStackTrace)))
           BufferedStackTrace();
-  if (__sanitizer::StackTrace::WillUseFastUnwind(false)) {
-    bp = GET_CURRENT_FRAME();
-    __sanitizer::GetThreadStackTopAndBottom(false, &top, &bottom);
-    ptrace->Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, true);
-  } else
-    ptrace->Unwind(kStackTraceMax, pc, 0, nullptr, 0, 0, false);
+  GetStackTrace(ptrace, kStackTraceMax, pc, bp, nullptr, false);
+
   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_standalone.cc

if (StackTrace::WillUseFastUnwind(fast)) {
     stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
 }
 
 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;
-  GET_CURRENT_PC_BP_SP;
-  (void)sp;
+  GET_CURRENT_PC_BP;
+  bool fast = common_flags()->fast_unwind_on_fatal;
   BufferedStackTrace stack;
-  if (__sanitizer::StackTrace::WillUseFastUnwind(request_fast_unwind)) {
-    __sanitizer::GetThreadStackTopAndBottom(false, &top, &bottom);
-    stack.Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, true);
-  } else {
-    stack.Unwind(kStackTraceMax, pc, 0, nullptr, 0, 0, false);
-  }  
+  GetStackTrace(&stack, kStackTraceMax, pc, bp, nullptr, fast);
   stack.Print();
 }
 } // extern "C"
 
 #endif  // CAN_SANITIZE_UB