re2 1.22.2 → 1.23.0

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

@@ -19,7 +19,7 @@
 //   - for use by Abseil internal code that Mutex itself depends on
 //   - for async signal safety (see below)
 
-// SpinLock with a base_internal::SchedulingMode::SCHEDULE_KERNEL_ONLY is async
+// SpinLock with a SchedulingMode::SCHEDULE_KERNEL_ONLY is async
 // signal safe. If a spinlock is used within a signal handler, all code that
 // acquires the lock must ensure that the signal cannot arrive while they are
 // holding the lock. Typically, this is done by blocking the signal.
@@ -31,14 +31,16 @@
 
 #include <atomic>
 #include <cstdint>
+#include <type_traits>
 
 #include "absl/base/attributes.h"
+#include "absl/base/config.h"
 #include "absl/base/const_init.h"
-#include "absl/base/dynamic_annotations.h"
 #include "absl/base/internal/low_level_scheduling.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/scheduling_mode.h"
 #include "absl/base/internal/tsan_mutex_interface.h"
+#include "absl/base/macros.h"
 #include "absl/base/thread_annotations.h"
 
 namespace tcmalloc {
@@ -55,17 +57,31 @@ namespace base_internal {
 
 class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
  public:
-  SpinLock() : lockword_(kSpinLockCooperative) {
-    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-  }
+  constexpr SpinLock() : lockword_(kSpinLockCooperative) { RegisterWithTsan(); }
 
   // Constructors that allow non-cooperative spinlocks to be created for use
   // inside thread schedulers.  Normal clients should not use these.
-  explicit SpinLock(base_internal::SchedulingMode mode);
+  constexpr explicit SpinLock(SchedulingMode mode)
+      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
+    RegisterWithTsan();
+  }
+
+#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(_WIN32)
+  // Constructor to inline users of the default scheduling mode.
+  //
+  // This only needs to exists for inliner runs, but doesn't work correctly in
+  // clang+windows builds, likely due to mangling differences.
+  ABSL_DEPRECATE_AND_INLINE()
+  constexpr explicit SpinLock(SchedulingMode mode)
+      __attribute__((enable_if(mode == SCHEDULE_COOPERATIVE_AND_KERNEL,
+                               "Cooperative use default constructor")))
+      : SpinLock() {}
+#endif
 
   // Constructor for global SpinLock instances.  See absl/base/const_init.h.
-  constexpr SpinLock(absl::ConstInitType, base_internal::SchedulingMode mode)
-      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {}
+  ABSL_DEPRECATE_AND_INLINE()
+  constexpr SpinLock(absl::ConstInitType, SchedulingMode mode)
+      : SpinLock(mode) {}
 
   // For global SpinLock instances prefer trivial destructor when possible.
   // Default but non-trivial destructor in some build configurations causes an
@@ -77,7 +93,7 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
 #endif
 
   // Acquire this SpinLock.
-  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+  inline void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
     ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
     if (!TryLockImpl()) {
       SlowLock();
@@ -85,12 +101,14 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
     ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
   }
 
+  ABSL_DEPRECATE_AND_INLINE()
+  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { return lock(); }
+
   // Try to acquire this SpinLock without blocking and return true if the
   // acquisition was successful.  If the lock was not acquired, false is
-  // returned.  If this SpinLock is free at the time of the call, TryLock
-  // will return true with high probability.
-  ABSL_MUST_USE_RESULT inline bool TryLock()
-      ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+  // returned.  If this SpinLock is free at the time of the call, try_lock will
+  // return true with high probability.
+  [[nodiscard]] inline bool try_lock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
     ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
     bool res = TryLockImpl();
     ABSL_TSAN_MUTEX_POST_LOCK(
@@ -99,15 +117,20 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
     return res;
   }
 
+  ABSL_DEPRECATE_AND_INLINE()
+  [[nodiscard]] inline bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    return try_lock();
+  }
+
   // Release this SpinLock, which must be held by the calling thread.
-  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
+  inline void unlock() ABSL_UNLOCK_FUNCTION() {
     ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
     uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
     lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
                                     std::memory_order_release);
 
     if ((lock_value & kSpinLockDisabledScheduling) != 0) {
-      base_internal::SchedulingGuard::EnableRescheduling(true);
+      SchedulingGuard::EnableRescheduling(true);
     }
     if ((lock_value & kWaitTimeMask) != 0) {
       // Collect contentionz profile info, and speed the wakeup of any waiter.
@@ -118,10 +141,13 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
     ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
   }
 
+  ABSL_DEPRECATE_AND_INLINE()
+  inline void Unlock() ABSL_UNLOCK_FUNCTION() { unlock(); }
+
   // Determine if the lock is held.  When the lock is held by the invoking
   // thread, true will always be returned. Intended to be used as
   // CHECK(lock.IsHeld()).
-  ABSL_MUST_USE_RESULT inline bool IsHeld() const {
+  [[nodiscard]] inline bool IsHeld() const {
     return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
   }
 
@@ -176,9 +202,16 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
       ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
 
   // Returns true if the provided scheduling mode is cooperative.
-  static constexpr bool IsCooperative(
-      base_internal::SchedulingMode scheduling_mode) {
-    return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+  static constexpr bool IsCooperative(SchedulingMode scheduling_mode) {
+    return scheduling_mode == SCHEDULE_COOPERATIVE_AND_KERNEL;
+  }
+
+  constexpr void RegisterWithTsan() {
+#if ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
+    if (!__builtin_is_constant_evaluated()) {
+      ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+    }
+#endif
   }
 
   bool IsCooperative() const {
@@ -203,28 +236,25 @@ class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
 
 // Corresponding locker object that arranges to acquire a spinlock for
 // the duration of a C++ scope.
-//
-// TODO(b/176172494): Use only [[nodiscard]] when baseline is raised.
-// TODO(b/6695610): Remove forward declaration when #ifdef is no longer needed.
-#if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
-class [[nodiscard]] SpinLockHolder;
-#else
-class ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_TRIVIAL_ABI SpinLockHolder;
-#endif
-
-class ABSL_SCOPED_LOCKABLE SpinLockHolder {
+class ABSL_SCOPED_LOCKABLE [[nodiscard]] SpinLockHolder {
  public:
-  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
+  inline explicit SpinLockHolder(
+      SpinLock& l ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this))
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
       : lock_(l) {
-    l->Lock();
+    l.lock();
   }
-  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
+  ABSL_DEPRECATE_AND_INLINE()
+  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
+      : SpinLockHolder(*l) {}
+
+  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_.unlock(); }
 
   SpinLockHolder(const SpinLockHolder&) = delete;
   SpinLockHolder& operator=(const SpinLockHolder&) = delete;
 
  private:
-  SpinLock* lock_;
+  SpinLock& lock_;
 };
 
 // Register a hook for profiling support.
@@ -253,7 +283,7 @@ inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
   if ((lock_value & kSpinLockCooperative) == 0) {
     // For non-cooperative locks we must make sure we mark ourselves as
     // non-reschedulable before we attempt to CompareAndSwap.
-    if (base_internal::SchedulingGuard::DisableRescheduling()) {
+    if (SchedulingGuard::DisableRescheduling()) {
       sched_disabled_bit = kSpinLockDisabledScheduling;
     }
   }
@@ -262,7 +292,7 @@ inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
           lock_value,
           kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
           std::memory_order_acquire, std::memory_order_relaxed)) {
-    base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
+    SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
   }
 
   return lock_value;

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

@@ -35,7 +35,7 @@ static void BM_TryLock(benchmark::State& state) {
   static absl::NoDestructor<absl::base_internal::SpinLock> spinlock(
       scheduling_mode);
   for (auto _ : state) {
-    if (spinlock->TryLock()) spinlock->Unlock();
+    if (spinlock->try_lock()) spinlock->unlock();
   }
 }
 
@@ -50,7 +50,7 @@ static void BM_SpinLock(benchmark::State& state) {
   static absl::NoDestructor<absl::base_internal::SpinLock> spinlock(
       scheduling_mode);
   for (auto _ : state) {
-    absl::base_internal::SpinLockHolder holder(spinlock.get());
+    absl::base_internal::SpinLockHolder holder(*spinlock.get());
   }
 }
 

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

@@ -41,7 +41,7 @@ TEST(SysinfoTest, GetTID) {
   EXPECT_EQ(GetTID(), GetTID());  // Basic compile and equality test.
 #ifdef __native_client__
   // Native Client has a race condition bug that leads to memory
-  // exaustion when repeatedly creating and joining threads.
+  // exhaustion when repeatedly creating and joining threads.
   // https://bugs.chromium.org/p/nativeclient/issues/detail?id=1027
   return;
 #endif
@@ -59,7 +59,7 @@ TEST(SysinfoTest, GetTID) {
       threads.push_back(std::thread([&]() {
         pid_t id = GetTID();
         {
-          MutexLock lock(&mutex);
+          MutexLock lock(mutex);
           ASSERT_TRUE(tids.find(id) == tids.end());
           tids.insert(id);
         }

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

@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "benchmark/benchmark.h"
 #include "absl/base/internal/thread_identity.h"
 #include "absl/synchronization/internal/create_thread_identity.h"
 #include "absl/synchronization/internal/per_thread_sem.h"
+#include "benchmark/benchmark.h"
 
 namespace {
 

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

@@ -31,7 +31,7 @@ namespace base_internal {
 namespace {
 
 ABSL_CONST_INIT static absl::base_internal::SpinLock map_lock(
-    absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+    base_internal::SCHEDULE_KERNEL_ONLY);
 ABSL_CONST_INIT static int num_identities_reused ABSL_GUARDED_BY(map_lock);
 
 static const void* const kCheckNoIdentity = reinterpret_cast<void*>(1);
@@ -58,7 +58,7 @@ static void TestThreadIdentityCurrent(const void* assert_no_identity) {
                    PerThreadSynch::kAlignment);
   EXPECT_EQ(identity, identity->per_thread_synch.thread_identity());
 
-  absl::base_internal::SpinLockHolder l(&map_lock);
+  absl::base_internal::SpinLockHolder l(map_lock);
   num_identities_reused++;
 }
 
@@ -90,7 +90,7 @@ TEST(ThreadIdentityTest, BasicIdentityWorksThreaded) {
   // We should have recycled ThreadIdentity objects above; while (external)
   // library threads allocating their own identities may preclude some
   // reuse, we should have sufficient repetitions to exclude this.
-  absl::base_internal::SpinLockHolder l(&map_lock);
+  absl::base_internal::SpinLockHolder l(map_lock);
   EXPECT_LT(kNumThreads, num_identities_reused);
 }
 
@@ -112,7 +112,7 @@ TEST(ThreadIdentityTest, ReusedThreadIdentityMutexTest) {
       threads.push_back(std::thread([&]() {
         for (int l = 0; l < kNumLockLoops; ++l) {
           for (int m = 0; m < kNumMutexes; ++m) {
-            MutexLock lock(&mutexes[m]);
+            MutexLock lock(mutexes[m]);
           }
         }
       }));

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

@@ -36,33 +36,33 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-inline uint16_t UnalignedLoad16(absl::Nonnull<const void *> p) {
+inline uint16_t UnalignedLoad16(const void* absl_nonnull p) {
   uint16_t t;
   memcpy(&t, p, sizeof t);
   return t;
 }
 
-inline uint32_t UnalignedLoad32(absl::Nonnull<const void *> p) {
+inline uint32_t UnalignedLoad32(const void* absl_nonnull p) {
   uint32_t t;
   memcpy(&t, p, sizeof t);
   return t;
 }
 
-inline uint64_t UnalignedLoad64(absl::Nonnull<const void *> p) {
+inline uint64_t UnalignedLoad64(const void* absl_nonnull p) {
   uint64_t t;
   memcpy(&t, p, sizeof t);
   return t;
 }
 
-inline void UnalignedStore16(absl::Nonnull<void *> p, uint16_t v) {
+inline void UnalignedStore16(void* absl_nonnull p, uint16_t v) {
   memcpy(p, &v, sizeof v);
 }
 
-inline void UnalignedStore32(absl::Nonnull<void *> p, uint32_t v) {
+inline void UnalignedStore32(void* absl_nonnull p, uint32_t v) {
   memcpy(p, &v, sizeof v);
 }
 
-inline void UnalignedStore64(absl::Nonnull<void *> p, uint64_t v) {
+inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   memcpy(p, &v, sizeof v);
 }
 

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

@@ -85,6 +85,10 @@ int64_t UnscaledCycleClock::Now() {
 double UnscaledCycleClock::Frequency() {
 #ifdef __GLIBC__
   return __ppc_get_timebase_freq();
+#elif defined(__linux__)
+  // Fallback for musl + ppc64le: use constant timebase frequency (512 MHz)
+  // Must come after __GLIBC__.
+  return static_cast<double>(512000000);
 #elif defined(_AIX)
   // This is the same constant value as returned by
   // __ppc_get_timebase_freq().

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

@@ -88,9 +88,14 @@ inline int64_t UnscaledCycleClock::Now() {
 #elif defined(__aarch64__)
 
 // System timer of ARMv8 runs at a different frequency than the CPU's.
-// The frequency is fixed, typically in the range 1-50MHz.  It can be
-// read at CNTFRQ special register.  We assume the OS has set up
-// the virtual timer properly.
+//
+// Frequency is fixed. From Armv8.6-A and Armv9.1-A on, the frequency is 1GHz.
+// Pre-Armv8.6-A, the frequency was a system design choice, typically in the
+// range of 1MHz to 50MHz. See also:
+// https://developer.arm.com/documentation/102379/0101/What-is-the-Generic-Timer-
+//
+// It can be read at CNTFRQ special register.  We assume the OS has set up the
+// virtual timer properly.
 inline int64_t UnscaledCycleClock::Now() {
   int64_t virtual_timer_value;
   asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));

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

@@ -135,11 +135,11 @@ class NoDestructor {
   // Pretend to be a smart pointer to T with deep constness.
   // Never returns a null pointer.
   T& operator*() { return *get(); }
-  absl::Nonnull<T*> operator->() { return get(); }
-  absl::Nonnull<T*> get() { return impl_.get(); }
+  T* absl_nonnull operator->() { return get(); }
+  T* absl_nonnull get() { return impl_.get(); }
   const T& operator*() const { return *get(); }
-  absl::Nonnull<const T*> operator->() const { return get(); }
-  absl::Nonnull<const T*> get() const { return impl_.get(); }
+  const T* absl_nonnull operator->() const { return get(); }
+  const T* absl_nonnull get() const { return impl_.get(); }
 
  private:
   class DirectImpl {
@@ -147,8 +147,8 @@ class NoDestructor {
     template <typename... Args>
     explicit constexpr DirectImpl(Args&&... args)
         : value_(std::forward<Args>(args)...) {}
-    absl::Nonnull<const T*> get() const { return &value_; }
-    absl::Nonnull<T*> get() { return &value_; }
+    const T* absl_nonnull get() const { return &value_; }
+    T* absl_nonnull get() { return &value_; }
 
    private:
     T value_;
@@ -160,33 +160,14 @@ class NoDestructor {
     explicit PlacementImpl(Args&&... args) {
       new (&space_) T(std::forward<Args>(args)...);
     }
-    absl::Nonnull<const T*> get() const {
-      return Launder(reinterpret_cast<const T*>(&space_));
+    const T* absl_nonnull get() const {
+      return std::launder(reinterpret_cast<const T*>(&space_));
     }
-    absl::Nonnull<T*> get() { return Launder(reinterpret_cast<T*>(&space_)); }
-
-   private:
-    template <typename P>
-    static absl::Nonnull<P*> Launder(absl::Nonnull<P*> p) {
-#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
-      return std::launder(p);
-#elif ABSL_HAVE_BUILTIN(__builtin_launder)
-      return __builtin_launder(p);
-#else
-      // When `std::launder` or equivalent are not available, we rely on
-      // undefined behavior, which works as intended on Abseil's officially
-      // supported platforms as of Q3 2023.
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
-      return p;
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-#endif
+    T* absl_nonnull get() {
+      return std::launder(reinterpret_cast<T*>(&space_));
     }
 
+   private:
     alignas(T) unsigned char space_[sizeof(T)];
   };
 
@@ -199,12 +180,10 @@ class NoDestructor {
       impl_;
 };
 
-#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
 // Provide 'Class Template Argument Deduction': the type of NoDestructor's T
 // will be the same type as the argument passed to NoDestructor's constructor.
 template <typename T>
 NoDestructor(T) -> NoDestructor<T>;
-#endif  // ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
 
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -196,14 +196,10 @@ TEST(NoDestructorTest, StaticPattern) {
   EXPECT_EQ(0, Int());  // should get zero-initialized
 }
 
-#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-// This would fail to compile if Class Template Argument Deduction was not
-// provided for absl::NoDestructor.
 TEST(NoDestructorTest, ClassTemplateArgumentDeduction) {
   absl::NoDestructor i(1);
   static_assert(std::is_same<decltype(i), absl::NoDestructor<int>>::value,
                 "Expected deduced type to be int.");
 }
-#endif
 
 }  // namespace