re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/crc/internal/crc_x86_arm_combined.cc

@@ -357,6 +357,71 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
     crc[2] = crc2;
   }
 
+#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__)
+  // This is only used if we have vector version of PCLMULQDQ.
+  // We don't have it on arm, and it isn't supported by default
+  // compiler targets on x86. If we want to use it, we need to either use
+  // new compiler flags for the whole function and compile it twice
+  // with new and default flags or use inline asm.
+  // The code below is the same as FinalizePclmulStream, but with
+  // PCLMUL and XOR operating on 2 values in a vector at the same time.
+  ABSL_ATTRIBUTE_ALWAYS_INLINE uint64_t
+  FinalizeVpclmulStream(V256* partialCRC) const {
+    uint64_t crc = 0;
+    uint64_t low64, high64;
+    __asm__(
+        // reduce 2 256-bit vectors into s single 256 vector
+        "vbroadcasti128 %[k256], %%ymm0 \n"
+        "vpclmulqdq $0x00, %%ymm0, %[crc0], %%ymm1 \n"
+        "vpclmulqdq $0x11, %%ymm0, %[crc0], %%ymm2 \n"
+        "vpxor %%ymm2, %%ymm1, %%ymm1 \n"
+        "vpxor %[crc1], %%ymm1, %%ymm1 \n"
+        // reduce upper and lower parts of 256-bit vector
+        "vextracti128 $1, %%ymm1, %%xmm2 \n"
+        "vpclmulqdq $0x00, %[k128], %%xmm1, %%xmm3 \n"
+        "vpclmulqdq $0x11, %[k128], %%xmm1, %%xmm1 \n"
+        "vpxor %%xmm1, %%xmm3, %%xmm3 \n"
+        "vpxor %%xmm2, %%xmm3, %%xmm3 \n"
+        // Move 2 parts of 128-bit vector into scalar register
+        // and reduce using sacalr crc instruction
+        "vmovq %%xmm3, %[low] \n"
+        "vpextrq $1, %%xmm3, %[high] \n"
+        "crc32q %[low], %[crc_out] \n"
+        "crc32q %[high], %[crc_out] \n"
+        : [crc_out] "+r"(crc), [low] "=&r"(low64), [high] "=&r"(high64)
+        : [k256] "m"(*(const __m128i*)kFoldAcross256Bits),
+          [crc0] "x"(partialCRC[0]), [crc1] "x"(partialCRC[1]),
+          [k128] "m"(*(const __m128i*)kFoldAcross128Bits)
+        : "ymm0", "ymm1", "ymm2", "ymm3");
+    return crc;
+  }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE void Process64BytesVpclmul(
+      const uint8_t* p, V256* vpartialCRC, V256 loopMultiplicands) const {
+    __asm__ volatile(
+        "vpclmulqdq $0x11, %3, %0, %%ymm0 \n"
+        "vpclmulqdq $0x11, %3, %1, %%ymm1 \n"
+        "vpclmulqdq $0x00, %3, %0, %0 \n"
+        "vpclmulqdq $0x00, %3, %1, %1 \n"
+        "vpxor %%ymm0, %0, %0 \n"
+        "vpxor %%ymm1, %1, %1 \n"
+        "vpxor (%2), %0, %0 \n"
+        "vpxor 32(%2), %1, %1 \n"
+        : "+x"(vpartialCRC[0]), "+x"(vpartialCRC[1])
+        : "r"(p), "x"(loopMultiplicands)
+        : "ymm0", "ymm1");
+  }
+#else
+  template <typename T = V256>
+  ABSL_ATTRIBUTE_ALWAYS_INLINE void Process64BytesVpclmul(const uint8_t*, T*,
+                                                          T) const {
+    static_assert(sizeof(T) == 0, "Vector PCLMUL not supported");
+  }
+  ABSL_ATTRIBUTE_ALWAYS_INLINE uint64_t FinalizeVpclmulStream(V256*) const {
+    return 0;
+  }
+#endif  // defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__)
+
   // Constants generated by './scripts/gen-crc-consts.py x86_pclmul
   // crc32_lsb_0x82f63b78' from the Linux kernel.
   alignas(16) static constexpr uint64_t kFoldAcross512Bits[2] = {
@@ -386,7 +451,7 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
 };
 
 template <size_t num_crc_streams, size_t num_pclmul_streams,
-          CutoffStrategy strategy>
+          size_t num_vpclmul_streams, CutoffStrategy strategy>
 class CRC32AcceleratedX86ARMCombinedMultipleStreams
     : public CRC32AcceleratedX86ARMCombinedMultipleStreamsBase {
   ABSL_ATTRIBUTE_HOT
@@ -396,6 +461,9 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
                   "Invalid number of crc streams");
     static_assert(num_pclmul_streams >= 0 && num_pclmul_streams <= kMaxStreams,
                   "Invalid number of pclmul streams");
+    static_assert(
+        num_vpclmul_streams >= 0 && num_vpclmul_streams <= kMaxStreams,
+        "Invalid number of vpclmul streams");
     const uint8_t* p = static_cast<const uint8_t*>(bytes);
     const uint8_t* e = p + length;
     uint32_t l = *crc;
@@ -474,17 +542,23 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
       }
 
       size_t bs = static_cast<size_t>(e - p) /
-                  (num_crc_streams + num_pclmul_streams) / 64;
+                  (num_crc_streams + num_pclmul_streams + num_vpclmul_streams) /
+                  64;
+      const uint8_t* stream_start = p;
       const uint8_t* crc_streams[kMaxStreams];
+      for (size_t i = 0; i < num_crc_streams; i++) {
+        crc_streams[i] = stream_start;
+        stream_start += bs * 64;
+      }
       const uint8_t* pclmul_streams[kMaxStreams];
-      // We are guaranteed to have at least one crc stream.
-      crc_streams[0] = p;
-      for (size_t i = 1; i < num_crc_streams; i++) {
-        crc_streams[i] = crc_streams[i - 1] + bs * 64;
+      for (size_t i = 0; i < num_pclmul_streams; i++) {
+        pclmul_streams[i] = stream_start;
+        stream_start += bs * 64;
       }
-      pclmul_streams[0] = crc_streams[num_crc_streams - 1] + bs * 64;
-      for (size_t i = 1; i < num_pclmul_streams; i++) {
-        pclmul_streams[i] = pclmul_streams[i - 1] + bs * 64;
+      const uint8_t* vpclmul_streams[kMaxStreams];
+      for (size_t i = 0; i < num_vpclmul_streams; i++) {
+        vpclmul_streams[i] = stream_start;
+        stream_start += bs * 64;
       }
 
       // Per stream crc sums.
@@ -520,6 +594,18 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
         pclmul_streams[i] += 16 * 4;
       }
 
+      V256 vpartialCRC[kMaxStreams][2];
+      V256 loopMultiplicands{};
+      loopMultiplicands =
+          V256_Broadcast128(reinterpret_cast<const V128*>(kFoldAcross512Bits));
+      for (size_t i = 0; i < num_vpclmul_streams; i++) {
+        vpartialCRC[i][0] = V256_LoadU(
+            reinterpret_cast<const V256*>(vpclmul_streams[i] + 32 * 0));
+        vpartialCRC[i][1] = V256_LoadU(
+            reinterpret_cast<const V256*>(vpclmul_streams[i] + 32 * 1));
+        vpclmul_streams[i] += 16 * 4;
+      }
+
       for (size_t i = 1; i < bs; i++) {
         // Prefetch data for next iterations.
         for (size_t j = 0; j < num_crc_streams; j++) {
@@ -530,6 +616,10 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
           PrefetchToLocalCache(reinterpret_cast<const char*>(pclmul_streams[j] +
                                                              kPrefetchHorizon));
         }
+        for (size_t j = 0; j < num_vpclmul_streams; j++) {
+          PrefetchToLocalCache(reinterpret_cast<const char*>(
+              vpclmul_streams[j] + kPrefetchHorizon));
+        }
 
         // We process each stream in 64 byte blocks. This can be written as
         // for (int i = 0; i < num_pclmul_streams; i++) {
@@ -568,6 +658,12 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
           Process64BytesPclmul(pclmul_streams[2], partialCRC[2]);
           pclmul_streams[2] += 16 * 4;
         }
+
+        if constexpr (num_vpclmul_streams > 0) {
+          Process64BytesVpclmul(vpclmul_streams[0], vpartialCRC[0],
+                                loopMultiplicands);
+          vpclmul_streams[0] += 16 * 4;
+        }
       }
 
       // PCLMULQDQ based streams require special final step;
@@ -576,6 +672,13 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
         l64_pclmul[i] = FinalizePclmulStream(partialCRC[i]);
       }
 
+      uint64_t l64_vpclmul[kMaxStreams] = {0};
+      if constexpr (num_vpclmul_streams > 0) {
+        for (size_t i = 0; i < num_vpclmul_streams; i++) {
+          l64_vpclmul[i] = FinalizeVpclmulStream(vpartialCRC[i]);
+        }
+      }
+
       // Combine all streams into single result.
       static_assert(64 % (1 << kNumDroppedBits) == 0);
       uint32_t magic = ComputeZeroConstant(bs * 64);
@@ -588,9 +691,15 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
         l64 = MultiplyWithExtraX33(static_cast<uint32_t>(l64), magic);
         l64 ^= l64_pclmul[i];
       }
+      for (size_t i = 0; i < num_vpclmul_streams; i++) {
+        l64 = MultiplyWithExtraX33(static_cast<uint32_t>(l64), magic);
+        l64 ^= l64_vpclmul[i];
+      }
 
       // Update p.
-      if (num_pclmul_streams > 0) {
+      if constexpr (num_vpclmul_streams > 0) {
+        p = vpclmul_streams[num_vpclmul_streams - 1];
+      } else if constexpr (num_pclmul_streams > 0) {
         p = pclmul_streams[num_pclmul_streams - 1];
       } else {
         p = crc_streams[num_crc_streams - 1];
@@ -618,6 +727,10 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
       ABSL_INTERNAL_STEP1(l, p);
     }
 
+    *crc = l;
+  }
+};
+
 #undef ABSL_INTERNAL_STEP8BY3
 #undef ABSL_INTERNAL_STEP8BY2
 #undef ABSL_INTERNAL_STEP8
@@ -625,10 +738,6 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
 #undef ABSL_INTERNAL_STEP2
 #undef ABSL_INTERNAL_STEP1
 
-    *crc = l;
-  }
-};
-
 }  // namespace
 
 // Intel processors with SSE4.2 have an instruction for one particular
@@ -636,14 +745,25 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
 CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
   CpuType type = GetCpuType();
   switch (type) {
-    case CpuType::kIntelHaswell:
     case CpuType::kAmdRome:
+      return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
+          3, 0, 0, CutoffStrategy::Fold3>();
+    case CpuType::kIntelHaswell:
     case CpuType::kAmdNaples:
+      return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
+          3, 1, 0, CutoffStrategy::Fold3>();
     case CpuType::kAmdMilan:
     case CpuType::kAmdGenoa:
     case CpuType::kAmdTurin:
+#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) && defined(__AVX__)
+      // We don't have vector pclmul on arm, but this still needs to
+      // compile.
+      return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
+          3, 0, 1, CutoffStrategy::Fold3>();
+#else
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          3, 1, CutoffStrategy::Fold3>();
+          3, 1, 0, CutoffStrategy::Fold3>();
+#endif
     // PCLMULQDQ is fast, use combined PCLMULQDQ + CRC implementation.
     case CpuType::kIntelCascadelakeXeon:
     case CpuType::kIntelSkylakeXeon:
@@ -654,32 +774,32 @@ CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
     case CpuType::kIntelEmeraldrapids:
     case CpuType::kIntelGraniterapidsap:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          3, 2, CutoffStrategy::Fold3>();
+          3, 2, 0, CutoffStrategy::Fold3>();
     // PCLMULQDQ is slow, don't use it.
     case CpuType::kIntelIvybridge:
     case CpuType::kIntelSandybridge:
     case CpuType::kIntelWestmere:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          3, 0, CutoffStrategy::Fold3>();
+          3, 0, 0, CutoffStrategy::Fold3>();
     case CpuType::kArmNeoverseN1:
     case CpuType::kArmNeoverseN2:
     case CpuType::kArmNeoverseV1:
     case CpuType::kArmNeoverseN3:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          1, 1, CutoffStrategy::Unroll64CRC>();
+          1, 1, 0, CutoffStrategy::Unroll64CRC>();
     case CpuType::kAmpereSiryn:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          3, 2, CutoffStrategy::Fold3>();
+          3, 2, 0, CutoffStrategy::Fold3>();
     case CpuType::kArmNeoverseV2:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          1, 2, CutoffStrategy::Unroll64CRC>();
+          1, 2, 0, CutoffStrategy::Unroll64CRC>();
 #if defined(__aarch64__)
     default:
       // Not all ARM processors support the needed instructions, so check here
       // before trying to use an accelerated implementation.
       if (SupportsArmCRC32PMULL()) {
         return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-            1, 1, CutoffStrategy::Unroll64CRC>();
+            1, 1, 0, CutoffStrategy::Unroll64CRC>();
       } else {
         return nullptr;
       }
@@ -687,71 +807,13 @@ CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
     default:
       // Something else, play it safe and assume slow PCLMULQDQ.
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
-          3, 0, CutoffStrategy::Fold3>();
+          3, 0, 0, CutoffStrategy::Fold3>();
 #endif
   }
 }
 
-std::vector<std::unique_ptr<CRCImpl>> NewCRC32AcceleratedX86ARMCombinedAll() {
-  auto ret = std::vector<std::unique_ptr<CRCImpl>>();
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 0, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 1, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 2, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 3, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 0, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 1, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 2, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 3, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 0, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 1, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 2, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 3, CutoffStrategy::Fold3>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 0, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 1, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 2, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    1, 3, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 0, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 1, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 2, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    2, 3, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 0, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 1, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 2, CutoffStrategy::Unroll64CRC>>());
-  ret.push_back(absl::make_unique<CRC32AcceleratedX86ARMCombinedMultipleStreams<
-                    3, 3, CutoffStrategy::Unroll64CRC>>());
-
-  return ret;
-}
-
 #else  // !ABSL_INTERNAL_CAN_USE_SIMD_CRC32C
 
-std::vector<std::unique_ptr<CRCImpl>> NewCRC32AcceleratedX86ARMCombinedAll() {
-  return std::vector<std::unique_ptr<CRCImpl>>();
-}
-
 // no hardware acceleration available
 CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() { return nullptr; }
 

package/vendor/abseil-cpp/absl/debugging/BUILD.bazel

@@ -35,33 +35,6 @@ package(
 
 licenses(["notice"])
 
-cc_library(
-    name = "borrowed_fixup_buffer",
-    srcs = ["internal/borrowed_fixup_buffer.cc"],
-    hdrs = ["internal/borrowed_fixup_buffer.h"],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        "//absl/base:config",
-        "//absl/base:core_headers",
-        "//absl/base:malloc_internal",
-        "//absl/hash",
-    ],
-)
-
-cc_test(
-    name = "borrowed_fixup_buffer_test",
-    srcs = ["internal/borrowed_fixup_buffer_test.cc"],
-    copts = ABSL_TEST_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":borrowed_fixup_buffer",
-        "//absl/base:config",
-        "@googletest//:gtest",
-        "@googletest//:gtest_main",
-    ],
-)
-
 cc_library(
     name = "stacktrace",
     srcs = [
@@ -81,7 +54,6 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        ":borrowed_fixup_buffer",
         ":debugging_internal",
         "//absl/base:config",
         "//absl/base:core_headers",
@@ -97,7 +69,6 @@ cc_test(
     copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        ":borrowed_fixup_buffer",
         ":stacktrace",
         "//absl/base:config",
         "//absl/base:core_headers",
@@ -164,10 +135,13 @@ cc_test(
         "//absl/base",
         "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/base:malloc_internal",
+        "//absl/cleanup",
         "//absl/log",
         "//absl/log:check",
         "//absl/memory",
         "//absl/strings",
+        "//absl/strings:str_format",
         "@googletest//:gtest",
     ],
 )
@@ -182,7 +156,10 @@ cc_library(
     ],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
-    visibility = ["//absl/log/internal:__pkg__"],
+    visibility = [
+        "//absl:friends",
+        "//absl/log/internal:__pkg__",
+    ],
     deps = [
         ":stacktrace",
         ":symbolize",
@@ -244,7 +221,7 @@ cc_library(
     ],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
-    visibility = ["//visibility:private"],
+    visibility = ["//absl:friends"],
     deps = [
         "//absl/base:config",
         "//absl/base:core_headers",
@@ -261,6 +238,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
         "//absl/container:__pkg__",
         "//absl/debugging:__pkg__",
     ],

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

@@ -16,38 +16,6 @@
 
 find_library(EXECINFO_LIBRARY execinfo)
 
-absl_cc_library(
-  NAME
-    borrowed_fixup_buffer
-  SRCS
-    "internal/borrowed_fixup_buffer.cc"
-  HDRS
-    "internal/borrowed_fixup_buffer.h"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  LINKOPTS
-    ${ABSL_DEFAULT_LINKOPTS}
-  DEPS
-    absl::config
-    absl::core_headers
-    absl::hash
-    absl::malloc_internal
-  PUBLIC
-)
-
-absl_cc_test(
-  NAME
-    borrowed_fixup_buffer_test
-  SRCS
-    "internal/borrowed_fixup_buffer_test.cc"
-  COPTS
-    ${ABSL_TEST_COPTS}
-  DEPS
-    absl::borrowed_fixup_buffer
-    absl::config
-    GTest::gmock_main
-)
-
 absl_cc_library(
   NAME
     stacktrace
@@ -70,7 +38,6 @@ absl_cc_library(
   LINKOPTS
     $<$<BOOL:${EXECINFO_LIBRARY}>:${EXECINFO_LIBRARY}>
   DEPS
-    absl::borrowed_fixup_buffer
     absl::debugging_internal
     absl::config
     absl::core_headers
@@ -140,12 +107,15 @@ absl_cc_test(
   DEPS
     absl::base
     absl::check
+    absl::cleanup
     absl::config
     absl::core_headers
     absl::log
+    absl::malloc_internal
     absl::memory
     absl::stack_consumption
     absl::strings
+    absl::str_format
     absl::symbolize
     GTest::gmock
 )

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

@@ -32,6 +32,14 @@ namespace debugging_internal {
 // DemangleRustSymbolEncoding is async-signal-safe and runs in bounded C++
 // call-stack space.  It is suitable for symbolizing stack traces in a signal
 // handler.
+//
+// Note that this demangler purposefully omits some details: generic argument
+// lists become `<>`, function types `fn...`, and long tuples `(t, u, v, ...)`.
+// This simplification suits crash backtracing, where the signal handler must
+// not `malloc`, and the human troubleshooter won't want the `file:line` blame
+// drowned in generic arguments.  Applications better served by a freely
+// allocating detailed demangler might prefer to use Rust's own `rustc-demangle`
+// crate.
 bool DemangleRustSymbolEncoding(const char* mangled, char* out,
                                 size_t out_size);
 

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

@@ -15,6 +15,7 @@
 #include "absl/debugging/internal/demangle.h"
 
 #include <cstdlib>
+#include <memory>
 #include <string>
 
 #include "gmock/gmock.h"
@@ -2000,7 +2001,7 @@ TEST(Demangle, DemangleStackConsumption) {
 
 static void TestOnInput(const char* input) {
   static const int kOutSize = 1048576;
-  auto out = absl::make_unique<char[]>(kOutSize);
+  auto out = std::make_unique<char[]>(kOutSize);
   Demangle(input, out.get(), kOutSize);
 }
 

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

@@ -143,6 +143,12 @@ void DumpPCAndFrameSizeAndSymbol(OutputWriter* writer, void* writer_arg,
   writer(buf, writer_arg);
 }
 
+void DebugStackTraceHookLegacyAdapter(void* const stack[], int depth,
+                                      OutputWriter* writer, void* writer_arg) {
+  debug_stack_trace_hook(stack, depth, /*crash_pc=*/nullptr, writer,
+                         writer_arg);
+}
+
 }  // namespace
 
 void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook) {
@@ -150,7 +156,11 @@ void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook) {
 }
 
 SymbolizeUrlEmitterLegacy GetDebugStackTraceHookLegacy() {
-  return debug_stack_trace_hook;
+  if (debug_stack_trace_hook == nullptr) {
+    // No prior call to RegisterDebugStackTraceHook.
+    return nullptr;
+  }
+  return &DebugStackTraceHookLegacyAdapter;
 }
 
 SymbolizeUrlEmitter GetDebugStackTraceHook() { return debug_stack_trace_hook; }
@@ -313,7 +323,7 @@ void DumpStackTrace(int min_dropped_frames, int max_num_frames,
 
   auto hook = GetDebugStackTraceHook();
   if (hook != nullptr) {
-    (*hook)(stack, depth, writer, writer_arg);
+    hook(stack, depth, /*crash_pc=*/nullptr, writer, writer_arg);
   }
 
   if (allocated_bytes != 0) Deallocate(stack, allocated_bytes);

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

@@ -31,7 +31,8 @@ typedef void OutputWriter(const char*, void*);
 // `hook` that is called each time DumpStackTrace() is called.
 // `hook` may be called from a signal handler.
 typedef void (*SymbolizeUrlEmitter)(void* const stack[], int depth,
-                                    OutputWriter* writer, void* writer_arg);
+                                    const void* crash_pc, OutputWriter* writer,
+                                    void* writer_arg);
 typedef void (*SymbolizeUrlEmitterLegacy)(void* const stack[], int depth,
                                           OutputWriter* writer,
                                           void* writer_arg);
@@ -41,8 +42,6 @@ typedef void (*SymbolizeUrlEmitterLegacy)(void* const stack[], int depth,
 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

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

@@ -212,6 +212,17 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
   stack_info.sig_stack_low = stack_info.stack_low;
   stack_info.sig_stack_high = kUnknownStackEnd;
 
+#if defined(__linux__)
+  // Similarly for the signal stack, retrieve the information into sig_stack and
+  // then pass it down per call. Calling sigaltstack with nullptr as the first
+  // argument doesn't change the signal stack.
+  stack_t sig_stack;
+  if (sigaltstack(nullptr, &sig_stack) == 0) {
+    stack_info.sig_stack_low = reinterpret_cast<uintptr_t>(sig_stack.ss_sp);
+    stack_info.sig_stack_high = stack_info.sig_stack_low + sig_stack.ss_size;
+  }
+#endif
+
   // The frame pointer points to low address of a frame.  The first 64-bit
   // word of a frame points to the next frame up the call chain, which normally
   // is just after the high address of the current frame.  The second word of

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

@@ -74,10 +74,19 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
   size =
       static_cast<int>(emscripten_stack_unwind_buffer(pc, stack, kStackLength));
 
-  int result_count = size - skip_count;
-  if (result_count < 0) result_count = 0;
-  if (result_count > max_depth) result_count = max_depth;
-  for (int i = 0; i < result_count; i++) result[i] = stack[i + skip_count];
+  int num_frames = size - skip_count;
+  if (num_frames < 0) num_frames = 0;
+  if (num_frames > max_depth) num_frames = max_depth;
+
+  int result_count = 0;
+  for (int i = 0; i < num_frames; i++) {
+    int stack_index = i + skip_count;
+    // Follow x86 and stop if the return address is null (end of stack).
+    if (stack[stack_index] == nullptr) {
+      break;
+    }
+    result[result_count++] = stack[stack_index];
+  }
 
   if (IS_STACK_FRAMES) {
     // No implementation for finding out the stack frames yet.

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

@@ -71,13 +71,20 @@ static int UnwindImpl(void** result, uintptr_t* frames, int* sizes,
 
   size = backtrace(stack, kStackLength);
   skip_count++;  // we want to skip the current frame as well
-  int result_count = size - skip_count;
-  if (result_count < 0)
-    result_count = 0;
-  if (result_count > max_depth)
-    result_count = max_depth;
-  for (int i = 0; i < result_count; i++)
-    result[i] = stack[i + skip_count];
+
+  int num_frames = size - skip_count;
+  if (num_frames < 0) num_frames = 0;
+  if (num_frames > max_depth) num_frames = max_depth;
+
+  int result_count = 0;
+  for (int i = 0; i < num_frames; i++) {
+    int stack_index = i + skip_count;
+    // Follow x86 and stop if the return address is null (end of stack).
+    if (stack[stack_index] == nullptr) {
+      break;
+    }
+    result[result_count++] = stack[stack_index];
+  }
 
   if (IS_STACK_FRAMES) {
     // No implementation for finding out the stack frames yet.