re2 1.22.2 → 1.23.0

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

@@ -31,11 +31,53 @@
 #ifndef ABSL_DEBUGGING_STACKTRACE_H_
 #define ABSL_DEBUGGING_STACKTRACE_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
+namespace internal_stacktrace {
+
+// Same as `absl::GetStackFrames`, but with an optional `frames` parameter to
+// allow callers to receive the raw stack frame addresses.
+// This is internal for now; use `absl::GetStackFrames()` instead.
+extern int GetStackFrames(void** result, uintptr_t* frames, int* sizes,
+                          int max_depth, int skip_count);
+
+// Same as `absl::GetStackFramesWithContext`, but with an optional `frames`
+// parameter to allow callers to receive a start address for each stack frame.
+// The address may be zero in cases where it cannot be computed.
+//
+// DO NOT use this function without consulting the owners of absl/debuggging.
+// There is NO GUARANTEE on the precise frame addresses returned on any given
+// platform. It is only intended to provide sufficient non-overlapping bounds on
+// the local variables of a stack frame when used in conjunction with the
+// returned frame sizes. The actual pointers may be ABI-dependent, may vary at
+// run time, and are subject to breakage without notice.
+//
+// Implementation note:
+// Currently, we *attempt* to return the Canonical Frame Address (CFA) in DWARF
+// on most platforms. This is the value of the stack pointer just before the
+// 'call' instruction is executed in the caller.
+// Not all platforms and toolchains support this exact address, so this should
+// not be relied on for correctness.
+extern int GetStackFramesWithContext(void** result, uintptr_t* frames,
+                                     int* sizes, int max_depth, int skip_count,
+                                     const void* uc, int* min_dropped_frames);
+
+// 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.
+extern int DefaultStackUnwinder(void** pcs, uintptr_t* frames, int* sizes,
+                                int max_depth, int skip_count, const void* uc,
+                                int* min_dropped_frames);
+
+}  // namespace internal_stacktrace
+
 // GetStackFrames()
 //
 // Records program counter values for up to `max_depth` frames, skipping the
@@ -78,8 +120,13 @@ ABSL_NAMESPACE_BEGIN
 //
 // This routine may return fewer stack frame entries than are
 // available. Also note that `result` and `sizes` must both be non-null.
-extern int GetStackFrames(void** result, int* sizes, int max_depth,
-                          int skip_count);
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline int GetStackFrames(void** result,
+                                                       int* sizes,
+                                                       int max_depth,
+                                                       int skip_count) {
+  return internal_stacktrace::GetStackFrames(result, nullptr, sizes, max_depth,
+                                             skip_count);
+}
 
 // GetStackFramesWithContext()
 //
@@ -102,9 +149,12 @@ extern int GetStackFrames(void** result, int* sizes, int max_depth,
 // or other reasons. (This value will be set to `0` if no frames were dropped.)
 // The number of total stack frames is guaranteed to be >= skip_count +
 // max_depth + *min_dropped_frames.
-extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
-                                     int skip_count, const void* uc,
-                                     int* min_dropped_frames);
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline int GetStackFramesWithContext(
+    void** result, int* sizes, int max_depth, int skip_count, const void* uc,
+    int* min_dropped_frames) {
+  return internal_stacktrace::GetStackFramesWithContext(
+      result, nullptr, sizes, max_depth, skip_count, uc, min_dropped_frames);
+}
 
 // GetStackTrace()
 //
@@ -225,6 +275,24 @@ namespace debugging_internal {
 // working.
 extern bool StackTraceWorksForTest();
 }  // namespace debugging_internal
+
+namespace internal_stacktrace {
+extern bool ShouldFixUpStack();
+
+// Fixes up the stack trace of the current thread, in the first `depth` frames
+// of each buffer. The buffers need to be larger than `depth`, to accommodate
+// any newly inserted elements. `depth` is updated to reflect the new number of
+// elements valid across all the buffers. (It is therefore recommended that all
+// buffer sizes be equal.)
+//
+// The `frames` and `sizes` parameters denote the bounds of the stack frame
+// corresponding to each instruction pointer in the `pcs`.
+// Any elements inside these buffers may be zero or null, in which case that
+// information is assumed to be absent/unavailable.
+extern void FixUpStack(void** pcs, uintptr_t* frames, int* sizes,
+                       size_t capacity, size_t& depth);
+}  // namespace internal_stacktrace
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

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

@@ -14,12 +14,58 @@
 
 #include "absl/debugging/stacktrace.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <cerrno>
+#include <csignal>
+#include <cstring>
+#include <memory>
+
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/base/macros.h"
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
 #include "absl/base/optimization.h"
+#include "absl/types/span.h"
+
+static int g_should_fixup_calls = 0;
+static int g_fixup_calls = 0;
+static bool g_enable_fixup = false;
+static uintptr_t g_last_fixup_frame_address = 0;
+
+#if ABSL_HAVE_ATTRIBUTE_WEAK
+bool absl::internal_stacktrace::ShouldFixUpStack() {
+  ++g_should_fixup_calls;
+  return g_enable_fixup;
+}
+
+void absl::internal_stacktrace::FixUpStack(void**, uintptr_t*, int*, size_t,
+                                           size_t&) {
+  const void* frame_address = nullptr;
+#if ABSL_HAVE_BUILTIN(__builtin_frame_address)
+  frame_address = __builtin_frame_address(0);
+#endif
+  g_last_fixup_frame_address = reinterpret_cast<uintptr_t>(frame_address);
+  ++g_fixup_calls;
+}
+#endif
 
 namespace {
 
+using ::testing::ContainerEq;
+using ::testing::Contains;
+using ::testing::internal::Cleanup;
+
+struct StackTrace {
+  static constexpr int kStackCount = 64;
+  int depth;
+  void* result[kStackCount];
+  uintptr_t frames[kStackCount];
+  int sizes[kStackCount];
+};
+
 // This test is currently only known to pass on Linux x86_64/aarch64.
 #if defined(__linux__) && (defined(__x86_64__) || defined(__aarch64__))
 ABSL_ATTRIBUTE_NOINLINE void Unwind(void* p) {
@@ -44,4 +90,392 @@ TEST(StackTrace, HugeFrame) {
 }
 #endif
 
+// This is a separate function to avoid inlining.
+ABSL_ATTRIBUTE_NOINLINE static void FixupNoFixupEquivalenceNoInline() {
+#if !ABSL_HAVE_ATTRIBUTE_WEAK
+  GTEST_SKIP() << "Need weak symbol support";
+#endif
+#if defined(__riscv)
+  GTEST_SKIP() << "Skipping test on RISC-V due to pre-existing failure";
+#endif
+#if defined(_WIN32)
+  // TODO(b/434184677): Add support for fixups on Windows if needed
+  GTEST_SKIP() << "Skipping test on Windows due to lack of support for fixups";
+#endif
+  bool can_rely_on_frame_pointers = false;
+  if (!can_rely_on_frame_pointers) {
+    GTEST_SKIP() << "Frame pointers are required, but not guaranteed in OSS";
+  }
+
+  // This test is known not to pass on MSVC (due to weak symbols)
+
+  const Cleanup restore_state([enable_fixup = g_enable_fixup,
+                               fixup_calls = g_fixup_calls,
+                               should_fixup_calls = g_should_fixup_calls]() {
+    g_enable_fixup = enable_fixup;
+    g_fixup_calls = fixup_calls;
+    g_should_fixup_calls = should_fixup_calls;
+  });
+
+  constexpr int kSkip = 1;  // Skip our own frame, whose return PCs won't match
+  constexpr auto kStackCount = 1;
+
+  StackTrace a;
+  StackTrace b;
+
+  // ==========================================================================
+
+  g_fixup_calls = 0;
+  g_should_fixup_calls = 0;
+  a.depth = absl::GetStackTrace(a.result, kStackCount, kSkip);
+  g_enable_fixup = !g_enable_fixup;
+  b.depth = absl::GetStackTrace(b.result, kStackCount, kSkip);
+  EXPECT_THAT(
+      absl::MakeSpan(a.result, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.result, static_cast<size_t>(b.depth))));
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GE(g_should_fixup_calls, g_fixup_calls);
+
+  // ==========================================================================
+
+  g_fixup_calls = 0;
+  g_should_fixup_calls = 0;
+  a.depth = absl::GetStackFrames(a.result, a.sizes, kStackCount, kSkip);
+  g_enable_fixup = !g_enable_fixup;
+  b.depth = absl::GetStackFrames(b.result, b.sizes, kStackCount, kSkip);
+  EXPECT_THAT(
+      absl::MakeSpan(a.result, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.result, static_cast<size_t>(b.depth))));
+  EXPECT_THAT(
+      absl::MakeSpan(a.sizes, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.sizes, static_cast<size_t>(b.depth))));
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GE(g_should_fixup_calls, g_fixup_calls);
+
+  // ==========================================================================
+
+  g_fixup_calls = 0;
+  g_should_fixup_calls = 0;
+  a.depth = absl::GetStackTraceWithContext(a.result, kStackCount, kSkip,
+                                           nullptr, nullptr);
+  g_enable_fixup = !g_enable_fixup;
+  b.depth = absl::GetStackTraceWithContext(b.result, kStackCount, kSkip,
+                                           nullptr, nullptr);
+  EXPECT_THAT(
+      absl::MakeSpan(a.result, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.result, static_cast<size_t>(b.depth))));
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GE(g_should_fixup_calls, g_fixup_calls);
+
+  // ==========================================================================
+
+  g_fixup_calls = 0;
+  g_should_fixup_calls = 0;
+  a.depth = absl::GetStackFramesWithContext(a.result, a.sizes, kStackCount,
+                                            kSkip, nullptr, nullptr);
+  g_enable_fixup = !g_enable_fixup;
+  b.depth = absl::GetStackFramesWithContext(b.result, b.sizes, kStackCount,
+                                            kSkip, nullptr, nullptr);
+  EXPECT_THAT(
+      absl::MakeSpan(a.result, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.result, static_cast<size_t>(b.depth))));
+  EXPECT_THAT(
+      absl::MakeSpan(a.sizes, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.sizes, static_cast<size_t>(b.depth))));
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GE(g_should_fixup_calls, g_fixup_calls);
+
+  // ==========================================================================
+
+  g_fixup_calls = 0;
+  g_should_fixup_calls = 0;
+  a.depth = absl::internal_stacktrace::GetStackFrames(
+      a.result, a.frames, a.sizes, kStackCount, kSkip);
+  g_enable_fixup = !g_enable_fixup;
+  b.depth = absl::internal_stacktrace::GetStackFrames(
+      b.result, b.frames, b.sizes, kStackCount, kSkip);
+  EXPECT_THAT(
+      absl::MakeSpan(a.result, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.result, static_cast<size_t>(b.depth))));
+  EXPECT_THAT(
+      absl::MakeSpan(a.sizes, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.sizes, static_cast<size_t>(b.depth))));
+  EXPECT_THAT(
+      absl::MakeSpan(a.frames, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.frames, static_cast<size_t>(b.depth))));
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GE(g_should_fixup_calls, g_fixup_calls);
+
+  // ==========================================================================
+
+  g_fixup_calls = 0;
+  g_should_fixup_calls = 0;
+  a.depth = absl::internal_stacktrace::GetStackFramesWithContext(
+      a.result, a.frames, a.sizes, kStackCount, kSkip, nullptr, nullptr);
+  g_enable_fixup = !g_enable_fixup;
+  b.depth = absl::internal_stacktrace::GetStackFramesWithContext(
+      b.result, b.frames, b.sizes, kStackCount, kSkip, nullptr, nullptr);
+  EXPECT_THAT(
+      absl::MakeSpan(a.result, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.result, static_cast<size_t>(b.depth))));
+  EXPECT_THAT(
+      absl::MakeSpan(a.sizes, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.sizes, static_cast<size_t>(b.depth))));
+  EXPECT_THAT(
+      absl::MakeSpan(a.frames, static_cast<size_t>(a.depth)),
+      ContainerEq(absl::MakeSpan(b.frames, static_cast<size_t>(b.depth))));
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GE(g_should_fixup_calls, g_fixup_calls);
+}
+
+TEST(StackTrace, FixupNoFixupEquivalence) { FixupNoFixupEquivalenceNoInline(); }
+
+TEST(StackTrace, FixupLowStackUsage) {
+#if !ABSL_HAVE_ATTRIBUTE_WEAK
+  GTEST_SKIP() << "Skipping test on MSVC due to weak symbols";
+#endif
+#if defined(_WIN32)
+  // TODO(b/434184677): Add support for fixups on Windows if needed
+  GTEST_SKIP() << "Skipping test on Windows due to lack of support for fixups";
+#endif
+
+  const Cleanup restore_state([enable_fixup = g_enable_fixup,
+                               fixup_calls = g_fixup_calls,
+                               should_fixup_calls = g_should_fixup_calls]() {
+    g_enable_fixup = enable_fixup;
+    g_fixup_calls = fixup_calls;
+    g_should_fixup_calls = should_fixup_calls;
+  });
+
+  g_enable_fixup = true;
+
+  // Request a ton of stack frames, regardless of how many are actually used.
+  // It's fine to request more frames than we have, since functions preallocate
+  // memory before discovering how high the stack really is, and we're really
+  // just trying to make sure the preallocations don't overflow the stack.
+  //
+  // Note that we loop in order to cover all sides of any branches in the
+  // implementation that switch allocation behavior (e.g., from stack to heap)
+  // and to ensure that no sides allocate too much stack space.
+  constexpr size_t kPageSize = 4096;
+  for (size_t depth = 2; depth < (1 << 20); depth += depth / 2) {
+    const auto stack = std::make_unique<void*[]>(depth);
+    const auto frames = std::make_unique<int[]>(depth);
+
+    absl::GetStackFrames(stack.get(), frames.get(), static_cast<int>(depth), 0);
+    const void* frame_address = nullptr;
+#if ABSL_HAVE_BUILTIN(__builtin_frame_address)
+    frame_address = __builtin_frame_address(0);
+#endif
+    size_t stack_usage =
+        reinterpret_cast<uintptr_t>(frame_address) - g_last_fixup_frame_address;
+    EXPECT_LT(stack_usage, kPageSize);
+  }
+}
+
+TEST(StackTrace, CustomUnwinderPerformsFixup) {
+#if !ABSL_HAVE_ATTRIBUTE_WEAK
+  GTEST_SKIP() << "Need weak symbol support";
+#endif
+#if defined(_WIN32)
+  // TODO(b/434184677): Add support for fixups on Windows if needed
+  GTEST_SKIP() << "Skipping test on Windows due to lack of support for fixups";
+#endif
+
+  constexpr int kSkip = 1;  // Skip our own frame, whose return PCs won't match
+  constexpr auto kStackCount = 1;
+
+  absl::SetStackUnwinder(absl::DefaultStackUnwinder);
+  const Cleanup restore_state([enable_fixup = g_enable_fixup,
+                               fixup_calls = g_fixup_calls,
+                               should_fixup_calls = g_should_fixup_calls]() {
+    absl::SetStackUnwinder(nullptr);
+    g_enable_fixup = enable_fixup;
+    g_fixup_calls = fixup_calls;
+    g_should_fixup_calls = should_fixup_calls;
+  });
+
+  StackTrace trace;
+
+  g_enable_fixup = true;
+  g_should_fixup_calls = 0;
+  g_fixup_calls = 0;
+  absl::GetStackTrace(trace.result, kSkip, kStackCount);
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GT(g_fixup_calls, 0);
+
+  g_enable_fixup = true;
+  g_should_fixup_calls = 0;
+  g_fixup_calls = 0;
+  absl::GetStackFrames(trace.result, trace.sizes, kSkip, kStackCount);
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GT(g_fixup_calls, 0);
+
+  g_enable_fixup = true;
+  g_should_fixup_calls = 0;
+  g_fixup_calls = 0;
+  absl::GetStackTraceWithContext(trace.result, kSkip, kStackCount, nullptr,
+                                 nullptr);
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GT(g_fixup_calls, 0);
+
+  g_enable_fixup = true;
+  g_should_fixup_calls = 0;
+  g_fixup_calls = 0;
+  absl::GetStackFramesWithContext(trace.result, trace.sizes, kSkip, kStackCount,
+                                  nullptr, nullptr);
+  EXPECT_GT(g_should_fixup_calls, 0);
+  EXPECT_GT(g_fixup_calls, 0);
+}
+
+#if ABSL_HAVE_BUILTIN(__builtin_frame_address)
+struct FrameInfo {
+  const void* return_address;
+  uintptr_t frame_address;
+};
+
+// Returns the canonical frame address and return address for the current stack
+// frame, while capturing the stack trace at the same time.
+// This performs any platform-specific adjustments necessary to convert from the
+// compiler built-ins to the expected API outputs.
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS     // May read random elements from stack.
+    ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY  // May read random elements from stack.
+        ABSL_ATTRIBUTE_NOINLINE static FrameInfo
+        CaptureBacktraceNoInline(StackTrace& backtrace) {
+  FrameInfo result;
+  result.return_address = __builtin_return_address(0);
+  // Large enough to cover all realistic slots the return address could be in
+  const int kMaxReturnAddressIndex = 5;
+  void* const* bfa = static_cast<void* const*>(__builtin_frame_address(0));
+  backtrace.depth = absl::internal_stacktrace::GetStackFramesWithContext(
+      backtrace.result, backtrace.frames, backtrace.sizes,
+      StackTrace::kStackCount, /*skip_count=*/0,
+      /*uc=*/nullptr, /*min_dropped_frames=*/nullptr);
+  // Make sure the return address is at a reasonable location in the frame
+  ptrdiff_t i;
+  for (i = 0; i < kMaxReturnAddressIndex; ++i) {
+    // Avoid std::find() here, since it lacks no-sanitize attributes.
+    if (bfa[i] == result.return_address) {
+      break;
+    }
+  }
+  result.frame_address =
+      i < kMaxReturnAddressIndex
+          ? reinterpret_cast<uintptr_t>(
+                bfa + i + 1 /* get the Canonical Frame Address (CFA) */)
+          : 0;
+  return result;
+}
+
+TEST(StackTrace, CanonicalFrameAddresses) {
+  // Now capture a stack trace and verify that the return addresses and frame
+  // addresses line up for one frame.
+  StackTrace backtrace;
+  const auto [return_address, frame_address] =
+      CaptureBacktraceNoInline(backtrace);
+  auto return_addresses = absl::MakeSpan(backtrace.result)
+                              .subspan(0, static_cast<size_t>(backtrace.depth));
+  auto frame_addresses = absl::MakeSpan(backtrace.frames)
+                             .subspan(0, static_cast<size_t>(backtrace.depth));
+
+  // Many platforms don't support this by default.
+  bool support_is_expected = false;
+
+  if (support_is_expected) {
+    // If all zeros were returned, that is valid per the function's contract.
+    // It just means we don't support returning frame addresses on this
+    // platform.
+    bool supported = static_cast<size_t>(std::count(frame_addresses.begin(),
+                                                    frame_addresses.end(), 0)) <
+                     frame_addresses.size();
+    EXPECT_TRUE(supported);
+    if (supported) {
+      ASSERT_TRUE(frame_address)
+          << "unable to obtain frame address corresponding to return address";
+      EXPECT_THAT(return_addresses, Contains(return_address).Times(1));
+      EXPECT_THAT(frame_addresses, Contains(frame_address).Times(1));
+      ptrdiff_t ifound = std::find(return_addresses.begin(),
+                                   return_addresses.end(), return_address) -
+                         return_addresses.begin();
+      // Make sure we found the frame in the first place.
+      ASSERT_LT(ifound, backtrace.depth);
+      // Make sure the frame address actually corresponds to the return
+      // address.
+      EXPECT_EQ(frame_addresses[static_cast<size_t>(ifound)], frame_address);
+      // Make sure the addresses only appear once.
+    }
+  }
+}
+#endif
+
+// This test is Linux specific.
+#if defined(__linux__)
+const void* g_return_address = nullptr;
+bool g_sigusr2_raised = false;
+
+void SigUsr2Handler(int, siginfo_t*, void* uc) {
+  // Many platforms don't support this by default.
+  bool support_is_expected = false;
+  constexpr int kMaxStackDepth = 64;
+  void* result[kMaxStackDepth];
+  int depth =
+      absl::GetStackTraceWithContext(result, kMaxStackDepth, 0, uc, nullptr);
+  // Verify we can unwind past the nested signal handlers.
+  if (support_is_expected) {
+    EXPECT_THAT(absl::MakeSpan(result, static_cast<size_t>(depth)),
+                Contains(g_return_address).Times(1));
+  }
+  depth = absl::GetStackTrace(result, kMaxStackDepth, 0);
+  if (support_is_expected) {
+    EXPECT_THAT(absl::MakeSpan(result, static_cast<size_t>(depth)),
+                Contains(g_return_address).Times(1));
+  }
+  g_sigusr2_raised = true;
+}
+
+void SigUsr1Handler(int, siginfo_t*, void*) {
+  raise(SIGUSR2);
+  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+}
+
+ABSL_ATTRIBUTE_NOINLINE void RaiseSignal() {
+  g_return_address = __builtin_return_address(0);
+  raise(SIGUSR1);
+  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+}
+
+ABSL_ATTRIBUTE_NOINLINE void TestNestedSignal() {
+  constexpr size_t kAltstackSize = 1 << 14;
+  // Allocate altstack on regular stack to make sure it'll have a higher
+  // address than some of the regular stack frames.
+  char space[kAltstackSize];
+  stack_t altstack;
+  stack_t old_stack;
+  altstack.ss_sp = space;
+  altstack.ss_size = kAltstackSize;
+  altstack.ss_flags = 0;
+  ASSERT_EQ(sigaltstack(&altstack, &old_stack), 0) << strerror(errno);
+  struct sigaction act;
+  struct sigaction oldusr1act;
+  struct sigaction oldusr2act;
+  act.sa_sigaction = SigUsr1Handler;
+  act.sa_flags = SA_SIGINFO | SA_ONSTACK;
+  sigemptyset(&act.sa_mask);
+  ASSERT_EQ(sigaction(SIGUSR1, &act, &oldusr1act), 0) << strerror(errno);
+  act.sa_sigaction = SigUsr2Handler;
+  ASSERT_EQ(sigaction(SIGUSR2, &act, &oldusr2act), 0) << strerror(errno);
+  RaiseSignal();
+  ASSERT_EQ(sigaltstack(&old_stack, nullptr), 0) << strerror(errno);
+  ASSERT_EQ(sigaction(SIGUSR1, &oldusr1act, nullptr), 0) << strerror(errno);
+  ASSERT_EQ(sigaction(SIGUSR2, &oldusr2act, nullptr), 0) << strerror(errno);
+  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+}
+
+TEST(StackTrace, NestedSignal) {
+  // Verify we can unwind past the nested signal handlers.
+  TestNestedSignal();
+  EXPECT_TRUE(g_sigusr2_raised);
+}
+#endif
+
 }  // namespace