[NFC][Sanitizer] Make GetStackTrace a private method of BufferedStackTrace

[yln]

Summary

GetStackTrace is a private implementation detail of BufferedStackTrace.
Make it a private method.

[vitalybuka]

LGTM, I asked exactly this in another review :)

compiler-rt/lib/asan/asan_stack.cc

31

I don't understand meaning of Runtime here.
Maybe UnwindRuntime -> UnwindImpl

Final decision is up to you
if you prefere Runtime, maybe UnwindByRuntime?

[yln]

compiler-rt/lib/asan/asan_stack.cc

31

Okay, let's go with UnwindImpl.

[yln]

Closed by: 9fe3b4906f351292691cd594b30fe6cf7230b94d

compiler-rt/lib/asan/asan_stack.cc

 }
 
 u32 GetMallocContextSize() {
   return atomic_load(&malloc_context_size, memory_order_acquire);
 }
 
 }  // namespace __asan
 
-void __sanitizer::GetStackTrace(BufferedStackTrace *stack, uptr max_depth,
-                                uptr pc, uptr bp, void *context, bool fast) {
+void __sanitizer::BufferedStackTrace::UnwindRuntime(
+    uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   using namespace __asan;
 #if SANITIZER_WINDOWS
   stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
 #else
   AsanThread *t;
-  stack->size = 0;
+  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)) {
-        if (StackTrace::WillUseFastUnwind(fast))
-          stack->Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom,
+        if (StackTrace::WillUseFastUnwind(request_fast))
+          Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom,
                       true);
         else
-          stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
+          Unwind(max_depth, pc, 0, context, 0, 0, false);
       }
-    } else if (!t && !fast) {
+    } else if (!t && !request_fast) {
       /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
-      stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
+      Unwind(max_depth, pc, bp, context, 0, 0, false);
     }
   }
 #endif // SANITIZER_WINDOWS
 }
 
 // ------------------ Interface -------------- {{{1
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   using namespace __asan;
   PRINT_CURRENT_STACK();
 }
 }  // extern "C"

compiler-rt/lib/hwasan/hwasan.cc

void InitInstrumentation() {
   InitThreads();
   hwasanThreadList().CreateCurrentThread();
 
   hwasan_instrumentation_inited = 1;
 }
 
 } // namespace __hwasan
 
-void __sanitizer::GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc,
-                                uptr bp, void *context,
-                                bool request_fast_unwind) {
+void __sanitizer::BufferedStackTrace::UnwindRuntime(
+    uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   using namespace __hwasan;
   Thread *t = GetCurrentThread();
   if (!t) {
     // the thread is still being created.
-    stack->size = 0;
+    size = 0;
     return;
   }
-  if (!StackTrace::WillUseFastUnwind(request_fast_unwind)) {
+  if (!StackTrace::WillUseFastUnwind(request_fast)) {
     // 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 Unwind(max_s, pc, bp, context, 0, 0, request_fast);
   }
-  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
-    stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
+  if (StackTrace::WillUseFastUnwind(request_fast))
+    Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
                   true);
   else
-    stack->Unwind(max_s, pc, 0, context, 0, 0, false);
+    Unwind(max_s, pc, 0, context, 0, 0, false);
 }
 
 // Interface.
 
 using namespace __hwasan;
 
 uptr __hwasan_shadow_memory_dynamic_address;  // Global interface symbol.
 

compiler-rt/lib/lsan/lsan.cc

 
 ///// Interface to the common LSan module. /////
 bool WordIsPoisoned(uptr addr) {
   return false;
 }
 
 }  // namespace __lsan
 
-void __sanitizer::GetStackTrace(BufferedStackTrace *stack, uptr max_depth,
-                                uptr pc, uptr bp, void *context, bool fast) {
+void __sanitizer::BufferedStackTrace::UnwindRuntime(
+    uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   using namespace __lsan;
   uptr stack_top = 0, stack_bottom = 0;
   ThreadContext *t;
-  if (StackTrace::WillUseFastUnwind(fast) &&
+  if (StackTrace::WillUseFastUnwind(request_fast) &&
       (t = CurrentThreadContext())) {
     stack_top = t->stack_end();
     stack_bottom = t->stack_begin();
   }
   if (!SANITIZER_MIPS || IsValidFrame(bp, stack_top, stack_bottom)) {
-    if (StackTrace::WillUseFastUnwind(fast))
-      stack->Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom, true);
+    if (StackTrace::WillUseFastUnwind(request_fast))
+      Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom, true);
     else
-      stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
+      Unwind(max_depth, pc, 0, context, 0, 0, false);
   }
 }
 
 using namespace __lsan;  // NOLINT
 
 static void InitializeFlags() {
   // Set all the default values.
   SetCommonFlagsDefaults();

compiler-rt/lib/msan/msan.cc

u32 ChainOrigin(u32 id, StackTrace *stack) {
   Origin o = Origin::FromRawId(id);
   stack->tag = StackTrace::TAG_UNKNOWN;
   Origin chained = Origin::CreateChainedOrigin(o, stack);
   return chained.raw_id();
 }
 
 } // namespace __msan
 
-void __sanitizer::GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc,
-                                uptr bp, void *context,
-                                bool request_fast_unwind) {
+void __sanitizer::BufferedStackTrace::UnwindRuntime(
+    uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   using namespace __msan;
   MsanThread *t = GetCurrentThread();
-  if (!t || !StackTrace::WillUseFastUnwind(request_fast_unwind)) {
+  if (!t || !StackTrace::WillUseFastUnwind(request_fast)) {
     // Block reports from our interceptors during _Unwind_Backtrace.
     SymbolizerScope sym_scope;
-    return stack->Unwind(max_s, pc, bp, context, 0, 0, false);
+    return Unwind(max_depth, pc, bp, context, 0, 0, false);
   }
-  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
-    stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
+  if (StackTrace::WillUseFastUnwind(request_fast))
+    Unwind(max_depth, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
                   true);
   else
-    stack->Unwind(max_s, pc, 0, context, 0, 0, false);
+    Unwind(max_depth, pc, 0, context, 0, 0, false);
 }
 
 // Interface.
 
 using namespace __msan;
 
 #define MSAN_MAYBE_WARNING(type, size)              \
   void __msan_maybe_warning_##size(type s, u32 o) { \

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 #ifndef SANITIZER_STACKTRACE_H
 #define SANITIZER_STACKTRACE_H
 
 #include "sanitizer_internal_defs.h"
 
 namespace __sanitizer {
 
 struct BufferedStackTrace;
-// 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.
-void GetStackTrace(BufferedStackTrace *stack, uptr max_depth, uptr pc, uptr bp,
-                   void *context, bool request_fast_unwind);
 
 static const u32 kStackTraceMax = 256;
 
 #if defined(__sparc__) || (SANITIZER_LINUX && defined(__mips__))
 # define SANITIZER_CAN_FAST_UNWIND 0
 #elif SANITIZER_WINDOWS
 # define SANITIZER_CAN_FAST_UNWIND 0
 #elif SANITIZER_OPENBSD

 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);
 
+  // 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.
   void Unwind(uptr pc, uptr bp, void *context, bool request_fast,
               u32 max_depth = kStackTraceMax) {
     top_frame_bp = (max_depth > 0) ? bp : 0;
     // Small max_depth optimization
     if (max_depth <= 1) {
       if (max_depth == 1)
         trace_buffer[0] = pc;
       size = max_depth;
       return;
     }
-    GetStackTrace(this, max_depth, pc, bp, context, request_fast);
+    UnwindRuntime(pc, bp, context, request_fast, max_depth);
   }
 
   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:
+  // Every runtime defines its own implementation of this method
+  void UnwindRuntime(uptr pc, uptr bp, void *context, bool request_fast,
+                     u32 max_depth);
+
+  // UnwindFast/Slow have platform-specific implementations
   void UnwindFast(uptr pc, uptr bp, uptr stack_top, uptr stack_bottom,
                   u32 max_depth);
   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.

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

 
 void VarSizeStackTrace::ReverseOrder() {
   for (u32 i = 0; i < (size >> 1); i++)
     Swap(trace_buffer[i], trace_buffer[size - 1 - i]);
 }
 
 }  // namespace __tsan
 
-void __sanitizer::GetStackTrace(BufferedStackTrace *stack, uptr max_depth,
-                                uptr pc, uptr bp, void *context,
-                                bool request_fast_unwind) {
+void __sanitizer::BufferedStackTrace::UnwindRuntime(
+    uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   uptr top = 0;
   uptr bottom = 0;
-  if (StackTrace::WillUseFastUnwind(request_fast_unwind)) {
+  if (StackTrace::WillUseFastUnwind(request_fast)) {
     GetThreadStackTopAndBottom(false, &top, &bottom);
-    stack->Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, true);
+    Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, true);
   } else
-    stack->Unwind(kStackTraceMax, pc, 0, context, 0, 0, false);
+    Unwind(kStackTraceMax, pc, 0, context, 0, 0, false);
 }

compiler-rt/lib/ubsan/ubsan_diag_standalone.cc

 //===-- ubsan_diag_standalone.cc ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Diagnostic reporting for the standalone UBSan runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ubsan_platform.h"
 #if CAN_SANITIZE_UB
 #include "ubsan_diag.h"
 
-void __sanitizer::GetStackTrace(BufferedStackTrace *stack, uptr max_depth,
-                                uptr pc, uptr bp, void *context, bool fast) {
+void __sanitizer::BufferedStackTrace::UnwindRuntime(
+    uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   uptr top = 0;
   uptr bottom = 0;
-  if (StackTrace::WillUseFastUnwind(fast)) {
+  if (StackTrace::WillUseFastUnwind(request_fast)) {
     GetThreadStackTopAndBottom(false, &top, &bottom);
-    stack->Unwind(max_depth, pc, bp, nullptr, top, bottom, true);
+    Unwind(max_depth, pc, bp, nullptr, top, bottom, true);
   } else
-    stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
+    Unwind(max_depth, pc, bp, context, 0, 0, false);
 }
 
 using namespace __ubsan;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   GET_CURRENT_PC_BP;
   bool fast = common_flags()->fast_unwind_on_fatal;
   BufferedStackTrace stack;
   stack.Unwind(pc, bp, nullptr, fast);
   stack.Print();
 }
 } // extern "C"
 
 #endif  // CAN_SANITIZE_UB