re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/crc/internal/crc32_x86_arm_combined_simd.h

@@ -99,19 +99,12 @@ V128 V128_PMul10(const V128 l, const V128 r);
 // Produces a XOR operation of |l| and |r|.
 V128 V128_Xor(const V128 l, const V128 r);
 
-// Produces an AND operation of |l| and |r|.
-V128 V128_And(const V128 l, const V128 r);
-
 // Sets the lower half of a 128 bit register to the given 64-bit value and
 // zeroes the upper half.
 // dst[63:0] := |r|
 // dst[127:64] := |0|
 V128 V128_From64WithZeroFill(const uint64_t r);
 
-// Shift |l| right by |imm| bytes while shifting in zeros.
-template <int imm>
-V128 V128_ShiftRight(const V128 l);
-
 // Extracts a 32-bit integer from |l|, selected with |imm|.
 template <int imm>
 int V128_Extract32(const V128 l);
@@ -170,17 +163,10 @@ inline V128 V128_PMul10(const V128 l, const V128 r) {
 
 inline V128 V128_Xor(const V128 l, const V128 r) { return _mm_xor_si128(l, r); }
 
-inline V128 V128_And(const V128 l, const V128 r) { return _mm_and_si128(l, r); }
-
 inline V128 V128_From64WithZeroFill(const uint64_t r) {
   return _mm_set_epi64x(static_cast<int64_t>(0), static_cast<int64_t>(r));
 }
 
-template <int imm>
-inline V128 V128_ShiftRight(const V128 l) {
-  return _mm_srli_si128(l, imm);
-}
-
 template <int imm>
 inline int V128_Extract32(const V128 l) {
   return _mm_extract_epi32(l, imm);
@@ -261,20 +247,12 @@ inline V128 V128_PMul10(const V128 l, const V128 r) {
 
 inline V128 V128_Xor(const V128 l, const V128 r) { return veorq_u64(l, r); }
 
-inline V128 V128_And(const V128 l, const V128 r) { return vandq_u64(l, r); }
-
 inline V128 V128_From64WithZeroFill(const uint64_t r){
   constexpr uint64x2_t kZero = {0, 0};
   return vsetq_lane_u64(r, kZero, 0);
 }
 
 
-template <int imm>
-inline V128 V128_ShiftRight(const V128 l) {
-  return vreinterpretq_u64_s8(
-      vextq_s8(vreinterpretq_s8_u64(l), vdupq_n_s8(0), imm));
-}
-
 template <int imm>
 inline int V128_Extract32(const V128 l) {
   return vgetq_lane_s32(vreinterpretq_s32_u64(l), imm);

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

@@ -422,6 +422,11 @@ CrcMemcpy::ArchSpecificEngines CrcMemcpy::GetArchSpecificEngines() {
       };
     // INTEL_SANDYBRIDGE performs better with SSE than AVX.
     case CpuType::kIntelSandybridge:
+    // Use SIMD memcpy on ARM cores.
+    case CpuType::kArmNeoverseN1:
+    case CpuType::kArmNeoverseN2:
+    case CpuType::kArmNeoverseV1:
+    case CpuType::kArmNeoverseV2:
       return {
           /*.temporal=*/new AcceleratedCrcMemcpyEngine<3, 0>(),
           /*.non_temporal=*/new CrcNonTemporalMemcpyEngine(),

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

@@ -64,27 +64,27 @@ class CRC32AcceleratedX86ARMCombined : public CRC32 {
 constexpr size_t kSmallCutoff = 256;
 constexpr size_t kMediumCutoff = 2048;
 
-#define ABSL_INTERNAL_STEP1(crc)                      \
+#define ABSL_INTERNAL_STEP1(crc, p)                   \
   do {                                                \
     crc = CRC32_u8(static_cast<uint32_t>(crc), *p++); \
   } while (0)
-#define ABSL_INTERNAL_STEP2(crc)                                               \
+#define ABSL_INTERNAL_STEP2(crc, p)                                            \
   do {                                                                         \
     crc =                                                                      \
         CRC32_u16(static_cast<uint32_t>(crc), absl::little_endian::Load16(p)); \
     p += 2;                                                                    \
   } while (0)
-#define ABSL_INTERNAL_STEP4(crc)                                               \
+#define ABSL_INTERNAL_STEP4(crc, p)                                            \
   do {                                                                         \
     crc =                                                                      \
         CRC32_u32(static_cast<uint32_t>(crc), absl::little_endian::Load32(p)); \
     p += 4;                                                                    \
   } while (0)
-#define ABSL_INTERNAL_STEP8(crc, data)                  \
-  do {                                                  \
-    crc = CRC32_u64(static_cast<uint32_t>(crc),         \
-                    absl::little_endian::Load64(data)); \
-    data += 8;                                          \
+#define ABSL_INTERNAL_STEP8(crc, p)                                            \
+  do {                                                                         \
+    crc =                                                                      \
+        CRC32_u64(static_cast<uint32_t>(crc), absl::little_endian::Load64(p)); \
+    p += 8;                                                                    \
   } while (0)
 #define ABSL_INTERNAL_STEP8BY2(crc0, crc1, p0, p1) \
   do {                                             \
@@ -100,47 +100,67 @@ constexpr size_t kMediumCutoff = 2048;
 
 namespace {
 
-uint32_t multiply(uint32_t a, uint32_t b) {
-  V128 power = V128_From64WithZeroFill(a);
-  V128 crc = V128_From64WithZeroFill(b);
-  V128 res = V128_PMulLow(power, crc);
-
-  // Combine crc values.
-  //
-  // Adding res to itself is equivalent to multiplying by 2,
-  // or shifting left by 1. Addition is used as not all compilers
-  // are able to generate optimal code without this hint.
-  // https://godbolt.org/z/rr3fMnf39
-  res = V128_Add64(res, res);
-  return static_cast<uint32_t>(V128_Extract32<1>(res)) ^
-         CRC32_u32(0, static_cast<uint32_t>(V128_Low64(res)));
+// Does polynomial multiplication a * b * x^33 mod G.
+//
+// One of the multiplicands needs to have an extra factor of x^-33 to cancel out
+// the extra factor of x^33. The extra factor of x^33 comes from:
+//
+// - x^1 from the carry-less multiplication, due to the
+//   "least-significant-bit-first" convention of CRC-32C.
+//
+// - x^32 from using CRC32_u64() to reduce the carry-less product to 32 bits.
+//
+// Both could be avoided, but at the cost of extra instructions. It's more
+// efficient to just drop a factor of x^33 from one of the multiplicands.
+uint32_t MultiplyWithExtraX33(uint32_t a, uint32_t b) {
+  V128 a_vec = V128_From64WithZeroFill(a);
+  V128 b_vec = V128_From64WithZeroFill(b);
+  V128 res = V128_PMulLow(a_vec, b_vec);
+
+  return CRC32_u64(0, static_cast<uint64_t>(V128_Low64(res)));
 }
 
-// Powers of crc32c polynomial, for faster ExtendByZeros.
-// Verified against folly:
-// folly/hash/detail/Crc32CombineDetail.cpp
+// The number of low-order bits that ComputeZeroConstant() drops from the
+// length, i.e. treats as zeroes
+constexpr int kNumDroppedBits = 4;
+
+// Precomputed constants for faster ExtendByZeroes(). This was generated by
+// gen_crc32c_consts.py. The entry at index i is x^(2^(i + 3 + kNumDroppedBits)
+// - 33) mod G. That is x^-33 times the polynomial by which the CRC value needs
+// to be multiplied to extend it by 2^(i + 3 + kNumDroppedBits) zero bits, or
+// equivalently 2^(i + kNumDroppedBits) zero bytes. The extra factor of x^-33
+// cancels out the extra factor of x^33 that MultiplyWithExtraX33() introduces.
 constexpr uint32_t kCRC32CPowers[] = {
-    0x82f63b78, 0x6ea2d55c, 0x18b8ea18, 0x510ac59a, 0xb82be955, 0xb8fdb1e7,
-    0x88e56f72, 0x74c360a4, 0xe4172b16, 0x0d65762a, 0x35d73a62, 0x28461564,
-    0xbf455269, 0xe2ea32dc, 0xfe7740e6, 0xf946610b, 0x3c204f8f, 0x538586e3,
-    0x59726915, 0x734d5309, 0xbc1ac763, 0x7d0722cc, 0xd289cabe, 0xe94ca9bc,
-    0x05b74f3f, 0xa51e1f42, 0x40000000, 0x20000000, 0x08000000, 0x00800000,
-    0x00008000, 0x82f63b78, 0x6ea2d55c, 0x18b8ea18, 0x510ac59a, 0xb82be955,
-    0xb8fdb1e7, 0x88e56f72, 0x74c360a4, 0xe4172b16, 0x0d65762a, 0x35d73a62,
-    0x28461564, 0xbf455269, 0xe2ea32dc, 0xfe7740e6, 0xf946610b, 0x3c204f8f,
-    0x538586e3, 0x59726915, 0x734d5309, 0xbc1ac763, 0x7d0722cc, 0xd289cabe,
-    0xe94ca9bc, 0x05b74f3f, 0xa51e1f42, 0x40000000, 0x20000000, 0x08000000,
-    0x00800000, 0x00008000,
+    0x493c7d27, 0xba4fc28e, 0x9e4addf8, 0x0d3b6092, 0xb9e02b86, 0xdd7e3b0c,
+    0x170076fa, 0xa51b6135, 0x82f89c77, 0x54a86326, 0x1dc403cc, 0x5ae703ab,
+    0xc5013a36, 0xac2ac6dd, 0x9b4615a9, 0x688d1c61, 0xf6af14e6, 0xb6ffe386,
+    0xb717425b, 0x478b0d30, 0x54cc62e5, 0x7b2102ee, 0x8a99adef, 0xa7568c8f,
+    0xd610d67e, 0x6b086b3f, 0xd94f3c0b, 0xbf818109, 0x780d5a4d, 0x05ec76f1,
+    0x00000001, 0x493c7d27, 0xba4fc28e, 0x9e4addf8, 0x0d3b6092, 0xb9e02b86,
+    0xdd7e3b0c, 0x170076fa, 0xa51b6135, 0x82f89c77, 0x54a86326, 0x1dc403cc,
+    0x5ae703ab, 0xc5013a36, 0xac2ac6dd, 0x9b4615a9, 0x688d1c61, 0xf6af14e6,
+    0xb6ffe386, 0xb717425b, 0x478b0d30, 0x54cc62e5, 0x7b2102ee, 0x8a99adef,
+    0xa7568c8f, 0xd610d67e, 0x6b086b3f, 0xd94f3c0b, 0xbf818109, 0x780d5a4d,
 };
+// There must be an entry for each non-dropped bit in the size_t length.
+static_assert(std::size(kCRC32CPowers) >= sizeof(size_t) * 8 - kNumDroppedBits);
 
 }  // namespace
 
-// Compute a magic constant, so that multiplying by it is the same as
-// extending crc by length zeros.
+// Compute a magic constant, so that multiplying by it is the same as extending
+// crc by length zeros. The lowest kNumDroppedBits of the length are ignored and
+// treated as zeroes; the caller is assumed to handle any nonzero bits there.
+#if defined(NDEBUG) && ABSL_HAVE_CPP_ATTRIBUTE(clang::no_sanitize)
+// The array accesses in this are safe: `length >= size_t{1} <<
+// kNumDroppedBits`, so `countr_zero(length >> kNumDroppedBits) < sizeof(size_t)
+// * 8 - kNumDroppedBits`, and `length & (length - 1)` cannot introduce bits
+// `>= sizeof(size_t) * 8 - kNumDroppedBits`. The compiler cannot prove this, so
+// manually disable bounds checking.
+[[clang::no_sanitize("array-bounds")]]
+#endif
 uint32_t CRC32AcceleratedX86ARMCombined::ComputeZeroConstant(
     size_t length) const {
-  // Lowest 2 bits are handled separately in ExtendByZeroes
-  length >>= 2;
+  length >>= kNumDroppedBits;
 
   int index = absl::countr_zero(length);
   uint32_t prev = kCRC32CPowers[index];
@@ -149,7 +169,7 @@ uint32_t CRC32AcceleratedX86ARMCombined::ComputeZeroConstant(
   while (length) {
     // For each bit of length, extend by 2**n zeros.
     index = absl::countr_zero(length);
-    prev = multiply(prev, kCRC32CPowers[index]);
+    prev = MultiplyWithExtraX33(prev, kCRC32CPowers[index]);
     length &= length - 1;
   }
   return prev;
@@ -159,22 +179,13 @@ void CRC32AcceleratedX86ARMCombined::ExtendByZeroes(uint32_t* crc,
                                                     size_t length) const {
   uint32_t val = *crc;
   // Don't bother with multiplication for small length.
-  switch (length & 3) {
-    case 0:
-      break;
-    case 1:
-      val = CRC32_u8(val, 0);
-      break;
-    case 2:
-      val = CRC32_u16(val, 0);
-      break;
-    case 3:
-      val = CRC32_u8(val, 0);
-      val = CRC32_u16(val, 0);
-      break;
-  }
-  if (length > 3) {
-    val = multiply(val, ComputeZeroConstant(length));
+  if (length & 1) val = CRC32_u8(val, 0);
+  if (length & 2) val = CRC32_u16(val, 0);
+  if (length & 4) val = CRC32_u32(val, 0);
+  if (length & 8) val = CRC32_u64(val, 0);
+  static_assert(kNumDroppedBits == 4);
+  if (length >= size_t{1} << kNumDroppedBits) {
+    val = MultiplyWithExtraX33(val, ComputeZeroConstant(length));
   }
   *crc = val;
 }
@@ -221,7 +232,8 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
   // We are applying it to CRC32C polynomial.
   ABSL_ATTRIBUTE_ALWAYS_INLINE void Process64BytesPclmul(
       const uint8_t* p, V128* partialCRC) const {
-    V128 loopMultiplicands = V128_Load(reinterpret_cast<const V128*>(k1k2));
+    V128 loopMultiplicands =
+        V128_Load(reinterpret_cast<const V128*>(kFoldAcross512Bits));
 
     V128 partialCRC1 = partialCRC[0];
     V128 partialCRC2 = partialCRC[1];
@@ -265,53 +277,33 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
 
     // Combine 4 vectors of partial crc into a single vector.
     V128 reductionMultiplicands =
-        V128_Load(reinterpret_cast<const V128*>(k5k6));
+        V128_Load(reinterpret_cast<const V128*>(kFoldAcross256Bits));
 
     V128 low = V128_PMulLow(reductionMultiplicands, partialCRC1);
     V128 high = V128_PMulHi(reductionMultiplicands, partialCRC1);
 
     partialCRC1 = V128_Xor(low, high);
-    partialCRC1 = V128_Xor(partialCRC1, partialCRC2);
+    partialCRC1 = V128_Xor(partialCRC1, partialCRC3);
 
-    low = V128_PMulLow(reductionMultiplicands, partialCRC3);
-    high = V128_PMulHi(reductionMultiplicands, partialCRC3);
+    low = V128_PMulLow(reductionMultiplicands, partialCRC2);
+    high = V128_PMulHi(reductionMultiplicands, partialCRC2);
 
-    partialCRC3 = V128_Xor(low, high);
-    partialCRC3 = V128_Xor(partialCRC3, partialCRC4);
+    partialCRC2 = V128_Xor(low, high);
+    partialCRC2 = V128_Xor(partialCRC2, partialCRC4);
 
-    reductionMultiplicands = V128_Load(reinterpret_cast<const V128*>(k3k4));
+    reductionMultiplicands =
+        V128_Load(reinterpret_cast<const V128*>(kFoldAcross128Bits));
 
     low = V128_PMulLow(reductionMultiplicands, partialCRC1);
     high = V128_PMulHi(reductionMultiplicands, partialCRC1);
     V128 fullCRC = V128_Xor(low, high);
-    fullCRC = V128_Xor(fullCRC, partialCRC3);
+    fullCRC = V128_Xor(fullCRC, partialCRC2);
 
     // Reduce fullCRC into scalar value.
-    reductionMultiplicands = V128_Load(reinterpret_cast<const V128*>(k5k6));
-
-    V128 mask = V128_Load(reinterpret_cast<const V128*>(kMask));
-
-    V128 tmp = V128_PMul01(reductionMultiplicands, fullCRC);
-    fullCRC = V128_ShiftRight<8>(fullCRC);
-    fullCRC = V128_Xor(fullCRC, tmp);
-
-    reductionMultiplicands = V128_Load(reinterpret_cast<const V128*>(k7k0));
-
-    tmp = V128_ShiftRight<4>(fullCRC);
-    fullCRC = V128_And(fullCRC, mask);
-    fullCRC = V128_PMulLow(reductionMultiplicands, fullCRC);
-    fullCRC = V128_Xor(tmp, fullCRC);
-
-    reductionMultiplicands = V128_Load(reinterpret_cast<const V128*>(kPoly));
-
-    tmp = V128_And(fullCRC, mask);
-    tmp = V128_PMul01(reductionMultiplicands, tmp);
-    tmp = V128_And(tmp, mask);
-    tmp = V128_PMulLow(reductionMultiplicands, tmp);
-
-    fullCRC = V128_Xor(tmp, fullCRC);
-
-    return static_cast<uint64_t>(V128_Extract32<1>(fullCRC));
+    uint32_t crc = 0;
+    crc = CRC32_u64(crc, V128_Extract64<0>(fullCRC));
+    crc = CRC32_u64(crc, V128_Extract64<1>(fullCRC));
+    return crc;
   }
 
   // Update crc with 64 bytes of data from p.
@@ -325,15 +317,23 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
     return crc;
   }
 
-  // Generated by crc32c_x86_test --crc32c_generate_constants=true
-  // and verified against constants in linux kernel for S390:
-  // https://github.com/torvalds/linux/blob/master/arch/s390/crypto/crc32le-vx.S
-  alignas(16) static constexpr uint64_t k1k2[2] = {0x0740eef02, 0x09e4addf8};
-  alignas(16) static constexpr uint64_t k3k4[2] = {0x1384aa63a, 0x0ba4fc28e};
-  alignas(16) static constexpr uint64_t k5k6[2] = {0x0f20c0dfe, 0x14cd00bd6};
-  alignas(16) static constexpr uint64_t k7k0[2] = {0x0dd45aab8, 0x000000000};
-  alignas(16) static constexpr uint64_t kPoly[2] = {0x105ec76f0, 0x0dea713f1};
-  alignas(16) static constexpr uint32_t kMask[4] = {~0u, 0u, ~0u, 0u};
+  // 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] = {
+      // (x^543 mod G) * x^32
+      0x00000000740eef02,
+      // (x^479 mod G) * x^32
+      0x000000009e4addf8};
+  alignas(16) static constexpr uint64_t kFoldAcross256Bits[2] = {
+      // (x^287 mod G) * x^32
+      0x000000003da6d0cb,
+      // (x^223 mod G) * x^32
+      0x00000000ba4fc28e};
+  alignas(16) static constexpr uint64_t kFoldAcross128Bits[2] = {
+      // (x^159 mod G) * x^32
+      0x00000000f20c0dfe,
+      // (x^95 mod G) * x^32
+      0x00000000493c7d27};
 
   // Medium runs of bytes are broken into groups of kGroupsSmall blocks of same
   // size. Each group is CRCed in parallel then combined at the end of the
@@ -345,30 +345,13 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
   static constexpr size_t kMaxStreams = 3;
 };
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-alignas(16) constexpr uint64_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k1k2[2];
-alignas(16) constexpr uint64_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k3k4[2];
-alignas(16) constexpr uint64_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k5k6[2];
-alignas(16) constexpr uint64_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k7k0[2];
-alignas(16) constexpr uint64_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kPoly[2];
-alignas(16) constexpr uint32_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kMask[4];
-constexpr size_t
-    CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kGroupsSmall;
-constexpr size_t CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kMaxStreams;
-#endif  // ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-
 template <size_t num_crc_streams, size_t num_pclmul_streams,
           CutoffStrategy strategy>
 class CRC32AcceleratedX86ARMCombinedMultipleStreams
     : public CRC32AcceleratedX86ARMCombinedMultipleStreamsBase {
   ABSL_ATTRIBUTE_HOT
-  void Extend(uint32_t* crc, const void* bytes, size_t length) const override {
+  void Extend(uint32_t* crc, const void* bytes,
+              const size_t length) const override {
     static_assert(num_crc_streams >= 1 && num_crc_streams <= kMaxStreams,
                   "Invalid number of crc streams");
     static_assert(num_pclmul_streams >= 0 && num_pclmul_streams <= kMaxStreams,
@@ -378,47 +361,15 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
     uint32_t l = *crc;
     uint64_t l64;
 
-    // We have dedicated instruction for 1,2,4 and 8 bytes.
-    if (length & 8) {
-      ABSL_INTERNAL_STEP8(l, p);
-      length &= ~size_t{8};
-    }
-    if (length & 4) {
-      ABSL_INTERNAL_STEP4(l);
-      length &= ~size_t{4};
-    }
-    if (length & 2) {
-      ABSL_INTERNAL_STEP2(l);
-      length &= ~size_t{2};
-    }
-    if (length & 1) {
-      ABSL_INTERNAL_STEP1(l);
-      length &= ~size_t{1};
-    }
-    if (length == 0) {
-      *crc = l;
-      return;
-    }
-    // length is now multiple of 16.
-
     // For small blocks just run simple loop, because cost of combining multiple
     // streams is significant.
-    if (strategy != CutoffStrategy::Unroll64CRC) {
-      if (length < kSmallCutoff) {
-        while (length >= 16) {
-          ABSL_INTERNAL_STEP8(l, p);
-          ABSL_INTERNAL_STEP8(l, p);
-          length -= 16;
-        }
-        *crc = l;
-        return;
-      }
-    }
-
-    // For medium blocks we run 3 crc streams and combine them as described in
-    // Intel paper above. Running 4th stream doesn't help, because crc
-    // instruction has latency 3 and throughput 1.
-    if (length < kMediumCutoff) {
+    if (strategy != CutoffStrategy::Unroll64CRC && (length < kSmallCutoff)) {
+      // fallthrough; Use the same strategy as we do for processing the
+      // remaining bytes after any other strategy.
+    }  else if (length < kMediumCutoff) {
+      // For medium blocks we run 3 crc streams and combine them as described in
+      // Intel paper above. Running 4th stream doesn't help, because crc
+      // instruction has latency 3 and throughput 1.
       l64 = l;
       if (strategy == CutoffStrategy::Fold3) {
         uint64_t l641 = 0;
@@ -467,6 +418,7 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
           p += 64;
         }
       }
+      l = static_cast<uint32_t>(l64);
     } else {
       // There is a lot of data, we can ignore combine costs and run all
       // requested streams (num_crc_streams + num_pclmul_streams),
@@ -478,7 +430,7 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
       const uint8_t* x = RoundUp<8>(p);
       // Process bytes until p is 8-byte aligned, if that isn't past the end.
       while (p != x) {
-        ABSL_INTERNAL_STEP1(l);
+        ABSL_INTERNAL_STEP1(l, p);
       }
 
       size_t bs = static_cast<size_t>(e - p) /
@@ -571,14 +523,15 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
       }
 
       // Combine all streams into single result.
+      static_assert(64 % (1 << kNumDroppedBits) == 0);
       uint32_t magic = ComputeZeroConstant(bs * 64);
       l64 = l64_crc[0];
       for (size_t i = 1; i < num_crc_streams; i++) {
-        l64 = multiply(static_cast<uint32_t>(l64), magic);
+        l64 = MultiplyWithExtraX33(static_cast<uint32_t>(l64), magic);
         l64 ^= l64_crc[i];
       }
       for (size_t i = 0; i < num_pclmul_streams; i++) {
-        l64 = multiply(static_cast<uint32_t>(l64), magic);
+        l64 = MultiplyWithExtraX33(static_cast<uint32_t>(l64), magic);
         l64 ^= l64_pclmul[i];
       }
 
@@ -588,16 +541,27 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
       } else {
         p = crc_streams[num_crc_streams - 1];
       }
+      l = static_cast<uint32_t>(l64);
     }
-    l = static_cast<uint32_t>(l64);
 
+    uint64_t remaining_bytes = static_cast<uint64_t>(e - p);
+    // Process the remaining bytes.
     while ((e - p) >= 16) {
       ABSL_INTERNAL_STEP8(l, p);
       ABSL_INTERNAL_STEP8(l, p);
     }
-    // Process the last few bytes
-    while (p != e) {
-      ABSL_INTERNAL_STEP1(l);
+
+    if (remaining_bytes & 8) {
+      ABSL_INTERNAL_STEP8(l, p);
+    }
+    if (remaining_bytes & 4) {
+      ABSL_INTERNAL_STEP4(l, p);
+    }
+    if (remaining_bytes & 2) {
+      ABSL_INTERNAL_STEP2(l, p);
+    }
+    if (remaining_bytes & 1) {
+      ABSL_INTERNAL_STEP1(l, p);
     }
 
 #undef ABSL_INTERNAL_STEP8BY3
@@ -622,6 +586,8 @@ CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
     case CpuType::kAmdRome:
     case CpuType::kAmdNaples:
     case CpuType::kAmdMilan:
+    case CpuType::kAmdGenoa:
+    case CpuType::kAmdTurin:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
           3, 1, CutoffStrategy::Fold3>();
     // PCLMULQDQ is fast, use combined PCLMULQDQ + CRC implementation.
@@ -629,6 +595,10 @@ CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
     case CpuType::kIntelSkylakeXeon:
     case CpuType::kIntelBroadwell:
     case CpuType::kIntelSkylake:
+    case CpuType::kIntelIcelake:
+    case CpuType::kIntelSapphirerapids:
+    case CpuType::kIntelEmeraldrapids:
+    case CpuType::kIntelGraniterapidsap:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
           3, 2, CutoffStrategy::Fold3>();
     // PCLMULQDQ is slow, don't use it.
@@ -640,6 +610,7 @@ CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
     case CpuType::kArmNeoverseN1:
     case CpuType::kArmNeoverseN2:
     case CpuType::kArmNeoverseV1:
+    case CpuType::kArmNeoverseN3:
       return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
           1, 1, CutoffStrategy::Unroll64CRC>();
     case CpuType::kAmpereSiryn:

package/vendor/abseil-cpp/absl/crc/internal/gen_crc32c_consts.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+#
+# 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.
+
+"""This script generates kCRC32CPowers[]."""
+
+
+def poly_mul(a, b):
+  """Polynomial multiplication: a * b."""
+  product = 0
+  for i in range(b.bit_length()):
+    if (b & (1 << i)) != 0:
+      product ^= a << i
+  return product
+
+
+def poly_div(a, b):
+  """Polynomial division: floor(a / b)."""
+  q = 0
+  while a.bit_length() >= b.bit_length():
+    q ^= 1 << (a.bit_length() - b.bit_length())
+    a ^= b << (a.bit_length() - b.bit_length())
+  return q
+
+
+def poly_reduce(a, b):
+  """Polynomial reduction: a mod b."""
+  return a ^ poly_mul(poly_div(a, b), b)
+
+
+def poly_exp(a, b, g):
+  """Polynomial exponentiation: a^b mod g."""
+  if b == 1:
+    return poly_reduce(a, g)
+  c = poly_exp(a, b // 2, g)
+  c = poly_mul(c, c)
+  if b % 2 != 0:
+    c = poly_mul(c, a)
+  return poly_reduce(c, g)
+
+
+def bitreflect(a, num_bits):
+  """Reflects the bits of the given integer."""
+  if a.bit_length() > num_bits:
+    raise ValueError(f'Integer has more than {num_bits} bits')
+  return sum(((a >> i) & 1) << (num_bits - 1 - i) for i in range(num_bits))
+
+
+G = 0x11EDC6F41  # The CRC-32C reducing polynomial, in the "natural" bit order
+CRC_BITS = 32  # The degree of G, i.e. the 32 in "CRC-32C"
+LSB_FIRST = True  # CRC-32C is a least-significant-bit-first CRC
+NUM_SIZE_BITS = 64  # The maximum number of bits in the length (size_t)
+NUM_DROPPED_BITS = 4  # The number of bits dropped from the length
+LOG2_BITS_PER_BYTE = 3  # log2 of the number of bits in a byte, i.e. log2(8)
+X = 2  # The polynomial 'x', in the "natural" bit order
+
+
+def print_crc32c_powers():
+  """Generates kCRC32CPowers[].
+
+  kCRC32CPowers[] is an array of length NUM_SIZE_BITS - NUM_DROPPED_BITS,
+  whose i'th entry is x^(2^(i + LOG2_BITS_PER_BYTE + NUM_DROPPED_BITS) -
+  CRC_BITS - 1) mod G. See kCRC32CPowers[] in the C++ source for more info.
+  """
+  for i in range(NUM_SIZE_BITS - NUM_DROPPED_BITS):
+    poly = poly_exp(
+        X,
+        2 ** (i + LOG2_BITS_PER_BYTE + NUM_DROPPED_BITS)
+        - CRC_BITS
+        - (1 if LSB_FIRST else 0),
+        G,
+    )
+    poly = bitreflect(poly, CRC_BITS)
+    print(f'0x{poly:0{2*CRC_BITS//8}x}, ', end='')
+
+
+if __name__ == '__main__':
+  print_crc32c_powers()

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

@@ -14,6 +14,9 @@
 # limitations under the License.
 #
 
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
 load(
     "//absl:copts/configure_copts.bzl",
     "ABSL_DEFAULT_COPTS",
@@ -55,6 +58,7 @@ cc_library(
         "//absl/base:config",
         "//absl/base:core_headers",
         "//absl/base:dynamic_annotations",
+        "//absl/base:malloc_internal",
         "//absl/base:raw_logging_internal",
     ],
 )
@@ -66,7 +70,9 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":stacktrace",
+        "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/types:span",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
@@ -202,6 +208,7 @@ cc_library(
     ],
     hdrs = [
         "internal/address_is_readable.h",
+        "internal/addresses.h",
         "internal/elf_mem_image.h",
         "internal/vdso_support.h",
     ],