[NFC][Sanitizer] Pull up GetStackTrace into sanitizer_common

[yln]

Summary

We already independently declare GetStackTrace in all (except TSan)
sanitizer runtime headers. Lets move it to sanitizer_stacktrace.h to
have one canonical way to fill in a BufferedStackFrame. Also enables us
to use it in sanitizer_common itself.

This patch defines GetStackTrace for TSan and moves the function from
ubsan_diag.cc to ubsan_diag_standalone.cc to avoid duplicate symbols
for the UBSan-ASan runtime.

Other than that this patch just moves the code out of headers and into
the correct namespace.

[vitalybuka]

I like it!

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

57 ↗

(On Diff #188270)

why common_flags()->fast_unwind_on_fatal when you had argument request_fast_unwind?

[vitalybuka]

LGTM assuming fast_unwind_on_fatal about is a typo

[yln]

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

57 ↗

(On Diff #188270)

Good catch! Thank you for your diligent reviews! :)

[yln]

This introduced the following linker error on some architectures (including ARM).
Attempt to fix: https://github.com/llvm/llvm-project/commit/52b751088b11547e0f4ef0589ebbe5e57752c68c

[2155/3703] Linking CXX shared library lib/clang/9.0.0/lib/linux/libclang_rt.scudo-armhf.so
FAILED: lib/clang/9.0.0/lib/linux/libclang_rt.scudo-armhf.so
: && /usr/local/bin/c++ -fPIC -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -std=c++11 -Wno-unused-parameter -O3 -Wl,-z,defs -Wl,-z,nodelete -march=armv7-a -mfloat-abi=hard -nodefaultlibs -Wl,--gc-sections -Wl,-rpath-link,/home/buildslave/buildslave/clang-cmake-armv8-full/stage1/./lib -shared -Wl,-soname,libclang_rt.scudo-armhf.so -o lib/clang/9.0.0/lib/linux/libclang_rt.scudo-armhf.so projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonNoTermination.armhf.dir/sanitizer_allocator.cc.o projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonNoTermination.armhf.dir/sanitizer_common.cc.o projects/compiler-rt/lib/sanitizer_common/CMakeFiles/ [...] projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_flags.cpp.o projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_malloc.cpp.o projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_termination.cpp.o projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_tsd_exclusive.cpp.o projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_tsd_shared.cpp.o projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_utils.cpp.o projects/compiler-rt/lib/scudo/CMakeFiles/clang_rt.scudo-dynamic-armhf.dir/scudo_new_delete.cpp.o -lgcc_s -lc -ldl -lrt -lpthread -lstdc++ -Wl,-rpath,"\$ORIGIN/../lib" && :
projects/compiler-rt/lib/ubsan/CMakeFiles/RTUbsan.armhf.dir/ubsan_diag.cc.o: In function `MaybePrintStackTrace':
/home/buildslave/buildslave/clang-cmake-armv8-full/llvm/projects/compiler-rt/lib/ubsan/ubsan_diag.cc:36: undefined reference to `sanitizer::GetStackTrace(sanitizer::BufferedStackTrace*, unsigned long, unsigned long, unsigned long, void*, bool)'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)

[mstorsjo]

+ @rnk

It turns out that the fix for Windows in rL355052 didn't turn out to help either: http://lab.llvm.org:8011/builders/sanitizer-windows/builds/42624/steps/stage%201%20build/logs/stdio

FWIW, on MinGW, this didn't break compilation like on MSVC, but linking still fails because SANITIZER_WEAK_ATTRIBUTE (as part of SANITIZER_WEAK_CXX_DEFAULT_IMPL) is empty for windows. (For MinGW, GCC does support __attribute__((weak)), but that isn't implemented in clang/llvm.)

[yln]

Is there a way to emulate weak linkage on windows?
Can you offer guidance on how to resolve this?

[rnk]

In D58651#1413884, @yln wrote:

Is there a way to emulate weak linkage on windows?
Can you offer guidance on how to resolve this?

You have activated the sanitizer trap card, attempting to use weak functions in portable code. You can achieve the same affect with weak aliases, #pragma comment(linker, "/alternatename:foo=foo_default"), but it is not directly functionally equivalent to weak functions. If you search around for that pragma you should be able to find the code pattern you need.

I wish the sanitizers would use fewer weak functions so that we didn't experience this pain every time a new one is introduced.

[yln]

You can achieve the same affect with weak aliases, #pragma comment(linker, "/alternatename:foo=foo_default"), but it is not directly functionally equivalent to weak functions. If you search around for that pragma you should be able to find the code pattern you need.

Thanks!

You have activated the sanitizer trap card, attempting to use weak functions in portable code.
I wish the sanitizers would use fewer weak functions so that we didn't experience this pain every time a new one is introduced.

I totally agree. This is a clear dependency violation (sanitizer_common -> asan, ubsan, ...). In my defense: this was present before (the implementation code is copy & pasted 5 times), but having it declared in sanitizer_common header "exposed" it.

The end goal of my refactoring is to either unify the implementation and pull it up into sanitizer_common or, if that is not possible, at least break the dependency violation (callback, templates?).

compiler-rt/trunk/lib/asan/asan_stack.h

 
 namespace __asan {
 
 static const u32 kDefaultMallocContextSize = 30;
 
 void SetMallocContextSize(u32 size);
 u32 GetMallocContextSize();
 
-// 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, 0, context, 0, 0, false);
-#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)) {
-        if (StackTrace::WillUseFastUnwind(fast))
-          stack->Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom,
-                      true);
-        else
-          stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
-      }
-    } else if (!t && !fast) {
-      /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
-      stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
-    }
-  }
-#endif // SANITIZER_WINDOWS
-}
-
 } // namespace __asan
 
 // NOTE: A Rule of thumb is to retrieve stack trace in the interceptors
 // as early as possible (in functions exposed to the user), as we generally
 // don't want stack trace to contain functions from ASan internals.
 
 #define GET_STACK_TRACE(max_size, fast)                          \
   BufferedStackTrace stack;                                      \

compiler-rt/trunk/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) {
+  using namespace __asan;
+#if SANITIZER_WINDOWS
+  stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
+#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)) {
+        if (StackTrace::WillUseFastUnwind(fast))
+          stack->Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom,
+                      true);
+        else
+          stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
+      }
+    } else if (!t && !fast) {
+      /* If GetCurrentThread() has failed, try to do slow unwind anyways. */
+      stack->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/trunk/lib/hwasan/hwasan.h

 void ExitSymbolizer();
 bool IsInSymbolizer();
 
 struct SymbolizerScope {
   SymbolizerScope() { EnterSymbolizer(); }
   ~SymbolizerScope() { ExitSymbolizer(); }
 };
 
-void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
-                   void *context, bool request_fast_unwind);
-
 // Returns a "chained" origin id, pointing to the given stack trace followed by
 // the previous origin id.
 u32 ChainOrigin(u32 id, StackTrace *stack);
 
 const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
 
 #define GET_MALLOC_STACK_TRACE                                            \
   BufferedStackTrace stack;                                               \

compiler-rt/trunk/lib/hwasan/hwasan.cpp

#endif
 
   InitializeCommonFlags();
 
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 }
 
-void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
-                   void *context, bool request_fast_unwind) {
-  Thread *t = GetCurrentThread();
-  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);
-  }
-  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
-    stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
-                  true);
-  else
-    stack->Unwind(max_s, pc, 0, context, 0, 0, false);
-}
-
 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();
 }
 
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) {
+  using namespace __hwasan;
+  Thread *t = GetCurrentThread();
+  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);
+  }
+  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
+    stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
+                  true);
+  else
+    stack->Unwind(max_s, pc, 0, context, 0, 0, false);
+}
+
 // Interface.
 
 using namespace __hwasan;
 
 uptr __hwasan_shadow_memory_dynamic_address;  // Global interface symbol.
 
 void __hwasan_init_frames(uptr beg, uptr end) {
   InitFrameDescriptors(beg, end);

compiler-rt/trunk/lib/lsan/lsan.h

 void ReplaceSystemMalloc();
 
 #define ENSURE_LSAN_INITED do {   \
   CHECK(!lsan_init_is_running);   \
   if (!lsan_inited)               \
     __lsan_init();                \
 } while (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.
-ALWAYS_INLINE
-void GetStackTrace(__sanitizer::BufferedStackTrace *stack,
-                   __sanitizer::uptr max_depth, __sanitizer::uptr pc,
-                   __sanitizer::uptr bp, void *context, bool fast) {
-  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)) {
-    if (StackTrace::WillUseFastUnwind(fast))
-      stack->Unwind(max_depth, pc, bp, nullptr, stack_top, stack_bottom, true);
-    else
-      stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
-  }
-}
-
 }  // namespace __lsan
 
 extern bool lsan_inited;
 extern bool lsan_init_is_running;
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __lsan_init();

compiler-rt/trunk/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) {
+  using namespace __lsan;
+  uptr stack_top = 0, stack_bottom = 0;
+  ThreadContext *t;
+  if (StackTrace::WillUseFastUnwind(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);
+    else
+      stack->Unwind(max_depth, pc, 0, context, 0, 0, false);
+  }
+}
+
 using namespace __lsan;  // NOLINT
 
 static void InitializeFlags() {
   // Set all the default values.
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());

compiler-rt/trunk/lib/msan/msan.h

 struct SymbolizerScope {
   SymbolizerScope() { EnterSymbolizer(); }
   ~SymbolizerScope() { ExitSymbolizer(); }
 };
 
 void PrintWarning(uptr pc, uptr bp);
 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin);
 
-void GetStackTrace(BufferedStackTrace *stack, uptr max_s, uptr pc, uptr bp,
-                   void *context, bool request_fast_unwind);
-
 // Unpoison first n function arguments.
 void UnpoisonParam(uptr n);
 void UnpoisonThreadLocalState();
 
 // Returns a "chained" origin id, pointing to the given stack trace followed by
 // the previous origin id.
 u32 ChainOrigin(u32 id, StackTrace *stack);
 

compiler-rt/trunk/lib/msan/msan.cc

Printf(
         "Origin per-stack limit invalid: %d. Must be 0 (unlimited) or in [1, "
         "%d] range.\n",
         f->origin_history_per_stack_limit, kStackDepotMaxUseCount / 2);
     Die();
   }
   if (f->store_context_size < 1) f->store_context_size = 1;
 }
 
-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, false);
-  }
-  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
-    stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
-                  true);
-  else
-    stack->Unwind(max_s, pc, 0, context, 0, 0, false);
-}
-
 void PrintWarning(uptr pc, uptr bp) {
   PrintWarningWithOrigin(pc, bp, __msan_origin_tls);
 }
 
 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin) {
   if (msan_expect_umr) {
     // Printf("Expected UMR\n");
     __msan_origin_tls = origin;
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) {
+  using namespace __msan;
+  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, false);
+  }
+  if (StackTrace::WillUseFastUnwind(request_fast_unwind))
+    stack->Unwind(max_s, pc, bp, nullptr, t->stack_top(), t->stack_bottom(),
+                  true);
+  else
+    stack->Unwind(max_s, 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) { \
     GET_CALLER_PC_BP_SP;                            \
     (void) sp;                                      \

compiler-rt/trunk/lib/sanitizer_common/sanitizer_stacktrace.h

private:
   void operator=(const BufferedStackTrace &) = delete;
 };
 
 // Check if given pointer points into allocated stack area.
 static inline bool IsValidFrame(uptr frame, uptr stack_top, uptr stack_bottom) {
   return frame > stack_bottom && frame < stack_top - 2 * sizeof (uhwptr);
 }
 
+// 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);
+
 }  // namespace __sanitizer
 
 // Use this macro if you want to print stack trace with the caller
 // of the current function in the top frame.
 #define GET_CALLER_PC_BP_SP \
   uptr bp = GET_CURRENT_FRAME();              \
   uptr pc = GET_CALLER_PC();                  \
   uptr local_stack;                           \

compiler-rt/trunk/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) {
+  uptr top = 0;
+  uptr bottom = 0;
+  if (StackTrace::WillUseFastUnwind(request_fast_unwind)) {
+    GetThreadStackTopAndBottom(false, &top, &bottom);
+    stack->Unwind(kStackTraceMax, pc, bp, nullptr, top, bottom, true);
+  } else
+    stack->Unwind(kStackTraceMax, pc, 0, context, 0, 0, false);
+}

compiler-rt/trunk/lib/ubsan/ubsan_diag.h

 };
 
 bool ignoreReport(SourceLocation SLoc, ReportOptions Opts, ErrorType ET);
 
 #define GET_REPORT_OPTIONS(unrecoverable_handler) \
     GET_CALLER_PC_BP; \
     ReportOptions Opts = {unrecoverable_handler, pc, bp}
 
-void GetStackTrace(BufferedStackTrace *stack, uptr max_depth, uptr pc, uptr bp,
-                   void *context, bool fast);
-
 /// \brief Instantiate this class before printing diagnostics in the error
 /// report. This class ensures that reports from different threads and from
 /// different sanitizers won't be mixed.
 class ScopedReport {
   struct Initializer {
     Initializer();
   };
   Initializer initializer_;

compiler-rt/trunk/lib/ubsan/ubsan_diag.cc

 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #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 (StackTrace::WillUseFastUnwind(fast)) {
-    GetThreadStackTopAndBottom(false, &top, &bottom);
-    stack->Unwind(max_depth, pc, bp, nullptr, top, bottom, true);
-  } else
-    stack->Unwind(max_depth, pc, bp, context, 0, 0, false);
-}
-
 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;
 
   BufferedStackTrace stack;
   GetStackTrace(&stack, kStackTraceMax, pc, bp, nullptr,

compiler-rt/trunk/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) {
+  uptr top = 0;
+  uptr bottom = 0;
+  if (StackTrace::WillUseFastUnwind(fast)) {
+    GetThreadStackTopAndBottom(false, &top, &bottom);
+    stack->Unwind(max_depth, pc, bp, nullptr, top, bottom, true);
+  } else
+    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;