re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/base/config.h

@@ -117,7 +117,7 @@
 //
 // LTS releases can be obtained from
 // https://github.com/abseil/abseil-cpp/releases.
-#define ABSL_LTS_RELEASE_VERSION 20250127
+#define ABSL_LTS_RELEASE_VERSION 20250814
 #define ABSL_LTS_RELEASE_PATCH_LEVEL 1
 
 // Helper macro to convert a CPP variable to a string literal.
@@ -237,6 +237,8 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #error ABSL_HAVE_TLS cannot be directly set
 #elif (defined(__linux__)) && (defined(__clang__) || defined(_GLIBCXX_HAVE_TLS))
 #define ABSL_HAVE_TLS 1
+#elif defined(__INTEL_LLVM_COMPILER)
+#define ABSL_HAVE_TLS 1
 #endif
 
 // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
@@ -274,15 +276,12 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_HAVE_STD_IS_TRIVIALLY_COPYABLE 1
 #endif
 
-
 // ABSL_HAVE_THREAD_LOCAL
 //
-// DEPRECATED - `thread_local` is available on all supported platforms.
-// Checks whether C++11's `thread_local` storage duration specifier is
-// supported.
+// Checks whether the `thread_local` storage duration specifier is supported.
 #ifdef ABSL_HAVE_THREAD_LOCAL
 #error ABSL_HAVE_THREAD_LOCAL cannot be directly set
-#else
+#elif !defined(__XTENSA__)
 #define ABSL_HAVE_THREAD_LOCAL 1
 #endif
 
@@ -469,6 +468,9 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 //
 // Checks the endianness of the platform.
 //
+// Prefer using `std::endian` in C++20, or `absl::endian` from
+// absl/numeric/bits.h prior to C++20.
+//
 // Notes: uses the built in endian macros provided by GCC (since 4.6) and
 // Clang (since 3.2); see
 // https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html.
@@ -520,54 +522,22 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
 #endif
 
-// ABSL_HAVE_STD_ANY
-//
-// Checks whether C++17 std::any is available.
-#ifdef ABSL_HAVE_STD_ANY
-#error "ABSL_HAVE_STD_ANY cannot be directly set."
-#elif defined(__cpp_lib_any) && __cpp_lib_any >= 201606L
-#define ABSL_HAVE_STD_ANY 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+// Deprecated macros for polyfill detection.
 #define ABSL_HAVE_STD_ANY 1
-#endif
-
-// ABSL_HAVE_STD_OPTIONAL
-//
-// Checks whether C++17 std::optional is available.
-#ifdef ABSL_HAVE_STD_OPTIONAL
-#error "ABSL_HAVE_STD_OPTIONAL cannot be directly set."
-#elif defined(__cpp_lib_optional) && __cpp_lib_optional >= 202106L
-#define ABSL_HAVE_STD_OPTIONAL 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define ABSL_USES_STD_ANY 1
 #define ABSL_HAVE_STD_OPTIONAL 1
-#endif
-
-// ABSL_HAVE_STD_VARIANT
-//
-// Checks whether C++17 std::variant is available.
-#ifdef ABSL_HAVE_STD_VARIANT
-#error "ABSL_HAVE_STD_VARIANT cannot be directly set."
-#elif defined(__cpp_lib_variant) && __cpp_lib_variant >= 201606L
-#define ABSL_HAVE_STD_VARIANT 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define ABSL_USES_STD_OPTIONAL 1
 #define ABSL_HAVE_STD_VARIANT 1
-#endif
+#define ABSL_USES_STD_VARIANT 1
 
 // ABSL_HAVE_STD_STRING_VIEW
 //
-// Checks whether C++17 std::string_view is available.
+// Deprecated: always defined to 1.
+// std::string_view was added in C++17, which means all versions of C++
+// supported by Abseil have it.
 #ifdef ABSL_HAVE_STD_STRING_VIEW
 #error "ABSL_HAVE_STD_STRING_VIEW cannot be directly set."
-#elif defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L
-#define ABSL_HAVE_STD_STRING_VIEW 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#else
 #define ABSL_HAVE_STD_STRING_VIEW 1
 #endif
 
@@ -587,63 +557,15 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_HAVE_STD_ORDERING 1
 #endif
 
-// ABSL_USES_STD_ANY
-//
-// Indicates whether absl::any is an alias for std::any.
-#if !defined(ABSL_OPTION_USE_STD_ANY)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_ANY == 0 || \
-    (ABSL_OPTION_USE_STD_ANY == 2 && !defined(ABSL_HAVE_STD_ANY))
-#undef ABSL_USES_STD_ANY
-#elif ABSL_OPTION_USE_STD_ANY == 1 || \
-    (ABSL_OPTION_USE_STD_ANY == 2 && defined(ABSL_HAVE_STD_ANY))
-#define ABSL_USES_STD_ANY 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// ABSL_USES_STD_OPTIONAL
-//
-// Indicates whether absl::optional is an alias for std::optional.
-#if !defined(ABSL_OPTION_USE_STD_OPTIONAL)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_OPTIONAL == 0 || \
-    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && !defined(ABSL_HAVE_STD_OPTIONAL))
-#undef ABSL_USES_STD_OPTIONAL
-#elif ABSL_OPTION_USE_STD_OPTIONAL == 1 || \
-    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && defined(ABSL_HAVE_STD_OPTIONAL))
-#define ABSL_USES_STD_OPTIONAL 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// ABSL_USES_STD_VARIANT
-//
-// Indicates whether absl::variant is an alias for std::variant.
-#if !defined(ABSL_OPTION_USE_STD_VARIANT)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_VARIANT == 0 || \
-    (ABSL_OPTION_USE_STD_VARIANT == 2 && !defined(ABSL_HAVE_STD_VARIANT))
-#undef ABSL_USES_STD_VARIANT
-#elif ABSL_OPTION_USE_STD_VARIANT == 1 || \
-    (ABSL_OPTION_USE_STD_VARIANT == 2 && defined(ABSL_HAVE_STD_VARIANT))
-#define ABSL_USES_STD_VARIANT 1
-#else
-#error options.h is misconfigured.
-#endif
-
 // ABSL_USES_STD_STRING_VIEW
 //
 // Indicates whether absl::string_view is an alias for std::string_view.
 #if !defined(ABSL_OPTION_USE_STD_STRING_VIEW)
 #error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_STRING_VIEW == 0 || \
-    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
-     !defined(ABSL_HAVE_STD_STRING_VIEW))
+#elif ABSL_OPTION_USE_STD_STRING_VIEW == 0
 #undef ABSL_USES_STD_STRING_VIEW
 #elif ABSL_OPTION_USE_STD_STRING_VIEW == 1 || \
-    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
-     defined(ABSL_HAVE_STD_STRING_VIEW))
+    ABSL_OPTION_USE_STD_STRING_VIEW == 2
 #define ABSL_USES_STD_STRING_VIEW 1
 #else
 #error options.h is misconfigured.
@@ -665,14 +587,6 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #error options.h is misconfigured.
 #endif
 
-// In debug mode, MSVC 2017's std::variant throws a EXCEPTION_ACCESS_VIOLATION
-// SEH exception from emplace for variant<SomeStruct> when constructing the
-// struct can throw. This defeats some of variant_test and
-// variant_exception_safety_test.
-#if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_DEBUG)
-#define ABSL_INTERNAL_MSVC_2017_DBG_MODE
-#endif
-
 // ABSL_INTERNAL_MANGLED_NS
 // ABSL_INTERNAL_MANGLED_BACKREFERENCE
 //
@@ -813,36 +727,15 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 
 // ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
 //
-// Class template argument deduction is a language feature added in C++17.
+// Deprecated: always defined to 1.
+// Class template argument deduction is a language feature added in C++17,
+// which means all versions of C++ supported by Abseil have it.
 #ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
 #error "ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION cannot be directly set."
-#elif defined(__cpp_deduction_guides)
+#else
 #define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
 #endif
 
-// ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-//
-// Prior to C++17, static constexpr variables defined in classes required a
-// separate definition outside of the class body, for example:
-//
-// class Foo {
-//   static constexpr int kBar = 0;
-// };
-// constexpr int Foo::kBar;
-//
-// In C++17, these variables defined in classes are considered inline variables,
-// and the extra declaration is redundant. Since some compilers warn on the
-// extra declarations, ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL can be used
-// conditionally ignore them:
-//
-// #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-// constexpr int Foo::kBar;
-// #endif
-#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
-    ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L
-#define ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 1
-#endif
-
 // `ABSL_INTERNAL_HAS_RTTI` determines whether abseil is being compiled with
 // RTTI support.
 #ifdef ABSL_INTERNAL_HAS_RTTI

package/vendor/abseil-cpp/absl/base/exception_safety_testing_test.cc

@@ -705,10 +705,6 @@ struct BasicGuaranteeWithExtraContracts : public NonNegative {
   static constexpr int kExceptionSentinel = 9999;
 };
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr int BasicGuaranteeWithExtraContracts::kExceptionSentinel;
-#endif
-
 TEST(ExceptionCheckTest, BasicGuaranteeWithExtraContracts) {
   auto tester_with_val =
       tester.WithInitialValue(BasicGuaranteeWithExtraContracts{});

package/vendor/abseil-cpp/absl/base/{internal/fast_type_id.h → fast_type_id.h}

@@ -1,4 +1,3 @@
-//
 // Copyright 2020 The Abseil Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,37 +13,33 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
-#define ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+#ifndef ABSL_BASE_FAST_TYPE_ID_H_
+#define ABSL_BASE_FAST_TYPE_ID_H_
 
 #include "absl/base/config.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
-namespace base_internal {
 
+namespace base_internal {
 template <typename Type>
 struct FastTypeTag {
-  constexpr static char dummy_var = 0;
+  static constexpr char kDummyVar = 0;
 };
+}  // namespace base_internal
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename Type>
-constexpr char FastTypeTag<Type>::dummy_var;
-#endif
+// The type returned by `absl::FastTypeId<T>()`.
+using FastTypeIdType = const void*;
 
-// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
+// `absl::FastTypeId<Type>()` evaluates at compile-time to a unique id for the
 // passed-in type. These are meant to be good match for keys into maps or
 // straight up comparisons.
-using FastTypeIdType = const void*;
-
 template <typename Type>
-constexpr inline FastTypeIdType FastTypeId() {
-  return &FastTypeTag<Type>::dummy_var;
+constexpr FastTypeIdType FastTypeId() {
+  return &base_internal::FastTypeTag<Type>::kDummyVar;
 }
 
-}  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
-#endif  // ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+#endif  // ABSL_BASE_FAST_TYPE_ID_H_

package/vendor/abseil-cpp/absl/base/{internal/fast_type_id_test.cc → fast_type_id_test.cc}

@@ -12,18 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/fast_type_id.h"
 
+#include <cstddef>
 #include <cstdint>
 #include <map>
 #include <vector>
 
 #include "gtest/gtest.h"
+#include "absl/base/macros.h"
 
 namespace {
-namespace bi = absl::base_internal;
 
-// NOLINTNEXTLINE
+// NOLINTBEGIN(runtime/int)
 #define PRIM_TYPES(A)   \
   A(bool)               \
   A(short)              \
@@ -37,28 +38,30 @@ namespace bi = absl::base_internal;
   A(float)              \
   A(double)             \
   A(long double)
+// NOLINTEND(runtime/int)
 
 TEST(FastTypeIdTest, PrimitiveTypes) {
-  bi::FastTypeIdType type_ids[] = {
-#define A(T) bi::FastTypeId<T>(),
+  // clang-format off
+  constexpr absl::FastTypeIdType kTypeIds[] = {
+#define A(T) absl::FastTypeId<T>(),
     PRIM_TYPES(A)
 #undef A
-#define A(T) bi::FastTypeId<const T>(),
+#define A(T) absl::FastTypeId<const T>(),
     PRIM_TYPES(A)
 #undef A
-#define A(T) bi::FastTypeId<volatile T>(),
+#define A(T) absl::FastTypeId<volatile T>(),
     PRIM_TYPES(A)
 #undef A
-#define A(T) bi::FastTypeId<const volatile T>(),
+#define A(T) absl::FastTypeId<const volatile T>(),
     PRIM_TYPES(A)
 #undef A
   };
-  size_t total_type_ids = sizeof(type_ids) / sizeof(bi::FastTypeIdType);
+  // clang-format on
 
-  for (int i = 0; i < total_type_ids; ++i) {
-    EXPECT_EQ(type_ids[i], type_ids[i]);
-    for (int j = 0; j < i; ++j) {
-      EXPECT_NE(type_ids[i], type_ids[j]);
+  for (size_t i = 0; i < ABSL_ARRAYSIZE(kTypeIds); ++i) {
+    EXPECT_EQ(kTypeIds[i], kTypeIds[i]);
+    for (size_t j = 0; j < i; ++j) {
+      EXPECT_NE(kTypeIds[i], kTypeIds[j]);
     }
   }
 }
@@ -74,41 +77,42 @@ TEST(FastTypeIdTest, PrimitiveTypes) {
   A(uint64_t)
 
 TEST(FastTypeIdTest, FixedWidthTypes) {
-  bi::FastTypeIdType type_ids[] = {
-#define A(T) bi::FastTypeId<T>(),
+  // clang-format off
+  constexpr absl::FastTypeIdType kTypeIds[] = {
+#define A(T) absl::FastTypeId<T>(),
     FIXED_WIDTH_TYPES(A)
 #undef A
-#define A(T) bi::FastTypeId<const T>(),
+#define A(T) absl::FastTypeId<const T>(),
     FIXED_WIDTH_TYPES(A)
 #undef A
-#define A(T) bi::FastTypeId<volatile T>(),
+#define A(T) absl::FastTypeId<volatile T>(),
     FIXED_WIDTH_TYPES(A)
 #undef A
-#define A(T) bi::FastTypeId<const volatile T>(),
+#define A(T) absl::FastTypeId<const volatile T>(),
     FIXED_WIDTH_TYPES(A)
 #undef A
   };
-  size_t total_type_ids = sizeof(type_ids) / sizeof(bi::FastTypeIdType);
+  // clang-format on
 
-  for (int i = 0; i < total_type_ids; ++i) {
-    EXPECT_EQ(type_ids[i], type_ids[i]);
-    for (int j = 0; j < i; ++j) {
-      EXPECT_NE(type_ids[i], type_ids[j]);
+  for (size_t i = 0; i < ABSL_ARRAYSIZE(kTypeIds); ++i) {
+    EXPECT_EQ(kTypeIds[i], kTypeIds[i]);
+    for (size_t j = 0; j < i; ++j) {
+      EXPECT_NE(kTypeIds[i], kTypeIds[j]);
     }
   }
 }
 
 TEST(FastTypeIdTest, AliasTypes) {
   using int_alias = int;
-  EXPECT_EQ(bi::FastTypeId<int_alias>(), bi::FastTypeId<int>());
+  EXPECT_EQ(absl::FastTypeId<int_alias>(), absl::FastTypeId<int>());
 }
 
 TEST(FastTypeIdTest, TemplateSpecializations) {
-  EXPECT_NE(bi::FastTypeId<std::vector<int>>(),
-            bi::FastTypeId<std::vector<long>>());
+  EXPECT_NE(absl::FastTypeId<std::vector<int>>(),
+            absl::FastTypeId<std::vector<long>>());  // NOLINT(runtime/int)
 
-  EXPECT_NE((bi::FastTypeId<std::map<int, float>>()),
-            (bi::FastTypeId<std::map<int, double>>()));
+  EXPECT_NE((absl::FastTypeId<std::map<int, float>>()),
+            (absl::FastTypeId<std::map<int, double>>()));
 }
 
 struct Base {};
@@ -116,8 +120,8 @@ struct Derived : Base {};
 struct PDerived : private Base {};
 
 TEST(FastTypeIdTest, Inheritance) {
-  EXPECT_NE(bi::FastTypeId<Base>(), bi::FastTypeId<Derived>());
-  EXPECT_NE(bi::FastTypeId<Base>(), bi::FastTypeId<PDerived>());
+  EXPECT_NE(absl::FastTypeId<Base>(), absl::FastTypeId<Derived>());
+  EXPECT_NE(absl::FastTypeId<Base>(), absl::FastTypeId<PDerived>());
 }
 
 }  // namespace

package/vendor/abseil-cpp/absl/base/internal/cycleclock.cc

@@ -35,11 +35,6 @@ namespace base_internal {
 
 #if ABSL_USE_UNSCALED_CYCLECLOCK
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr int32_t CycleClock::kShift;
-constexpr double CycleClock::kFrequencyScale;
-#endif
-
 ABSL_CONST_INIT std::atomic<CycleClockSourceFunc>
     CycleClock::cycle_clock_source_{nullptr};
 

package/vendor/abseil-cpp/absl/base/internal/cycleclock_config.h

@@ -18,7 +18,6 @@
 #include <cstdint>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/inline_variable.h"
 #include "absl/base/internal/unscaledcycleclock_config.h"
 
 namespace absl {
@@ -31,22 +30,23 @@ namespace base_internal {
 // Not debug mode and the UnscaledCycleClock frequency is the CPU
 // frequency.  Scale the CycleClock to prevent overflow if someone
 // tries to represent the time as cycles since the Unix epoch.
-ABSL_INTERNAL_INLINE_CONSTEXPR(int32_t, kCycleClockShift, 1);
+inline constexpr int32_t kCycleClockShift = 1;
 #else
 // Not debug mode and the UnscaledCycleClock isn't operating at the
 // raw CPU frequency. There is no need to do any scaling, so don't
 // needlessly sacrifice precision.
-ABSL_INTERNAL_INLINE_CONSTEXPR(int32_t, kCycleClockShift, 0);
+inline constexpr int32_t kCycleClockShift = 0;
 #endif
 #else   // NDEBUG
 // In debug mode use a different shift to discourage depending on a
 // particular shift value.
-ABSL_INTERNAL_INLINE_CONSTEXPR(int32_t, kCycleClockShift, 2);
+inline constexpr int32_t kCycleClockShift = 2;
 #endif  // NDEBUG
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(double, kCycleClockFrequencyScale,
-                               1.0 / (1 << kCycleClockShift));
-#endif  //  ABSL_USE_UNSCALED_CYCLECLOC
+inline constexpr double kCycleClockFrequencyScale =
+    1.0 / (1 << kCycleClockShift);
+
+#endif  // ABSL_USE_UNSCALED_CYCLECLOCK
 
 }  // namespace base_internal
 ABSL_NAMESPACE_END

package/vendor/abseil-cpp/absl/base/internal/endian.h

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
+// This file is for Abseil internal use only.
+// See //absl/numeric/bits.h for supported functions related to endian-ness.
 
 #ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
 #define ABSL_BASE_INTERNAL_ENDIAN_H_
@@ -28,44 +30,38 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-inline uint64_t gbswap_64(uint64_t host_int) {
+constexpr uint64_t gbswap_64(uint64_t x) {
 #if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__)
-  return __builtin_bswap64(host_int);
-#elif defined(_MSC_VER)
-  return _byteswap_uint64(host_int);
+  return __builtin_bswap64(x);
 #else
-  return (((host_int & uint64_t{0xFF}) << 56) |
-          ((host_int & uint64_t{0xFF00}) << 40) |
-          ((host_int & uint64_t{0xFF0000}) << 24) |
-          ((host_int & uint64_t{0xFF000000}) << 8) |
-          ((host_int & uint64_t{0xFF00000000}) >> 8) |
-          ((host_int & uint64_t{0xFF0000000000}) >> 24) |
-          ((host_int & uint64_t{0xFF000000000000}) >> 40) |
-          ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+  return (((x & uint64_t{0xFF}) << 56) |
+          ((x & uint64_t{0xFF00}) << 40) |
+          ((x & uint64_t{0xFF0000}) << 24) |
+          ((x & uint64_t{0xFF000000}) << 8) |
+          ((x & uint64_t{0xFF00000000}) >> 8) |
+          ((x & uint64_t{0xFF0000000000}) >> 24) |
+          ((x & uint64_t{0xFF000000000000}) >> 40) |
+          ((x & uint64_t{0xFF00000000000000}) >> 56));
 #endif
 }
 
-inline uint32_t gbswap_32(uint32_t host_int) {
+constexpr uint32_t gbswap_32(uint32_t x) {
 #if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
-  return __builtin_bswap32(host_int);
-#elif defined(_MSC_VER)
-  return _byteswap_ulong(host_int);
+  return __builtin_bswap32(x);
 #else
-  return (((host_int & uint32_t{0xFF}) << 24) |
-          ((host_int & uint32_t{0xFF00}) << 8) |
-          ((host_int & uint32_t{0xFF0000}) >> 8) |
-          ((host_int & uint32_t{0xFF000000}) >> 24));
+  return (((x & uint32_t{0xFF}) << 24) |
+          ((x & uint32_t{0xFF00}) << 8) |
+          ((x & uint32_t{0xFF0000}) >> 8) |
+          ((x & uint32_t{0xFF000000}) >> 24));
 #endif
 }
 
-inline uint16_t gbswap_16(uint16_t host_int) {
+constexpr uint16_t gbswap_16(uint16_t x) {
 #if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
-  return __builtin_bswap16(host_int);
-#elif defined(_MSC_VER)
-  return _byteswap_ushort(host_int);
+  return __builtin_bswap16(x);
 #else
-  return (((host_int & uint16_t{0xFF}) << 8) |
-          ((host_int & uint16_t{0xFF00}) >> 8));
+  return (((x & uint16_t{0xFF}) << 8) |
+          ((x & uint16_t{0xFF00}) >> 8));
 #endif
 }
 
@@ -161,27 +157,27 @@ inline int64_t ToHost(int64_t x) {
 }
 
 // Functions to do unaligned loads and stores in little-endian order.
-inline uint16_t Load16(absl::Nonnull<const void *> p) {
+inline uint16_t Load16(const void* absl_nonnull p) {
   return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
 }
 
-inline void Store16(absl::Nonnull<void *> p, uint16_t v) {
+inline void Store16(void* absl_nonnull p, uint16_t v) {
   ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
 }
 
-inline uint32_t Load32(absl::Nonnull<const void *> p) {
+inline uint32_t Load32(const void* absl_nonnull p) {
   return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
 }
 
-inline void Store32(absl::Nonnull<void *> p, uint32_t v) {
+inline void Store32(void* absl_nonnull p, uint32_t v) {
   ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
 }
 
-inline uint64_t Load64(absl::Nonnull<const void *> p) {
+inline uint64_t Load64(const void* absl_nonnull p) {
   return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
 }
 
-inline void Store64(absl::Nonnull<void *> p, uint64_t v) {
+inline void Store64(void* absl_nonnull p, uint64_t v) {
   ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
 }
 
@@ -251,27 +247,27 @@ inline int64_t ToHost(int64_t x) {
 }
 
 // Functions to do unaligned loads and stores in big-endian order.
-inline uint16_t Load16(absl::Nonnull<const void *> p) {
+inline uint16_t Load16(const void* absl_nonnull p) {
   return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
 }
 
-inline void Store16(absl::Nonnull<void *> p, uint16_t v) {
+inline void Store16(void* absl_nonnull p, uint16_t v) {
   ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
 }
 
-inline uint32_t Load32(absl::Nonnull<const void *> p) {
+inline uint32_t Load32(const void* absl_nonnull p) {
   return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
 }
 
-inline void Store32(absl::Nonnull<void *>p, uint32_t v) {
+inline void Store32(void* absl_nonnull p, uint32_t v) {
   ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
 }
 
-inline uint64_t Load64(absl::Nonnull<const void *> p) {
+inline uint64_t Load64(const void* absl_nonnull p) {
   return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
 }
 
-inline void Store64(absl::Nonnull<void *> p, uint64_t v) {
+inline void Store64(void* absl_nonnull p, uint64_t v) {
   ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
 }