re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/container/linked_hash_map.h

@@ -43,8 +43,8 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
 #include "absl/base/optimization.h"
+#include "absl/base/throw_delegate.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/container/internal/common.h"
 
@@ -377,7 +377,7 @@ class linked_hash_map {
   mapped_type& at(const key_arg<K>& key) {
     auto it = find(key);
     if (ABSL_PREDICT_FALSE(it == end())) {
-      absl::base_internal::ThrowStdOutOfRange("absl::linked_hash_map::at");
+      ThrowStdOutOfRange("absl::linked_hash_map::at");
     }
     return it->second;
   }

package/vendor/abseil-cpp/absl/container/node_hash_map.h

@@ -167,16 +167,28 @@ class ABSL_ATTRIBUTE_OWNER node_hash_map
   //   // Move is guaranteed efficient
   //   absl::node_hash_map<int, std::string> map5(std::move(map4));
   //
+  //   // After the move, map4 is in a valid but unspecified state. The only
+  //   // operations guaranteed to be safe on a moved-from map are destruction,
+  //   // assignment, and clear(). Any other operation (e.g. size(), empty(),
+  //   // iteration) results in undefined behavior.
+  //
   // * Move assignment operator
   //
   //   // May be efficient if allocators are compatible
   //   absl::node_hash_map<int, std::string> map6;
   //   map6 = std::move(map5);
   //
+  //   // Same moved-from guarantees apply to map5 after this operation.
+  //
   // * Range constructor
   //
   //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
   //   absl::node_hash_map<int, std::string> map7(v.begin(), v.end());
+  //
+  // * from_range constructor (C++23)
+  //
+  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+  //   absl::node_hash_map<int, std::string> map8(std::from_range, v);
   node_hash_map() {}
   using Base::Base;
 
@@ -599,22 +611,22 @@ namespace container_internal {
 // Erasure and/or insertion of elements in the function is not allowed.
 template <typename K, typename V, typename H, typename E, typename A,
           typename Function>
-decay_t<Function> c_for_each_fast(const node_hash_map<K, V, H, E, A>& c,
-                                  Function&& f) {
+std::decay_t<Function> c_for_each_fast(const node_hash_map<K, V, H, E, A>& c,
+                                       Function&& f) {
   container_internal::ForEach(f, &c);
   return f;
 }
 template <typename K, typename V, typename H, typename E, typename A,
           typename Function>
-decay_t<Function> c_for_each_fast(node_hash_map<K, V, H, E, A>& c,
-                                  Function&& f) {
+std::decay_t<Function> c_for_each_fast(node_hash_map<K, V, H, E, A>& c,
+                                       Function&& f) {
   container_internal::ForEach(f, &c);
   return f;
 }
 template <typename K, typename V, typename H, typename E, typename A,
           typename Function>
-decay_t<Function> c_for_each_fast(node_hash_map<K, V, H, E, A>&& c,
-                                  Function&& f) {
+std::decay_t<Function> c_for_each_fast(node_hash_map<K, V, H, E, A>&& c,
+                                       Function&& f) {
   container_internal::ForEach(f, &c);
   return f;
 }
@@ -640,23 +652,22 @@ class NodeHashMapPolicy
 
   template <class Allocator, class... Args>
   static value_type* new_element(Allocator* alloc, Args&&... args) {
-    using PairAlloc = typename absl::allocator_traits<
+    using PairAlloc = typename std::allocator_traits<
         Allocator>::template rebind_alloc<value_type>;
     PairAlloc pair_alloc(*alloc);
-    value_type* res =
-        absl::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
-    absl::allocator_traits<PairAlloc>::construct(pair_alloc, res,
-                                                 std::forward<Args>(args)...);
+    value_type* res = std::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
+    std::allocator_traits<PairAlloc>::construct(pair_alloc, res,
+                                                std::forward<Args>(args)...);
     return res;
   }
 
   template <class Allocator>
   static void delete_element(Allocator* alloc, value_type* pair) {
-    using PairAlloc = typename absl::allocator_traits<
+    using PairAlloc = typename std::allocator_traits<
         Allocator>::template rebind_alloc<value_type>;
     PairAlloc pair_alloc(*alloc);
-    absl::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
-    absl::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
+    std::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
+    std::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
   }
 
   template <class F, class... Args>
@@ -677,7 +688,8 @@ class NodeHashMapPolicy
   template <class Hash, bool kIsDefault>
   static constexpr HashSlotFn get_hash_slot_fn() {
     return memory_internal::IsLayoutCompatible<Key, Value>::value
-               ? &TypeErasedDerefAndApplyToSlotFn<Hash, Key, kIsDefault>
+               ? &TypeErasedDerefAndApplyToSlotFirstFn<Hash, value_type,
+                                                       kIsDefault>
                : nullptr;
   }
 };

package/vendor/abseil-cpp/absl/container/node_hash_map_test.cc

@@ -32,6 +32,10 @@
 #include "absl/container/internal/unordered_map_members_test.h"
 #include "absl/container/internal/unordered_map_modifiers_test.h"
 
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+#include <ranges>  // NOLINT(build/c++20)
+#endif
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
@@ -342,6 +346,36 @@ TEST(NodeHashMap, RecursiveTypeCompiles) {
   t.m[0] = RecursiveType{};
 }
 
+#if defined(__cpp_lib_containers_ranges) && \
+    __cpp_lib_containers_ranges >= 202202L
+TEST(NodeHashMap, FromRange) {
+  std::vector<std::pair<int, int>> v = {{1, 2}, {3, 4}, {5, 6}};
+  absl::node_hash_map<int, int> m(std::from_range, v);
+  EXPECT_THAT(m, UnorderedElementsAre(Pair(1, 2), Pair(3, 4), Pair(5, 6)));
+}
+
+TEST(NodeHashMap, FromRangeWithAllocator) {
+  std::vector<std::pair<int, int>> v = {{1, 2}, {3, 4}, {5, 6}};
+  absl::node_hash_map<int, int,
+                      absl::container_internal::hash_default_hash<int>,
+                      absl::container_internal::hash_default_eq<int>,
+                      Alloc<std::pair<const int, int>>>
+      m(std::from_range, v, 0, Alloc<std::pair<const int, int>>());
+  EXPECT_THAT(m, UnorderedElementsAre(Pair(1, 2), Pair(3, 4), Pair(5, 6)));
+}
+
+TEST(NodeHashMap, FromRangeWithHasherAndAllocator) {
+  std::vector<std::pair<int, int>> v = {{1, 2}, {3, 4}, {5, 6}};
+  using TestingHash = absl::container_internal::StatefulTestingHash;
+  absl::node_hash_map<int, int, TestingHash,
+                      absl::container_internal::hash_default_eq<int>,
+                      Alloc<std::pair<const int, int>>>
+      m(std::from_range, v, 0, TestingHash{},
+        Alloc<std::pair<const int, int>>());
+  EXPECT_THAT(m, UnorderedElementsAre(Pair(1, 2), Pair(3, 4), Pair(5, 6)));
+}
+#endif
+
 }  // namespace
 }  // namespace container_internal
 ABSL_NAMESPACE_END

package/vendor/abseil-cpp/absl/container/node_hash_set.h

@@ -161,16 +161,28 @@ class ABSL_ATTRIBUTE_OWNER node_hash_set
   //   // Move is guaranteed efficient
   //   absl::node_hash_set<std::string> set5(std::move(set4));
   //
+  //   // After the move, set4 is in a valid but unspecified state. The only
+  //   // operations guaranteed to be safe on a moved-from set are destruction,
+  //   // assignment, and clear(). Any other operation (e.g. size(), empty(),
+  //   // iteration) results in undefined behavior.
+  //
   // * Move assignment operator
   //
   //   // May be efficient if allocators are compatible
   //   absl::node_hash_set<std::string> set6;
   //   set6 = std::move(set5);
   //
+  //   // Same moved-from guarantees apply to set5 after this operation.
+  //
   // * Range constructor
   //
   //   std::vector<std::string> v = {"a", "b"};
   //   absl::node_hash_set<std::string> set7(v.begin(), v.end());
+  //
+  // * from_range constructor (C++23)
+  //
+  //   std::vector<std::string> v = {"a", "b"};
+  //   absl::node_hash_set<std::string> set8(std::from_range, v);
   node_hash_set() {}
   using Base::Base;
 
@@ -507,18 +519,20 @@ namespace container_internal {
 // There is no guarantees on the order of the function calls.
 // Erasure and/or insertion of elements in the function is not allowed.
 template <typename T, typename H, typename E, typename A, typename Function>
-decay_t<Function> c_for_each_fast(const node_hash_set<T, H, E, A>& c,
-                                  Function&& f) {
+std::decay_t<Function> c_for_each_fast(const node_hash_set<T, H, E, A>& c,
+                                       Function&& f) {
   container_internal::ForEach(f, &c);
   return f;
 }
 template <typename T, typename H, typename E, typename A, typename Function>
-decay_t<Function> c_for_each_fast(node_hash_set<T, H, E, A>& c, Function&& f) {
+std::decay_t<Function> c_for_each_fast(node_hash_set<T, H, E, A>& c,
+                                       Function&& f) {
   container_internal::ForEach(f, &c);
   return f;
 }
 template <typename T, typename H, typename E, typename A, typename Function>
-decay_t<Function> c_for_each_fast(node_hash_set<T, H, E, A>&& c, Function&& f) {
+std::decay_t<Function> c_for_each_fast(node_hash_set<T, H, E, A>&& c,
+                                       Function&& f) {
   container_internal::ForEach(f, &c);
   return f;
 }
@@ -541,21 +555,21 @@ struct NodeHashSetPolicy
   template <class Allocator, class... Args>
   static T* new_element(Allocator* alloc, Args&&... args) {
     using ValueAlloc =
-        typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
+        typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
     ValueAlloc value_alloc(*alloc);
-    T* res = absl::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
-    absl::allocator_traits<ValueAlloc>::construct(value_alloc, res,
-                                                  std::forward<Args>(args)...);
+    T* res = std::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
+    std::allocator_traits<ValueAlloc>::construct(value_alloc, res,
+                                                 std::forward<Args>(args)...);
     return res;
   }
 
   template <class Allocator>
   static void delete_element(Allocator* alloc, T* elem) {
     using ValueAlloc =
-        typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
+        typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
     ValueAlloc value_alloc(*alloc);
-    absl::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
-    absl::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
+    std::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
+    std::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
   }
 
   template <class F, class... Args>

package/vendor/abseil-cpp/absl/container/node_hash_set_test.cc

@@ -31,6 +31,10 @@
 #include "absl/container/internal/unordered_set_modifiers_test.h"
 #include "absl/memory/memory.h"
 
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+#include <ranges>  // NOLINT(build/c++20)
+#endif
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
@@ -71,11 +75,11 @@ TEST(NodeHashSet, MergeExtractInsert) {
     }
   };
   absl::node_hash_set<std::unique_ptr<int>, Hash, Eq> set1, set2;
-  set1.insert(absl::make_unique<int>(7));
-  set1.insert(absl::make_unique<int>(17));
+  set1.insert(std::make_unique<int>(7));
+  set1.insert(std::make_unique<int>(17));
 
-  set2.insert(absl::make_unique<int>(7));
-  set2.insert(absl::make_unique<int>(19));
+  set2.insert(std::make_unique<int>(7));
+  set2.insert(std::make_unique<int>(19));
 
   EXPECT_THAT(set1, UnorderedElementsAre(Pointee(7), Pointee(17)));
   EXPECT_THAT(set2, UnorderedElementsAre(Pointee(7), Pointee(19)));
@@ -85,7 +89,7 @@ TEST(NodeHashSet, MergeExtractInsert) {
   EXPECT_THAT(set1, UnorderedElementsAre(Pointee(7), Pointee(17), Pointee(19)));
   EXPECT_THAT(set2, UnorderedElementsAre(Pointee(7)));
 
-  auto node = set1.extract(absl::make_unique<int>(7));
+  auto node = set1.extract(std::make_unique<int>(7));
   EXPECT_TRUE(node);
   EXPECT_THAT(node.value(), Pointee(7));
   EXPECT_THAT(set1, UnorderedElementsAre(Pointee(17), Pointee(19)));
@@ -99,12 +103,12 @@ TEST(NodeHashSet, MergeExtractInsert) {
   EXPECT_NE(insert_result.position->get(), insert_result.node.value().get());
   EXPECT_THAT(set2, UnorderedElementsAre(Pointee(7)));
 
-  node = set1.extract(absl::make_unique<int>(17));
+  node = set1.extract(std::make_unique<int>(17));
   EXPECT_TRUE(node);
   EXPECT_THAT(node.value(), Pointee(17));
   EXPECT_THAT(set1, UnorderedElementsAre(Pointee(19)));
 
-  node.value() = absl::make_unique<int>(23);
+  node.value() = std::make_unique<int>(23);
 
   insert_result = set2.insert(std::move(node));
   EXPECT_FALSE(node);
@@ -182,6 +186,34 @@ TEST(NodeHashSet, CForEach) {
   }
 }
 
+#if defined(__cpp_lib_containers_ranges) && \
+    __cpp_lib_containers_ranges >= 202202L
+TEST(NodeHashSet, FromRange) {
+  std::vector<int> v = {1, 2, 3, 4, 5};
+  absl::node_hash_set<int> s(std::from_range, v);
+  EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
+}
+
+TEST(NodeHashSet, FromRangeWithAllocator) {
+  std::vector<int> v = {1, 2, 3, 4, 5};
+  absl::node_hash_set<int, absl::container_internal::hash_default_hash<int>,
+                      absl::container_internal::hash_default_eq<int>,
+                      Alloc<int>>
+      s(std::from_range, v, 0, Alloc<int>());
+  EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
+}
+
+TEST(NodeHashSet, FromRangeWithHasherAndAllocator) {
+  std::vector<int> v = {1, 2, 3, 4, 5};
+  using TestingHash = absl::container_internal::StatefulTestingHash;
+  absl::node_hash_set<int, TestingHash,
+                      absl::container_internal::hash_default_eq<int>,
+                      Alloc<int>>
+      s(std::from_range, v, 0, TestingHash{}, Alloc<int>());
+  EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
+}
+#endif
+
 }  // namespace
 }  // namespace container_internal
 ABSL_NAMESPACE_END

package/vendor/abseil-cpp/absl/container/sample_element_size_test.cc

@@ -57,12 +57,13 @@ void TestInlineElementSize(
     tables.back().insert(values.begin(), values.end());
   }
   size_t new_count = 0;
-  sampler.Iterate([&](const HashtablezInfo& info) {
+  EXPECT_EQ(sampler.Iterate([&](const HashtablezInfo& info) {
     if (preexisting_info.insert(&info).second) {
       EXPECT_EQ(info.inline_element_size, expected_element_size);
       ++new_count;
     }
-  });
+  }),
+            0);
   // Make sure we actually did get a new hashtablez.
   EXPECT_GT(new_count, 0);
 }
@@ -99,8 +100,10 @@ TEST(FlatHashMap, SampleElementSize) {
   // cannot be a flat_hash_set, however, since that would introduce a mutex
   // deadlock.
   std::unordered_set<const HashtablezInfo*> preexisting_info;  // NOLINT
-  sampler.Iterate(
-      [&](const HashtablezInfo& info) { preexisting_info.insert(&info); });
+  EXPECT_EQ(sampler.Iterate([&](const HashtablezInfo& info) {
+    preexisting_info.insert(&info);
+  }),
+            0);
   TestInlineElementSize(sampler, preexisting_info, flat_map_tables, map_values,
                         sizeof(int) + sizeof(bigstruct));
   TestInlineElementSize(sampler, preexisting_info, node_map_tables, map_values,

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

@@ -45,7 +45,6 @@ cc_library(
     deps = [
         "//absl/base",
         "//absl/base:config",
-        "//absl/types:optional",
     ],
 )
 

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

@@ -25,7 +25,6 @@ absl_cc_library(
   DEPS
     absl::base
     absl::config
-    absl::optional
 )
 
 # Internal-only target, do not depend on directly.
@@ -43,13 +42,13 @@ absl_cc_library(
     ${ABSL_DEFAULT_COPTS}
   DEPS
     absl::crc_cpu_detect
+    absl::bits
     absl::config
     absl::core_headers
     absl::endian
+    absl::memory
     absl::prefetch
     absl::raw_logging_internal
-    absl::memory
-    absl::bits
 )
 
 absl_cc_library(

package/vendor/abseil-cpp/absl/crc/crc32c_benchmark.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <memory>
 #include <string>
 
 #include "absl/crc/crc32c.h"
@@ -144,7 +145,7 @@ void BM_Memcpy(benchmark::State& state) {
   int string_len = state.range(0);
 
   std::string source = TestString(string_len);
-  auto dest = absl::make_unique<char[]>(string_len);
+  auto dest = std::make_unique<char[]>(string_len);
 
   for (auto s : state) {
     benchmark::DoNotOptimize(source);

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

@@ -15,10 +15,10 @@
 #include "absl/crc/internal/cpu_detect.h"
 
 #include <cstdint>
+#include <optional>  // IWYU pragma: keep
 #include <string>
 
 #include "absl/base/config.h"
-#include "absl/types/optional.h"  // IWYU pragma: keep
 
 #if defined(__aarch64__) && defined(__linux__)
 #include <asm/hwcap.h>
@@ -308,12 +308,12 @@ bool SupportsArmCRC32PMULL() {
 CpuType GetCpuType() { return CpuType::kUnknown; }
 
 template <typename T>
-static absl::optional<T> ReadSysctlByName(const char* name) {
+static std::optional<T> ReadSysctlByName(const char* name) {
   T val;
   size_t val_size = sizeof(T);
   int ret = sysctlbyname(name, &val, &val_size, nullptr, 0);
   if (ret == -1) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   return val;
 }
@@ -322,7 +322,7 @@ bool SupportsArmCRC32PMULL() {
   // Newer XNU kernels support querying all capabilities in a single
   // sysctlbyname.
 #if defined(CAP_BIT_CRC32) && defined(CAP_BIT_FEAT_PMULL)
-  static const absl::optional<uint64_t> caps =
+  static const std::optional<uint64_t> caps =
       ReadSysctlByName<uint64_t>("hw.optional.arm.caps");
   if (caps.has_value()) {
     constexpr uint64_t kCrc32AndPmullCaps =
@@ -332,13 +332,13 @@ bool SupportsArmCRC32PMULL() {
 #endif
 
   // https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics#3915619
-  static const absl::optional<int> armv8_crc32 =
+  static const std::optional<int> armv8_crc32 =
       ReadSysctlByName<int>("hw.optional.armv8_crc32");
   if (armv8_crc32.value_or(0) == 0) {
     return false;
   }
   // https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics#3918855
-  static const absl::optional<int> feat_pmull =
+  static const std::optional<int> feat_pmull =
       ReadSysctlByName<int>("hw.optional.arm.FEAT_PMULL");
   if (feat_pmull.value_or(0) == 0) {
     return false;

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

@@ -47,6 +47,7 @@
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/prefetch.h"
 #include "absl/crc/internal/crc_internal.h"
+#include "absl/numeric/bits.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -410,16 +411,13 @@ void CRC32::Scramble(uint32_t* crc) const {
   // Rotate by near half the word size plus 1.  See the scramble comment in
   // crc_internal.h for an explanation.
   constexpr int scramble_rotate = (32 / 2) + 1;
-  *crc = RotateRight<uint32_t>(static_cast<unsigned int>(*crc + kScrambleLo),
-                               32, scramble_rotate) &
-         MaskOfLength<uint32_t>(32);
+  *crc = absl::rotr(static_cast<uint32_t>(*crc + kScrambleLo), scramble_rotate);
 }
 
 void CRC32::Unscramble(uint32_t* crc) const {
   constexpr int scramble_rotate = (32 / 2) + 1;
-  uint64_t rotated = RotateRight<uint32_t>(static_cast<unsigned int>(*crc), 32,
-                                           32 - scramble_rotate);
-  *crc = (rotated - kScrambleLo) & MaskOfLength<uint32_t>(32);
+  uint64_t rotated = absl::rotl(*crc, scramble_rotate);
+  *crc = static_cast<uint32_t>(rotated - kScrambleLo);
 }
 
 // Constructor and destructor for base class CRC.

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

@@ -15,6 +15,7 @@
 #ifndef ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_
 #define ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_
 
+#include <array>
 #include <cstdint>
 
 #include "absl/base/config.h"
@@ -65,6 +66,13 @@ using V128 = uint64x2_t;
 using V128 = __m128i;
 #endif
 
+#if defined(__AVX__)
+using V256 = __m256i;
+#else
+// Placeholder for V256 when AVX is not available.
+using V256 = std::array<uint64_t, 4>;
+#endif
+
 // Starting with the initial value in |crc|, accumulates a CRC32 value for
 // unsigned integers of different sizes.
 uint32_t CRC32_u8(uint32_t crc, uint8_t v);
@@ -119,6 +127,17 @@ int64_t V128_Low64(const V128 l);
 // Add packed 64-bit integers in |l| and |r|.
 V128 V128_Add64(const V128 l, const V128 r);
 
+#if defined(__AVX__)
+inline V256 V256_LoadU(const V256* src);
+inline V256 V256_Broadcast128(const V128* src);
+#else
+template <typename T = V256>
+T V256_LoadU(const T* src);
+
+template <typename T = V256>
+T V256_Broadcast128(const V128* src);
+#endif
+
 #endif
 
 #if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
@@ -271,6 +290,28 @@ inline V128 V128_Add64(const V128 l, const V128 r) { return vaddq_u64(l, r); }
 
 #endif
 
+#if defined(__AVX__) && defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
+inline V256 V256_LoadU(const V256* src) { return _mm256_loadu_si256(src); }
+
+inline V256 V256_Broadcast128(const V128* src) {
+  return _mm256_castps_si256(
+      _mm256_broadcast_ps(reinterpret_cast<const __m128*>(src)));
+}
+#elif defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD) || \
+    defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD)
+template <typename T>
+inline T V256_LoadU(const T* src) {
+  (void)src;
+  return T{};
+}
+
+template <typename T>
+inline T V256_Broadcast128(const V128* src) {
+  (void)src;
+  return T{};
+}
+#endif
+
 }  // namespace crc_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -137,22 +137,6 @@ class CRC32 : public CRCImpl {
 
 // Helpers
 
-// Return a bit mask containing len 1-bits.
-// Requires 0 < len <= sizeof(T)
-template <typename T>
-T MaskOfLength(int len) {
-  // shift 2 by len-1 rather than 1 by len because shifts of wordsize
-  // are undefined.
-  return (T(2) << (len - 1)) - 1;
-}
-
-// Rotate low-order "width" bits of "in" right by "r" bits,
-// setting other bits in word to arbitrary values.
-template <typename T>
-T RotateRight(T in, int width, int r) {
-  return (in << (width - r)) | ((in >> r) & MaskOfLength<T>(width - r));
-}
-
 // RoundUp<N>(p) returns the lowest address >= p aligned to an N-byte
 // boundary.  Requires that N is a power of 2.
 template <int alignment>