[NFC][Sanitizer] Rename BufferedStackTrace::FastUnwindStack

[yln]

Summary

FastUnwindStack -> UnwindFast
SlowUnwindStack -> UnwindSlow
Stack is redundant, verb should come first.

SlowUnwindStackWithContext(uptr pc, void *context, u32 max_depth) ->
SlowUnwindStack
WithContext is redundant, since it is a required parameter.

Overview revision:
https://reviews.llvm.org/D58536

lib/sanitizer_common/sanitizer_stacktrace.h

void Unwind(u32 max_depth, uptr pc, uptr bp, void *context, uptr stack_top,
               uptr stack_bottom, bool request_fast_unwind);
 
   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 UnwindFast(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom,
+  void UnwindSlow(uptr pc, u32 max_depth);
+  void UnwindSlow(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.

lib/sanitizer_common/sanitizer_stacktrace.cc

#ifdef __arm__
   // 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) {
+void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
   const uptr kPageSize = GetPageSizeCached();
   CHECK_GE(max_depth, 2);
   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.

lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
   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);
+      UnwindSlow(pc, context, max_depth);
     else
-      SlowUnwindStack(pc, max_depth);
+      UnwindSlow(pc, max_depth);
 #else
     UNREACHABLE("slow unwind requested but not available");
 #endif
   } else {
-    FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
+    UnwindFast(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);

lib/sanitizer_common/sanitizer_stacktrace_sparc.cc

 // Sparc v9.
 #if defined(__sparcv8__) || defined(__sparcv8) || defined(__sparc_v8__)
 
 #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) {
+void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
   const uptr kPageSize = GetPageSizeCached();
   CHECK_GE(max_depth, 2);
   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;

lib/sanitizer_common/sanitizer_symbolizer_markup.cc

_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
   CHECK_LT(arg->stack->size, arg->max_depth);
   uptr pc = _Unwind_GetIP(ctx);
   if (pc < PAGE_SIZE) return _URC_NORMAL_STOP;
   arg->stack->trace_buffer[arg->stack->size++] = pc;
   return (arg->stack->size == arg->max_depth ? _URC_NORMAL_STOP
                                              : _URC_NO_REASON);
 }
 
-void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
+void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
   CHECK_GE(max_depth, 2);
   size = 0;
   UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
   _Unwind_Backtrace(Unwind_Trace, &arg);
   CHECK_GT(size, 0);
   // We need to pop a few frames so that pc is on top.
   uptr to_pop = LocatePcInTrace(pc);
   // trace_buffer[0] belongs to the current function so we always pop it,
   // 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,
+void BufferedStackTrace::UnwindSlow(uptr pc, void *context,
                                                     u32 max_depth) {
   CHECK_NE(context, nullptr);
   UNREACHABLE("signal context doesn't exist");
 }
 #endif  // SANITIZER_CAN_SLOW_UNWIND
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SYMBOLIZER_MARKUP

lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

 
 #if SANITIZER_FREEBSD
 #define _GNU_SOURCE  // to declare _Unwind_Backtrace() from <unwind.h>
 #endif
 #include <unwind.h>
 
 namespace __sanitizer {
 
-//------------------------- SlowUnwindStack -----------------------------------
+//---------------------------- UnwindSlow --------------------------------------
 
 typedef struct {
   uptr absolute_pc;
   uptr stack_top;
   uptr stack_size;
 } backtrace_frame_t;
 
 extern "C" {
_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
   // x86_64) is invalid and stop unwinding here.  If we're adding support for
   // a platform where this isn't true, we need to reconsider this check.
   if (pc < kPageSize) return UNWIND_STOP;
   arg->stack->trace_buffer[arg->stack->size++] = pc;
   if (arg->stack->size == arg->max_depth) return UNWIND_STOP;
   return UNWIND_CONTINUE;
 }
 
-void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
+void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
   CHECK_GE(max_depth, 2);
   size = 0;
   UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
   _Unwind_Backtrace(Unwind_Trace, &arg);
   // We need to pop a few frames so that pc is on top.
   uptr to_pop = LocatePcInTrace(pc);
   // trace_buffer[0] belongs to the current function so we always pop it,
   // unless there is only 1 frame in the stack trace (1 frame is always better
   // than 0!).
   // 1-frame stacks don't normally happen, but this depends on the actual
   // unwinder implementation (libgcc, libunwind, etc) which is outside of our
   // control.
   if (to_pop == 0 && size > 1)
     to_pop = 1;
   PopStackFrames(to_pop);
   trace_buffer[0] = pc;
 }
 
-void BufferedStackTrace::SlowUnwindStackWithContext(uptr pc, void *context,
+void BufferedStackTrace::UnwindSlow(uptr pc, void *context,
                                                     u32 max_depth) {
   CHECK_GE(max_depth, 2);
   if (!unwind_backtrace_signal_arch) {
-    SlowUnwindStack(pc, max_depth);
+    UnwindSlow(pc, max_depth);
     return;
   }
 
   void *map = acquire_my_map_info_list();
   CHECK(map);
   InternalMmapVector<backtrace_frame_t> frames(kStackTraceMax);
   // siginfo argument appears to be unused.
   sptr res = unwind_backtrace_signal_arch(/* siginfo */ 0, context, map,

lib/sanitizer_common/sanitizer_unwind_win.cc

 
 #include "sanitizer_dbghelp.h"  // for StackWalk64
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_symbolizer.h"  // for InitializeDbgHelpIfNeeded
 
 using namespace __sanitizer;
 
 #if !SANITIZER_GO
-void BufferedStackTrace::SlowUnwindStack(uptr pc, u32 max_depth) {
+void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
   CHECK_GE(max_depth, 2);
   // FIXME: CaptureStackBackTrace might be too slow for us.
   // FIXME: Compare with StackWalk64.
   // FIXME: Look at LLVMUnhandledExceptionFilter in Signals.inc
   size = CaptureStackBackTrace(1, Min(max_depth, kStackTraceMax),
     (void **)&trace_buffer[0], 0);
   if (size == 0)
     return;
 
   // 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,
+void BufferedStackTrace::UnwindSlow(uptr pc, void *context,
   u32 max_depth) {
   CONTEXT ctx = *(CONTEXT *)context;
   STACKFRAME64 stack_frame;
   memset(&stack_frame, 0, sizeof(stack_frame));
 
   InitializeDbgHelpIfNeeded();
 
   size = 0;

lib/sanitizer_common/tests/sanitizer_stacktrace_test.cc

void FastUnwindTest::SetUp() {
   // even indices.
   for (uptr i = 0; i + 1 < fake_stack_size; i += 2) {
     fake_stack[i] = (uptr)&fake_stack[i+2];  // fp
     fake_stack[i+1] = PC(i + 1); // retaddr
   }
   // Mark the last fp point back up to terminate the stack trace.
   fake_stack[RoundDownTo(fake_stack_size - 1, 2)] = (uhwptr)&fake_stack[0];
 
-  // Top is two slots past the end because FastUnwindStack subtracts two.
+  // Top is two slots past the end because UnwindFast subtracts two.
   fake_top = (uhwptr)&fake_stack[fake_stack_size + 2];
-  // Bottom is one slot before the start because FastUnwindStack uses >.
+  // Bottom is one slot before the start because UnwindFast uses >.
   fake_bottom = (uhwptr)mapping;
   start_pc = PC(0);
 }
 
 void FastUnwindTest::TearDown() {
   size_t ps = GetPageSize();
   UnmapOrDie(mapping, 2 * ps);
 }