Adds functionality to return stack frame pointers during stack walking, in addition to code addresses

Together with the frame sizes already being returned, this gives us the bounds on each stack frame.

Note that this may slightly affect MSVC in debug builds, as it does not respect ABSL_ATTRIBUTE_ALWAYS_INLINE without optimizations. To remedy this, either enable inlining (/Ob1 or higher), or write a wrapper that ensures any stack traces obtained are robust to frames being added (such as by manually filtering everything below the caller).

Do not depend on the new APIs publicly. They are subject to change or removal.

PiperOrigin-RevId: 740075920
Change-Id: I6cd0909e7be3af4c9f32d39633230f655946b6a8

Author: Abseil Team

absl/debugging/BUILD.bazel

@@ -66,7 +66,9 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":stacktrace",
+        "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/types:span",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],

absl/debugging/CMakeLists.txt

@@ -55,7 +55,9 @@ absl_cc_test(
     ${ABSL_TEST_COPTS}
   DEPS
     absl::stacktrace
+    absl::config
     absl::core_headers
+    absl::span
     GTest::gmock_main
 )
 

absl/debugging/internal/addresses.h

@@ -25,14 +25,14 @@ namespace debugging_internal {
 
 // Removes any metadata (tag bits) from the given pointer, converting it into a
 // user-readable address.
-inline uintptr_t StripPointerMetadata(void* ptr) {
+inline uintptr_t StripPointerMetadata(uintptr_t ptr) {
 #if defined(__aarch64__)
   // When PAC-RET (-mbranch-protection=pac-ret) is enabled, return addresses
   // stored on the stack will be signed, which means that pointer bits outside
   // of the virtual address range are potentially set. Since the stacktrace code
   // is expected to return normal code pointers, this function clears those
   // bits.
-  register uintptr_t x30 __asm__("x30") = reinterpret_cast<uintptr_t>(ptr);
+  register uintptr_t x30 __asm__("x30") = ptr;
   // The normal instruction for clearing PAC bits is XPACI, but for
   // compatibility with ARM platforms that do not support pointer
   // authentication, we use the hint space instruction XPACLRI instead. Hint
@@ -42,10 +42,14 @@ inline uintptr_t StripPointerMetadata(void* ptr) {
 #undef ABSL_XPACLRI_HINT
   return x30;
 #else
-  return reinterpret_cast<uintptr_t>(ptr);
+  return ptr;
 #endif
 }
 
+inline uintptr_t StripPointerMetadata(void* ptr) {
+  return StripPointerMetadata(reinterpret_cast<uintptr_t>(ptr));
+}
+
 }  // namespace debugging_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

absl/debugging/internal/stacktrace_aarch64-inl.inc

@@ -185,8 +185,9 @@ template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 ABSL_ATTRIBUTE_NOINLINE
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
+static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
+                      int max_depth, int skip_count, const void *ucp,
+                      int *min_dropped_frames) {
 #ifdef __GNUC__
   void **frame_pointer = reinterpret_cast<void**>(__builtin_frame_address(0));
 #else
@@ -223,8 +224,15 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
       result[n] = reinterpret_cast<void *>(
           absl::debugging_internal::StripPointerMetadata(prev_return_address));
       if (IS_STACK_FRAMES) {
-        sizes[n] = static_cast<int>(
-            ComputeStackFrameSize(prev_frame_pointer, frame_pointer));
+        if (frames != nullptr) {
+          frames[n] = absl::debugging_internal::StripPointerMetadata(
+                          prev_frame_pointer) +
+                      2 * sizeof(void *) /* go past the return address */;
+        }
+        if (sizes != nullptr) {
+          sizes[n] = static_cast<int>(
+              ComputeStackFrameSize(prev_frame_pointer, frame_pointer));
+        }
       }
       n++;
     }

absl/debugging/internal/stacktrace_arm-inl.inc

@@ -19,6 +19,7 @@
 
 #include <cstdint>
 
+#include "absl/debugging/internal/addresses.h"
 #include "absl/debugging/stacktrace.h"
 
 // WARNING:
@@ -67,8 +68,9 @@ void StacktraceArmDummyFunction() { __asm__ volatile(""); }
 #endif
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
-                      const void * /* ucp */, int *min_dropped_frames) {
+static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
+                      int max_depth, int skip_count, const void * /* ucp */,
+                      int *min_dropped_frames) {
 #ifdef __GNUC__
   void **sp = reinterpret_cast<void**>(__builtin_frame_address(0));
 #else
@@ -97,11 +99,18 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
       result[n] = *sp;
 
       if (IS_STACK_FRAMES) {
-        if (next_sp > sp) {
-          sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
-        } else {
-          // A frame-size of 0 is used to indicate unknown frame size.
-          sizes[n] = 0;
+        if (frames != nullptr) {
+          frames[n] = absl::debugging_internal::StripPointerMetadata(sp) +
+                      1 * sizeof(void *) /* go past the return address */;
+        }
+        if (sizes != nullptr) {
+          if (next_sp > sp) {
+            sizes[n] = 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;
+          }
         }
       }
       n++;

absl/debugging/internal/stacktrace_emscripten-inl.inc

@@ -21,6 +21,7 @@
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
 
 #include <emscripten.h>
+#include <stdint.h>
 
 #include <atomic>
 #include <cstring>
@@ -62,8 +63,9 @@ ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
 }();
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
+static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
+                      int max_depth, int skip_count, const void *ucp,
+                      int *min_dropped_frames) {
   if (recursive || disable_stacktraces.load(std::memory_order_relaxed)) {
     return 0;
   }
@@ -83,8 +85,13 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
   for (int i = 0; i < result_count; i++) result[i] = stack[i + skip_count];
 
   if (IS_STACK_FRAMES) {
-    // No implementation for finding out the stack frame sizes yet.
-    memset(sizes, 0, sizeof(*sizes) * result_count);
+    // No implementation for finding out the stack frames yet.
+    if (frames != nullptr) {
+      memset(frames, 0, sizeof(*frames) * result_count);
+    }
+    if (sizes != nullptr) {
+      memset(sizes, 0, sizeof(*sizes) * result_count);
+    }
   }
   if (min_dropped_frames != nullptr) {
     if (size - skip_count - max_depth > 0) {

absl/debugging/internal/stacktrace_generic-inl.inc

@@ -56,8 +56,9 @@ ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
 }();
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
+static int UnwindImpl(void** result, uintptr_t* frames, int* sizes,
+                      int max_depth, int skip_count, const void* ucp,
+                      int* min_dropped_frames) {
   if (recursive || disable_stacktraces.load(std::memory_order_relaxed)) {
     return 0;
   }
@@ -79,8 +80,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
     result[i] = stack[i + skip_count];
 
   if (IS_STACK_FRAMES) {
-    // No implementation for finding out the stack frame sizes yet.
-    memset(sizes, 0, sizeof(*sizes) * static_cast<size_t>(result_count));
+    // No implementation for finding out the stack frames yet.
+    if (frames != nullptr) {
+      memset(frames, 0, sizeof(*frames) * static_cast<size_t>(result_count));
+    }
+    if (sizes != nullptr) {
+      memset(sizes, 0, sizeof(*sizes) * static_cast<size_t>(result_count));
+    }
   }
   if (min_dropped_frames != nullptr) {
     if (size - skip_count - max_depth > 0) {

absl/debugging/internal/stacktrace_powerpc-inl.inc

@@ -21,6 +21,7 @@
 #ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
 
+#include "absl/debugging/internal/addresses.h"
 #if defined(__linux__)
 #include <asm/ptrace.h>   // for PT_NIP.
 #include <ucontext.h>     // for ucontext_t
@@ -40,22 +41,22 @@
 
 // Given a stack pointer, return the saved link register value.
 // Note that this is the link register for a callee.
-static inline void *StacktracePowerPCGetLR(void **sp) {
+static inline void **StacktracePowerPCGetLRPtr(void **sp) {
   // PowerPC has 3 main ABIs, which say where in the stack the
   // Link Register is.  For DARWIN and AIX (used by apple and
   // linux ppc64), it's in sp[2].  For SYSV (used by linux ppc),
   // it's in sp[1].
 #if defined(_CALL_AIX) || defined(_CALL_DARWIN)
-  return *(sp+2);
+  return (sp + 2);
 #elif defined(_CALL_SYSV)
-  return *(sp+1);
+  return (sp + 1);
 #elif defined(__APPLE__) || defined(__FreeBSD__) || \
     (defined(__linux__) && defined(__PPC64__))
   // This check is in case the compiler doesn't define _CALL_AIX/etc.
-  return *(sp+2);
+  return (sp + 2);
 #elif defined(__linux)
   // This check is in case the compiler doesn't define _CALL_SYSV.
-  return *(sp+1);
+  return (sp + 1);
 #else
 #error Need to specify the PPC ABI for your architecture.
 #endif
@@ -125,9 +126,8 @@ static void **NextStackFrame(void **old_sp, const void *uc) {
       }
     }
 
-    if (new_sp != nullptr &&
-        kernel_symbol_status == kAddressValid &&
-        StacktracePowerPCGetLR(new_sp) == kernel_sigtramp_rt64_address) {
+    if (new_sp != nullptr && kernel_symbol_status == kAddressValid &&
+        *StacktracePowerPCGetLRPtr(new_sp) == kernel_sigtramp_rt64_address) {
       const ucontext_t* signal_context =
           reinterpret_cast<const ucontext_t*>(uc);
       void **const sp_before_signal =
@@ -164,8 +164,9 @@ ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() {
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
+static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
+                      int max_depth, int skip_count, const void *ucp,
+                      int *min_dropped_frames) {
   void **sp;
   // Apple macOS uses an old version of gnu as -- both Darwin 7.9.0 (Panther)
   // and Darwin 8.8.1 (Tiger) use as 1.38.  This means we have to use a
@@ -211,13 +212,21 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
     if (skip_count > 0) {
       skip_count--;
     } else {
-      result[n] = StacktracePowerPCGetLR(sp);
+      void **lr = StacktracePowerPCGetLRPtr(sp);
+      result[n] = *lr;
       if (IS_STACK_FRAMES) {
-        if (next_sp > sp) {
-          sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
-        } else {
-          // A frame-size of 0 is used to indicate unknown frame size.
-          sizes[n] = 0;
+        if (frames != nullptr) {
+          frames[n] = absl::debugging_internal::StripPointerMetadata(lr) +
+                      1 * sizeof(void *) /* go past the return address */;
+        }
+        if (sizes != nullptr) {
+          if (next_sp > sp) {
+            sizes[n] = 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;
+          }
         }
       }
       n++;

absl/debugging/internal/stacktrace_riscv-inl.inc

@@ -20,6 +20,7 @@
 #include <sys/ucontext.h>
 
 #include "absl/base/config.h"
+#include "absl/debugging/internal/addresses.h"
 #if defined(__linux__)
 #include <sys/mman.h>
 #include <ucontext.h>
@@ -117,8 +118,9 @@ static void ** NextStackFrame(void **old_frame_pointer, const void *uc,
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
+static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
+                      int max_depth, int skip_count, const void *ucp,
+                      int *min_dropped_frames) {
   // The `frame_pointer` that is computed here points to the top of the frame.
   // The two words preceding the address are the return address and the previous
   // frame pointer.
@@ -153,8 +155,13 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
       result[n] = return_address;
       if (IS_STACK_FRAMES) {
         // NextStackFrame() has already checked that frame size fits to int
-        sizes[n] = static_cast<int>(ComputeStackFrameSize(frame_pointer,
-                                                          next_frame_pointer));
+        if (frames != nullptr) {
+          frames[n] =
+              absl::debugging_internal::StripPointerMetadata(frame_pointer);
+        }
+        if (sizes != nullptr) {
+          sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
+        }
       }
       n++;
     }

absl/debugging/internal/stacktrace_unimplemented-inl.inc

@@ -2,9 +2,10 @@
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-static int UnwindImpl(void** /* result */, int* /* sizes */,
-                      int /* max_depth */, int /* skip_count */,
-                      const void* /* ucp */, int *min_dropped_frames) {
+static int UnwindImpl(void** /* result */, uintptr_t* /* frames */,
+                      int* /* sizes */, int /* max_depth */,
+                      int /* skip_count */, const void* /* ucp */,
+                      int* min_dropped_frames) {
   if (min_dropped_frames != nullptr) {
     *min_dropped_frames = 0;
   }