re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/strings/internal/cordz_info.cc

@@ -17,7 +17,8 @@
 #include <cstdint>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/spinlock.h"
+#include "absl/base/const_init.h"
+#include "absl/base/no_destructor.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/debugging/stacktrace.h"
 #include "absl/strings/internal/cord_internal.h"
@@ -34,8 +35,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
-ABSL_CONST_INIT CordzInfo::List CordzInfo::global_list_{absl::kConstInit};
-
 namespace {
 
 // CordRepAnalyzer performs the analysis of a cord.
@@ -221,24 +220,32 @@ class CordRepAnalyzer {
 
 }  // namespace
 
+CordzInfo::List* CordzInfo::GlobalList() {
+  static absl::NoDestructor<CordzInfo::List> list;
+  return list.get();
+}
+
 CordzInfo* CordzInfo::Head(const CordzSnapshot& snapshot) {
   ABSL_ASSERT(snapshot.is_snapshot());
 
-  // We can do an 'unsafe' load of 'head', as we are guaranteed that the
-  // instance it points to is kept alive by the provided CordzSnapshot, so we
-  // can simply return the current value using an acquire load.
+  // We obtain the lock here as we must synchronize the first call into the list
+  // with any concurrent 'Untrack()` operation to avoid any read in the list to
+  // reorder before the observation of the thread 'untracking a cord' of the
+  // delete queue being empty or not. After this all next observations are safe
+  // as we have established all subsequent untracks will be queued for delete.
   // We do enforce in DEBUG builds that the 'head' value is present in the
-  // delete queue: ODR violations may lead to 'snapshot' and 'global_list_'
+  // delete queue: ODR violations may lead to 'snapshot' and 'global_list'
   // being in different libraries / modules.
-  CordzInfo* head = global_list_.head.load(std::memory_order_acquire);
-  ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(head));
-  return head;
+  auto global_list = GlobalList();
+  absl::MutexLock l(global_list->mutex);
+  ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(global_list->head));
+  return global_list->head;
 }
 
 CordzInfo* CordzInfo::Next(const CordzSnapshot& snapshot) const {
   ABSL_ASSERT(snapshot.is_snapshot());
 
-  // Similar to the 'Head()' function, we do not need a mutex here.
+  // We do not need a lock here. See also comments in Head().
   CordzInfo* next = ci_next_.load(std::memory_order_acquire);
   ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(this));
   ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(next));
@@ -327,22 +334,21 @@ CordzInfo::~CordzInfo() {
 }
 
 void CordzInfo::Track() {
-  SpinLockHolder l(list_->mutex);
-
-  CordzInfo* const head = list_->head.load(std::memory_order_acquire);
+  absl::MutexLock l(list_->mutex);
+  CordzInfo* const head = list_->head;
   if (head != nullptr) {
     head->ci_prev_.store(this, std::memory_order_release);
   }
   ci_next_.store(head, std::memory_order_release);
-  list_->head.store(this, std::memory_order_release);
+  list_->head = this;
 }
 
 void CordzInfo::Untrack() {
   ODRCheck();
   {
-    SpinLockHolder l(list_->mutex);
+    absl::MutexLock l(list_->mutex);
 
-    CordzInfo* const head = list_->head.load(std::memory_order_acquire);
+    CordzInfo* const head = list_->head;
     CordzInfo* const next = ci_next_.load(std::memory_order_acquire);
     CordzInfo* const prev = ci_prev_.load(std::memory_order_acquire);
 
@@ -356,7 +362,7 @@ void CordzInfo::Untrack() {
       prev->ci_next_.store(next, std::memory_order_release);
     } else {
       ABSL_ASSERT(head == this);
-      list_->head.store(next, std::memory_order_release);
+      list_->head = next;
     }
   }
 

package/vendor/abseil-cpp/absl/strings/internal/cordz_info.h

@@ -20,8 +20,8 @@
 #include <functional>
 
 #include "absl/base/config.h"
+#include "absl/base/const_init.h"
 #include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/spinlock.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cordz_functions.h"
@@ -121,12 +121,10 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   CordzInfo& operator=(const CordzInfo&) = delete;
 
   // Retrieves the oldest existing CordzInfo.
-  static CordzInfo* Head(const CordzSnapshot& snapshot)
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+  static CordzInfo* Head(const CordzSnapshot& snapshot);
 
   // Retrieves the next oldest existing CordzInfo older than 'this' instance.
-  CordzInfo* Next(const CordzSnapshot& snapshot) const
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+  CordzInfo* Next(const CordzSnapshot& snapshot) const;
 
   // Locks this instance for the update identified by `method`.
   // Increases the count for `method` in `update_tracker`.
@@ -185,18 +183,15 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   int64_t sampling_stride() const { return sampling_stride_; }
 
  private:
-  using SpinLock = absl::base_internal::SpinLock;
-  using SpinLockHolder = ::absl::base_internal::SpinLockHolder;
-
   // Global cordz info list. CordzInfo stores a pointer to the global list
   // instance to harden against ODR violations.
   struct List {
-    constexpr explicit List(absl::ConstInitType) {}
-
-    SpinLock mutex;
-    std::atomic<CordzInfo*> head ABSL_GUARDED_BY(mutex){nullptr};
+    absl::Mutex mutex;
+    CordzInfo* head ABSL_GUARDED_BY(mutex){nullptr};
   };
 
+  static List* GlobalList();
+
   static constexpr size_t kMaxStackDepth = 64;
 
   explicit CordzInfo(CordRep* rep, const CordzInfo* src,
@@ -221,7 +216,7 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
 
   void ODRCheck() const {
 #ifndef NDEBUG
-    ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
+    ABSL_RAW_CHECK(list_ == GlobalList(), "ODR violation in Cord");
 #endif
   }
 
@@ -231,12 +226,11 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   static void MaybeTrackCordImpl(InlineData& cord, const InlineData& src,
                                  MethodIdentifier method);
 
-  ABSL_CONST_INIT static List global_list_;
-  List* const list_ = &global_list_;
+  List* const list_ = GlobalList();
 
   // ci_prev_ and ci_next_ require the global list mutex to be held.
   // Unfortunately we can't use thread annotations such that the thread safety
-  // analysis understands that list_ and global_list_ are one and the same.
+  // analysis understands that list_ and GlobalList() are one and the same.
   std::atomic<CordzInfo*> ci_prev_{nullptr};
   std::atomic<CordzInfo*> ci_next_{nullptr};
 

package/vendor/abseil-cpp/absl/strings/internal/escaping.h

@@ -17,7 +17,7 @@
 
 #include <cassert>
 
-#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/resize_and_overwrite.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -42,12 +42,14 @@ void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest,
                           bool do_padding, const char* base64_chars) {
   const size_t calc_escaped_size =
       CalculateBase64EscapedLenInternal(szsrc, do_padding);
-  STLStringResizeUninitialized(dest, calc_escaped_size);
-
-  const size_t escaped_len = Base64EscapeInternal(
-      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
-  assert(calc_escaped_size == escaped_len);
-  dest->erase(escaped_len);
+  StringResizeAndOverwrite(
+      *dest, calc_escaped_size,
+      [src, szsrc, base64_chars, do_padding](char* buf, size_t buf_size) {
+        const size_t escaped_len = Base64EscapeInternal(
+            src, szsrc, buf, buf_size, base64_chars, do_padding);
+        assert(escaped_len == buf_size);
+        return escaped_len;
+      });
 }
 
 }  // namespace strings_internal

package/vendor/abseil-cpp/absl/strings/internal/generic_printer.cc

@@ -0,0 +1,107 @@
+// Copyright 2025 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/strings/internal/generic_printer.h"
+
+#include <cstddef>
+#include <cstdlib>
+#include <ostream>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_format.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal_generic_printer {
+
+// Out-of-line helper for PrintAsStringWithEscaping.
+std::ostream& PrintEscapedString(std::ostream& os, absl::string_view v) {
+  return os << "\"" << absl::CHexEscape(v) << "\"";
+}
+
+// Retuns a string representation of 'v', shortened if possible.
+template <class T, class F>
+std::string TryShorten(T v, F strtox) {
+  std::string printed =
+      absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10 / 2, v);
+  T parsed = strtox(printed.data());
+  if (parsed != v) {
+    printed =
+        absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10 + 1, v);
+  }
+  return printed;
+}
+
+// Out-of-line helpers for floating point values. These don't necessarily
+// ensure that values are precise, but rather that they are wide enough to
+// represent distinct values. go/c++17std/numeric.limits.members.html
+std::ostream& PrintPreciseFP(std::ostream& os, float v) {
+  return os << TryShorten(v, [](const char* buf) {
+           char* unused;
+           return std::strtof(buf, &unused);
+         }) << "f";
+}
+std::ostream& PrintPreciseFP(std::ostream& os, double v) {
+  return os << TryShorten(v, [](const char* buf) {
+           char* unused;
+           return std::strtod(buf, &unused);
+         });
+}
+std::ostream& PrintPreciseFP(std::ostream& os, long double v) {
+  return os << TryShorten(v, [](const char* buf) {
+           char* unused;
+           return std::strtold(buf, &unused);
+         }) << "L";
+}
+
+// Prints a nibble of 'v' in hexadecimal.
+inline char hexnib(int v) {
+  return static_cast<char>((v < 10 ? '0' : ('a' - 10)) + v);
+}
+
+template <typename T>
+static std::ostream& PrintCharImpl(std::ostream& os, T v) {
+  // Specialization for chars: print as 'c' if printable, otherwise
+  // hex-escaped.
+  return (absl::ascii_isprint(static_cast<unsigned char>(v))
+              ? (os << (v == '\'' ? "'\\" : "'") << v)
+              : (os << "'\\x" << hexnib((v >> 4) & 0xf) << hexnib(v & 0xf)))
+         << "' (0x" << hexnib((v >> 4) & 0xf) << hexnib(v & 0xf) << " "
+         << static_cast<int>(v) << ")";
+}
+
+std::ostream& PrintChar(std::ostream& os, char c) {
+  return PrintCharImpl(os, c);
+}
+
+std::ostream& PrintChar(std::ostream& os, signed char c) {
+  return PrintCharImpl(os, c);
+}
+
+std::ostream& PrintChar(std::ostream& os, unsigned char c) {
+  return PrintCharImpl(os, c);
+}
+
+std::ostream& PrintByte(std::ostream& os, std::byte b) {
+  auto v = std::to_integer<int>(b);
+  os << "0x" << hexnib((v >> 4) & 0xf) << hexnib(v & 0xf);
+  return os;
+}
+
+}  // namespace internal_generic_printer
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/strings/internal/generic_printer.h

@@ -0,0 +1,115 @@
+// Copyright 2025 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.
+
+#ifndef ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_H_
+#define ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_H_
+
+#include "absl/strings/internal/generic_printer_internal.h"  // IWYU pragma: export
+
+// Helpers for printing objects in generic code.
+//
+// These functions help with streaming in generic code. It may be desirable, for
+// example, to log values from generic functions; however, operator<< may not be
+// overloaded for all types.
+//
+// The helpers in this library use, in order of precedence:
+//
+//  1. std::string and std::string_view are quoted and escaped. (The specific
+//     format is not guaranteed to be stable.)
+//  2. A defined AbslStringify() method.
+//  3. absl::log_internal::LogContainer, if the object is a STL container.
+//  4. For std::tuple, std::pair, and std::optional, recursively calls
+//     GenericPrint for each element.
+//  5. Floating point values are printed with enough precision for round-trip.
+//  6. char values are quoted, with non-printable values escaped, and the
+//     char's numeric value is included.
+//  7. A defined operator<< overload (which should be found by ADL).
+//  8. A defined DebugString() const method.
+//  9. A fallback value with basic information otherwise.
+//
+// Note that the fallback value means that if no formatting conversion is
+// defined, you will not see a compile-time error. This also means that
+// GenericPrint() can safely be used in generic template contexts, and can
+// format any types needed (even though the output will vary).
+//
+// Example usage:
+//
+//   // All values after GenericPrint() are formatted:
+//   LOG(INFO) << GenericPrint()
+//             << int_var         // <- printed normally
+//             << float_var       // <- sufficient precision for round-trip
+//             << " unchanged literal text ";
+//
+//   // Just one value is formatted:
+//   LOG(INFO) << GenericPrint(string("this is quoted and escaped\t\n"))
+//             << GenericPrint("but not this, ");
+//             << string("and not this.");
+//
+// To make a type loggable with GenericPrint, prefer defining operator<< as a
+// friend function. For example:
+//
+//   class TypeToLog {
+//    public:
+//     string ToString() const;  // Many types already implement this.
+//                               // Define out-of-line if it is complex.
+//     friend std::ostream& operator<<(std::ostream& os, const TypeToLog& v) {
+//       return os << v.ToString();  // OK to define in-line instead, if simple.
+//     }
+//   };
+//
+// (Defining operator<< as an inline friend free function allows it to be found
+// by Argument-Dependent Lookup, or ADL, which is the mechanism typically used
+// for operator overload resolution. An inline friend function is the tightest
+// scope possible for overloading the left-hand side of an operator.)
+
+#include <ostream>
+#include <utility>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// Helper for logging values in generic code.
+//
+// Example usage:
+//
+//   template <typename T>
+//   void GenericFunction() {
+//     T v1, v2;
+//     VLOG(1) << GenericPrint() << v1 << v2;  // GenericPrint everything
+//     VLOG(1) << GenericPrint(v1) << v2;  // GenericPrint just v1
+//   }
+//
+inline constexpr internal_generic_printer::GenericPrintAdapterFactory
+    GenericPrint{};
+
+// Generic printer type: this class can be used, for example, as a template
+// argument to allow users to provide alternative printing strategies.
+//
+// For example, to allow callers to provide a custom strategy:
+//
+//   template <typename T, typename PrinterT = GenericPrinter<T>>
+//   void GenericFunction() {
+//     T value;
+//     VLOG(1) << PrinterT{value};
+//   }
+//
+template <typename T>
+using GenericPrinter = internal_generic_printer::GenericPrinter<T>;
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_H_