re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.cc

@@ -0,0 +1,118 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/internal/borrowed_fixup_buffer.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <atomic>
+#include <iterator>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/hash/hash.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal_stacktrace {
+
+// A buffer for holding fix-up information for stack traces of common sizes_.
+struct BorrowedFixupBuffer::FixupStackBuffer {
+  static constexpr size_t kMaxStackElements = 128;  // Can be reduced if needed
+  std::atomic_flag in_use{};
+  uintptr_t frames[kMaxStackElements];
+  int sizes[kMaxStackElements];
+
+  ABSL_CONST_INIT static FixupStackBuffer g_instances[kNumStaticBuffers];
+};
+
+ABSL_CONST_INIT BorrowedFixupBuffer::FixupStackBuffer
+    BorrowedFixupBuffer::FixupStackBuffer::g_instances[kNumStaticBuffers] = {};
+
+BorrowedFixupBuffer::~BorrowedFixupBuffer() {
+  if (borrowed_) {
+    std::move(*this).Unlock();
+  } else {
+    base_internal::LowLevelAlloc::Free(frames_);
+  }
+}
+
+BorrowedFixupBuffer::BorrowedFixupBuffer(size_t length)
+    : borrowed_(0 < length && length <= FixupStackBuffer::kMaxStackElements
+                    ? TryLock()
+                    : nullptr) {
+  if (borrowed_) {
+    InitViaBorrow();
+  } else {
+    InitViaAllocation(length);
+  }
+}
+
+void BorrowedFixupBuffer::InitViaBorrow() {
+  assert(borrowed_);
+  frames_ = borrowed_->frames;
+  sizes_ = borrowed_->sizes;
+}
+
+void BorrowedFixupBuffer::InitViaAllocation(size_t length) {
+  static_assert(alignof(decltype(*frames_)) >= alignof(decltype(*sizes_)),
+                "contiguous layout assumes decreasing alignment, otherwise "
+                "padding may be needed in the middle");
+  assert(!borrowed_);
+
+  base_internal::InitSigSafeArena();
+  void* buf = base_internal::LowLevelAlloc::AllocWithArena(
+      length * (sizeof(*frames_) + sizeof(*sizes_)),
+      base_internal::SigSafeArena());
+
+  if (buf == nullptr) {
+    frames_ = nullptr;
+    sizes_ = nullptr;
+    return;
+  }
+
+  frames_ = new (buf) uintptr_t[length];
+  sizes_ = new (static_cast<void*>(static_cast<unsigned char*>(buf) +
+                                   length * sizeof(*frames_))) int[length];
+}
+
+[[nodiscard]] BorrowedFixupBuffer::FixupStackBuffer*
+BorrowedFixupBuffer::TryLock() {
+  constexpr size_t kNumSlots = std::size(FixupStackBuffer::g_instances);
+  const size_t i = absl::Hash<const void*>()(this) % kNumSlots;
+  for (size_t k = 0; k < kNumSlots; ++k) {
+    auto* instance = &FixupStackBuffer::g_instances[(i + k) % kNumSlots];
+    // Use memory_order_acquire to ensure that no reads and writes on the
+    // borrowed buffer are reordered before the borrowing.
+    if (!instance->in_use.test_and_set(std::memory_order_acquire)) {
+      return instance;
+    }
+  }
+  return nullptr;
+}
+
+void BorrowedFixupBuffer::Unlock() && {
+  // Use memory_order_release to ensure that no reads and writes on the borrowed
+  // buffer are reordered after the borrowing.
+  borrowed_->in_use.clear(std::memory_order_release);
+}
+
+}  // namespace internal_stacktrace
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.h

@@ -0,0 +1,71 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_
+#define ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal_stacktrace {
+
+// An RAII type that temporarily acquires a buffer for stack trace fix-ups from
+// a pool of preallocated buffers, or attempts to allocate a new buffer if no
+// such buffer is available.
+// When destroyed, returns the buffer to the pool if it borrowed successfully,
+// otherwise deallocates any previously allocated buffer.
+class BorrowedFixupBuffer {
+ public:
+  static constexpr size_t kNumStaticBuffers = 64;
+  ~BorrowedFixupBuffer();
+
+  // The number of frames to allocate space for. Note that allocations can fail.
+  explicit BorrowedFixupBuffer(size_t length);
+
+  uintptr_t* frames() const { return frames_; }
+  int* sizes() const { return sizes_; }
+
+ private:
+  struct FixupStackBuffer;
+
+  uintptr_t* frames_;
+  int* sizes_;
+
+  // The borrowed pre-existing buffer, if any (if we haven't allocated our own)
+  FixupStackBuffer* const borrowed_;
+
+  void InitViaBorrow();
+  void InitViaAllocation(size_t length);
+
+  // Attempts to opportunistically borrow a small buffer in a thread- and
+  // signal-safe manner. Returns nullptr on failure.
+  [[nodiscard]] FixupStackBuffer* TryLock();
+
+  // Returns the borrowed buffer.
+  void Unlock() &&;
+
+  BorrowedFixupBuffer(const BorrowedFixupBuffer&) = delete;
+  BorrowedFixupBuffer& operator=(const BorrowedFixupBuffer&) = delete;
+};
+
+}  // namespace internal_stacktrace
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_

package/vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer_test.cc

@@ -0,0 +1,97 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/internal/borrowed_fixup_buffer.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal_stacktrace {
+namespace {
+
+TEST(BorrowedFixupBuffer, ProperReuse) {
+  uintptr_t first_borrowed_frame = 0;
+  uintptr_t first_borrowed_size = 0;
+
+  // Ensure that we borrow the same buffer each time, indicating proper reuse.
+  // Disable loop unrolling. We need all iterations to match exactly, to coax
+  // reuse of the the same underlying buffer.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC unroll 1  // <= 1 disables unrolling
+#endif
+  for (int i = 0; i < 100; ++i) {
+    BorrowedFixupBuffer buf0(0);
+    EXPECT_EQ(buf0.frames(), nullptr);
+    EXPECT_EQ(buf0.sizes(), nullptr);
+
+    BorrowedFixupBuffer buf1(1);
+    EXPECT_NE(buf1.frames(), nullptr);
+    EXPECT_NE(buf1.sizes(), nullptr);
+    if (first_borrowed_frame == 0) {
+      first_borrowed_frame = reinterpret_cast<uintptr_t>(buf1.frames());
+    } else {
+      EXPECT_EQ(reinterpret_cast<uintptr_t>(buf1.frames()),
+                first_borrowed_frame);
+    }
+    if (first_borrowed_size == 0) {
+      first_borrowed_size = reinterpret_cast<uintptr_t>(buf1.sizes());
+    } else {
+      EXPECT_EQ(reinterpret_cast<uintptr_t>(buf1.sizes()), first_borrowed_size);
+    }
+
+    BorrowedFixupBuffer buf2(2);
+    EXPECT_NE(buf2.frames(), buf1.frames());
+    EXPECT_NE(buf2.sizes(), buf1.sizes());
+    EXPECT_NE(buf2.frames(), nullptr);
+    EXPECT_NE(buf2.sizes(), nullptr);
+  }
+}
+
+TEST(BorrowedFixupBuffer, NoOverlap) {
+  using BufferPtr = std::unique_ptr<BorrowedFixupBuffer>;
+  static constexpr std::less<const void*> less;
+  static constexpr size_t kBufLen = 5;
+  static constexpr size_t kNumBuffers =
+      BorrowedFixupBuffer::kNumStaticBuffers * 37 + 1;
+
+  auto bufs = std::make_unique<BufferPtr[]>(kNumBuffers);
+  for (size_t i = 0; i < kNumBuffers; ++i) {
+    bufs[i] = std::make_unique<BorrowedFixupBuffer>(kBufLen);
+  }
+
+  std::sort(bufs.get(), bufs.get() + kNumBuffers,
+            [](const BufferPtr& a, const BufferPtr& b) {
+              return less(a->frames(), b->frames());
+            });
+
+  // Verify there are no overlaps
+  for (size_t i = 1; i < kNumBuffers; ++i) {
+    EXPECT_FALSE(less(bufs[i]->frames(), bufs[i - 1]->frames() + kBufLen));
+    EXPECT_FALSE(less(bufs[i]->sizes(), bufs[i - 1]->sizes() + kBufLen));
+  }
+}
+
+}  // namespace
+}  // namespace internal_stacktrace
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/debugging/internal/demangle.cc

@@ -28,7 +28,7 @@
 #include "absl/base/config.h"
 #include "absl/debugging/internal/demangle_rust.h"
 
-#if ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
 #include <cxxabi.h>
 #endif
 
@@ -2941,7 +2941,7 @@ std::string DemangleString(const char* mangled) {
   std::string out;
   int status = 0;
   char* demangled = nullptr;
-#if ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
   demangled = abi::__cxa_demangle(mangled, nullptr, nullptr, &status);
 #endif
   if (status == 0 && demangled != nullptr) {

package/vendor/abseil-cpp/absl/debugging/internal/elf_mem_image.h

@@ -32,10 +32,10 @@
 #error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
 #endif
 
-#if defined(__ELF__) && !defined(__OpenBSD__) && !defined(__QNX__) && \
-    !defined(__native_client__) && !defined(__asmjs__) &&             \
-    !defined(__wasm__) && !defined(__HAIKU__) && !defined(__sun) &&   \
-    !defined(__VXWORKS__) && !defined(__hexagon__) && !defined(__XTENSA__)
+#if defined(__ELF__) && !defined(__OpenBSD__) && !defined(__QNX__) &&    \
+    !defined(__asmjs__) && !defined(__wasm__) && !defined(__HAIKU__) &&  \
+    !defined(__sun) && !defined(__VXWORKS__) && !defined(__hexagon__) && \
+    !defined(__XTENSA__)
 #define ABSL_HAVE_ELF_MEM_IMAGE 1
 #endif
 

package/vendor/abseil-cpp/absl/debugging/internal/examine_stack.cc

@@ -149,6 +149,10 @@ void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook) {
   debug_stack_trace_hook = hook;
 }
 
+SymbolizeUrlEmitterLegacy GetDebugStackTraceHookLegacy() {
+  return debug_stack_trace_hook;
+}
+
 SymbolizeUrlEmitter GetDebugStackTraceHook() { return debug_stack_trace_hook; }
 
 // Returns the program counter from signal context, nullptr if

package/vendor/abseil-cpp/absl/debugging/internal/examine_stack.h

@@ -32,12 +32,19 @@ typedef void OutputWriter(const char*, void*);
 // `hook` may be called from a signal handler.
 typedef void (*SymbolizeUrlEmitter)(void* const stack[], int depth,
                                     OutputWriter* writer, void* writer_arg);
+typedef void (*SymbolizeUrlEmitterLegacy)(void* const stack[], int depth,
+                                          OutputWriter* writer,
+                                          void* writer_arg);
 
 // Registration of SymbolizeUrlEmitter for use inside of a signal handler.
 // This is inherently unsafe and must be signal safe code.
 void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook);
 SymbolizeUrlEmitter GetDebugStackTraceHook();
 
+// Currently exact copy of above. Needed for the 3-CL dance due to
+// TCMallocDebugStackTraceHook dependency on this API.
+SymbolizeUrlEmitterLegacy GetDebugStackTraceHookLegacy();
+
 // Returns the program counter from signal context, or nullptr if
 // unknown. `vuc` is a ucontext_t*. We use void* to avoid the use of
 // ucontext_t on non-POSIX systems.

package/vendor/abseil-cpp/absl/debugging/internal/stacktrace_aarch64-inl.inc

@@ -123,7 +123,7 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc,
       // earlier in the stack than the old_frame_pointer, then use it. If it is
       // later, then we have already unwound through it and it needs no special
       // handling.
-      if (pre_signal_frame_pointer >= old_frame_pointer) {
+      if (pre_signal_frame_pointer > old_frame_pointer) {
         new_frame_pointer = pre_signal_frame_pointer;
       }
     }

package/vendor/abseil-cpp/absl/debugging/internal/stacktrace_emscripten-inl.inc

@@ -52,13 +52,6 @@ static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
 // Waiting until static initializers run seems to be late enough.
 // This file is included into stacktrace.cc so this will only run once.
 ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
-  // Check if we can even create stacktraces. If not, bail early and leave
-  // disable_stacktraces set as-is.
-  // clang-format off
-  if (!EM_ASM_INT({ return (typeof wasmOffsetConverter !== 'undefined'); })) {
-    return 0;
-  }
-  // clang-format on
   disable_stacktraces.store(false, std::memory_order_relaxed);
   return 0;
 }();

package/vendor/abseil-cpp/absl/debugging/internal/stacktrace_powerpc-inl.inc

@@ -223,8 +223,9 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
         }
         if (sizes != nullptr) {
           if (next_sp > sp) {
-            sizes[n] = absl::debugging_internal::StripPointerMetadata(next_sp) -
-                       absl::debugging_internal::StripPointerMetadata(sp);
+            sizes[n] = static_cast<int>(
+                absl::debugging_internal::StripPointerMetadata(next_sp) -
+                absl::debugging_internal::StripPointerMetadata(sp));
           } else {
             // A frame-size of 0 is used to indicate unknown frame size.
             sizes[n] = 0;

package/vendor/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc

@@ -162,7 +162,8 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
               absl::debugging_internal::StripPointerMetadata(frame_pointer);
         }
         if (sizes != nullptr) {
-          sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
+          sizes[n] = static_cast<int>(
+              ComputeStackFrameSize(frame_pointer, next_frame_pointer));
         }
       }
       n++;

package/vendor/abseil-cpp/absl/debugging/internal/stacktrace_x86-inl.inc

@@ -245,6 +245,7 @@ static void **NextStackFrame(void **old_fp, const void *uc,
   }
 #endif
 
+  const size_t page_size = static_cast<size_t>(getpagesize());
   const uintptr_t old_fp_u = reinterpret_cast<uintptr_t>(old_fp);
   const uintptr_t new_fp_u = reinterpret_cast<uintptr_t>(new_fp);
 
@@ -273,8 +274,7 @@ static void **NextStackFrame(void **old_fp, const void *uc,
     // so we assume the large frame is legit if we know the real stack bounds
     // and are within the stack.
     if (new_fp_u <= old_fp_u || new_fp_u - old_fp_u > kMaxFrameBytes) {
-      if (stack_high < kUnknownStackEnd &&
-          static_cast<size_t>(getpagesize()) < stack_low) {
+      if (stack_high < kUnknownStackEnd && page_size < stack_low) {
         // Stack bounds are known.
         if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
           // new_fp_u is not within the known stack.
@@ -311,7 +311,12 @@ static void **NextStackFrame(void **old_fp, const void *uc,
   if (new_fp_u >= 0xffffe000) return nullptr;
 #endif
 #if !defined(_WIN32)
-  if (!STRICT_UNWINDING) {
+  const uintptr_t old_fp_page = old_fp_u & ~(page_size - 1);
+  const uintptr_t new_fp_page = new_fp_u & ~(page_size - 1);
+  if (old_fp_page == new_fp_page && (new_fp_u & (sizeof(void*) - 1)) == 0) {
+    // We dereferenced the old_fp above, so it is safe to dereference
+    // new_fp if it's on the same page as the old_fp and is aligned.
+  } else if (!STRICT_UNWINDING) {
     // Lax sanity checks cause a crash in 32-bit tcmalloc/crash_reason_test
     // on AMD-based machines with VDSO-enabled kernels.
     // Make an extra sanity check to insure new_fp is readable.

package/vendor/abseil-cpp/absl/debugging/internal/symbolize.h

@@ -28,8 +28,8 @@
 
 #ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 #error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
-#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \
-      && !defined(__asmjs__) && !defined(__wasm__)
+#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__asmjs__) \
+      && !defined(__wasm__)
 #define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
 
 #include <elf.h>

package/vendor/abseil-cpp/absl/debugging/stacktrace.cc

@@ -42,29 +42,28 @@
 
 #include <algorithm>
 #include <atomic>
-#include <iterator>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/low_level_alloc.h"
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"
+#include "absl/debugging/internal/borrowed_fixup_buffer.h"
 #include "absl/debugging/internal/stacktrace_config.h"
 
 #if defined(ABSL_STACKTRACE_INL_HEADER)
 #include ABSL_STACKTRACE_INL_HEADER
 #else
-# error Cannot calculate stack trace: will need to write for your environment
-
-# include "absl/debugging/internal/stacktrace_aarch64-inl.inc"
-# include "absl/debugging/internal/stacktrace_arm-inl.inc"
-# include "absl/debugging/internal/stacktrace_emscripten-inl.inc"
-# include "absl/debugging/internal/stacktrace_generic-inl.inc"
-# include "absl/debugging/internal/stacktrace_powerpc-inl.inc"
-# include "absl/debugging/internal/stacktrace_riscv-inl.inc"
-# include "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
-# include "absl/debugging/internal/stacktrace_win32-inl.inc"
-# include "absl/debugging/internal/stacktrace_x86-inl.inc"
+#error Cannot calculate stack trace: will need to write for your environment
+
+#include "absl/debugging/internal/stacktrace_aarch64-inl.inc"
+#include "absl/debugging/internal/stacktrace_arm-inl.inc"
+#include "absl/debugging/internal/stacktrace_emscripten-inl.inc"
+#include "absl/debugging/internal/stacktrace_generic-inl.inc"
+#include "absl/debugging/internal/stacktrace_powerpc-inl.inc"
+#include "absl/debugging/internal/stacktrace_riscv-inl.inc"
+#include "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+#include "absl/debugging/internal/stacktrace_win32-inl.inc"
+#include "absl/debugging/internal/stacktrace_x86-inl.inc"
 #endif
 
 namespace absl {
@@ -78,29 +77,10 @@ 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) {
-  static constexpr size_t kMinPageSize = 4096;
-
-  // Allow up to ~half a page, leaving some slack space for local variables etc.
-  static constexpr size_t kMaxStackElements =
-      (kMinPageSize / 2) / (sizeof(*frames) + sizeof(*sizes));
-
-  // 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;
-
-  bool unwind_with_fixup = internal_stacktrace::ShouldFixUpStack();
+                                               int* min_dropped_frames,
+                                               bool unwind_with_fixup = true) {
+  unwind_with_fixup =
+      unwind_with_fixup && internal_stacktrace::ShouldFixUpStack();
 
 #ifdef _WIN32
   if (unwind_with_fixup) {
@@ -112,29 +92,17 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
   }
 #endif
 
-  if (unwind_with_fixup) {
-    // Some implementations of FixUpStack may need to be passed frame
-    // information from Unwind, even if the caller doesn't need that
-    // information. We allocate the necessary buffers for such implementations
-    // here.
-
-    if (frames == nullptr) {
-      if (max_depth <= std::size(frames_stackbuf)) {
-        frames = frames_stackbuf;
-      } 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;
-      } else {
-        sizes = static_cast<int*>(allocate(max_depth * sizeof(*sizes)));
-        must_free_sizes = true;
-      }
-    }
+  // Some implementations of FixUpStack may need to be passed frame
+  // information from Unwind, even if the caller doesn't need that
+  // information. We allocate the necessary buffers for such implementations
+  // here.
+  const internal_stacktrace::BorrowedFixupBuffer fixup_buffer(
+      unwind_with_fixup ? max_depth : 0);
+  if (frames == nullptr) {
+    frames = fixup_buffer.frames();
+  }
+  if (sizes == nullptr) {
+    sizes = fixup_buffer.sizes();
   }
 
   Unwinder g = custom.load(std::memory_order_acquire);
@@ -162,14 +130,6 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
     internal_stacktrace::FixUpStack(result, frames, sizes, max_depth, size);
   }
 
-  if (must_free_sizes) {
-    base_internal::LowLevelAlloc::Free(sizes);
-  }
-
-  if (must_free_frames) {
-    base_internal::LowLevelAlloc::Free(frames);
-  }
-
   ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
   return static_cast<int>(size);
 }
@@ -194,6 +154,14 @@ internal_stacktrace::GetStackFramesWithContext(void** result, uintptr_t* frames,
                             min_dropped_frames);
 }
 
+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);
+}
+
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace(
     void** result, int max_depth, int skip_count) {
   return Unwind<false, false>(result, nullptr, nullptr,

package/vendor/abseil-cpp/absl/debugging/stacktrace.h

@@ -69,6 +69,9 @@ extern int GetStackFramesWithContext(void** result, uintptr_t* frames,
                                      int* sizes, int max_depth, int skip_count,
                                      const void* uc, int* min_dropped_frames);
 
+// As above, but skips fix-ups for efficiency.
+extern int GetStackTraceNoFixup(void** result, int max_depth, int skip_count);
+
 // Same as `absl::DefaultStackUnwinder`, but with an optional `frames` parameter
 // to allow callers to receive the raw stack frame addresses.
 // This is internal for now; do not depend on this externally.

package/vendor/abseil-cpp/absl/debugging/stacktrace_benchmark.cc

@@ -12,12 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/optimization.h"
+#include "absl/cleanup/cleanup.h"
 #include "absl/debugging/stacktrace.h"
 #include "benchmark/benchmark.h"
 
+static bool g_enable_fixup = false;
+
+#if ABSL_HAVE_ATTRIBUTE_WEAK
+// Override these weak symbols if possible.
+bool absl::internal_stacktrace::ShouldFixUpStack() { return g_enable_fixup; }
+void absl::internal_stacktrace::FixUpStack(void**, uintptr_t*, int*, size_t,
+                                           size_t&) {}
+#endif
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace {
@@ -42,14 +55,24 @@ ABSL_ATTRIBUTE_NOINLINE void func(benchmark::State& state, int x, int depth) {
   func(state, --x, depth);
 }
 
+template <bool EnableFixup>
 void BM_GetStackTrace(benchmark::State& state) {
+  const Cleanup restore_state(
+      [prev = g_enable_fixup]() { g_enable_fixup = prev; });
+  g_enable_fixup = EnableFixup;
   int depth = state.range(0);
   for (auto s : state) {
     func(state, depth, depth);
   }
 }
 
-BENCHMARK(BM_GetStackTrace)->DenseRange(10, kMaxStackDepth, 10);
+#if ABSL_HAVE_ATTRIBUTE_WEAK
+auto& BM_GetStackTraceWithFixup = BM_GetStackTrace<true>;
+BENCHMARK(BM_GetStackTraceWithFixup)->DenseRange(10, kMaxStackDepth, 10);
+#endif
+
+auto& BM_GetStackTraceWithoutFixup = BM_GetStackTrace<false>;
+BENCHMARK(BM_GetStackTraceWithoutFixup)->DenseRange(10, kMaxStackDepth, 10);
 }  // namespace
 ABSL_NAMESPACE_END
 }  // namespace absl