grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/meta/type_traits.h

@@ -40,10 +40,12 @@
 #include <string>
 #include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/macros.h"
 
 #ifdef __cpp_lib_span
 #include <span>  // NOLINT(build/c++20)
@@ -102,9 +104,10 @@ struct is_detected : is_detected_impl<void, Op, Args...>::type {};
 // metafunction allows you to create a general case that maps to `void` while
 // allowing specializations that map to specific types.
 //
-// This metafunction is not 100% compatible with the C++17 `std::void_t`
-// metafunction. It has slightly different behavior, such as when ordering
-// partial specializations. It is recommended to use `std::void_t` instead.
+// This metafunction is a workaround for some implementations of `std::void_t`
+// that evaluate to `void` prematurely, causing partial specializations to
+// appear duplicated (and thus invalid) to the compiler prior to substitution
+// taking place. Whenever possible, use `std::void_t` instead.
 template <typename... Ts>
 using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
 
@@ -114,38 +117,115 @@ using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
 //
 // See the documentation for the STL <type_traits> header for more information:
 // https://en.cppreference.com/w/cpp/header/type_traits
-using std::add_const_t;
-using std::add_cv_t;
-using std::add_lvalue_reference_t;
-using std::add_pointer_t;
-using std::add_rvalue_reference_t;
-using std::add_volatile_t;
-using std::common_type_t;
-using std::conditional_t;
-using std::conjunction;
-using std::decay_t;
-using std::enable_if_t;
-using std::disjunction;
-using std::is_copy_assignable;
-using std::is_function;
-using std::is_move_assignable;
-using std::is_trivially_copy_assignable;
-using std::is_trivially_copy_constructible;
-using std::is_trivially_default_constructible;
-using std::is_trivially_destructible;
-using std::is_trivially_move_assignable;
-using std::is_trivially_move_constructible;
-using std::make_signed_t;
-using std::make_unsigned_t;
-using std::negation;
-using std::remove_all_extents_t;
-using std::remove_const_t;
-using std::remove_cv_t;
-using std::remove_extent_t;
-using std::remove_pointer_t;
-using std::remove_reference_t;
-using std::remove_volatile_t;
-using std::underlying_type_t;
+
+template <class T>
+using add_const_t ABSL_DEPRECATE_AND_INLINE() = std::add_const_t<T>;
+
+template <class T>
+using add_cv_t ABSL_DEPRECATE_AND_INLINE() = std::add_cv_t<T>;
+
+template <class T>
+using add_lvalue_reference_t ABSL_DEPRECATE_AND_INLINE() =
+    std::add_lvalue_reference_t<T>;
+
+template <class T>
+using add_pointer_t ABSL_DEPRECATE_AND_INLINE() = std::add_pointer_t<T>;
+
+template <class T>
+using add_rvalue_reference_t ABSL_DEPRECATE_AND_INLINE() =
+    std::add_rvalue_reference_t<T>;
+
+template <class T>
+using add_volatile_t ABSL_DEPRECATE_AND_INLINE() = std::add_volatile_t<T>;
+
+template <class... T>
+using common_type_t ABSL_DEPRECATE_AND_INLINE() = std::common_type_t<T...>;
+
+template <bool C, class T, class F>
+using conditional_t ABSL_DEPRECATE_AND_INLINE() = std::conditional_t<C, T, F>;
+
+template <class... T>
+using conjunction ABSL_DEPRECATE_AND_INLINE() = std::conjunction<T...>;
+
+template <class T>
+using decay_t ABSL_DEPRECATE_AND_INLINE() = std::decay_t<T>;
+
+template <bool C, class T = void>
+using enable_if_t [[deprecated("Use std::enable_if_t instead.")]] =
+    std::enable_if_t<C, T>;
+
+template <class... T>
+using disjunction ABSL_DEPRECATE_AND_INLINE() = std::disjunction<T...>;
+
+template <class T>
+using is_copy_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_copy_assignable<T>;
+
+template <class T>
+using is_function ABSL_DEPRECATE_AND_INLINE() = std::is_function<T>;
+
+template <class T>
+using is_move_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_move_assignable<T>;
+
+template <class T>
+using is_trivially_copy_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_copy_assignable<T>;
+
+template <class T>
+using is_trivially_copy_constructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_copy_constructible<T>;
+
+template <class T>
+using is_trivially_default_constructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_default_constructible<T>;
+
+template <class T>
+using is_trivially_destructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_destructible<T>;
+
+template <class T>
+using is_trivially_move_assignable ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_move_assignable<T>;
+
+template <class T>
+using is_trivially_move_constructible ABSL_DEPRECATE_AND_INLINE() =
+    std::is_trivially_move_constructible<T>;
+
+template <class T>
+using make_signed_t ABSL_DEPRECATE_AND_INLINE() = std::make_signed_t<T>;
+
+template <class T>
+using make_unsigned_t ABSL_DEPRECATE_AND_INLINE() = std::make_unsigned_t<T>;
+
+template <class T>
+using negation ABSL_DEPRECATE_AND_INLINE() = std::negation<T>;
+
+template <class T>
+using remove_all_extents_t ABSL_DEPRECATE_AND_INLINE() =
+    std::remove_all_extents_t<T>;
+
+template <class T>
+using remove_const_t ABSL_DEPRECATE_AND_INLINE() = std::remove_const_t<T>;
+
+template <class T>
+using remove_cv_t ABSL_DEPRECATE_AND_INLINE() = std::remove_cv_t<T>;
+
+template <class T>
+using remove_extent_t ABSL_DEPRECATE_AND_INLINE() = std::remove_extent_t<T>;
+
+template <class T>
+using remove_pointer_t ABSL_DEPRECATE_AND_INLINE() = std::remove_pointer_t<T>;
+
+template <class T>
+using remove_reference_t ABSL_DEPRECATE_AND_INLINE() =
+    std::remove_reference_t<T>;
+
+template <class T>
+using remove_volatile_t ABSL_DEPRECATE_AND_INLINE() = std::remove_volatile_t<T>;
+
+template <class T>
+using underlying_type_t ABSL_DEPRECATE_AND_INLINE() = std::underlying_type_t<T>;
 
 #if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L
 template <typename T>
@@ -168,6 +248,28 @@ template <typename T>
 using remove_cvref_t = typename remove_cvref<T>::type;
 #endif
 
+#if defined(__cpp_lib_type_identity) && __cpp_lib_type_identity >= 201806L
+template <typename T>
+using type_identity = std::type_identity<T>;
+
+template <typename T>
+using type_identity_t = std::type_identity_t<T>;
+#else
+// type_identity
+//
+// Back-fill of C++20's `std::type_identity`.
+template <typename T>
+struct type_identity {
+  typedef T type;
+};
+
+// type_identity_t
+//
+// Back-fill of C++20's `std::type_identity_t`.
+template <typename T>
+using type_identity_t = typename type_identity<T>::type;
+#endif
+
 namespace type_traits_internal {
 
 #if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
@@ -188,31 +290,16 @@ template <typename F>
 using result_of_t = typename type_traits_internal::result_of<F>::type;
 
 namespace type_traits_internal {
-// In MSVC we can't probe std::hash or stdext::hash because it triggers a
-// static_assert instead of failing substitution. Libc++ prior to 4.0
-// also used a static_assert.
-//
-#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
-                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
-#else
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
-#endif
 
-#if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-template <typename Key, typename = size_t>
-struct IsHashable : std::true_type {};
-#else   // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 template <typename Key, typename = void>
 struct IsHashable : std::false_type {};
 
 template <typename Key>
 struct IsHashable<
     Key,
-    absl::enable_if_t<std::is_convertible<
+    std::enable_if_t<std::is_convertible<
         decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
         std::size_t>::value>> : std::true_type {};
-#endif  // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 
 struct AssertHashEnabledHelper {
  private:
@@ -235,7 +322,7 @@ struct AssertHashEnabledHelper {
     static_assert(
         std::is_copy_constructible<std::hash<Key>>::value,
         "std::hash<Key> must be copy constructible when it is enabled");
-    static_assert(absl::is_copy_assignable<std::hash<Key>>::value,
+    static_assert(std::is_copy_assignable<std::hash<Key>>::value,
                   "std::hash<Key> must be copy assignable when it is enabled");
     // is_destructible is unchecked as it's implied by each of the
     // is_constructible checks.
@@ -298,7 +385,7 @@ struct IsNothrowSwappable
 //
 // Performs the swap idiom from a namespace where valid candidates may only be
 // found in `std` or via ADL.
-template <class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0>
+template <class T, std::enable_if_t<IsSwappable<T>::value, int> = 0>
 void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
   swap(lhs, rhs);
 }
@@ -451,7 +538,7 @@ namespace type_traits_internal {
 
 // Detects if a class's definition has declared itself to be an owner by
 // declaring
-//   using absl_internal_is_view = std::true_type;
+//   using absl_internal_is_view = std::false_type;
 // as a member.
 // Types that don't want either must either omit this declaration entirely, or
 // (if e.g. inheriting from a base class) define the member to something that
@@ -467,7 +554,7 @@ template <typename T>
 struct IsOwnerImpl<
     T,
     std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>
-    : absl::negation<typename T::absl_internal_is_view> {};
+    : std::negation<typename T::absl_internal_is_view> {};
 
 // A trait to determine whether a type is an owner.
 // Do *not* depend on the correctness of this trait for correct code behavior.
@@ -479,6 +566,17 @@ struct IsOwnerImpl<
 template <typename T>
 struct IsOwner : IsOwnerImpl<T> {};
 
+// This allows incomplete types to be used for associative containers, and also
+// expands the set of types we can handle to include std::pair.
+template <typename T1, typename T2>
+struct IsOwner<std::pair<T1, T2>>
+    : std::integral_constant<
+          bool, std::conditional_t<std::is_reference_v<T1>, std::false_type,
+                                   IsOwner<std::remove_cv_t<T1>>>::value &&
+                    std::conditional_t<std::is_reference_v<T2>, std::false_type,
+                                       IsOwner<std::remove_cv_t<T2>>>::value> {
+};
+
 template <typename T, typename Traits, typename Alloc>
 struct IsOwner<std::basic_string<T, Traits, Alloc>> : std::true_type {};
 
@@ -513,6 +611,13 @@ template <typename T>
 struct IsView : std::integral_constant<bool, std::is_pointer<T>::value ||
                                                  IsViewImpl<T>::value> {};
 
+// This allows incomplete types to be used for associative containers, and also
+// expands the set of types we can handle to include std::pair.
+template <typename T1, typename T2>
+struct IsView<std::pair<T1, T2>>
+    : std::integral_constant<bool, IsView<std::remove_cv_t<T1>>::value &&
+                                       IsView<std::remove_cv_t<T2>>::value> {};
+
 template <typename Char, typename Traits>
 struct IsView<std::basic_string_view<Char, Traits>> : std::true_type {};
 
@@ -529,7 +634,7 @@ struct IsView<std::span<T>> : std::true_type {};
 // Until then, we consider an assignment from an "owner" (such as std::string)
 // to a "view" (such as std::string_view) to be a lifetime-bound assignment.
 template <typename T, typename U>
-using IsLifetimeBoundAssignment = absl::conjunction<
+using IsLifetimeBoundAssignment = std::conjunction<
     std::integral_constant<bool, !std::is_lvalue_reference<U>::value>,
     IsOwner<absl::remove_cvref_t<U>>, IsView<absl::remove_cvref_t<T>>>;
 

data/third_party/abseil-cpp/absl/numeric/int128.h

@@ -164,9 +164,9 @@ class
   constexpr explicit operator __int128() const;
   constexpr explicit operator unsigned __int128() const;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
+  constexpr explicit operator float() const;
+  constexpr explicit operator double() const;
+  constexpr explicit operator long double() const;
 
   // Trivial copy constructor, assignment operator and destructor.
 
@@ -357,14 +357,18 @@ class int128 {
   constexpr int128(unsigned long v);       // NOLINT(runtime/int)
   constexpr int128(long long v);           // NOLINT(runtime/int)
   constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
+  constexpr explicit int128(uint128 v);
 #ifdef ABSL_HAVE_INTRINSIC_INT128
   constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
   constexpr explicit int128(unsigned __int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit int128(uint128 v);
+  constexpr explicit int128(float v);
+  constexpr explicit int128(double v);
+  constexpr explicit int128(long double v);
+#else
   explicit int128(float v);
   explicit int128(double v);
   explicit int128(long double v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
   // Assignment operators from arithmetic types
   int128& operator=(int v);
@@ -401,9 +405,9 @@ class int128 {
   constexpr explicit operator __int128() const;
   constexpr explicit operator unsigned __int128() const;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
+  constexpr explicit operator float() const;
+  constexpr explicit operator double() const;
+  constexpr explicit operator long double() const;
 
   // Trivial copy constructor, assignment operator and destructor.
 
@@ -609,9 +613,15 @@ constexpr uint128 operator<<(uint128 lhs, int amount);
 constexpr uint128 operator>>(uint128 lhs, int amount);
 constexpr uint128 operator+(uint128 lhs, uint128 rhs);
 constexpr uint128 operator-(uint128 lhs, uint128 rhs);
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+constexpr uint128 operator*(uint128 lhs, uint128 rhs);
+constexpr uint128 operator/(uint128 lhs, uint128 rhs);
+constexpr uint128 operator%(uint128 lhs, uint128 rhs);
+#else   // ABSL_HAVE_INTRINSIC_INT128
 uint128 operator*(uint128 lhs, uint128 rhs);
 uint128 operator/(uint128 lhs, uint128 rhs);
 uint128 operator%(uint128 lhs, uint128 rhs);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 inline uint128& uint128::operator<<=(int amount) {
   *this = *this << amount;
@@ -788,18 +798,18 @@ constexpr uint128::operator unsigned __int128() const {
 
 // Conversion operators to floating point types.
 
-inline uint128::operator float() const {
+constexpr uint128::operator float() const {
   // Note: This method might return Inf.
   constexpr float pow_2_64 = 18446744073709551616.0f;
   return static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;
 }
 
-inline uint128::operator double() const {
+constexpr uint128::operator double() const {
   constexpr double pow_2_64 = 18446744073709551616.0;
   return static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;
 }
 
-inline uint128::operator long double() const {
+constexpr uint128::operator long double() const {
   constexpr long double pow_2_64 = 18446744073709551616.0L;
   return static_cast<long double>(lo_) +
          static_cast<long double>(hi_) * pow_2_64;
@@ -1021,19 +1031,15 @@ constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 #endif
 }
 
+#if !defined(ABSL_HAVE_INTRINSIC_INT128)
 inline uint128 operator*(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
-  // can be used for uint128 storage.
-  return static_cast<unsigned __int128>(lhs) *
-         static_cast<unsigned __int128>(rhs);
-#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
+#if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
   uint64_t carry;
   uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
   return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
                          Uint128High64(lhs) * Uint128Low64(rhs) + carry,
                      low);
-#else   // ABSL_HAVE_INTRINSIC128
+#else   // _MSC_VER
   uint64_t a32 = Uint128Low64(lhs) >> 32;
   uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
   uint64_t b32 = Uint128Low64(rhs) >> 32;
@@ -1045,16 +1051,24 @@ inline uint128 operator*(uint128 lhs, uint128 rhs) {
   result += uint128(a32 * b00) << 32;
   result += uint128(a00 * b32) << 32;
   return result;
-#endif  // ABSL_HAVE_INTRINSIC128
+#endif  // _MSC_VER
 }
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-inline uint128 operator/(uint128 lhs, uint128 rhs) {
+constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
+  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
+  // can be used for uint128 storage.
+  return static_cast<unsigned __int128>(lhs) *
+         static_cast<unsigned __int128>(rhs);
+}
+
+constexpr uint128 operator/(uint128 lhs, uint128 rhs) {
   return static_cast<unsigned __int128>(lhs) /
          static_cast<unsigned __int128>(rhs);
 }
 
-inline uint128 operator%(uint128 lhs, uint128 rhs) {
+constexpr uint128 operator%(uint128 lhs, uint128 rhs) {
   return static_cast<unsigned __int128>(lhs) %
          static_cast<unsigned __int128>(rhs);
 }
@@ -1112,9 +1126,15 @@ inline int128& int128::operator=(unsigned long long v) {
 constexpr int128 operator-(int128 v);
 constexpr int128 operator+(int128 lhs, int128 rhs);
 constexpr int128 operator-(int128 lhs, int128 rhs);
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+constexpr int128 operator*(int128 lhs, int128 rhs);
+constexpr int128 operator/(int128 lhs, int128 rhs);
+constexpr int128 operator%(int128 lhs, int128 rhs);
+#else
 int128 operator*(int128 lhs, int128 rhs);
 int128 operator/(int128 lhs, int128 rhs);
 int128 operator%(int128 lhs, int128 rhs);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 constexpr int128 operator|(int128 lhs, int128 rhs);
 constexpr int128 operator&(int128 lhs, int128 rhs);
 constexpr int128 operator^(int128 lhs, int128 rhs);

data/third_party/abseil-cpp/absl/numeric/int128_have_intrinsic.inc

@@ -73,17 +73,11 @@ constexpr int128::int128(unsigned long long v) : v_{v} {}
 
 constexpr int128::int128(unsigned __int128 v) : v_{static_cast<__int128>(v)} {}
 
-inline int128::int128(float v) {
-  v_ = static_cast<__int128>(v);
-}
+constexpr int128::int128(float v) : v_{static_cast<__int128>(v)} {}
 
-inline int128::int128(double v) {
-  v_ = static_cast<__int128>(v);
-}
+constexpr int128::int128(double v) : v_{static_cast<__int128>(v)} {}
 
-inline int128::int128(long double v) {
-  v_ = static_cast<__int128>(v);
-}
+constexpr int128::int128(long double v) : v_{static_cast<__int128>(v)} {}
 
 constexpr int128::int128(uint128 v) : v_{static_cast<__int128>(v)} {}
 
@@ -119,9 +113,7 @@ constexpr int128::operator unsigned short() const {  // NOLINT(runtime/int)
   return static_cast<unsigned short>(v_);            // NOLINT(runtime/int)
 }
 
-constexpr int128::operator int() const {
-  return static_cast<int>(v_);
-}
+constexpr int128::operator int() const { return static_cast<int>(v_); }
 
 constexpr int128::operator unsigned int() const {
   return static_cast<unsigned int>(v_);
@@ -153,17 +145,17 @@ constexpr int128::operator unsigned __int128() const {
 // conversions. In that case, we do the conversion with a similar implementation
 // to the conversion operators in int128_no_intrinsic.inc.
 #if defined(__clang__) && !defined(__ppc64__)
-inline int128::operator float() const { return static_cast<float>(v_); }
+constexpr int128::operator float() const { return static_cast<float>(v_); }
 
-inline int128::operator double() const { return static_cast<double>(v_); }
+constexpr int128::operator double() const { return static_cast<double>(v_); }
 
-inline int128::operator long double() const {
+constexpr int128::operator long double() const {
   return static_cast<long double>(v_);
 }
 
-#else  // Clang on PowerPC
+#else   // Clang on PowerPC
 
-inline int128::operator float() const {
+constexpr int128::operator float() const {
   // We must convert the absolute value and then negate as needed, because
   // floating point types are typically sign-magnitude. Otherwise, the
   // difference between the high and low 64 bits when interpreted as two's
@@ -177,7 +169,7 @@ inline int128::operator float() const {
                    static_cast<float>(Int128High64(*this)) * pow_2_64;
 }
 
-inline int128::operator double() const {
+constexpr int128::operator double() const {
   // See comment in int128::operator float() above.
   constexpr double pow_2_64 = 18446744073709551616.0;
   return v_ < 0 && *this != Int128Min()
@@ -186,7 +178,7 @@ inline int128::operator double() const {
                    static_cast<double>(Int128High64(*this)) * pow_2_64;
 }
 
-inline int128::operator long double() const {
+constexpr int128::operator long double() const {
   // See comment in int128::operator float() above.
   constexpr long double pow_2_64 = 18446744073709551616.0L;
   return v_ < 0 && *this != Int128Min()
@@ -254,17 +246,19 @@ constexpr int128 operator-(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) - static_cast<__int128>(rhs);
 }
 
-inline int128 operator*(int128 lhs, int128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+constexpr int128 operator*(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) * static_cast<__int128>(rhs);
 }
 
-inline int128 operator/(int128 lhs, int128 rhs) {
+constexpr int128 operator/(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) / static_cast<__int128>(rhs);
 }
 
-inline int128 operator%(int128 lhs, int128 rhs) {
+constexpr int128 operator%(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) % static_cast<__int128>(rhs);
 }
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 inline int128 int128::operator++(int) {
   int128 tmp(*this);

data/third_party/abseil-cpp/absl/numeric/int128_no_intrinsic.inc

@@ -132,7 +132,7 @@ constexpr int128::operator unsigned long long() const {  // NOLINT(runtime/int)
   return static_cast<unsigned long long>(lo_);           // NOLINT(runtime/int)
 }
 
-inline int128::operator float() const {
+constexpr int128::operator float() const {
   // We must convert the absolute value and then negate as needed, because
   // floating point types are typically sign-magnitude. Otherwise, the
   // difference between the high and low 64 bits when interpreted as two's
@@ -142,20 +142,18 @@ inline int128::operator float() const {
   constexpr float pow_2_64 = 18446744073709551616.0f;
   return hi_ < 0 && *this != Int128Min()
              ? -static_cast<float>(-*this)
-             : static_cast<float>(lo_) +
-                   static_cast<float>(hi_) * pow_2_64;
+             : static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;
 }
 
-inline int128::operator double() const {
+constexpr int128::operator double() const {
   // See comment in int128::operator float() above.
   constexpr double pow_2_64 = 18446744073709551616.0;
   return hi_ < 0 && *this != Int128Min()
              ? -static_cast<double>(-*this)
-             : static_cast<double>(lo_) +
-                   static_cast<double>(hi_) * pow_2_64;
+             : static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;
 }
 
-inline int128::operator long double() const {
+constexpr int128::operator long double() const {
   // See comment in int128::operator float() above.
   constexpr long double pow_2_64 = 18446744073709551616.0L;
   return hi_ < 0 && *this != Int128Min()

data/third_party/abseil-cpp/absl/numeric/internal/bits.h

@@ -77,8 +77,28 @@ template <class T>
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
                 "T must have a power-of-2 size");
 
-  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
+  // Rotate by s mod the number of digits to avoid unnecessary rotations.
+  //
+  // A negative s represents a left rotation instead of a right rotation.
+  // We compute it as an equivalent complementary right rotation by leveraging
+  // its two's complement representation.
+  //
+  // For example, suppose we rotate a 3-bit number by -2.
+  // In that case:
+  //   * s = 0b11111111111111111111111111111110
+  //   * n = 8
+  //   * r = (0b11111111111111111111111111111110 & 0b111) = 0b110
+  //
+  // Instead of rotating by 2 to the left, we rotate by 6 to the right, which
+  // is equivalent.
+  const int n = std::numeric_limits<T>::digits;
+  const int r = s & (n - 1);
+
+  if (r == 0) {
+    return x;
+  } else {
+    return (x >> r) | (x << (n - r));
+  }
 }
 
 template <class T>
@@ -88,8 +108,16 @@ template <class T>
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
                 "T must have a power-of-2 size");
 
-  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
+  // Rotate by s mod the number of digits to avoid unnecessary rotations.
+  // See comment in RotateRight for a detailed explanation of the logic below.
+  const int n = std::numeric_limits<T>::digits;
+  const int r = s & (n - 1);
+
+  if (r == 0) {
+    return x;
+  } else {
+    return (x << r) | (x >> (n - r));
+  }
 }
 
 ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int