Reduce stack usage when unwinding without fixups

The existing code uses the same stack space regardless of whether fixups are performed. This commit avoids using the stack space in calls that statically bypass fixups, to reduce the potential of a stack overflow.

PiperOrigin-RevId: 830610605
Change-Id: I06168e44e7199e10a606ff634e214ac9a8f9b872

Author: Abseil Team

absl/debugging/stacktrace.cc

@@ -43,6 +43,7 @@
 #include <algorithm>
 #include <atomic>
 #include <iterator>
+#include <type_traits>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
@@ -74,36 +75,37 @@ namespace {
 typedef int (*Unwinder)(void**, int*, int, int, const void*, int*);
 std::atomic<Unwinder> custom;
 
-template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
-                                               int* sizes, size_t max_depth,
-                                               int skip_count, const void* uc,
-                                               int* min_dropped_frames,
-                                               bool unwind_with_fixup = true) {
-  static constexpr size_t kMaxStackElements = 128;
+constexpr size_t kMinPageSize = 4096;
 
-  static constexpr size_t kMinPageSize = 4096;
-  static_assert(
-      kMaxStackElements * (sizeof(*frames) + sizeof(*sizes)) < kMinPageSize / 2,
-      "buffer size should be a fraction of a page to avoid stack overflows");
+struct FixupBuffer {
+  static constexpr size_t kMaxStackElements = 128;  // Can be reduced if needed
+  uintptr_t frames[kMaxStackElements];
+  int sizes[kMaxStackElements];
+};
+static_assert(std::is_trivially_default_constructible_v<FixupBuffer>);
+static_assert(sizeof(FixupBuffer) < kMinPageSize / 2,
+              "buffer size should no larger than a small fraction of a page, "
+              "to avoid stack overflows");
 
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(
+    void** result, uintptr_t* frames, int* sizes, size_t max_depth,
+    int skip_count, const void* uc, int* min_dropped_frames,
+    FixupBuffer* fixup_buffer /* if NULL, fixups are skipped */) {
   // Allocate a buffer dynamically, using the signal-safe allocator.
   static constexpr auto allocate = [](size_t num_bytes) -> void* {
     base_internal::InitSigSafeArena();
     return base_internal::LowLevelAlloc::AllocWithArena(
         num_bytes, base_internal::SigSafeArena());
   };
 
-  uintptr_t frames_stackbuf[kMaxStackElements];
-  int sizes_stackbuf[kMaxStackElements];
-
   // We only need to free the buffers if we allocated them with the signal-safe
   // allocator.
   bool must_free_frames = false;
   bool must_free_sizes = false;
 
-  unwind_with_fixup =
-      unwind_with_fixup && internal_stacktrace::ShouldFixUpStack();
+  bool unwind_with_fixup =
+      fixup_buffer != nullptr && internal_stacktrace::ShouldFixUpStack();
 
 #ifdef _WIN32
   if (unwind_with_fixup) {
@@ -122,17 +124,17 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
     // here.
 
     if (frames == nullptr) {
-      if (max_depth <= std::size(frames_stackbuf)) {
-        frames = frames_stackbuf;
+      if (max_depth <= std::size(fixup_buffer->frames)) {
+        frames = fixup_buffer->frames;
       } else {
         frames = static_cast<uintptr_t*>(allocate(max_depth * sizeof(*frames)));
         must_free_frames = true;
       }
     }
 
     if (sizes == nullptr) {
-      if (max_depth <= std::size(sizes_stackbuf)) {
-        sizes = sizes_stackbuf;
+      if (max_depth <= std::size(fixup_buffer->sizes)) {
+        sizes = fixup_buffer->sizes;
       } else {
         sizes = static_cast<int*>(allocate(max_depth * sizeof(*sizes)));
         must_free_sizes = true;
@@ -182,42 +184,46 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
 internal_stacktrace::GetStackFrames(void** result, uintptr_t* frames,
                                     int* sizes, int max_depth, int skip_count) {
+  FixupBuffer fixup_stack_buf;
   return Unwind<true, false>(result, frames, sizes,
                              static_cast<size_t>(max_depth), skip_count,
-                             nullptr, nullptr);
+                             nullptr, nullptr, &fixup_stack_buf);
 }
 
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
 internal_stacktrace::GetStackFramesWithContext(void** result, uintptr_t* frames,
                                                int* sizes, int max_depth,
                                                int skip_count, const void* uc,
                                                int* min_dropped_frames) {
+  FixupBuffer fixup_stack_buf;
   return Unwind<true, true>(result, frames, sizes,
                             static_cast<size_t>(max_depth), skip_count, uc,
-                            min_dropped_frames);
+                            min_dropped_frames, &fixup_stack_buf);
 }
 
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
 internal_stacktrace::GetStackTraceNoFixup(void** result, int max_depth,
                                           int skip_count) {
   return Unwind<false, false>(result, nullptr, nullptr,
                               static_cast<size_t>(max_depth), skip_count,
-                              nullptr, nullptr, /*unwind_with_fixup=*/false);
+                              nullptr, nullptr, nullptr);
 }
 
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace(
     void** result, int max_depth, int skip_count) {
+  FixupBuffer fixup_stack_buf;
   return Unwind<false, false>(result, nullptr, nullptr,
                               static_cast<size_t>(max_depth), skip_count,
-                              nullptr, nullptr);
+                              nullptr, nullptr, &fixup_stack_buf);
 }
 
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
 GetStackTraceWithContext(void** result, int max_depth, int skip_count,
                          const void* uc, int* min_dropped_frames) {
+  FixupBuffer fixup_stack_buf;
   return Unwind<false, true>(result, nullptr, nullptr,
                              static_cast<size_t>(max_depth), skip_count, uc,
-                             min_dropped_frames);
+                             min_dropped_frames, &fixup_stack_buf);
 }
 
 void SetStackUnwinder(Unwinder w) {