grpc 1.73.0 → 1.74.0

data/third_party/abseil-cpp/absl/functional/internal/front_binder.h

@@ -21,7 +21,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/base/internal/invoke.h"
 #include "absl/container/internal/compressed_tuple.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
@@ -33,9 +32,8 @@ namespace functional_internal {
 // Invoke the method, expanding the tuple of bound arguments.
 template <class R, class Tuple, size_t... Idx, class... Args>
 R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free) {
-  return base_internal::invoke(
-      std::forward<Tuple>(bound).template get<Idx>()...,
-      std::forward<Args>(free)...);
+  return std::invoke(std::forward<Tuple>(bound).template get<Idx>()...,
+                     std::forward<Args>(free)...);
 }
 
 template <class F, class... BoundArgs>
@@ -50,23 +48,23 @@ class FrontBinder {
   constexpr explicit FrontBinder(absl::in_place_t, Ts&&... ts)
       : bound_args_(std::forward<Ts>(ts)...) {}
 
-  template <class... FreeArgs, class R = base_internal::invoke_result_t<
-                                   F&, BoundArgs&..., FreeArgs&&...>>
+  template <class... FreeArgs,
+            class R = std::invoke_result_t<F&, BoundArgs&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) & {
     return functional_internal::Apply<R>(bound_args_, Idx(),
                                          std::forward<FreeArgs>(free_args)...);
   }
 
   template <class... FreeArgs,
-            class R = base_internal::invoke_result_t<
-                const F&, const BoundArgs&..., FreeArgs&&...>>
+            class R = std::invoke_result_t<const F&, const BoundArgs&...,
+                                           FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) const& {
     return functional_internal::Apply<R>(bound_args_, Idx(),
                                          std::forward<FreeArgs>(free_args)...);
   }
 
-  template <class... FreeArgs, class R = base_internal::invoke_result_t<
-                                   F&&, BoundArgs&&..., FreeArgs&&...>>
+  template <class... FreeArgs,
+            class R = std::invoke_result_t<F&&, BoundArgs&&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) && {
     // This overload is called when *this is an rvalue. If some of the bound
     // arguments are stored by value or rvalue reference, we move them.
@@ -75,8 +73,8 @@ class FrontBinder {
   }
 
   template <class... FreeArgs,
-            class R = base_internal::invoke_result_t<
-                const F&&, const BoundArgs&&..., FreeArgs&&...>>
+            class R = std::invoke_result_t<const F&&, const BoundArgs&&...,
+                                           FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) const&& {
     // This overload is called when *this is an rvalue. If some of the bound
     // arguments are stored by value or rvalue reference, we move them.

data/third_party/abseil-cpp/absl/functional/internal/function_ref.h

@@ -19,7 +19,6 @@
 #include <functional>
 #include <type_traits>
 
-#include "absl/base/internal/invoke.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/meta/type_traits.h"
 
@@ -74,15 +73,13 @@ using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
 template <typename Obj, typename R, typename... Args>
 R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto o = static_cast<const Obj*>(ptr.obj);
-  return static_cast<R>(
-      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
+  return static_cast<R>(std::invoke(*o, std::forward<Args>(args)...));
 }
 
 template <typename Fun, typename R, typename... Args>
 R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto f = reinterpret_cast<Fun>(ptr.fun);
-  return static_cast<R>(
-      absl::base_internal::invoke(f, std::forward<Args>(args)...));
+  return static_cast<R>(std::invoke(f, std::forward<Args>(args)...));
 }
 
 template <typename Sig>

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

@@ -87,6 +87,7 @@
 #include "absl/base/config.h"
 #include "absl/functional/function_ref.h"
 #include "absl/hash/internal/hash.h"
+#include "absl/hash/internal/weakly_mixed_integer.h"
 #include "absl/meta/type_traits.h"
 
 namespace absl {
@@ -356,6 +357,12 @@ class HashState : public hash_internal::HashStateBase<HashState> {
     hash_state.combine_contiguous_(hash_state.state_, first, size);
     return hash_state;
   }
+
+  static HashState combine_weakly_mixed_integer(
+      HashState hash_state, hash_internal::WeaklyMixedInteger value) {
+    hash_state.combine_weakly_mixed_integer_(hash_state.state_, value);
+    return hash_state;
+  }
   using HashState::HashStateBase::combine_contiguous;
 
  private:
@@ -371,6 +378,13 @@ class HashState : public hash_internal::HashStateBase<HashState> {
     state = T::combine_contiguous(std::move(state), first, size);
   }
 
+  template <typename T>
+  static void CombineWeaklyMixedIntegerImpl(
+      void* p, hash_internal::WeaklyMixedInteger value) {
+    T& state = *static_cast<T*>(p);
+    state = T::combine_weakly_mixed_integer(std::move(state), value);
+  }
+
   static HashState combine_raw(HashState hash_state, uint64_t value) {
     hash_state.combine_raw_(hash_state.state_, value);
     return hash_state;
@@ -385,6 +399,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   template <typename T>
   void Init(T* state) {
     state_ = state;
+    combine_weakly_mixed_integer_ = &CombineWeaklyMixedIntegerImpl<T>;
     combine_contiguous_ = &CombineContiguousImpl<T>;
     combine_raw_ = &CombineRawImpl<T>;
     run_combine_unordered_ = &RunCombineUnorderedImpl<T>;
@@ -424,6 +439,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   // Do not erase an already erased state.
   void Init(HashState* state) {
     state_ = state->state_;
+    combine_weakly_mixed_integer_ = state->combine_weakly_mixed_integer_;
     combine_contiguous_ = state->combine_contiguous_;
     combine_raw_ = state->combine_raw_;
     run_combine_unordered_ = state->run_combine_unordered_;
@@ -435,6 +451,8 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   }
 
   void* state_;
+  void (*combine_weakly_mixed_integer_)(
+      void*, absl::hash_internal::WeaklyMixedInteger);
   void (*combine_contiguous_)(void*, const unsigned char*, size_t);
   void (*combine_raw_)(void*, uint64_t);
   HashState (*run_combine_unordered_)(

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

@@ -55,13 +55,9 @@ uint64_t MixingHashState::CombineLargeContiguousImpl64(
 
 ABSL_CONST_INIT const void* const MixingHashState::kSeed = &kSeed;
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr uint64_t MixingHashState::kStaticRandomData[];
-#endif
-
 uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data,
                                            size_t len) {
-  return LowLevelHashLenGt16(data, len, Seed(), &kStaticRandomData[0]);
+  return LowLevelHashLenGt32(data, len, Seed(), &kStaticRandomData[0]);
 }
 
 }  // namespace hash_internal

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

@@ -24,15 +24,29 @@
 #include <TargetConditionals.h>
 #endif
 
+// We include config.h here to make sure that ABSL_INTERNAL_CPLUSPLUS_LANG is
+// defined.
 #include "absl/base/config.h"
 
+// GCC15 warns that <ciso646> is deprecated in C++17 and suggests using
+// <version> instead, even though <version> is not available in C++17 mode prior
+// to GCC9.
+#if defined(__has_include)
+#if __has_include(<version>)
+#define ABSL_INTERNAL_VERSION_HEADER_AVAILABLE 1
+#endif
+#endif
+
 // For feature testing and determining which headers can be included.
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L || \
+    defined(ABSL_INTERNAL_VERSION_HEADER_AVAILABLE)
 #include <version>
 #else
 #include <ciso646>
 #endif
 
+#undef ABSL_INTERNAL_VERSION_HEADER_AVAILABLE
+
 #include <algorithm>
 #include <array>
 #include <bitset>
@@ -51,6 +65,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <type_traits>
 #include <unordered_map>
@@ -65,7 +80,7 @@
 #include "absl/base/port.h"
 #include "absl/container/fixed_array.h"
 #include "absl/hash/internal/city.h"
-#include "absl/hash/internal/low_level_hash.h"
+#include "absl/hash/internal/weakly_mixed_integer.h"
 #include "absl/meta/type_traits.h"
 #include "absl/numeric/bits.h"
 #include "absl/numeric/int128.h"
@@ -78,14 +93,6 @@
 #include <filesystem>  // NOLINT
 #endif
 
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef __ARM_ACLE
-#include <arm_acle.h>
-#endif
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -375,14 +382,14 @@ template <typename H, typename T,
 H hash_bytes(H hash_state, const T& value) {
   const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
   uint64_t v;
-  if (sizeof(T) == 1) {
+  if constexpr (sizeof(T) == 1) {
     v = *start;
-  } else if (sizeof(T) == 2) {
+  } else if constexpr (sizeof(T) == 2) {
     v = absl::base_internal::UnalignedLoad16(start);
-  } else if (sizeof(T) == 4) {
+  } else if constexpr (sizeof(T) == 4) {
     v = absl::base_internal::UnalignedLoad32(start);
   } else {
-    assert(sizeof(T) == 8);
+    static_assert(sizeof(T) == 8);
     v = absl::base_internal::UnalignedLoad64(start);
   }
   return CombineRaw()(std::move(hash_state), v);
@@ -394,6 +401,11 @@ H hash_bytes(H hash_state, const T& value) {
   return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
 }
 
+template <typename H>
+H hash_weakly_mixed_integer(H hash_state, WeaklyMixedInteger value) {
+  return H::combine_weakly_mixed_integer(std::move(hash_state), value);
+}
+
 // -----------------------------------------------------------------------------
 // AbslHashValue for Basic Types
 // -----------------------------------------------------------------------------
@@ -512,7 +524,7 @@ H AbslHashValue(H hash_state, T C::*ptr) {
     // padding (namely when they have 1 or 3 ints). The value below is a lower
     // bound on the number of salient, non-padding bytes that we use for
     // hashing.
-    if (alignof(T C::*) == alignof(int)) {
+    if constexpr (alignof(T C::*) == alignof(int)) {
       // No padding when all subobjects have the same size as the total
       // alignment. This happens in 32-bit mode.
       return n;
@@ -609,7 +621,7 @@ 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()),
-      str.size());
+      WeaklyMixedInteger{str.size()});
 }
 
 // Support std::wstring, std::u16string and std::u32string.
@@ -622,11 +634,9 @@ H AbslHashValue(
     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()),
-      str.size());
+      WeaklyMixedInteger{str.size()});
 }
 
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-
 // 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 ||
@@ -635,11 +645,9 @@ template <typename Char, typename H,
 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()),
-      str.size());
+      WeaklyMixedInteger{str.size()});
 }
 
-#endif  // ABSL_HAVE_STD_STRING_VIEW
-
 #if defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && \
     (!defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) ||        \
      __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000) &&       \
@@ -685,7 +693,7 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
   for (const auto& t : deque) {
     hash_state = H::combine(std::move(hash_state), t);
   }
-  return H::combine(std::move(hash_state), deque.size());
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{deque.size()});
 }
 
 // AbslHashValue for hashing std::forward_list
@@ -697,7 +705,7 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
     hash_state = H::combine(std::move(hash_state), t);
     ++size;
   }
-  return H::combine(std::move(hash_state), size);
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{size});
 }
 
 // AbslHashValue for hashing std::list
@@ -707,7 +715,7 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
   for (const auto& t : list) {
     hash_state = H::combine(std::move(hash_state), t);
   }
-  return H::combine(std::move(hash_state), list.size());
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{list.size()});
 }
 
 // AbslHashValue for hashing std::vector
@@ -721,7 +729,7 @@ typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
 AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
   return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(),
                                           vector.size()),
-                    vector.size());
+                    WeaklyMixedInteger{vector.size()});
 }
 
 // AbslHashValue special cases for hashing std::vector<bool>
@@ -742,7 +750,8 @@ AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
     unsigned char c = static_cast<unsigned char>(i);
     hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
   }
-  return H::combine(combiner.finalize(std::move(hash_state)), vector.size());
+  return H::combine(combiner.finalize(std::move(hash_state)),
+                    WeaklyMixedInteger{vector.size()});
 }
 #else
 // When not working around the libstdc++ bug above, we still have to contend
@@ -758,7 +767,7 @@ typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value,
 AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
   return H::combine(std::move(hash_state),
                     std::hash<std::vector<T, Allocator>>{}(vector),
-                    vector.size());
+                    WeaklyMixedInteger{vector.size()});
 }
 #endif
 
@@ -775,7 +784,7 @@ AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map) {
   for (const auto& t : map) {
     hash_state = H::combine(std::move(hash_state), t);
   }
-  return H::combine(std::move(hash_state), map.size());
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{map.size()});
 }
 
 // AbslHashValue for hashing std::multimap
@@ -788,7 +797,7 @@ AbslHashValue(H hash_state,
   for (const auto& t : map) {
     hash_state = H::combine(std::move(hash_state), t);
   }
-  return H::combine(std::move(hash_state), map.size());
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{map.size()});
 }
 
 // AbslHashValue for hashing std::set
@@ -798,7 +807,7 @@ typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
   for (const auto& t : set) {
     hash_state = H::combine(std::move(hash_state), t);
   }
-  return H::combine(std::move(hash_state), set.size());
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{set.size()});
 }
 
 // AbslHashValue for hashing std::multiset
@@ -808,7 +817,7 @@ typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
   for (const auto& t : set) {
     hash_state = H::combine(std::move(hash_state), t);
   }
-  return H::combine(std::move(hash_state), set.size());
+  return H::combine(std::move(hash_state), WeaklyMixedInteger{set.size()});
 }
 
 // -----------------------------------------------------------------------------
@@ -822,7 +831,7 @@ typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
     H hash_state, const std::unordered_set<Key, Hash, KeyEqual, Alloc>& s) {
   return H::combine(
       H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
+      WeaklyMixedInteger{s.size()});
 }
 
 // AbslHashValue for hashing std::unordered_multiset
@@ -833,7 +842,7 @@ typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
     const std::unordered_multiset<Key, Hash, KeyEqual, Alloc>& s) {
   return H::combine(
       H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
+      WeaklyMixedInteger{s.size()});
 }
 
 // AbslHashValue for hashing std::unordered_set
@@ -845,7 +854,7 @@ AbslHashValue(H hash_state,
               const std::unordered_map<Key, T, Hash, KeyEqual, Alloc>& s) {
   return H::combine(
       H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
+      WeaklyMixedInteger{s.size()});
 }
 
 // AbslHashValue for hashing std::unordered_multiset
@@ -857,7 +866,7 @@ AbslHashValue(H hash_state,
               const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& s) {
   return H::combine(
       H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
+      WeaklyMixedInteger{s.size()});
 }
 
 // -----------------------------------------------------------------------------
@@ -968,11 +977,20 @@ hash_range_or_bytes(H hash_state, const T* data, size_t size) {
 // `false`.
 struct HashSelect {
  private:
+  struct WeaklyMixedIntegerProbe {
+    template <typename H>
+    static H Invoke(H state, WeaklyMixedInteger value) {
+      return hash_internal::hash_weakly_mixed_integer(std::move(state), value);
+    }
+  };
+
   struct State : HashStateBase<State> {
     static State combine_contiguous(State hash_state, const unsigned char*,
                                     size_t);
     using State::HashStateBase::combine_contiguous;
     static State combine_raw(State state, uint64_t value);
+    static State combine_weakly_mixed_integer(State hash_state,
+                                              WeaklyMixedInteger value);
   };
 
   struct UniquelyRepresentedProbe {
@@ -1034,6 +1052,7 @@ struct HashSelect {
   // disjunction provides short circuiting wrt instantiation.
   template <typename T>
   using Apply = absl::disjunction<         //
+      Probe<WeaklyMixedIntegerProbe, T>,   //
       Probe<UniquelyRepresentedProbe, T>,  //
       Probe<HashValueProbe, T>,            //
       Probe<LegacyHashProbe, T>,           //
@@ -1063,8 +1082,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   };
 
   static constexpr uint64_t kMul =
-  sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
-                      : uint64_t{0xdcb22ca68cb134ed};
+   uint64_t{0xdcb22ca68cb134ed};
 
   template <typename T>
   using IntegralFastPath =
@@ -1099,7 +1117,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   template <typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
   static size_t hash(T value) {
     return static_cast<size_t>(
-        WeakMix(Seed() ^ static_cast<std::make_unsigned_t<T>>(value)));
+        WeakMix(Seed(), static_cast<std::make_unsigned_t<T>>(value)));
   }
 
   // Overload of MixingHashState::hash()
@@ -1114,6 +1132,18 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   MixingHashState() : state_(Seed()) {}
 
   friend class MixingHashState::HashStateBase;
+  template <typename H>
+  friend H absl::hash_internal::hash_weakly_mixed_integer(H,
+                                                          WeaklyMixedInteger);
+
+  static MixingHashState combine_weakly_mixed_integer(
+      MixingHashState hash_state, WeaklyMixedInteger value) {
+    // Some transformation for the value is needed to make an empty
+    // string/container change the mixing hash state.
+    // We use constant smaller than 8 bits to make compiler use
+    // `add` with an immediate operand with 1 byte value.
+    return MixingHashState{hash_state.state_ + (0x57 + value.value)};
+  }
 
   template <typename CombinerT>
   static MixingHashState RunCombineUnordered(MixingHashState state,
@@ -1152,7 +1182,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // 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));
+    return MixingHashState(WeakMix(hash_state.state_, value));
   }
 
   // Implementation of the base case for combine_contiguous where we actually
@@ -1180,7 +1210,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
       // Empty ranges have no effect.
       return state;
     }
-    return WeakMix(state ^ v);
+    return WeakMix(state, v);
   }
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t CombineContiguousImpl9to16(
@@ -1222,8 +1252,8 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
                                                size_t len);
 
   // Reads 9 to 16 bytes from p.
-  // The least significant 8 bytes are in .first, the rest (zero padded) bytes
-  // are in .second.
+  // 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);
@@ -1251,11 +1281,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
 #endif
   }
 
-  // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
-  // TODO(b/384509507): consider optimizing this by not requiring the output to
-  // be equivalent to an integer load for 4/8 bytes. Currently, we rely on this
-  // behavior for the HashConsistentAcrossIntTypes test case. Ditto for
-  // Read1To3.
+  // 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.:
@@ -1274,7 +1300,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return most_significant | least_significant;
   }
 
-  // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
+  // 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.
@@ -1290,27 +1316,26 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   }
 
   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.
-    using MultType =
-        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
-    MultType m = lhs;
+    uint128 m = lhs;
     m *= rhs;
-    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
+    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 n) {
+  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 (sizeof(size_t) < 8) return Mix(n, kMul);
-#ifdef __ARM_ACLE
-    // gbswap_64 compiles to `rev` on ARM, but `rbit` is better because it
-    // reverses bits rather than reversing bytes.
-    return __rbitll(n * kMul);
-#else
+    if constexpr (sizeof(size_t) < 8) return Mix(n, kMul);
     return absl::gbswap_64(n * kMul);
-#endif
   }
 
   // An extern to avoid bloat on a direct call to LowLevelHash() with fixed