re2 1.24.0 → 1.25.0

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

@@ -142,6 +142,10 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
   void *return_address = nullptr;
   while (frame_pointer && n < max_depth) {
     return_address = frame_pointer[-1];
+    // Follow x86 and stop if the return address is null (end of stack).
+    if (return_address == nullptr) {
+      break;
+    }
 
     // The absl::GetStackFrames routine is called when we are in some
     // informational context (the failure signal handler for example).  Use the

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

@@ -22,6 +22,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 
 #include "absl/base/config.h"
 #include "absl/strings/string_view.h"
@@ -35,7 +36,6 @@
 #include <elf.h>
 #include <link.h>  // For ElfW() macro.
 #include <functional>
-#include <string>
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -78,44 +78,54 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
-struct SymbolDecoratorArgs {
-  // The program counter we are getting symbolic name for.
-  const void *pc;
-  // 0 for main executable, load address for shared libraries.
-  ptrdiff_t relocation;
-  // Read-only file descriptor for ELF image covering "pc",
-  // or -1 if no such ELF image exists in /proc/self/maps.
-  int fd;
-  // Output buffer, size.
-  // Note: the buffer may not be empty -- default symbolizer may have already
-  // produced some output, and earlier decorators may have adorned it in
-  // some way. You are free to replace or augment the contents (within the
-  // symbol_buf_size limit).
-  char *const symbol_buf;
-  size_t symbol_buf_size;
-  // Temporary scratch space, size.
-  // Use that space in preference to allocating your own stack buffer to
-  // conserve stack.
-  char *const tmp_buf;
-  size_t tmp_buf_size;
-  // User-provided argument
-  void* arg;
-};
-using SymbolDecorator = void (*)(const SymbolDecoratorArgs *);
+class SymbolDecorator;
 
-// Installs a function-pointer as a decorator. Returns a value less than zero
-// if the system cannot install the decorator. Otherwise, returns a unique
-// identifier corresponding to the decorator. This identifier can be used to
-// uninstall the decorator - See RemoveSymbolDecorator() below.
-int InstallSymbolDecorator(SymbolDecorator decorator, void* arg);
+class SymbolDecoratorDeleter {
+ public:
+  void operator()(SymbolDecorator* ptr);
+};
 
-// Removes a previously installed function-pointer decorator. Parameter "ticket"
-// is the return-value from calling InstallSymbolDecorator().
-bool RemoveSymbolDecorator(int ticket);
+using SymbolDecoratorPtr =
+    std::unique_ptr<SymbolDecorator, SymbolDecoratorDeleter>;
+
+// Represents an object that can add additional information to a symbol
+// name.
+class SymbolDecorator {
+ public:
+  // The signature of a factory function used to register and create a symbol
+  // decorator. This function may be called from a signal handler, so it must
+  // use an async-signal-safe allocation mechanism to allocate the returned
+  // object.
+  using Factory = SymbolDecoratorPtr(int fd);
+
+  virtual ~SymbolDecorator() = default;
+
+  // Decorates symbol name with additional information.
+  //
+  // pc represents the program counter we are getting symbolic name for.
+  // relocation is difference between the link-time and the load-time address.
+  // symbol_buf and symbol_buf_size represent the output buffer and its size.
+  // Note that the buffer may not be empty -- default symbolizer may have
+  // already produced some output. You are free to replace or augment the
+  // contents (within the symbol_buf_size limit). tmp_buf and tmp_buf_size
+  // represent temporary scratch space and its size. Use that space in
+  // preference to allocating your own stack buffer to conserve stack.
+  //
+  // This function will not be called concurrently for the same object, but it
+  // may be called from a signal handler, so it must avoid any operation that is
+  // not async-signal-safe. However, it does not have to be reentrant -- if it
+  // is interrupted by a signal and the handler tries to symbolize, the request
+  // will go to a new SymbolDecorator instance.
+  virtual void Decorate(
+      const void* pc,
+      ptrdiff_t relocation,
+      char* symbol_buf, size_t symbol_buf_size,
+      char* tmp_buf, size_t tmp_buf_size) const = 0;
+};
 
-// Remove all installed decorators.  Returns true if successful, false if
-// symbolization is currently in progress.
-bool RemoveAllSymbolDecorators();
+// Registers a new symbol decorator factory and returns the previous one.
+SymbolDecorator::Factory* SetSymbolDecoratorFactory(
+    SymbolDecorator::Factory* factory);
 
 // Registers an address range to a file mapping.
 //

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

@@ -47,7 +47,6 @@
 #include "absl/base/config.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)
@@ -92,19 +91,6 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
   }
 #endif
 
-  // 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);
   size_t size;
   // Add 1 to skip count for the unwinder function itself
@@ -117,14 +103,9 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
       std::fill(frames, frames + size, uintptr_t());
     }
   } else {
-    size = static_cast<size_t>(
-        unwind_with_fixup
-            ? UnwindImpl<true, IS_WITH_CONTEXT>(
-                  result, frames, sizes, static_cast<int>(max_depth),
-                  skip_count, uc, min_dropped_frames)
-            : UnwindImpl<IS_STACK_FRAMES, IS_WITH_CONTEXT>(
-                  result, frames, sizes, static_cast<int>(max_depth),
-                  skip_count, uc, min_dropped_frames));
+    size = static_cast<size_t>(UnwindImpl<IS_STACK_FRAMES, IS_WITH_CONTEXT>(
+        result, frames, sizes, static_cast<int>(max_depth), skip_count, uc,
+        min_dropped_frames));
   }
   if (unwind_with_fixup) {
     internal_stacktrace::FixUpStack(result, frames, sizes, max_depth, size);
@@ -136,24 +117,13 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
 
 }  // anonymous namespace
 
-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) {
-  return Unwind<true, false>(result, frames, sizes,
+ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFrames(
+    void** result, int* sizes, int max_depth, int skip_count) {
+  return Unwind<true, false>(result, nullptr, sizes,
                              static_cast<size_t>(max_depth), skip_count,
                              nullptr, nullptr);
 }
 
-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) {
-  return Unwind<true, true>(result, frames, sizes,
-                            static_cast<size_t>(max_depth), skip_count, uc,
-                            min_dropped_frames);
-}
-
 ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
 internal_stacktrace::GetStackTraceNoFixup(void** result, int max_depth,
                                           int skip_count) {
@@ -162,6 +132,15 @@ internal_stacktrace::GetStackTraceNoFixup(void** result, int max_depth,
                               nullptr, nullptr, /*unwind_with_fixup=*/false);
 }
 
+ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
+GetStackFramesWithContext(void** result, int* sizes, int max_depth,
+                          int skip_count, const void* uc,
+                          int* min_dropped_frames) {
+  return Unwind<true, true>(result, nullptr, sizes,
+                            static_cast<size_t>(max_depth), skip_count, uc,
+                            min_dropped_frames);
+}
+
 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,
@@ -181,9 +160,8 @@ void SetStackUnwinder(Unwinder w) {
   custom.store(w, std::memory_order_release);
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE static inline int DefaultStackUnwinderImpl(
-    void** pcs, uintptr_t* frames, int* sizes, int depth, int skip,
-    const void* uc, int* min_dropped_frames) {
+int DefaultStackUnwinder(void** pcs, int* sizes, int depth, int skip,
+                         const void* uc, int* min_dropped_frames) {
   skip++;  // For this function
   decltype(&UnwindImpl<false, false>) f;
   if (sizes == nullptr) {
@@ -199,25 +177,7 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE static inline int DefaultStackUnwinderImpl(
       f = &UnwindImpl<true, true>;
     }
   }
-  return (*f)(pcs, frames, sizes, depth, skip, uc, min_dropped_frames);
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
-internal_stacktrace::DefaultStackUnwinder(void** pcs, uintptr_t* frames,
-                                          int* sizes, int depth, int skip,
-                                          const void* uc,
-                                          int* min_dropped_frames) {
-  int n = DefaultStackUnwinderImpl(pcs, frames, sizes, depth, skip, uc,
-                                   min_dropped_frames);
-  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
-  return n;
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int DefaultStackUnwinder(
-    void** pcs, int* sizes, int depth, int skip, const void* uc,
-    int* min_dropped_frames) {
-  int n = DefaultStackUnwinderImpl(pcs, nullptr, sizes, depth, skip, uc,
-                                   min_dropped_frames);
+  int n = (*f)(pcs, nullptr, sizes, depth, skip, uc, min_dropped_frames);
   ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
   return n;
 }

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

@@ -34,7 +34,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "absl/base/attributes.h"
 #include "absl/base/config.h"
 
 namespace absl {
@@ -42,43 +41,9 @@ 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);
-
 // 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.
-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()
@@ -123,13 +88,8 @@ extern int DefaultStackUnwinder(void** pcs, uintptr_t* frames, int* sizes,
 //
 // This routine may return fewer stack frame entries than are
 // available. Also note that `result` and `sizes` must both be non-null.
-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);
-}
+extern int GetStackFrames(void** result, int* sizes, int max_depth,
+                          int skip_count);
 
 // GetStackFramesWithContext()
 //
@@ -152,12 +112,9 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int GetStackFrames(void** result,
 // 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.
-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);
-}
+extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
+                                     int skip_count, const void* uc,
+                                     int* min_dropped_frames);
 
 // GetStackTrace()
 //

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

@@ -17,7 +17,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <algorithm>
 #include <cerrno>
 #include <csignal>
 #include <cstring>
@@ -63,7 +62,6 @@ struct StackTrace {
   static constexpr int kStackCount = 64;
   int depth;
   void* result[kStackCount];
-  uintptr_t frames[kStackCount];
   int sizes[kStackCount];
 };
 
@@ -193,48 +191,6 @@ ABSL_ATTRIBUTE_NOINLINE static void FixupNoFixupEquivalenceNoInline() {
       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(); }
@@ -351,86 +307,6 @@ TEST(StackTrace, CustomUnwinderPerformsFixup) {
   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;
@@ -502,4 +378,14 @@ TEST(StackTrace, NestedSignal) {
 }
 #endif
 
+TEST(StackTrace, NoNullptrInPopulatedRange) {
+  constexpr int kMaxDepth = 1024;
+  void* results[kMaxDepth];
+  int depth = absl::GetStackTrace(results, kMaxDepth, 0);
+  for (int i = 0; i < depth; ++i) {
+    EXPECT_NE(results[i], nullptr) << "Unexpected nullptr found at index " << i;
+  }
+}
+
+
 }  // namespace

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

@@ -12,10 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// SKIP_ABSL_INLINE_NAMESPACE_CHECK
-
 #include "absl/debugging/symbolize.h"
 
+#include "absl/base/config.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/debugging/internal/symbolize.h"
+
 #ifdef _WIN32
 #include <winapifamily.h>
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
@@ -42,3 +44,19 @@
 #else
 #include "absl/debugging/symbolize_unimplemented.inc"
 #endif
+
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace debugging_internal {
+
+void SymbolDecoratorDeleter::operator()(SymbolDecorator* ptr) {
+  ptr->~SymbolDecorator();
+  base_internal::LowLevelAlloc::Free(ptr);
+}
+
+}  // namespace debugging_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl