re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/debugging/CMakeLists.txt

@@ -42,6 +42,7 @@ absl_cc_library(
     absl::config
     absl::core_headers
     absl::dynamic_annotations
+    absl::malloc_internal
     absl::raw_logging_internal
   PUBLIC
 )
@@ -55,7 +56,9 @@ absl_cc_test(
     ${ABSL_TEST_COPTS}
   DEPS
     absl::stacktrace
+    absl::config
     absl::core_headers
+    absl::span
     GTest::gmock_main
 )
 
@@ -174,6 +177,7 @@ absl_cc_library(
     debugging_internal
   HDRS
     "internal/address_is_readable.h"
+    "internal/addresses.h"
     "internal/elf_mem_image.h"
     "internal/vdso_support.h"
   SRCS

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

@@ -0,0 +1,57 @@
+// 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_ADDRESSES_H_
+#define ABSL_DEBUGGING_INTERNAL_ADDRESSES_H_
+
+#include <stdint.h>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Removes any metadata (tag bits) from the given pointer, converting it into a
+// user-readable address.
+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") = 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
+  // space instructions behave as NOPs on unsupported platforms.
+#define ABSL_XPACLRI_HINT "hint #0x7;"
+  asm(ABSL_XPACLRI_HINT : "+r"(x30));  // asm("xpaclri" : "+r"(x30));
+#undef ABSL_XPACLRI_HINT
+  return x30;
+#else
+  return ptr;
+#endif
+}
+
+inline uintptr_t StripPointerMetadata(void* ptr) {
+  return StripPointerMetadata(reinterpret_cast<uintptr_t>(ptr));
+}
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_ADDRESSES_H_

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

@@ -172,7 +172,7 @@ bool ScanNextDelta(const char*& punycode_begin, const char* const punycode_end,
 
 }  // namespace
 
-absl::Nullable<char*> DecodeRustPunycode(DecodeRustPunycodeOptions options) {
+char* absl_nullable DecodeRustPunycode(DecodeRustPunycodeOptions options) {
   const char* punycode_begin = options.punycode_begin;
   const char* const punycode_end = options.punycode_end;
   char* const out_begin = options.out_begin;

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

@@ -23,10 +23,10 @@ ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 struct DecodeRustPunycodeOptions {
-  const char* punycode_begin;
-  const char* punycode_end;
-  char* out_begin;
-  char* out_end;
+  const char* absl_nonnull punycode_begin;
+  const char* absl_nonnull punycode_end;
+  char* absl_nonnull out_begin;
+  char* absl_nonnull out_end;
 };
 
 // Given Rust Punycode in `punycode_begin .. punycode_end`, writes the
@@ -46,7 +46,7 @@ struct DecodeRustPunycodeOptions {
 // DecodeRustPunycode is async-signal-safe with bounded runtime and a small
 // stack footprint, making it suitable for use in demangling Rust symbol names
 // from a signal handler.
-absl::Nullable<char*> DecodeRustPunycode(DecodeRustPunycodeOptions options);
+char* absl_nullable DecodeRustPunycode(DecodeRustPunycodeOptions options);
 
 }  // namespace debugging_internal
 ABSL_NAMESPACE_END

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

@@ -484,36 +484,6 @@ static bool IsAlpha(char c) {
 
 static bool IsDigit(char c) { return c >= '0' && c <= '9'; }
 
-// Returns true if "str" is a function clone suffix.  These suffixes are used
-// by GCC 4.5.x and later versions (and our locally-modified version of GCC
-// 4.4.x) to indicate functions which have been cloned during optimization.
-// We treat any sequence (.<alpha>+.<digit>+)+ as a function clone suffix.
-// Additionally, '_' is allowed along with the alphanumeric sequence.
-static bool IsFunctionCloneSuffix(const char *str) {
-  size_t i = 0;
-  while (str[i] != '\0') {
-    bool parsed = false;
-    // Consume a single [.<alpha> | _]*[.<digit>]* sequence.
-    if (str[i] == '.' && (IsAlpha(str[i + 1]) || str[i + 1] == '_')) {
-      parsed = true;
-      i += 2;
-      while (IsAlpha(str[i]) || str[i] == '_') {
-        ++i;
-      }
-    }
-    if (str[i] == '.' && IsDigit(str[i + 1])) {
-      parsed = true;
-      i += 2;
-      while (IsDigit(str[i])) {
-        ++i;
-      }
-    }
-    if (!parsed)
-      return false;
-  }
-  return true;  // Consumed everything in "str".
-}
-
 static bool EndsWith(State *state, const char chr) {
   return state->parse_state.out_cur_idx > 0 &&
          state->parse_state.out_cur_idx < state->out_end_idx &&
@@ -1039,7 +1009,8 @@ static bool ParseNumber(State *state, int *number_out) {
     number = ~number + 1;
   }
   if (p != RemainingInput(state)) {  // Conversion succeeded.
-    state->parse_state.mangled_idx += p - RemainingInput(state);
+    state->parse_state.mangled_idx +=
+        static_cast<int>(p - RemainingInput(state));
     UpdateHighWaterMark(state);
     if (number_out != nullptr) {
       // Note: possibly truncate "number".
@@ -1062,7 +1033,8 @@ static bool ParseFloatNumber(State *state) {
     }
   }
   if (p != RemainingInput(state)) {  // Conversion succeeded.
-    state->parse_state.mangled_idx += p - RemainingInput(state);
+    state->parse_state.mangled_idx +=
+        static_cast<int>(p - RemainingInput(state));
     UpdateHighWaterMark(state);
     return true;
   }
@@ -1081,7 +1053,8 @@ static bool ParseSeqId(State *state) {
     }
   }
   if (p != RemainingInput(state)) {  // Conversion succeeded.
-    state->parse_state.mangled_idx += p - RemainingInput(state);
+    state->parse_state.mangled_idx +=
+        static_cast<int>(p - RemainingInput(state));
     UpdateHighWaterMark(state);
     return true;
   }
@@ -1100,7 +1073,7 @@ static bool ParseIdentifier(State *state, size_t length) {
   } else {
     MaybeAppendWithLength(state, RemainingInput(state), length);
   }
-  state->parse_state.mangled_idx += length;
+  state->parse_state.mangled_idx += static_cast<int>(length);
   UpdateHighWaterMark(state);
   return true;
 }
@@ -2929,7 +2902,7 @@ static bool ParseTopLevelMangledName(State *state) {
   if (ParseMangledName(state)) {
     if (RemainingInput(state)[0] != '\0') {
       // Drop trailing function clone suffix, if any.
-      if (IsFunctionCloneSuffix(RemainingInput(state))) {
+      if (RemainingInput(state)[0] == '.') {
         return true;
       }
       // Append trailing version suffix if any.

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

@@ -84,7 +84,7 @@ class RustSymbolParser {
   // structure was not recognized or exceeded implementation limits, such as by
   // nesting structures too deep.  In either case *this should not be used
   // again.
-  ABSL_MUST_USE_RESULT bool Parse() && {
+  [[nodiscard]] bool Parse() && {
     // Recursively parses the grammar production named by callee, then resumes
     // execution at the next statement.
     //
@@ -564,7 +564,7 @@ class RustSymbolParser {
 
   // If the next input character is the given character, consumes it and returns
   // true; otherwise returns false without consuming a character.
-  ABSL_MUST_USE_RESULT bool Eat(char want) {
+  [[nodiscard]] bool Eat(char want) {
     if (encoding_[pos_] != want) return false;
     ++pos_;
     return true;
@@ -573,7 +573,7 @@ class RustSymbolParser {
   // Provided there is enough remaining output space, appends c to the output,
   // writing a fresh NUL terminator afterward, and returns true.  Returns false
   // if the output buffer had less than two bytes free.
-  ABSL_MUST_USE_RESULT bool EmitChar(char c) {
+  [[nodiscard]] bool EmitChar(char c) {
     if (silence_depth_ > 0) return true;
     if (out_end_ - out_ < 2) return false;
     *out_++ = c;
@@ -584,7 +584,7 @@ class RustSymbolParser {
   // Provided there is enough remaining output space, appends the C string token
   // to the output, followed by a NUL character, and returns true.  Returns
   // false if not everything fit into the output buffer.
-  ABSL_MUST_USE_RESULT bool Emit(const char* token) {
+  [[nodiscard]] bool Emit(const char* token) {
     if (silence_depth_ > 0) return true;
     const size_t token_length = std::strlen(token);
     const size_t bytes_to_copy = token_length + 1;  // token and final NUL
@@ -598,7 +598,7 @@ class RustSymbolParser {
   // of disambiguator (if it's nonnegative) or "?" (if it's negative) to the
   // output, followed by a NUL character, and returns true.  Returns false if
   // not everything fit into the output buffer.
-  ABSL_MUST_USE_RESULT bool EmitDisambiguator(int disambiguator) {
+  [[nodiscard]] bool EmitDisambiguator(int disambiguator) {
     if (disambiguator < 0) return EmitChar('?');  // parsed but too large
     if (disambiguator == 0) return EmitChar('0');
     // Convert disambiguator to decimal text.  Three digits per byte is enough
@@ -618,7 +618,7 @@ class RustSymbolParser {
   // On success returns true and fills value with the encoded value if it was
   // not too big, otherwise with -1.  If the optional disambiguator was omitted,
   // value is 0.  On parse failure returns false and sets value to -1.
-  ABSL_MUST_USE_RESULT bool ParseDisambiguator(int& value) {
+  [[nodiscard]] bool ParseDisambiguator(int& value) {
     value = -1;
 
     // disambiguator = s base-62-number
@@ -639,7 +639,7 @@ class RustSymbolParser {
   // On success returns true and fills value with the encoded value if it was
   // not too big, otherwise with -1.  On parse failure returns false and sets
   // value to -1.
-  ABSL_MUST_USE_RESULT bool ParseBase62Number(int& value) {
+  [[nodiscard]] bool ParseBase62Number(int& value) {
     value = -1;
 
     // base-62-number = (digit | lower | upper)* _
@@ -686,7 +686,7 @@ class RustSymbolParser {
   // A nonzero uppercase_namespace specifies the character after the N in a
   // nested-identifier, e.g., 'C' for a closure, allowing ParseIdentifier to
   // write out the name with the conventional decoration for that namespace.
-  ABSL_MUST_USE_RESULT bool ParseIdentifier(char uppercase_namespace = '\0') {
+  [[nodiscard]] bool ParseIdentifier(char uppercase_namespace = '\0') {
     // identifier -> disambiguator? undisambiguated-identifier
     int disambiguator = 0;
     if (!ParseDisambiguator(disambiguator)) return false;
@@ -703,7 +703,7 @@ class RustSymbolParser {
   //
   // At other appearances of undisambiguated-identifier in the grammar, this
   // treatment is not applicable, and the call site omits both arguments.
-  ABSL_MUST_USE_RESULT bool ParseUndisambiguatedIdentifier(
+  [[nodiscard]] bool ParseUndisambiguatedIdentifier(
       char uppercase_namespace = '\0', int disambiguator = 0) {
     // undisambiguated-identifier -> u? decimal-number _? bytes
     const bool is_punycoded = Eat('u');
@@ -766,7 +766,7 @@ class RustSymbolParser {
   // Consumes a decimal number like 0 or 123 from the input.  On success returns
   // true and fills value with the encoded value.  If the encoded value is too
   // large or otherwise unparsable, returns false and sets value to -1.
-  ABSL_MUST_USE_RESULT bool ParseDecimalNumber(int& value) {
+  [[nodiscard]] bool ParseDecimalNumber(int& value) {
     value = -1;
     if (!IsDigit(Peek())) return false;
     int encoded_number = Take() - '0';
@@ -788,7 +788,7 @@ class RustSymbolParser {
   // Consumes a binder of higher-ranked lifetimes if one is present.  On success
   // returns true and discards the encoded lifetime count.  On parse failure
   // returns false.
-  ABSL_MUST_USE_RESULT bool ParseOptionalBinder() {
+  [[nodiscard]] bool ParseOptionalBinder() {
     // binder -> G base-62-number
     if (!Eat('G')) return true;
     int ignored_binding_count;
@@ -802,7 +802,7 @@ class RustSymbolParser {
   // things we omit from output, such as the entire contents of generic-args.
   //
   // On parse failure returns false.
-  ABSL_MUST_USE_RESULT bool ParseOptionalLifetime() {
+  [[nodiscard]] bool ParseOptionalLifetime() {
     // lifetime -> L base-62-number
     if (!Eat('L')) return true;
     int ignored_de_bruijn_index;
@@ -811,14 +811,14 @@ class RustSymbolParser {
 
   // Consumes a lifetime just like ParseOptionalLifetime, but returns false if
   // there is no lifetime here.
-  ABSL_MUST_USE_RESULT bool ParseRequiredLifetime() {
+  [[nodiscard]] bool ParseRequiredLifetime() {
     if (Peek() != 'L') return false;
     return ParseOptionalLifetime();
   }
 
   // Pushes ns onto the namespace stack and returns true if the stack is not
   // full, else returns false.
-  ABSL_MUST_USE_RESULT bool PushNamespace(char ns) {
+  [[nodiscard]] bool PushNamespace(char ns) {
     if (namespace_depth_ == kNamespaceStackSize) return false;
     namespace_stack_[namespace_depth_++] = ns;
     return true;
@@ -830,7 +830,7 @@ class RustSymbolParser {
 
   // Pushes position onto the position stack and returns true if the stack is
   // not full, else returns false.
-  ABSL_MUST_USE_RESULT bool PushPosition(int position) {
+  [[nodiscard]] bool PushPosition(int position) {
     if (position_depth_ == kPositionStackSize) return false;
     position_stack_[position_depth_++] = position;
     return true;
@@ -845,7 +845,7 @@ class RustSymbolParser {
   // beginning of the backref target.  Returns true on success.  Returns false
   // if parsing failed, the stack is exhausted, or the backref target position
   // is out of range.
-  ABSL_MUST_USE_RESULT bool BeginBackref() {
+  [[nodiscard]] bool BeginBackref() {
     // backref = B base-62-number (B already consumed)
     //
     // Reject backrefs that don't parse, overflow int, or don't point backward.

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

@@ -556,14 +556,15 @@ TEST(Demangle, Clones) {
   EXPECT_TRUE(Demangle("_ZL3Foov.part.9.165493.constprop.775.31805", tmp,
                        sizeof(tmp)));
   EXPECT_STREQ("Foo()", tmp);
-  // Invalid (. without anything else), should not demangle.
-  EXPECT_FALSE(Demangle("_ZL3Foov.", tmp, sizeof(tmp)));
-  // Invalid (. with mix of alpha and digits), should not demangle.
-  EXPECT_FALSE(Demangle("_ZL3Foov.abc123", tmp, sizeof(tmp)));
-  // Invalid (.clone. not followed by number), should not demangle.
-  EXPECT_FALSE(Demangle("_ZL3Foov.clone.", tmp, sizeof(tmp)));
-  // Invalid (.constprop. not followed by number), should not demangle.
-  EXPECT_FALSE(Demangle("_ZL3Foov.isra.2.constprop.", tmp, sizeof(tmp)));
+  // Other suffixes should demangle too.
+  EXPECT_TRUE(Demangle("_ZL3Foov.", tmp, sizeof(tmp)));
+  EXPECT_STREQ("Foo()", tmp);
+  EXPECT_TRUE(Demangle("_ZL3Foov.abc123", tmp, sizeof(tmp)));
+  EXPECT_STREQ("Foo()", tmp);
+  EXPECT_TRUE(Demangle("_ZL3Foov.clone.", tmp, sizeof(tmp)));
+  EXPECT_STREQ("Foo()", tmp);
+  EXPECT_TRUE(Demangle("_ZL3Foov.isra.2.constprop.", tmp, sizeof(tmp)));
+  EXPECT_STREQ("Foo()", tmp);
 }
 
 TEST(Demangle, Discriminators) {
@@ -1935,11 +1936,11 @@ static const char *DemangleStackConsumption(const char *mangled,
   return g_demangle_result;
 }
 
-// Demangle stack consumption should be within 8kB for simple mangled names
+// Demangle stack consumption should be within 9kB for simple mangled names
 // with some level of nesting. With alternate signal stack we have 64K,
 // but some signal handlers run on thread stack, and could have arbitrarily
 // little space left (so we don't want to make this number too large).
-const int kStackConsumptionUpperLimit = 8192;
+const int kStackConsumptionUpperLimit = 9670;
 
 // Returns a mangled name nested to the given depth.
 static std::string NestedMangledName(int depth) {

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

@@ -18,6 +18,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/addresses.h"
 #include "absl/debugging/internal/vdso_support.h"  // a no-op on non-elf or non-glibc systems
 #include "absl/debugging/stacktrace.h"
 
@@ -101,7 +102,8 @@ static bool InsideSignalStack(void** ptr, const StackInfo* stack_info) {
 // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
 template<bool STRICT_UNWINDING, bool WITH_CONTEXT>
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_THREAD   // May read random elements from stack.
 static void **NextStackFrame(void **old_frame_pointer, const void *uc,
                              const StackInfo *stack_info) {
   void **new_frame_pointer = reinterpret_cast<void**>(*old_frame_pointer);
@@ -124,6 +126,7 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc,
       if (pre_signal_frame_pointer >= old_frame_pointer) {
         new_frame_pointer = pre_signal_frame_pointer;
       }
+    }
   }
 #endif
 
@@ -131,17 +134,13 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc,
   if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 7) != 0)
     return nullptr;
 
-  // Check that alleged frame pointer is actually readable. This is to
-  // prevent "double fault" in case we hit the first fault due to e.g.
-  // stack corruption.
-  if (!absl::debugging_internal::AddressIsReadable(
-          new_frame_pointer))
-    return nullptr;
-  }
-
+  uintptr_t new_fp_comparable = reinterpret_cast<uintptr_t>(new_frame_pointer);
   // Only check the size if both frames are in the same stack.
-  if (InsideSignalStack(new_frame_pointer, stack_info) ==
-      InsideSignalStack(old_frame_pointer, stack_info)) {
+  const bool old_inside_signal_stack =
+      InsideSignalStack(old_frame_pointer, stack_info);
+  const bool new_inside_signal_stack =
+      InsideSignalStack(new_frame_pointer, stack_info);
+  if (new_inside_signal_stack == old_inside_signal_stack) {
     // Check frame size.  In strict mode, we assume frames to be under
     // 100,000 bytes.  In non-strict mode, we relax the limit to 1MB.
     const size_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
@@ -155,16 +154,15 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc,
     if (frame_size > max_size) {
       size_t stack_low = stack_info->stack_low;
       size_t stack_high = stack_info->stack_high;
-      if (InsideSignalStack(new_frame_pointer, stack_info)) {
+      if (new_inside_signal_stack) {
         stack_low = stack_info->sig_stack_low;
         stack_high = stack_info->sig_stack_high;
       }
       if (stack_high < kUnknownStackEnd &&
           static_cast<size_t>(getpagesize()) < stack_low) {
-        const uintptr_t new_fp_u =
-            reinterpret_cast<uintptr_t>(new_frame_pointer);
         // Stack bounds are known.
-        if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
+        if (!(stack_low < new_fp_comparable &&
+              new_fp_comparable <= stack_high)) {
           // new_frame_pointer is not within a known stack.
           return nullptr;
         }
@@ -174,24 +172,19 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc,
       }
     }
   }
+  // New frame pointer is valid if it is inside either known stack or readable.
+  // This assumes that everything within either known stack is readable. Outside
+  // either known stack but readable is unexpected, and possibly corrupt, but
+  // for now assume it is valid. If it isn't actually valid, the next frame will
+  // be corrupt and we will detect that next iteration.
+  if (new_inside_signal_stack ||
+      (new_fp_comparable >= stack_info->stack_low &&
+       new_fp_comparable < stack_info->stack_high) ||
+      absl::debugging_internal::AddressIsReadable(new_frame_pointer)) {
+    return new_frame_pointer;
+  }
 
-  return new_frame_pointer;
-}
-
-// 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 VA range are potentially set. Since the stacktrace code is expected to
-// return normal code pointers, this function clears those bits.
-inline void* ClearPacBits(void* ptr) {
-  register void* 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
-  // space instructions behave as NOPs on unsupported platforms.
-#define ABSL_XPACLRI_HINT "hint #0x7;"
-  asm(ABSL_XPACLRI_HINT : "+r"(x30));  // asm("xpaclri" : "+r"(x30));
-#undef ABSL_XPACLRI_HINT
-  return x30;
+  return nullptr;
 }
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
@@ -200,8 +193,10 @@ 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) {
+ABSL_ATTRIBUTE_NO_SANITIZE_THREAD   // May read random elements from stack.
+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
@@ -235,10 +230,18 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
     if (skip_count > 0) {
       skip_count--;
     } else {
-      result[n] = ClearPacBits(prev_return_address);
+      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++;
     }

package/vendor/abseil-cpp/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++;

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

@@ -43,11 +43,12 @@
   "absl/debugging/internal/stacktrace_emscripten-inl.inc"
 
 #elif defined(__ANDROID__) && __ANDROID_API__ >= 33
-
+#ifdef ABSL_HAVE_THREAD_LOCAL
 // Use the generic implementation for Android 33+ (Android T+). This is the
 // first version of Android for which <execinfo.h> implements backtrace().
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
+#endif  // defined(ABSL_HAVE_THREAD_LOCAL)
 
 #elif defined(__linux__) && !defined(__ANDROID__)
 
@@ -59,11 +60,11 @@
   "absl/debugging/internal/stacktrace_libunwind-inl.inc"
 #define STACKTRACE_USES_LIBUNWIND 1
 #elif defined(NO_FRAME_POINTER) && defined(__has_include)
-#if __has_include(<execinfo.h>)
+#if __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // __has_include(<execinfo.h>)
+#endif  // __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 #elif defined(__i386__) || defined(__x86_64__)
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_x86-inl.inc"
@@ -77,11 +78,11 @@
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_riscv-inl.inc"
 #elif defined(__has_include)
-#if __has_include(<execinfo.h>)
+#if __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // __has_include(<execinfo.h>)
+#endif  // __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 #endif  // defined(__has_include)
 
 #endif  // defined(__linux__) && !defined(__ANDROID__)

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

@@ -21,8 +21,10 @@
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
 
 #include <emscripten.h>
+#include <stdint.h>
 
 #include <atomic>
+#include <cstddef>
 #include <cstring>
 
 #include "absl/base/attributes.h"
@@ -62,8 +64,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;
   }
@@ -75,7 +78,8 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
 
   int size;
   uintptr_t pc = emscripten_stack_snapshot();
-  size = emscripten_stack_unwind_buffer(pc, stack, kStackLength);
+  size =
+      static_cast<int>(emscripten_stack_unwind_buffer(pc, stack, kStackLength));
 
   int result_count = size - skip_count;
   if (result_count < 0) result_count = 0;
@@ -83,8 +87,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) * 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) {