re2 1.24.0 → 1.25.0

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

@@ -0,0 +1,168 @@
+// Copyright 2026 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/hardening.h"
+
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/macros.h"
+#include "absl/base/options.h"
+
+namespace {
+
+bool IsHardened() {
+  bool hardened = false;
+  ABSL_HARDENING_ASSERT([&hardened]() {
+      hardened = true;
+      return true;
+    }()
+  );
+  return hardened;
+}
+
+bool IsHardenedSlow() {
+  bool hardened = false;
+  ABSL_HARDENING_ASSERT_SLOW([&hardened]() {
+      hardened = true;
+      return true;
+    }()
+  );
+  return hardened;
+}
+
+TEST(HardeningTest, HardeningAssertSlow) {
+  absl::base_internal::HardeningAssertSlow(true);
+  if (!IsHardenedSlow()) {
+    absl::base_internal::HardeningAssertSlow(false);
+  }
+}
+
+TEST(HardeningDeathTest, HardeningAssertSlow) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardenedSlow()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    EXPECT_DEATH(absl::base_internal::HardeningAssertSlow(false), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertGT) {
+  absl::base_internal::HardeningAssertGT(1, 0);
+}
+
+TEST(HardeningDeathTest, HardeningAssertGT) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    EXPECT_DEATH(absl::base_internal::HardeningAssertGT(1, 1), "");
+    EXPECT_DEATH(absl::base_internal::HardeningAssertGT(0, 1), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertGE) {
+  absl::base_internal::HardeningAssertGE(1, 0);
+  absl::base_internal::HardeningAssertGE(1, 1);
+}
+
+TEST(HardeningDeathTest, HardeningAssertGE) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    EXPECT_DEATH(absl::base_internal::HardeningAssertGE(0, 1), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertLT) {
+  absl::base_internal::HardeningAssertLT(0, 1);
+}
+
+TEST(HardeningDeathTest, HardeningAssertLT) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    EXPECT_DEATH(absl::base_internal::HardeningAssertLT(1, 1), "");
+    EXPECT_DEATH(absl::base_internal::HardeningAssertLT(1, 0), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertLE) {
+  absl::base_internal::HardeningAssertLE(0, 1);
+  absl::base_internal::HardeningAssertLE(1, 1);
+}
+
+TEST(HardeningDeathTest, HardeningAssertLE) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    EXPECT_DEATH(absl::base_internal::HardeningAssertLE(1, 0), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertInBounds) {
+  absl::base_internal::HardeningAssertInBounds(0, 10);
+}
+
+TEST(HardeningDeathTest, HardeningAssertInBounds) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    EXPECT_DEATH(absl::base_internal::HardeningAssertInBounds(10, 10), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertNonEmpty) {
+  std::vector<int> v = {1};
+  absl::base_internal::HardeningAssertNonEmpty(v);
+}
+
+TEST(HardeningDeathTest, HardeningAssertNonEmpty) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    std::vector<int> v = {};
+    EXPECT_DEATH(absl::base_internal::HardeningAssertNonEmpty(v), "");
+  }
+#endif
+}
+
+TEST(HardeningTest, HardeningAssertNonNull) {
+  int x = 1;
+  absl::base_internal::HardeningAssertNonNull(&x);
+}
+
+TEST(HardeningDeathTest, HardeningAssertNonNull) {
+#if GTEST_HAS_DEATH_TEST
+  if (IsHardened()) {
+    // The underlying mechanism of termination varies, and may include SIGILL
+    // or SIGABRT.
+    int *x = nullptr;
+    EXPECT_DEATH(absl::base_internal::HardeningAssertNonNull(x), "");
+  }
+#endif
+}
+
+}  // namespace

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

@@ -37,7 +37,7 @@ struct IteratorCategory {};
 template <typename Iterator>
 struct IteratorCategory<
     Iterator,
-    absl::void_t<typename std::iterator_traits<Iterator>::iterator_category>> {
+    std::void_t<typename std::iterator_traits<Iterator>::iterator_category>> {
   using type = typename std::iterator_traits<Iterator>::iterator_category;
 };
 
@@ -47,7 +47,7 @@ struct IteratorConceptImpl : IteratorCategory<Iterator> {};
 template <typename Iterator>
 struct IteratorConceptImpl<
     Iterator,
-    absl::void_t<typename std::iterator_traits<Iterator>::iterator_concept>> {
+    std::void_t<typename std::iterator_traits<Iterator>::iterator_concept>> {
   using type = typename std::iterator_traits<Iterator>::iterator_concept;
 };
 

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

@@ -47,6 +47,12 @@
 
 #ifdef __linux__
 #include <sys/prctl.h>
+#ifndef PR_SET_VMA
+#define PR_SET_VMA 0x53564d41
+#endif
+#ifndef PR_SET_VMA_ANON_NAME
+#define PR_SET_VMA_ANON_NAME 0
+#endif
 #endif
 
 #include <string.h>

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

@@ -18,8 +18,11 @@
 #ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 #define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 
+#include <atomic>
+
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/thread_identity.h"
 #include "absl/base/macros.h"
 
 // The following two declarations exist so SchedulingGuard may friend them with
@@ -64,7 +67,6 @@ class SchedulingGuard {
   SchedulingGuard(const SchedulingGuard&) = delete;
   SchedulingGuard& operator=(const SchedulingGuard&) = delete;
 
- private:
   // Disable cooperative rescheduling of the calling thread.  It may still
   // initiate scheduling operations (e.g. wake-ups), however, it may not itself
   // reschedule.  Nestable.  The returned result is opaque, clients should not
@@ -96,13 +98,6 @@ class SchedulingGuard {
    private:
     int scheduling_disabled_depth_;
   };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class absl::CondVar;
-  friend class absl::Mutex;
-  friend class SchedulingHelper;
-  friend class SpinLock;
-  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
 };
 
 //------------------------------------------------------------------------------
@@ -110,21 +105,88 @@ class SchedulingGuard {
 //------------------------------------------------------------------------------
 
 inline bool SchedulingGuard::ReschedulingIsAllowed() {
-  return false;
+  ThreadIdentity* identity = CurrentThreadIdentityIfPresent();
+  if (identity != nullptr) {
+    ThreadIdentity::SchedulerState* state = &identity->scheduler_state;
+    // For a thread to be eligible for re-scheduling it must have a bound
+    // schedulable (otherwise it's not cooperative) and not be within a
+    // SchedulerGuard region.
+    return state->bound_schedulable.load(std::memory_order_relaxed) !=
+               nullptr &&
+           state->scheduling_disabled_depth.load(std::memory_order_relaxed) ==
+               0;
+  } else {
+    // Cooperative threads always have a ThreadIdentity.
+    return false;
+  }
 }
 
+// We don't use [[nodiscard]] here as some clients (e.g.
+// FinishPotentiallyBlockingRegion()) cannot yet properly consume it.
 inline bool SchedulingGuard::DisableRescheduling() {
-  return false;
+  ThreadIdentity* identity;
+  identity = CurrentThreadIdentityIfPresent();
+  if (identity != nullptr) {
+    // The depth is accessed concurrently from other threads, so it must be
+    // atomic, but it's only mutated from this thread, so we don't need an
+    // atomic increment.
+    int old_val = identity->scheduler_state.scheduling_disabled_depth.load(
+        std::memory_order_relaxed);
+    identity->scheduler_state.scheduling_disabled_depth.store(
+        old_val + 1, std::memory_order_relaxed);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+inline void SchedulingGuard::EnableRescheduling(bool disable_result) {
+  if (!disable_result) {
+    // There was no installed thread identity at the time that scheduling was
+    // disabled, so we have nothing to do.  This is an implementation detail
+    // that may change in the future, clients may not depend on it.
+    // EnableRescheduling() must always be called.
+    return;
+  }
+
+  ThreadIdentity* identity;
+  // A thread identity exists, see above
+  identity = CurrentThreadIdentityIfPresent();
+  // The depth is accessed concurrently from other threads, so it must be
+  // atomic, but it's only mutated from this thread, so we don't need an atomic
+  // decrement.
+  int old_val = identity->scheduler_state.scheduling_disabled_depth.load(
+      std::memory_order_relaxed);
+  identity->scheduler_state.scheduling_disabled_depth.store(
+      old_val - 1, std::memory_order_relaxed);
 }
 
-inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
-  return;
+inline SchedulingGuard::ScopedEnable::ScopedEnable() {
+  ThreadIdentity* identity;
+  identity = CurrentThreadIdentityIfPresent();
+  if (identity != nullptr) {
+    scheduling_disabled_depth_ =
+        identity->scheduler_state.scheduling_disabled_depth.load(
+            std::memory_order_relaxed);
+    if (scheduling_disabled_depth_ != 0) {
+      // The store below does not need to be compare_exchange because
+      // the value is never modified concurrently (only accessed).
+      identity->scheduler_state.scheduling_disabled_depth.store(
+          0, std::memory_order_relaxed);
+    }
+  } else {
+    scheduling_disabled_depth_ = 0;
+  }
 }
 
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
 inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
+  if (scheduling_disabled_depth_ == 0) {
+    return;
+  }
+  ThreadIdentity* identity = CurrentThreadIdentityIfPresent();
+  // itentity is guaranteed to exist, see the constructor above.
+  identity->scheduler_state.scheduling_disabled_depth.store(
+      scheduling_disabled_depth_, std::memory_order_relaxed);
 }
 
 }  // namespace base_internal

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

@@ -244,8 +244,7 @@ static int64_t ReadMonotonicClockNanos() {
   int rc = clock_gettime(CLOCK_MONOTONIC, &t);
 #endif
   if (rc != 0) {
-    ABSL_INTERNAL_LOG(
-        FATAL, "clock_gettime() failed: (" + std::to_string(errno) + ")");
+    ABSL_RAW_LOG(FATAL, "clock_gettime() failed: (%d)", errno);
   }
   return int64_t{t.tv_sec} * 1000000000 + t.tv_nsec;
 }

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

@@ -146,6 +146,54 @@ struct ThreadIdentity {
   // ThreadIdentity itself.
   PerThreadSynch per_thread_synch;
 
+  struct SchedulerState {
+    std::atomic<void*> bound_schedulable{nullptr};
+    // Storage space for a SpinLock, which is created through a placement new to
+    // break a dependency cycle.
+    uint32_t association_lock_word;
+    std::atomic<int> scheduling_disabled_depth;
+    int potentially_blocking_depth;
+    uint32_t schedule_next_state;
+
+    // When true, current thread is unlocking a mutex and actively waking a
+    // thread that was previously waiting, but that lock has yet more waiters.
+    // Used to signal to schedulers that work being woken should get an
+    // elevated priority.
+    bool waking_designated_waker;
+
+    inline SpinLock* association_lock() {
+      return reinterpret_cast<SpinLock*>(&association_lock_word);
+    }
+  } scheduler_state;  // Private: Reserved for use in Gloop
+
+  // For worker threads that may not be doing any interesting user work, this
+  // tracks the current state of the worker. This is used to handle those
+  // threads differently e.g. when printing stacktraces.
+  //
+  // It should only be written to by the thread itself.
+  //
+  // Note that this is different from the mutex idle bit - threads running user
+  // work can be waiting but still be active.
+  //
+  // Note: not all parts of the code-base may maintain this field correctly and
+  // therefore this field should only be used to improve debugging/monitoring.
+  //
+  // Put it here to reuse some of the padding space.
+  enum class WaitState : uint8_t {
+    kActive = 0,
+    kWaitingForWork = 1,
+  };
+  std::atomic<WaitState> wait_state;
+  static_assert(std::atomic<WaitState>::is_always_lock_free);
+
+  // Add a padding such that scheduler_state is on a different cache line than
+  // waiter state.  We use padding here, so that the size of the structure does
+  // not substantially grow due to the added padding.
+  static constexpr size_t kToBePaddedSize =
+      sizeof(SchedulerState) + sizeof(std::atomic<WaitState>);
+  static_assert(ABSL_CACHELINE_SIZE >= kToBePaddedSize);
+  char padding[ABSL_CACHELINE_SIZE - kToBePaddedSize];
+
   // Private: Reserved for absl::synchronization_internal::Waiter.
   struct WaiterState {
     alignas(void*) char data[256];
@@ -161,6 +209,10 @@ struct ThreadIdentity {
   std::atomic<int> wait_start;  // Ticker value when thread started waiting.
   std::atomic<bool> is_idle;    // Has thread become idle yet?
 
+  // For tracking depth of __cxa_guard_acquire.  This used to recognize heap
+  // allocations for function static objects.
+  int static_initialization_depth;
+
   ThreadIdentity* next;
 };
 

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

@@ -47,6 +47,10 @@
 
 #if ABSL_USE_UNSCALED_CYCLECLOCK
 
+namespace gloop_do_not_use {
+class UnscaledCycleClockWrapperForPerCpuTest;
+}  // namespace gloop_do_not_use
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace time_internal {
@@ -75,6 +79,7 @@ class UnscaledCycleClock {
   friend class base_internal::CycleClock;
   friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
   friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
+  friend class gloop_do_not_use::UnscaledCycleClockWrapperForPerCpuTest;
 };
 
 #if defined(__x86_64__)

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

@@ -53,9 +53,40 @@ namespace macros_internal {
 template <typename T, size_t N>
 auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
 }  // namespace macros_internal
+
+namespace base_internal {
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::nomerge)
+[[clang::nomerge]]  // Needed when this function is not inlined
+#endif
+[[noreturn]] inline void HardeningAbort() {
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::nomerge)
+  [[clang::nomerge]]  // Needed when this function is inlined
+#endif
+  ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL();
+  ABSL_INTERNAL_UNREACHABLE_IMPL();
+}
+}  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
+// ABSL_INTERNAL_UNEVALUATED()
+//
+// Expands into a no-op expression that contains the given expression. Used to
+// avoid unused-variable warnings in configurations that don't need to evaluate
+// the given expression (e.g., NDEBUG).
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+// We use `decltype` here to avoid generating unnecessary code that the
+// optimizer then has to optimize away.
+// This not only improves compilation performance by reducing codegen bloat
+// and optimization work, but also guarantees fast run-time performance without
+// having to rely on the optimizer.
+#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())
+#else
+// Pre-C++20, lambdas can't be inside unevaluated operands, so we're forced to
+// rely on the optimizer.
+#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
+#endif
+
 // ABSL_BAD_CALL_IF()
 //
 // Used on a function overload to trap bad calls: any call that matches the
@@ -93,33 +124,18 @@ ABSL_NAMESPACE_END
 // This macro is inspired by
 // https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
 #if defined(NDEBUG)
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
-// We use `decltype` here to avoid generating unnecessary code that the
-// optimizer then has to optimize away.
-// This not only improves compilation performance by reducing codegen bloat
-// and optimization work, but also guarantees fast run-time performance without
-// having to rely on the optimizer.
-#define ABSL_ASSERT(expr) (decltype((expr) ? void() : void())())
-#else
-// Pre-C++20, lambdas can't be inside unevaluated operands, so we're forced to
-// rely on the optimizer.
-#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
-#endif
+#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
 #else
 #define ABSL_ASSERT(expr)                           \
   (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
-                             : [] { assert(false && #expr); }())  // NOLINT
+                             : assert(false && #expr))  // NOLINT
 #endif
 
 // `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
 // aborts the program in release mode (when NDEBUG is defined). The
 // implementation should abort the program as quickly as possible and ideally it
 // should not be possible to ignore the abort request.
-#define ABSL_INTERNAL_HARDENING_ABORT()   \
-  do {                                    \
-    ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL(); \
-    ABSL_INTERNAL_UNREACHABLE_IMPL();     \
-  } while (false)
+#define ABSL_INTERNAL_HARDENING_ABORT() ::absl::base_internal::HardeningAbort()
 
 // ABSL_HARDENING_ASSERT()
 //
@@ -135,7 +151,7 @@ ABSL_NAMESPACE_END
 #if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
 #define ABSL_HARDENING_ASSERT(expr)                 \
   (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
-                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
+                             : ABSL_INTERNAL_HARDENING_ABORT())
 #else
 #define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
 #endif
@@ -154,7 +170,7 @@ ABSL_NAMESPACE_END
 #if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
 #define ABSL_HARDENING_ASSERT_SLOW(expr)            \
   (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
-                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
+                             : ABSL_INTERNAL_HARDENING_ABORT())
 #else
 #define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
 #endif

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

@@ -95,7 +95,7 @@
 // // describes is preferred, unless inconsistent with surrounding code.
 // absl_nonnull std::unique_ptr<Employee> employee;
 //
-// // Invalid annotation usage – this attempts to declare a pointer to a
+// // Invalid annotation usage - this attempts to declare a pointer to a
 // // nullable `Employee`, which is meaningless.
 // absl_nullable Employee* e;
 //
@@ -130,7 +130,7 @@
 //
 // // CompleteTransaction() guarantees the returned pointer to an `Account` to
 // // be non-null.
-// Account* absl_nonnull balance CompleteTransaction(double fee) {
+// Account* absl_nonnull CompleteTransaction(double fee) {
 // ...
 // }
 //
@@ -180,6 +180,7 @@
 // `absl_nonnull` is *not guaranteed* to be non-null, and the compiler won't
 // alert or prevent assignment of a `T* absl_nullable` to a `T* absl_nonnull`.
 // ===========================================================================
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
 #ifndef ABSL_BASE_NULLABILITY_H_
 #define ABSL_BASE_NULLABILITY_H_
 
@@ -203,7 +204,7 @@
 //     T* absl_nullable GetNullablePtr();           // explicitly nullable
 //     T* absl_nullability_unknown GetUnknownPtr();  // explicitly unknown
 //
-// The macro can be safely used in header files – it will not affect any files
+// The macro can be safely used in header files - it will not affect any files
 // that include it.
 //
 // In files with the macro, plain `T*` syntax means `T* absl_nonnull`, and the

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

@@ -31,6 +31,7 @@
 #define ABSL_BASE_OPTIMIZATION_H_
 
 #include <assert.h>
+#include <stdlib.h>
 
 #ifdef __cplusplus
 // Included for std::unreachable()
@@ -217,12 +218,12 @@
 #elif defined(_MSC_VER)
 #define ABSL_INTERNAL_UNREACHABLE_IMPL() __assume(false)
 #else
-#define ABSL_INTERNAL_UNREACHABLE_IMPL()
+#define ABSL_INTERNAL_UNREACHABLE_IMPL() ((void)0)
 #endif
 
 // `ABSL_UNREACHABLE()` is an unreachable statement.  A program which reaches
 // one has undefined behavior, and the compiler may optimize accordingly.
-#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
 // Abort in hardened mode to avoid dangerous undefined behavior.
 #define ABSL_UNREACHABLE()                \
   do {                                    \

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

@@ -14,8 +14,9 @@
 
 #include "absl/base/optimization.h"
 
+#include <optional>
+
 #include "gtest/gtest.h"
-#include "absl/types/optional.h"
 
 namespace {
 
@@ -80,8 +81,8 @@ TEST(PredictTest, Pointer) {
 
 TEST(PredictTest, Optional) {
   // Note: An optional's truth value is the value's existence, not its truth.
-  absl::optional<bool> has_value(false);
-  absl::optional<bool> no_value;
+  std::optional<bool> has_value(false);
+  std::optional<bool> no_value;
   EXPECT_TRUE(ABSL_PREDICT_TRUE(has_value));
   EXPECT_FALSE(ABSL_PREDICT_TRUE(no_value));
   EXPECT_TRUE(ABSL_PREDICT_FALSE(has_value));

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

@@ -73,6 +73,34 @@
 // Type Compatibility Options
 // -----------------------------------------------------------------------------
 
+// ABSL_OPTION_USE_STD_SOURCE_LOCATION
+//
+// This option controls whether absl::SourceLocation is implemented as an alias
+// to the std::source_location type, or as an independent implementation.
+//
+// A value of 0 means to use Abseil's implementation.  This requires only C++17
+// support, and is expected to run on every toolchain we support, and to
+// properly capture source location information on every toolchain that supports
+// the necessary built-ins (such as `__builtin_LINE`).
+//
+// A value of 1 means to use aliases.  This requires that all code using Abseil
+// is built in C++20 mode or later.
+//
+// A value of 2 means to detect the C++ version being used to compile Abseil,
+// and use an alias only if working std::source_location types are available.
+// This option is useful when you are building your program from source.  It
+// should not be used otherwise -- for example, if you are distributing Abseil
+// in a binary package manager -- since in mode 2, they will name different
+// types, with different mangled names and binary layout, depending on the
+// compiler flags passed by the end user.  For more info, see
+// https://abseil.io/about/design/dropin-types.
+//
+// User code should not inspect this macro.  To check in the preprocessor if
+// the source location type is an alias of std::source_location type, use the
+// feature macro ABSL_USES_STD_SOURCE_LOCATION.
+//
+#define ABSL_OPTION_USE_STD_SOURCE_LOCATION 2
+
 // ABSL_OPTION_USE_STD_ORDERING
 //
 // This option controls whether absl::{partial,weak,strong}_ordering are
@@ -123,7 +151,7 @@
 // allowed.
 
 #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20260107
+#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20260526
 
 // ABSL_OPTION_HARDENED
 //
@@ -155,4 +183,30 @@
 
 #define ABSL_OPTION_HARDENED 0
 
+// ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY
+//
+// This option controls whether Abseil is allowed to use non-portable
+// hardware-accelerated implementations in headers (where they are typically
+// inlined into the caller's translation unit).
+//
+// Using such optimizations in headers can lead to One Definition Rule (ODR)
+// violations if different translation units are built with different CPU
+// architecture flags (e.g., -march=native vs -march=generic) and linked
+// together.
+//
+// A value of 0 means to use the portable software implementation in headers.
+// This provides the best ODR guarantees when linking code built with
+// inconsistent flags, but may be slower.
+//
+// A value of 1 means that the implementation requires the use of a
+// hardware-accelerated implementation. This requires the compiler environment
+// to support these instructions; otherwise, the build will fail.
+//
+// A value of 2 means to select the best available implementation based on
+// the compiler flags, but can't guarantee ODR safety if translation units are
+// built with inconsistent flags.
+//
+// User code should not inspect this macro.
+#define ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY 0
+
 #endif  // ABSL_BASE_OPTIONS_H_