grpc 1.84.0 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/hash/internal/hash.h

@@ -63,6 +63,7 @@
 #include <list>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <string_view>
@@ -71,12 +72,14 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/base/internal/endian.h"
 #include "absl/base/internal/unaligned_access.h"
 #include "absl/base/optimization.h"
+#include "absl/base/options.h"
 #include "absl/base/port.h"
 #include "absl/container/fixed_array.h"
 #include "absl/hash/internal/city.h"
@@ -89,10 +92,59 @@
 #include "absl/types/variant.h"
 #include "absl/utility/utility.h"
 
-#if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L
+#if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && \
+    !defined(__XTENSA__)
 #include <filesystem>  // NOLINT
 #endif
 
+// We are allowed to use a non-portable hardware-accelerated implementation in
+// headers if ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY != 0
+#if ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY != 0
+
+// 32-bit builds with SSE 4.2 do not have _mm_crc32_u64, so the
+// __x86_64__ condition is necessary.
+#if defined(__SSE4_2__) && defined(__x86_64__)
+
+#include <x86intrin.h>
+#define ABSL_HASH_INTERNAL_HAS_CRC32
+#define ABSL_HASH_INTERNAL_CRC32_U64 _mm_crc32_u64
+#define ABSL_HASH_INTERNAL_CRC32_U32 _mm_crc32_u32
+#define ABSL_HASH_INTERNAL_CRC32_U8 _mm_crc32_u8
+
+// 32-bit builds with AVX do not have _mm_crc32_u64, so the _M_X64 condition is
+// necessary.
+#elif defined(_MSC_VER) && !defined(__clang__) && defined(__AVX__) && \
+    defined(_M_X64)
+
+// MSVC AVX (/arch:AVX) implies SSE 4.2.
+#include <intrin.h>
+#define ABSL_HASH_INTERNAL_HAS_CRC32
+#define ABSL_HASH_INTERNAL_CRC32_U64 _mm_crc32_u64
+#define ABSL_HASH_INTERNAL_CRC32_U32 _mm_crc32_u32
+#define ABSL_HASH_INTERNAL_CRC32_U8 _mm_crc32_u8
+
+#elif defined(__ARM_FEATURE_CRC32)
+
+#include <arm_acle.h>
+#define ABSL_HASH_INTERNAL_HAS_CRC32
+// Casting to uint32_t to be consistent with x86 intrinsic (_mm_crc32_u64
+// accepts crc as 64 bit integer).
+#define ABSL_HASH_INTERNAL_CRC32_U64(crc, data) \
+  __crc32cd(static_cast<uint32_t>(crc), data)
+#define ABSL_HASH_INTERNAL_CRC32_U32 __crc32cw
+#define ABSL_HASH_INTERNAL_CRC32_U8 __crc32cb
+
+#endif  // Platform tests
+
+#endif  // ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY != 0
+
+
+#if ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY == 1
+#ifndef ABSL_HASH_INTERNAL_HAS_CRC32
+#error "Hardware acceleration is required by ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY but not supported on this platform; see absl/base/options.h"
+#endif
+#endif
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -104,8 +156,6 @@ namespace hash_internal {
 // returns the size of these chunks.
 constexpr size_t PiecewiseChunkSize() { return 1024; }
 
-// PiecewiseCombiner
-//
 // PiecewiseCombiner is an internal-only helper class for hashing a piecewise
 // buffer of `char` or `unsigned char` as though it were contiguous.  This class
 // provides two methods:
@@ -126,12 +176,10 @@ constexpr size_t PiecewiseChunkSize() { return 1024; }
 //    return combiner.finalize(std::move(state));
 class PiecewiseCombiner {
  public:
-  PiecewiseCombiner() : position_(0) {}
+  PiecewiseCombiner() = default;
   PiecewiseCombiner(const PiecewiseCombiner&) = delete;
   PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete;
 
-  // PiecewiseCombiner::add_buffer()
-  //
   // Appends the given range of bytes to the sequence to be hashed, which may
   // modify the provided hash state.
   template <typename H>
@@ -142,8 +190,6 @@ class PiecewiseCombiner {
                       reinterpret_cast<const unsigned char*>(data), size);
   }
 
-  // PiecewiseCombiner::finalize()
-  //
   // Finishes combining the hash sequence, which may may modify the provided
   // hash state.
   //
@@ -156,21 +202,19 @@ class PiecewiseCombiner {
 
  private:
   unsigned char buf_[PiecewiseChunkSize()];
-  size_t position_;
+  size_t position_ = 0;
+  bool added_something_ = false;
 };
 
-// is_hashable()
-//
 // Trait class which returns true if T is hashable by the absl::Hash framework.
 // Used for the AbslHashValue implementations for composite types below.
 template <typename T>
 struct is_hashable;
 
-// HashStateBase
-//
-// An internal implementation detail that contains common implementation details
-// for all of the "hash state objects" objects generated by Abseil.  This is not
-// a public API; users should not create classes that inherit from this.
+// HashStateBase is an internal implementation detail that contains common
+// implementation details for all of the "hash state objects" objects generated
+// by Abseil.  This is not a public API; users should not create classes that
+// inherit from this.
 //
 // A hash state object is the template argument `H` passed to `AbslHashValue`.
 // It represents an intermediate state in the computation of an unspecified hash
@@ -235,8 +279,6 @@ struct is_hashable;
 template <typename H>
 class HashStateBase {
  public:
-  // HashStateBase::combine()
-  //
   // Combines an arbitrary number of values into a hash state, returning the
   // updated state.
   //
@@ -256,8 +298,6 @@ class HashStateBase {
   static H combine(H state, const T& value, const Ts&... values);
   static H combine(H state) { return state; }
 
-  // HashStateBase::combine_contiguous()
-  //
   // Combines a contiguous array of `size` elements into a hash state, returning
   // the updated state.
   //
@@ -297,8 +337,6 @@ class HashStateBase {
   };
 };
 
-// is_uniquely_represented
-//
 // `is_uniquely_represented<T>` is a trait class that indicates whether `T`
 // is uniquely represented.
 //
@@ -333,8 +371,6 @@ class HashStateBase {
 template <typename T, typename Enable = void>
 struct is_uniquely_represented : std::false_type {};
 
-// is_uniquely_represented<unsigned char>
-//
 // unsigned char is a synonym for "byte", so it is guaranteed to be
 // uniquely represented.
 template <>
@@ -349,9 +385,6 @@ struct is_uniquely_represented<
     Integral, typename std::enable_if<std::is_integral<Integral>::value>::type>
     : std::true_type {};
 
-// is_uniquely_represented<bool>
-//
-//
 template <>
 struct is_uniquely_represented<bool> : std::false_type {};
 
@@ -373,12 +406,19 @@ struct CombineRaw {
   }
 };
 
-// hash_bytes()
-//
+// For use in `raw_hash_set` to pass a seed to the hash function.
+struct HashWithSeed {
+  template <typename Hasher, typename T>
+  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
+    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
+    return hasher.hash_with_seed(value, seed);
+  }
+};
+
 // Convenience function that combines `hash_state` with the byte representation
 // of `value`.
 template <typename H, typename T,
-          absl::enable_if_t<FitsIn64Bits<T>::value, int> = 0>
+          std::enable_if_t<FitsIn64Bits<T>::value, int> = 0>
 H hash_bytes(H hash_state, const T& value) {
   const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
   uint64_t v;
@@ -395,7 +435,7 @@ H hash_bytes(H hash_state, const T& value) {
   return CombineRaw()(std::move(hash_state), v);
 }
 template <typename H, typename T,
-          absl::enable_if_t<!FitsIn64Bits<T>::value, int> = 0>
+          std::enable_if_t<!FitsIn64Bits<T>::value, int> = 0>
 H hash_bytes(H hash_state, const T& value) {
   const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
   return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
@@ -422,8 +462,10 @@ H hash_weakly_mixed_integer(H hash_state, WeaklyMixedInteger value) {
 template <typename H, typename B>
 typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue(
     H hash_state, B value) {
+  // We use ~size_t{} instead of 1 so that all bits are different between
+  // true/false instead of only 1.
   return H::combine(std::move(hash_state),
-                    static_cast<unsigned char>(value ? 1 : 0));
+                    static_cast<size_t>(value ? ~size_t{} : 0));
 }
 
 // AbslHashValue() for hashing enum values
@@ -502,10 +544,10 @@ std::enable_if_t<std::is_pointer<T>::value, H> AbslHashValue(H hash_state,
                                                              T ptr) {
   auto v = reinterpret_cast<uintptr_t>(ptr);
   // Due to alignment, pointers tend to have low bits as zero, and the next few
-  // bits follow a pattern since they are also multiples of some base value. The
-  // byte swap in WeakMix helps ensure we still have good entropy in low bits.
-  // Mix pointers twice to ensure we have good entropy in low bits.
-  return H::combine(std::move(hash_state), v, v);
+  // bits follow a pattern since they are also multiples of some base value.
+  // The PointerAlignment test verifies that our mixing is good enough to handle
+  // these cases.
+  return H::combine(std::move(hash_state), v);
 }
 
 // AbslHashValue() for hashing nullptr_t
@@ -559,12 +601,10 @@ AbslHashValue(H hash_state, const std::pair<T1, T2>& p) {
   return H::combine(std::move(hash_state), p.first, p.second);
 }
 
-// hash_tuple()
-//
 // Helper function for hashing a tuple. The third argument should
 // be an index_sequence running from 0 to tuple_size<Tuple> - 1.
 template <typename H, typename Tuple, size_t... Is>
-H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>) {
+H hash_tuple(H hash_state, const Tuple& t, std::index_sequence<Is...>) {
   return H::combine(std::move(hash_state), std::get<Is>(t)...);
 }
 
@@ -575,11 +615,11 @@ template <typename H, typename... Ts>
 // for now.
 H
 #else   // _MSC_VER
-typename std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type
+typename std::enable_if<std::conjunction<is_hashable<Ts>...>::value, H>::type
 #endif  // _MSC_VER
 AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
   return hash_internal::hash_tuple(std::move(hash_state), t,
-                                   absl::make_index_sequence<sizeof...(Ts)>());
+                                   std::make_index_sequence<sizeof...(Ts)>());
 }
 
 // -----------------------------------------------------------------------------
@@ -619,47 +659,42 @@ H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) {
 // `eq()` member isn't equivalent to `==` on the underlying character type.
 template <typename H>
 H AbslHashValue(H hash_state, absl::string_view str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      WeaklyMixedInteger{str.size()});
+  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
 }
 
 // Support std::wstring, std::u16string and std::u32string.
 template <typename Char, typename Alloc, typename H,
-          typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
+          typename = std::enable_if_t<std::is_same<Char, wchar_t>::value ||
                                        std::is_same<Char, char16_t>::value ||
                                        std::is_same<Char, char32_t>::value>>
 H AbslHashValue(
     H hash_state,
     const std::basic_string<Char, std::char_traits<Char>, Alloc>& str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      WeaklyMixedInteger{str.size()});
+  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
 }
 
 // Support std::wstring_view, std::u16string_view and std::u32string_view.
 template <typename Char, typename H,
-          typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
+          typename = std::enable_if_t<std::is_same<Char, wchar_t>::value ||
                                        std::is_same<Char, char16_t>::value ||
                                        std::is_same<Char, char32_t>::value>>
 H AbslHashValue(H hash_state, std::basic_string_view<Char> str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      WeaklyMixedInteger{str.size()});
+  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
 }
 
 #if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && \
     (!defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) ||        \
      __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000) &&       \
     (!defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) ||         \
-     __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500)
+     __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500) &&        \
+    (!defined(__XTENSA__))
 
 #define ABSL_INTERNAL_STD_FILESYSTEM_PATH_HASH_AVAILABLE 1
 
 // Support std::filesystem::path. The SFINAE is required because some string
 // types are implicitly convertible to std::filesystem::path.
 template <typename Path, typename H,
-          typename = absl::enable_if_t<
+          typename = std::enable_if_t<
               std::is_same_v<Path, std::filesystem::path>>>
 H AbslHashValue(H hash_state, const Path& path) {
   // This is implemented by deferring to the standard library to compute the
@@ -727,9 +762,8 @@ template <typename H, typename T, typename Allocator>
 typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
                         H>::type
 AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(),
-                                          vector.size()),
-                    WeaklyMixedInteger{vector.size()});
+  return H::combine_contiguous(std::move(hash_state), vector.data(),
+                               vector.size());
 }
 
 // AbslHashValue special cases for hashing std::vector<bool>
@@ -880,15 +914,14 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
   return H::combine(std::move(hash_state), opt.get());
 }
 
-// AbslHashValue for hashing absl::optional
+// AbslHashValue for hashing std::optional
 template <typename H, typename T>
 typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const absl::optional<T>& opt) {
+    H hash_state, const std::optional<T>& opt) {
   if (opt) hash_state = H::combine(std::move(hash_state), *opt);
   return H::combine(std::move(hash_state), opt.has_value());
 }
 
-// VariantVisitor
 template <typename H>
 struct VariantVisitor {
   H&& hash_state;
@@ -898,12 +931,12 @@ struct VariantVisitor {
   }
 };
 
-// AbslHashValue for hashing absl::variant
+// AbslHashValue for hashing std::variant
 template <typename H, typename... T>
-typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type
-AbslHashValue(H hash_state, const absl::variant<T...>& v) {
+typename std::enable_if<std::conjunction<is_hashable<T>...>::value, H>::type
+AbslHashValue(H hash_state, const std::variant<T...>& v) {
   if (!v.valueless_by_exception()) {
-    hash_state = absl::visit(VariantVisitor<H>{std::move(hash_state)}, v);
+    hash_state = std::visit(VariantVisitor<H>{std::move(hash_state)}, v);
   }
   return H::combine(std::move(hash_state), v.index());
 }
@@ -937,8 +970,6 @@ H AbslHashValue(H hash_state, const std::bitset<N>& set) {
 
 // -----------------------------------------------------------------------------
 
-// hash_range_or_bytes()
-//
 // Mixes all values in the range [data, data+size) into the hash state.
 // This overload accepts only uniquely-represented types, and hashes them by
 // hashing the entire range of bytes.
@@ -949,25 +980,311 @@ hash_range_or_bytes(H hash_state, const T* data, size_t size) {
   return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
 }
 
-// hash_range_or_bytes()
 template <typename H, typename T>
 typename std::enable_if<!is_uniquely_represented<T>::value, H>::type
 hash_range_or_bytes(H hash_state, const T* data, size_t size) {
   for (const auto end = data + size; data < end; ++data) {
     hash_state = H::combine(std::move(hash_state), *data);
   }
-  return hash_state;
+  return H::combine(std::move(hash_state),
+                    hash_internal::WeaklyMixedInteger{size});
+}
+
+inline constexpr uint64_t kMul = uint64_t{0x79d5f9e0de1e8cf5};
+
+// Random data taken from the hexadecimal digits of Pi's fractional component.
+// https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
+ABSL_CACHELINE_ALIGNED inline constexpr uint64_t kStaticRandomData[] = {
+    0x243f'6a88'85a3'08d3, 0x1319'8a2e'0370'7344, 0xa409'3822'299f'31d0,
+    0x082e'fa98'ec4e'6c89, 0x4528'21e6'38d0'1377,
+};
+
+// Extremely weak mixture of length that is mixed into the state before
+// combining the data. It is used only for small strings. This also ensures that
+// we have high entropy in all bits of the state.
+inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
+  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
+  uint64_t data = absl::base_internal::UnalignedLoad64(
+      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
+  return state ^ data;
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t Mix(uint64_t lhs, uint64_t rhs) {
+  // Though the 128-bit product needs multiple instructions on non-x86-64
+  // platforms, it is still a good balance between speed and hash quality.
+  absl::uint128 m = lhs;
+  m *= rhs;
+  return Uint128High64(m) ^ Uint128Low64(m);
+}
+
+// Suppress erroneous array bounds errors on GCC.
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+inline uint32_t Read4(const unsigned char* p) {
+  return absl::base_internal::UnalignedLoad32(p);
+}
+inline uint64_t Read8(const unsigned char* p) {
+  return absl::base_internal::UnalignedLoad64(p);
+}
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+// Reads 9 to 16 bytes from p.
+// The first 8 bytes are in .first, and the rest of the bytes are in .second
+// along with duplicated bytes from .first if len<16.
+inline std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
+                                               size_t len) {
+  return {Read8(p), Read8(p + len - 8)};
+}
+
+// Reads 4 to 8 bytes from p.
+// Bytes are permuted and some input bytes may be duplicated in output.
+inline uint64_t Read4To8(const unsigned char* p, size_t len) {
+  // If `len < 8`, we duplicate bytes. We always put low memory at the end.
+  // E.g., on little endian platforms:
+  // `ABCD` will be read as `ABCDABCD`.
+  // `ABCDE` will be read as `BCDEABCD`.
+  // `ABCDEF` will be read as `CDEFABCD`.
+  // `ABCDEFG` will be read as `DEFGABCD`.
+  // `ABCDEFGH` will be read as `EFGHABCD`.
+  // We also do not care about endianness. On big-endian platforms, bytes will
+  // be permuted differently. We always shift low memory by 32, because that
+  // can be pipelined earlier. Reading high memory requires computing
+  // `p + len - 4`.
+  uint64_t most_significant =
+      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
+  uint64_t least_significant =
+      absl::base_internal::UnalignedLoad32(p + len - 4);
+  return most_significant | least_significant;
 }
 
-#if defined(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE) && \
-    ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+// Reads 1 to 3 bytes from p. Some input bytes may be duplicated in output.
+inline uint32_t Read1To3(const unsigned char* p, size_t len) {
+  // The trick used by this implementation is to avoid branches.
+  // We always read three bytes by duplicating.
+  // E.g.,
+  // `A` is read as `AAA`.
+  // `AB` is read as `ABB`.
+  // `ABC` is read as `ABC`.
+  // We always shift `p[0]` so that it can be pipelined better.
+  // Other bytes require extra computation to find indices.
+  uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
+  uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
+  return mem0 | mem1;
+}
+
+#ifdef ABSL_HASH_INTERNAL_HAS_CRC32
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t CombineRawImpl(uint64_t state,
+                                                            uint64_t value) {
+  // We use a union to access the high and low 32 bits of the state.
+  union {
+    uint64_t u64;
+    struct {
+#ifdef ABSL_IS_LITTLE_ENDIAN
+      uint32_t low, high;
+#else  // big endian
+      uint32_t high, low;
+#endif
+    } u32s;
+  } s;
+  s.u64 = state;
+  // The general idea here is to do two CRC32 operations in parallel using the
+  // low and high 32 bits of state as CRC states. Note that: (1) when absl::Hash
+  // is inlined into swisstable lookups, we know that the seed's high bits are
+  // zero so s.u32s.high is available immediately. (2) We chose to multiply
+  // value by 3 for the low CRC because (a) multiplication by 3 can be done in 1
+  // cycle on x86/ARM and (b) multiplication has carry bits so it's nonlinear in
+  // GF(2) and therefore ensures that the two CRCs are independent (unlike bit
+  // rotation, XOR, etc). (3) We also tried using addition instead of
+  // multiplication by 3, but (a) code size is larger and (b) if the input keys
+  // all have 0s in the bits where the addition constant has 1s, then the
+  // addition is equivalent to XOR and linear in GF(2). (4) The union makes it
+  // easy for the compiler to understand that the high and low CRC states are
+  // independent from each other so that when CombineRawImpl is repeated (e.g.
+  // for std::pair<size_t, size_t>), the CRC chains can run in parallel. We
+  // originally tried using bswaps rather than shifting by 32 bits (to get from
+  // high to low bits) because bswap is one byte smaller in code size, but the
+  // compiler couldn't understand that the CRC chains were independent.
+  s.u32s.high =
+      static_cast<uint32_t>(ABSL_HASH_INTERNAL_CRC32_U64(s.u32s.high, value));
+  s.u32s.low = static_cast<uint32_t>(
+      ABSL_HASH_INTERNAL_CRC32_U64(s.u32s.low, 3 * value));
+  return s.u64;
+}
+#else   // ABSL_HASH_INTERNAL_HAS_CRC32
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t CombineRawImpl(uint64_t state,
+                                                            uint64_t value) {
+  return Mix(state ^ value, kMul);
+}
+#endif  // ABSL_HASH_INTERNAL_HAS_CRC32
+
+// Slow dispatch path for calls to CombineContiguousImpl with a size argument
+// larger than inlined size. Has the same effect as calling
+// CombineContiguousImpl() repeatedly with the chunk stride size.
+uint64_t CombineLargeContiguousImplOn32BitLengthGt8(uint64_t state,
+                                                    const unsigned char* first,
+                                                    size_t len);
+uint64_t CombineLargeContiguousImplOn64BitLengthGt32(uint64_t state,
+                                                     const unsigned char* first,
+                                                     size_t len);
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t CombineSmallContiguousImpl(
+    uint64_t state, const unsigned char* first, size_t len) {
+  ABSL_ASSUME(len <= 8);
+  uint64_t v;
+  if (len >= 4) {
+    v = Read4To8(first, len);
+  } else if (len > 0) {
+    v = Read1To3(first, len);
+  } else {
+    // Empty string must modify the state.
+    v = 0x57;
+  }
+  return CombineRawImpl(state, v);
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t CombineContiguousImpl9to16(
+    uint64_t state, const unsigned char* first, size_t len) {
+  ABSL_ASSUME(len >= 9);
+  ABSL_ASSUME(len <= 16);
+  // Note: any time one half of the mix function becomes zero it will fail to
+  // incorporate any bits from the other half. However, there is exactly 1 in
+  // 2^64 values for each side that achieve this, and only when the size is
+  // exactly 16 -- for smaller sizes there is an overlapping byte that makes
+  // this impossible unless the seed is *also* incredibly unlucky.
+  auto p = Read9To16(first, len);
+  return Mix(state ^ p.first, kMul ^ p.second);
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t CombineContiguousImpl17to32(
+    uint64_t state, const unsigned char* first, size_t len) {
+  ABSL_ASSUME(len >= 17);
+  ABSL_ASSUME(len <= 32);
+  // Do two mixes of overlapping 16-byte ranges in parallel to minimize
+  // latency.
+  const uint64_t m0 =
+      Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
+
+  const unsigned char* tail_16b_ptr = first + (len - 16);
+  const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
+                          Read8(tail_16b_ptr + 8) ^ state);
+  return m0 ^ m1;
+}
+
+// Implementation of the base case for combine_contiguous where we actually
+// mix the bytes into the state.
+// Dispatch to different implementations of combine_contiguous depending
+// on the value of `sizeof(size_t)`.
+inline uint64_t CombineContiguousImpl(
+    uint64_t state, const unsigned char* first, size_t len,
+    std::integral_constant<int, 4> /* sizeof_size_t */) {
+  // For large values we use CityHash, for small ones we use custom low latency
+  // hash.
+  if (len <= 8) {
+    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
+                                      len);
+  }
+  return CombineLargeContiguousImplOn32BitLengthGt8(state, first, len);
+}
+
+#ifdef ABSL_HASH_INTERNAL_HAS_CRC32
+inline uint64_t CombineContiguousImpl(
+    uint64_t state, const unsigned char* first, size_t len,
+    std::integral_constant<int, 8> /* sizeof_size_t */) {
+  if (ABSL_PREDICT_FALSE(len > 32)) {
+    return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
+  }
+  // `mul` is the salt that is used for final mixing. It is important to fill
+  // high 32 bits because CRC wipes out high 32 bits.
+  // `rotr` is important to mix `len` into high 32 bits.
+  uint64_t mul = absl::rotr(kMul, static_cast<int>(len));
+  // Only low 32 bits of each uint64_t are used in CRC32 so we use gbswap_64 to
+  // move high 32 bits to low 32 bits. It has slightly smaller binary size than
+  // `>> 32`. `state + 8 * len` is a single instruction on both x86 and ARM, so
+  // we use it to better mix length. Although only the low 32 bits of the pair
+  // elements are used, we use pair<uint64_t, uint64_t> for better generated
+  // code.
+  std::pair<uint64_t, uint64_t> crcs = {state + 8 * len,
+                                        absl::gbswap_64(state)};
+
+  // All CRC operations here directly read bytes from the memory.
+  // Single fused instructions are used, like `crc32 rcx, qword ptr [rsi]`.
+  // On x86, llvm-mca reports latency `R + 2` for such fused instructions, while
+  // `R + 3` for two separate `mov` + `crc` instructions. `R` is the latency of
+  // reading the memory. Fused instructions also reduce register pressure
+  // allowing surrounding code to be more efficient when this code is inlined.
+  if (len > 8) {
+    crcs = {ABSL_HASH_INTERNAL_CRC32_U64(crcs.first, Read8(first)),
+            ABSL_HASH_INTERNAL_CRC32_U64(crcs.second, Read8(first + len - 8))};
+    if (len > 16) {
+      // We compute the second round of dependent CRC32 operations.
+      crcs = {ABSL_HASH_INTERNAL_CRC32_U64(crcs.first, Read8(first + len - 16)),
+              ABSL_HASH_INTERNAL_CRC32_U64(crcs.second, Read8(first + 8))};
+    }
+  } else {
+    if (len >= 4) {
+      // We use CRC for 4 bytes to benefit from the fused instruction and better
+      // hash quality.
+      // Using `xor` or `add` may reduce latency for this case, but would
+      // require more registers, more instructions and will have worse hash
+      // quality.
+      crcs = {ABSL_HASH_INTERNAL_CRC32_U32(static_cast<uint32_t>(crcs.first),
+                                           Read4(first)),
+              ABSL_HASH_INTERNAL_CRC32_U32(static_cast<uint32_t>(crcs.second),
+                                           Read4(first + len - 4))};
+    } else if (len >= 1) {
+      // We mix three bytes all into different output registers.
+      // This way, we do not need shifting of these bytes (so they don't overlap
+      // with each other).
+      crcs = {ABSL_HASH_INTERNAL_CRC32_U8(static_cast<uint32_t>(crcs.first),
+                                          first[0]),
+              ABSL_HASH_INTERNAL_CRC32_U8(static_cast<uint32_t>(crcs.second),
+                                          first[len - 1])};
+      // Middle byte is mixed weaker. It is a new byte only for len == 3.
+      // Mixing is independent from CRC operations so it is scheduled ASAP.
+      mul += first[len / 2];
+    }
+  }
+  // `mul` is mixed into both sides of `Mix` to guarantee non-zero values for
+  // both multiplicands. Using Mix instead of just multiplication here improves
+  // hash quality, especially for short strings.
+  return Mix(mul - crcs.first, crcs.second - mul);
+}
+#else
+inline uint64_t CombineContiguousImpl(
+    uint64_t state, const unsigned char* first, size_t len,
+    std::integral_constant<int, 8> /* sizeof_size_t */) {
+  // For large values we use LowLevelHash or CityHash depending on the platform,
+  // for small ones we use custom low latency hash.
+  if (len <= 8) {
+    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
+                                      len);
+  }
+  if (len <= 16) {
+    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
+                                      len);
+  }
+  if (len <= 32) {
+    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
+                                       len);
+  }
+  // We must not mix length into the state here because calling
+  // CombineContiguousImpl twice with PiecewiseChunkSize() must be equivalent
+  // to calling CombineLargeContiguousImpl once with 2 * PiecewiseChunkSize().
+  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
+}
+#endif  // ABSL_HASH_INTERNAL_HAS_CRC32
+
+#if defined(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE)
 #define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 1
 #else
 #define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
 #endif
 
-// HashSelect
-//
 // Type trait to select the appropriate hash implementation to use.
 // HashSelect::type<T> will give the proper hash implementation, to be invoked
 // as:
@@ -996,14 +1313,14 @@ struct HashSelect {
   struct UniquelyRepresentedProbe {
     template <typename H, typename T>
     static auto Invoke(H state, const T& value)
-        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
+        -> std::enable_if_t<is_uniquely_represented<T>::value, H> {
       return hash_internal::hash_bytes(std::move(state), value);
     }
   };
 
   struct HashValueProbe {
     template <typename H, typename T>
-    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
+    static auto Invoke(H state, const T& value) -> std::enable_if_t<
         std::is_same<H,
                      decltype(AbslHashValue(std::move(state), value))>::value,
         H> {
@@ -1014,7 +1331,7 @@ struct HashSelect {
   struct LegacyHashProbe {
 #if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
     template <typename H, typename T>
-    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
+    static auto Invoke(H state, const T& value) -> std::enable_if_t<
         std::is_convertible<
             decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
             size_t>::value,
@@ -1029,7 +1346,7 @@ struct HashSelect {
   struct StdHashProbe {
     template <typename H, typename T>
     static auto Invoke(H state, const T& value)
-        -> absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> {
+        -> std::enable_if_t<type_traits_internal::IsHashable<T>::value, H> {
       return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value));
     }
   };
@@ -1051,7 +1368,7 @@ struct HashSelect {
   // Probe each implementation in order.
   // disjunction provides short circuiting wrt instantiation.
   template <typename T>
-  using Apply = absl::disjunction<         //
+  using Apply = std::disjunction<         //
       Probe<WeaklyMixedIntegerProbe, T>,   //
       Probe<UniquelyRepresentedProbe, T>,  //
       Probe<HashValueProbe, T>,            //
@@ -1064,38 +1381,17 @@ template <typename T>
 struct is_hashable
     : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
 
-// MixingHashState
 class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
-  // absl::uint128 is not an alias or a thin wrapper around the intrinsic.
-  // We use the intrinsic when available to improve performance.
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  using uint128 = __uint128_t;
-#else   // ABSL_HAVE_INTRINSIC_INT128
-  using uint128 = absl::uint128;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-  // Random data taken from the hexadecimal digits of Pi's fractional component.
-  // https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
-  ABSL_CACHELINE_ALIGNED static constexpr uint64_t kStaticRandomData[] = {
-      0x243f'6a88'85a3'08d3, 0x1319'8a2e'0370'7344, 0xa409'3822'299f'31d0,
-      0x082e'fa98'ec4e'6c89, 0x4528'21e6'38d0'1377,
-  };
-
-  static constexpr uint64_t kMul =
-   uint64_t{0xdcb22ca68cb134ed};
-
   template <typename T>
   using IntegralFastPath =
-      conjunction<std::is_integral<T>, is_uniquely_represented<T>,
-                  FitsIn64Bits<T>>;
+      std::conjunction<std::is_integral<T>, is_uniquely_represented<T>,
+                       FitsIn64Bits<T>>;
 
  public:
   // Move only
   MixingHashState(MixingHashState&&) = default;
   MixingHashState& operator=(MixingHashState&&) = default;
 
-  // MixingHashState::combine_contiguous()
-  //
   // Fundamental base case for hash recursion: mixes the given range of bytes
   // into the hash state.
   static MixingHashState combine_contiguous(MixingHashState hash_state,
@@ -1107,34 +1403,59 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   }
   using MixingHashState::HashStateBase::combine_contiguous;
 
-  // MixingHashState::hash()
-  //
+  template <typename T>
+  static size_t hash(const T& value) {
+    return hash_with_seed(value, Seed());
+  }
+
   // For performance reasons in non-opt mode, we specialize this for
   // integral types.
   // Otherwise we would be instantiating and calling dozens of functions for
   // something that is just one multiplication and a couple xor's.
   // The result should be the same as running the whole algorithm, but faster.
-  template <typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(T value) {
+  template <typename T, std::enable_if_t<IntegralFastPath<T>::value, int> = 0>
+  static size_t hash_with_seed(T value, size_t seed) {
     return static_cast<size_t>(
-        WeakMix(Seed(), static_cast<std::make_unsigned_t<T>>(value)));
+        CombineRawImpl(seed, static_cast<std::make_unsigned_t<T>>(value)));
   }
 
-  // Overload of MixingHashState::hash()
-  template <typename T, absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(const T& value) {
-    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
+  template <typename T, std::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
+  static size_t hash_with_seed(const T& value, size_t seed) {
+    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
   }
 
  private:
-  // Invoked only once for a given argument; that plus the fact that this is
-  // move-only ensures that there is only one non-moved-from object.
-  MixingHashState() : state_(Seed()) {}
-
   friend class MixingHashState::HashStateBase;
   template <typename H>
   friend H absl::hash_internal::hash_weakly_mixed_integer(H,
                                                           WeaklyMixedInteger);
+  // Allow the HashState type-erasure implementation to invoke
+  // RunCombinedUnordered() directly.
+  friend class absl::HashState;
+  friend struct CombineRaw;
+
+  // For use in Seed().
+  static const void* const kSeed;
+
+  // Invoked only once for a given argument; that plus the fact that this is
+  // move-only ensures that there is only one non-moved-from object.
+  MixingHashState() : state_(Seed()) {}
+
+  // Workaround for MSVC bug.
+  // We make the type copyable to fix the calling convention, even though we
+  // never actually copy it. Keep it private to not affect the public API of the
+  // type.
+  MixingHashState(const MixingHashState&) = default;
+
+  explicit MixingHashState(uint64_t state) : state_(state) {}
+
+  // Combines a raw value from e.g. integrals/floats/pointers/etc. This allows
+  // us to be consistent with IntegralFastPath when combining raw types, but
+  // optimize Read1To3 and Read4To8 differently for the string case.
+  static MixingHashState combine_raw(MixingHashState hash_state,
+                                     uint64_t value) {
+    return MixingHashState(CombineRawImpl(hash_state.state_, value));
+  }
 
   static MixingHashState combine_weakly_mixed_integer(
       MixingHashState hash_state, WeaklyMixedInteger value) {
@@ -1164,195 +1485,6 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return MixingHashState::combine(std::move(state), unordered_state);
   }
 
-  // Allow the HashState type-erasure implementation to invoke
-  // RunCombinedUnordered() directly.
-  friend class absl::HashState;
-  friend struct CombineRaw;
-
-  // Workaround for MSVC bug.
-  // We make the type copyable to fix the calling convention, even though we
-  // never actually copy it. Keep it private to not affect the public API of the
-  // type.
-  MixingHashState(const MixingHashState&) = default;
-
-  explicit MixingHashState(uint64_t state) : state_(state) {}
-
-  // Combines a raw value from e.g. integrals/floats/pointers/etc. This allows
-  // us to be consistent with IntegralFastPath when combining raw types, but
-  // optimize Read1To3 and Read4To8 differently for the string case.
-  static MixingHashState combine_raw(MixingHashState hash_state,
-                                     uint64_t value) {
-    return MixingHashState(WeakMix(hash_state.state_, value));
-  }
-
-  // Implementation of the base case for combine_contiguous where we actually
-  // mix the bytes into the state.
-  // Dispatch to different implementations of the combine_contiguous depending
-  // on the value of `sizeof(size_t)`.
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 4>
-                                        /* sizeof_size_t */);
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 8>
-                                        /* sizeof_size_t */);
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineSmallContiguousImpl(
-      uint64_t state, const unsigned char* first, size_t len) {
-    ABSL_ASSUME(len <= 8);
-    uint64_t v;
-    if (len >= 4) {
-      v = Read4To8(first, len);
-    } else if (len > 0) {
-      v = Read1To3(first, len);
-    } else {
-      // Empty ranges have no effect.
-      return state;
-    }
-    return WeakMix(state, v);
-  }
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineContiguousImpl9to16(
-      uint64_t state, const unsigned char* first, size_t len) {
-    ABSL_ASSUME(len >= 9);
-    ABSL_ASSUME(len <= 16);
-    // Note: any time one half of the mix function becomes zero it will fail to
-    // incorporate any bits from the other half. However, there is exactly 1 in
-    // 2^64 values for each side that achieve this, and only when the size is
-    // exactly 16 -- for smaller sizes there is an overlapping byte that makes
-    // this impossible unless the seed is *also* incredibly unlucky.
-    auto p = Read9To16(first, len);
-    return Mix(state ^ p.first, kMul ^ p.second);
-  }
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineContiguousImpl17to32(
-      uint64_t state, const unsigned char* first, size_t len) {
-    ABSL_ASSUME(len >= 17);
-    ABSL_ASSUME(len <= 32);
-    // Do two mixes of overlapping 16-byte ranges in parallel to minimize
-    // latency.
-    const uint64_t m0 =
-        Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
-
-    const unsigned char* tail_16b_ptr = first + (len - 16);
-    const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
-                            Read8(tail_16b_ptr + 8) ^ state);
-    return m0 ^ m1;
-  }
-
-  // Slow dispatch path for calls to CombineContiguousImpl with a size argument
-  // larger than PiecewiseChunkSize().  Has the same effect as calling
-  // CombineContiguousImpl() repeatedly with the chunk stride size.
-  static uint64_t CombineLargeContiguousImpl32(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-  static uint64_t CombineLargeContiguousImpl64(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-
-  // Reads 9 to 16 bytes from p.
-  // The least significant 8 bytes are in .first, and the rest of the bytes are
-  // in .second along with duplicated bytes from .first if len<16.
-  static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
-                                                 size_t len) {
-    uint64_t low_mem = Read8(p);
-    uint64_t high_mem = Read8(p + len - 8);
-#ifdef ABSL_IS_LITTLE_ENDIAN
-    uint64_t most_significant = high_mem;
-    uint64_t least_significant = low_mem;
-#else
-    uint64_t most_significant = low_mem;
-    uint64_t least_significant = high_mem;
-#endif
-    return {least_significant, most_significant};
-  }
-
-  // Reads 8 bytes from p.
-  static uint64_t Read8(const unsigned char* p) {
-    // Suppress erroneous array bounds errors on GCC.
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-    return absl::base_internal::UnalignedLoad64(p);
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-  }
-
-  // Reads 4 to 8 bytes from p. Some input bytes may be duplicated in output.
-  static uint64_t Read4To8(const unsigned char* p, size_t len) {
-    // If `len < 8`, we duplicate bytes in the middle.
-    // E.g.:
-    // `ABCD` will be read as `ABCDABCD`.
-    // `ABCDE` will be read as `ABCDBCDE`.
-    // `ABCDEF` will be read as `ABCDCDEF`.
-    // `ABCDEFG` will be read as `ABCDDEFG`.
-    // We also do not care about endianness. On big-endian platforms, bytes will
-    // be shuffled (it's fine). We always shift low memory by 32, because that
-    // can be pipelined earlier. Reading high memory requires computing
-    // `p + len - 4`.
-    uint64_t most_significant =
-        static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
-    uint64_t least_significant =
-        absl::base_internal::UnalignedLoad32(p + len - 4);
-    return most_significant | least_significant;
-  }
-
-  // Reads 1 to 3 bytes from p. Some input bytes may be duplicated in output.
-  static uint32_t Read1To3(const unsigned char* p, size_t len) {
-    // The trick used by this implementation is to avoid branches.
-    // We always read three bytes by duplicating.
-    // E.g.,
-    // `A` is read as `AAA`.
-    // `AB` is read as `ABB`.
-    // `ABC` is read as `ABC`.
-    // We always shift `p[0]` so that it can be pipelined better.
-    // Other bytes require extra computation to find indices.
-    uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
-    uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
-    return mem0 | mem1;
-  }
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t lhs, uint64_t rhs) {
-    // For 32 bit platforms we are trying to use all 64 lower bits.
-    if constexpr (sizeof(size_t) < 8) {
-      uint64_t m = lhs * rhs;
-      return m ^ (m >> 32);
-    }
-    // Though the 128-bit product on AArch64 needs two instructions, it is
-    // still a good balance between speed and hash quality.
-    uint128 m = lhs;
-    m *= rhs;
-    return Uint128High64(m) ^ Uint128Low64(m);
-  }
-
-  // Slightly lower latency than Mix, but with lower quality. The byte swap
-  // helps ensure that low bits still have high quality.
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t WeakMix(uint64_t lhs,
-                                                       uint64_t rhs) {
-    const uint64_t n = lhs ^ rhs;
-    // WeakMix doesn't work well on 32-bit platforms so just use Mix.
-    if constexpr (sizeof(size_t) < 8) return Mix(n, kMul);
-    return absl::gbswap_64(n * kMul);
-  }
-
-  // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
-  // values for both the seed and salt parameters.
-  static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
-                                                      size_t len) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-    return LowLevelHashImpl(data, len);
-#else
-    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
-#endif
-  }
-
-  // Seed()
-  //
   // A non-deterministic seed.
   //
   // The current purpose of this seed is to generate non-deterministic results
@@ -1367,64 +1499,23 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   //
   // On other platforms this is still going to be non-deterministic but most
   // probably per-build and not per-process.
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static size_t Seed() {
 #if (!defined(__clang__) || __clang_major__ > 11) && \
     (!defined(__apple_build_version__) ||            \
      __apple_build_version__ >= 19558921)  // Xcode 12
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
+    return static_cast<size_t>(reinterpret_cast<uintptr_t>(&kSeed));
 #else
     // Workaround the absence of
     // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
+    return static_cast<size_t>(reinterpret_cast<uintptr_t>(kSeed));
 #endif
   }
-  static const void* const kSeed;
 
   uint64_t state_;
 };
 
-// MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 4> /* sizeof_size_t */) {
-  // For large values we use CityHash, for small ones we just use a
-  // multiplicative hash.
-  if (len <= 8) {
-    return CombineSmallContiguousImpl(state, first, len);
-  }
-  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
-    return Mix(state ^ hash_internal::CityHash32(
-                           reinterpret_cast<const char*>(first), len),
-               kMul);
-  }
-  return CombineLargeContiguousImpl32(state, first, len);
-}
-
-// Overload of MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 8> /* sizeof_size_t */) {
-  // For large values we use LowLevelHash or CityHash depending on the platform,
-  // for small ones we just use a multiplicative hash.
-  if (len <= 8) {
-    return CombineSmallContiguousImpl(state, first, len);
-  }
-  if (len <= 16) {
-    return CombineContiguousImpl9to16(state, first, len);
-  }
-  if (len <= 32) {
-    return CombineContiguousImpl17to32(state, first, len);
-  }
-  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
-    return Mix(state ^ Hash64(first, len), kMul);
-  }
-  return CombineLargeContiguousImpl64(state, first, len);
-}
-
 struct AggregateBarrier {};
 
-// HashImpl
-
 // Add a private base class to make sure this type is not an aggregate.
 // Aggregates can be aggregate initialized even if the default constructor is
 // deleted.
@@ -1439,11 +1530,18 @@ struct HashImpl {
   size_t operator()(const T& value) const {
     return MixingHashState::hash(value);
   }
+
+ private:
+  friend struct HashWithSeed;
+
+  size_t hash_with_seed(const T& value, size_t seed) const {
+    return MixingHashState::hash_with_seed(value, seed);
+  }
 };
 
 template <typename T>
 struct Hash
-    : absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {};
+    : std::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {};
 
 template <typename H>
 template <typename T, typename... Ts>
@@ -1453,14 +1551,12 @@ H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
                     values...);
 }
 
-// HashStateBase::combine_contiguous()
 template <typename H>
 template <typename T>
 H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
   return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 }
 
-// HashStateBase::combine_unordered()
 template <typename H>
 template <typename I>
 H HashStateBase<H>::combine_unordered(H state, I begin, I end) {
@@ -1468,7 +1564,6 @@ H HashStateBase<H>::combine_unordered(H state, I begin, I end) {
                                 CombineUnorderedCallback<I>{begin, end});
 }
 
-// HashStateBase::PiecewiseCombiner::add_buffer()
 template <typename H>
 H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
                                 size_t size) {
@@ -1478,7 +1573,7 @@ H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
     position_ += size;
     return state;
   }
-
+  added_something_ = true;
   // If the buffer is partially filled we need to complete the buffer
   // and hash it.
   if (position_ != 0) {
@@ -1501,10 +1596,14 @@ H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
   return state;
 }
 
-// HashStateBase::PiecewiseCombiner::finalize()
 template <typename H>
 H PiecewiseCombiner::finalize(H state) {
-  // Hash the remainder left in the buffer, which may be empty
+  // Do not call combine_contiguous with empty remainder since it is modifying
+  // state.
+  if (added_something_ && position_ == 0) {
+    return state;
+  }
+  // We still call combine_contiguous for the entirely empty buffer.
   return H::combine_contiguous(std::move(state), buf_, position_);
 }
 
@@ -1512,4 +1611,9 @@ H PiecewiseCombiner::finalize(H state) {
 ABSL_NAMESPACE_END
 }  // namespace absl
 
+#undef ABSL_HASH_INTERNAL_HAS_CRC32
+#undef ABSL_HASH_INTERNAL_CRC32_U64
+#undef ABSL_HASH_INTERNAL_CRC32_U32
+#undef ABSL_HASH_INTERNAL_CRC32_U8
+
 #endif  // ABSL_HASH_INTERNAL_HASH_H_