re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/debugging/symbolize_elf.inc

@@ -67,6 +67,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <memory>
 
 #include "absl/base/casts.h"
 #include "absl/base/dynamic_annotations.h"
@@ -145,16 +146,7 @@ inline constexpr bool kPlatformUsesOPDSections = false;
 // pointers and the first one is the function's entry.
 const size_t kFunctionDescriptorSize = sizeof(void *) * 2;
 
-const int kMaxDecorators = 10;  // Seems like a reasonable upper limit.
-
-struct InstalledSymbolDecorator {
-  SymbolDecorator fn;
-  void *arg;
-  int ticket;
-};
-
-int g_num_decorators;
-InstalledSymbolDecorator g_decorators[kMaxDecorators];
+std::atomic<SymbolDecorator::Factory*> g_decorator_factory = nullptr;
 
 struct FileMappingHint {
   const void *start;
@@ -163,16 +155,6 @@ struct FileMappingHint {
   const char *filename;
 };
 
-// Protects g_decorators.
-// We are using SpinLock and not a Mutex here, because we may be called
-// from inside Mutex::Lock itself, and it prohibits recursive calls.
-// This happens in e.g. base/stacktrace_syscall_unittest.
-// Moreover, we are using only try_lock(), if the decorator list
-// is being modified (is busy), we skip all decorators, and possibly
-// loose some info. Sorry, that's the best we could do.
-ABSL_CONST_INIT absl::base_internal::SpinLock g_decorators_mu(
-    absl::base_internal::SCHEDULE_KERNEL_ONLY);
-
 const int kMaxFileMappingHints = 8;
 int g_num_file_mapping_hints;
 FileMappingHint g_file_mapping_hints[kMaxFileMappingHints];
@@ -190,32 +172,23 @@ static void SafeMemZero(void *p, size_t size) {
 }
 
 struct ObjFile {
-  ObjFile()
-      : filename(nullptr),
-        start_addr(nullptr),
-        end_addr(nullptr),
-        offset(0),
-        fd(-1),
-        elf_type(-1) {
-    SafeMemZero(&elf_header, sizeof(elf_header));
-    SafeMemZero(&phdr[0], sizeof(phdr));
-  }
-
-  char *filename;
-  const void *start_addr;
-  const void *end_addr;
-  uint64_t offset;
+  char *filename = nullptr;
+  const void *start_addr = nullptr;
+  const void *end_addr = nullptr;
+  uint64_t offset = 0;
 
   // The following fields are initialized on the first access to the
   // object file.
-  int fd;
-  int elf_type;
-  ElfW(Ehdr) elf_header;
+  int fd = -1;
+  int elf_type = -1;
+  ElfW(Ehdr) elf_header = {};
 
   // PT_LOAD program header describing executable code.
   // Normally we expect just one, but SWIFT binaries have two.
   // CUDA binaries have 3 (see cr/473913254 description).
-  std::array<ElfW(Phdr), 4> phdr;
+  std::array<ElfW(Phdr), 4> phdr = {};
+
+  SymbolDecoratorPtr decorator = {};
 };
 
 // Build 4-way associative cache for symbols. Within each cache line, symbols
@@ -266,7 +239,8 @@ ObjFile *AddrMap::Add() {
         static_cast<ObjFile *>(base_internal::LowLevelAlloc::AllocWithArena(
             new_allocated * sizeof(*new_obj_), base_internal::SigSafeArena()));
     if (obj_) {
-      memcpy(new_obj_, obj_, allocated_ * sizeof(*new_obj_));
+      std::uninitialized_move_n(obj_, size_, new_obj_);
+      std::destroy_n(obj_, size_);
       base_internal::LowLevelAlloc::Free(obj_);
     }
     obj_ = new_obj_;
@@ -309,6 +283,8 @@ class Symbolizer {
   ~Symbolizer();
   const char *GetSymbol(const void *const pc);
 
+  void UpdateDecoratorsIfNeeded(SymbolDecorator::Factory* decorator_factory);
+
  private:
   char *CopyString(const char *s) {
     size_t len = strlen(s);
@@ -345,6 +321,7 @@ class Symbolizer {
   };
 
   AddrMap addr_map_;
+  SymbolDecorator::Factory* decorator_factory_ = nullptr;
 
   bool ok_;
   bool addr_map_read_;
@@ -422,11 +399,14 @@ static Symbolizer *AllocateSymbolizer() {
   base_internal::InitSigSafeArena();
   Symbolizer *symbolizer =
       g_cached_symbolizer.exchange(nullptr, std::memory_order_acquire);
-  if (symbolizer != nullptr) {
-    return symbolizer;
-  }
-  return new (base_internal::LowLevelAlloc::AllocWithArena(
-      SymbolizerSize(), base_internal::SigSafeArena())) Symbolizer();
+  if (symbolizer == nullptr) {
+    void* ptr = base_internal::LowLevelAlloc::AllocWithArena(
+        SymbolizerSize(), base_internal::SigSafeArena());
+    symbolizer = new (ptr) Symbolizer();
+  }
+  symbolizer->UpdateDecoratorsIfNeeded(
+      g_decorator_factory.load(std::memory_order_acquire));
+  return symbolizer;
 }
 
 // Set g_cached_symbolize_state to s if it is null, otherwise
@@ -443,7 +423,7 @@ static void FreeSymbolizer(Symbolizer *s) {
 
 Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) {
   for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
-    for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) {
+    for (size_t j = 0; j < std::size(symbol_cache_line.name); ++j) {
       symbol_cache_line.pc[j] = nullptr;
       symbol_cache_line.name[j] = nullptr;
       symbol_cache_line.age[j] = 0;
@@ -460,6 +440,26 @@ Symbolizer::~Symbolizer() {
   ClearAddrMap();
 }
 
+void Symbolizer::UpdateDecoratorsIfNeeded(
+    SymbolDecorator::Factory* decorator_factory) {
+  if (decorator_factory_ == decorator_factory) return;
+
+  for (SymbolCacheLine& symbol_cache_line : symbol_cache_) {
+    for (size_t j = 0; j < std::size(symbol_cache_line.name); ++j) {
+      symbol_cache_line.pc[j] = nullptr;
+      base_internal::LowLevelAlloc::Free(symbol_cache_line.name[j]);
+      symbol_cache_line.name[j] = nullptr;
+      symbol_cache_line.age[j] = 0;
+    }
+  }
+
+  decorator_factory_ = decorator_factory;
+  for (size_t i = 0, end = addr_map_.Size(); i < end; ++i) {
+    ObjFile* obj = addr_map_.At(i);
+    obj->decorator.reset();
+  }
+}
+
 // We don't use assert() since it's not guaranteed to be
 // async-signal-safe.  Instead we define a minimal assertion
 // macro. So far, we don't need pretty printing for __FILE__, etc.
@@ -1387,7 +1387,8 @@ static void MaybeOpenFdFromSelfExe(ObjFile *obj) {
   obj->fd = fd;
 }
 
-static bool MaybeInitializeObjFile(ObjFile *obj) {
+static bool MaybeInitializeObjFile(
+    ObjFile* obj, SymbolDecorator::Factory* decorator_factory) {
   if (obj->fd < 0) {
     obj->fd = OpenReadOnlyWithHighFD(obj->filename);
 
@@ -1469,6 +1470,9 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
       return false;
     }
   }
+  if (decorator_factory != nullptr && obj->decorator == nullptr) {
+    obj->decorator = decorator_factory(obj->fd);
+  }
   return true;
 }
 
@@ -1482,9 +1486,8 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
 const char *Symbolizer::GetUncachedSymbol(const void *pc) {
   ObjFile *const obj = FindObjFile(pc, 1);
   ptrdiff_t relocation = 0;
-  int fd = -1;
   if (obj != nullptr) {
-    if (MaybeInitializeObjFile(obj)) {
+    if (MaybeInitializeObjFile(obj, decorator_factory_)) {
       const size_t start_addr = reinterpret_cast<size_t>(obj->start_addr);
       if (obj->elf_type == ET_DYN && start_addr >= obj->offset) {
         // This object was relocated.
@@ -1524,7 +1527,6 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
         }
       }
 
-      fd = obj->fd;
       if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_,
                                   sizeof(symbol_buf_), tmp_buf_,
                                   sizeof(tmp_buf_)) == SYMBOL_FOUND) {
@@ -1549,17 +1551,9 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
 #endif
   }
 
-  if (g_decorators_mu.try_lock()) {
-    if (g_num_decorators > 0) {
-      SymbolDecoratorArgs decorator_args = {
-          pc,       relocation,       fd,     symbol_buf_, sizeof(symbol_buf_),
-          tmp_buf_, sizeof(tmp_buf_), nullptr};
-      for (int i = 0; i < g_num_decorators; ++i) {
-        decorator_args.arg = g_decorators[i].arg;
-        g_decorators[i].fn(&decorator_args);
-      }
-    }
-    g_decorators_mu.unlock();
+  if (obj != nullptr && obj->decorator != nullptr) {
+    obj->decorator->Decorate(pc, relocation, symbol_buf_, sizeof(symbol_buf_),
+                             tmp_buf_, sizeof(tmp_buf_));
   }
   if (symbol_buf_[0] == '\0') {
     return nullptr;
@@ -1604,51 +1598,9 @@ const char *Symbolizer::GetSymbol(const void *pc) {
 #endif
 }
 
-bool RemoveAllSymbolDecorators(void) {
-  if (!g_decorators_mu.try_lock()) {
-    // Someone else is using decorators. Get out.
-    return false;
-  }
-  g_num_decorators = 0;
-  g_decorators_mu.unlock();
-  return true;
-}
-
-bool RemoveSymbolDecorator(int ticket) {
-  if (!g_decorators_mu.try_lock()) {
-    // Someone else is using decorators. Get out.
-    return false;
-  }
-  for (int i = 0; i < g_num_decorators; ++i) {
-    if (g_decorators[i].ticket == ticket) {
-      while (i < g_num_decorators - 1) {
-        g_decorators[i] = g_decorators[i + 1];
-        ++i;
-      }
-      g_num_decorators = i;
-      break;
-    }
-  }
-  g_decorators_mu.unlock();
-  return true;  // Decorator is known to be removed.
-}
-
-int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
-  static int ticket = 0;
-
-  if (!g_decorators_mu.try_lock()) {
-    // Someone else is using decorators. Get out.
-    return -2;
-  }
-  int ret = ticket;
-  if (g_num_decorators >= kMaxDecorators) {
-    ret = -1;
-  } else {
-    g_decorators[g_num_decorators] = {decorator, arg, ticket++};
-    ++g_num_decorators;
-  }
-  g_decorators_mu.unlock();
-  return ret;
+SymbolDecorator::Factory* SetSymbolDecoratorFactory(
+    SymbolDecorator::Factory* factory) {
+  return g_decorator_factory.exchange(factory, std::memory_order_acq_rel);
 }
 
 bool RegisterFileMappingHint(const void *start, const void *end,

package/vendor/abseil-cpp/absl/debugging/symbolize_test.cc

@@ -13,6 +13,10 @@
 // limitations under the License.
 
 #include "absl/debugging/symbolize.h"
+#include <cstddef>
+
+#include "absl/debugging/internal/symbolize.h"
+#include "absl/strings/str_format.h"
 
 #ifdef __EMSCRIPTEN__
 #include <emscripten.h>
@@ -32,8 +36,10 @@
 #include "absl/base/attributes.h"
 #include "absl/base/casts.h"
 #include "absl/base/config.h"
+#include "absl/base/internal/low_level_alloc.h"
 #include "absl/base/internal/per_thread_tls.h"
 #include "absl/base/optimization.h"
+#include "absl/cleanup/cleanup.h"
 #include "absl/debugging/internal/stack_consumption.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
@@ -130,7 +136,7 @@ static const char *TrySymbolizeWithLimit(void *pc, int limit) {
       << "try_symbolize_buffer is too small";
 
   // Use the heap to facilitate heap and buffer sanitizer tools.
-  auto heap_buffer = absl::make_unique<char[]>(sizeof(try_symbolize_buffer));
+  auto heap_buffer = std::make_unique<char[]>(sizeof(try_symbolize_buffer));
   bool found = absl::Symbolize(pc, heap_buffer.get(), limit);
   if (found) {
     CHECK_LT(static_cast<int>(
@@ -369,46 +375,41 @@ TEST(Symbolize, SymbolizeWithMultipleMaps) {
   }
 }
 
-// Appends string(*args->arg) to args->symbol_buf.
-static void DummySymbolDecorator(
-    const absl::debugging_internal::SymbolDecoratorArgs *args) {
-  std::string *message = static_cast<std::string *>(args->arg);
-  strncat(args->symbol_buf, message->c_str(),
-          args->symbol_buf_size - strlen(args->symbol_buf) - 1);
-}
-
-TEST(Symbolize, InstallAndRemoveSymbolDecorators) {
-  int ticket_a;
-  std::string a_message("a");
-  EXPECT_GE(ticket_a = absl::debugging_internal::InstallSymbolDecorator(
-                DummySymbolDecorator, &a_message),
-            0);
-
-  int ticket_b;
-  std::string b_message("b");
-  EXPECT_GE(ticket_b = absl::debugging_internal::InstallSymbolDecorator(
-                DummySymbolDecorator, &b_message),
-            0);
+template <char C>
+class TestSymbolDecorator final
+    : public absl::debugging_internal::SymbolDecorator {
+ public:
+  static absl::debugging_internal::SymbolDecoratorPtr Factory(int /*fd*/) {
+    void* ptr = absl::base_internal::LowLevelAlloc::AllocWithArena(
+        sizeof(TestSymbolDecorator), absl::base_internal::SigSafeArena());
+    return absl::debugging_internal::SymbolDecoratorPtr(
+        new (ptr) TestSymbolDecorator());
+  }
 
-  int ticket_c;
-  std::string c_message("c");
-  EXPECT_GE(ticket_c = absl::debugging_internal::InstallSymbolDecorator(
-                DummySymbolDecorator, &c_message),
-            0);
+  void Decorate(const void* /*pc*/, ptrdiff_t /*relocation*/, char* symbol_buf,
+                size_t symbol_buf_size, char* /*tmp_buf*/,
+                size_t /*tmp_buf_size*/) const override {
+    const size_t len = strlen(symbol_buf);
+    absl::SNPrintF(symbol_buf + len, symbol_buf_size - len, " hello %c", C);
+  }
+};
 
-  // Use addresses 4 and 8 here to ensure that we always use valid addresses
-  // even on systems that require instructions to be 32-bit aligned.
-  char *address = reinterpret_cast<char *>(4);
-  EXPECT_STREQ("abc", TrySymbolize(address));
+TEST(Symbolize, SetSymbolDecorator) {
+  absl::Cleanup cleanup =
+      [old_decorator = absl::debugging_internal::SetSymbolDecoratorFactory(
+           &TestSymbolDecorator<'a'>::Factory)] {
+        absl::debugging_internal::SetSymbolDecoratorFactory(old_decorator);
+      };
 
-  EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_b));
+  EXPECT_STREQ("nonstatic_func hello a",
+               TrySymbolize(reinterpret_cast<void*>(&nonstatic_func)));
 
-  EXPECT_STREQ("ac", TrySymbolize(address + 4));
+  EXPECT_EQ(absl::debugging_internal::SetSymbolDecoratorFactory(
+                &TestSymbolDecorator<'b'>::Factory),
+            &TestSymbolDecorator<'a'>::Factory);
 
-  // Cleanup: remove all remaining decorators so other stack traces don't
-  // get mystery "ac" decoration.
-  EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_a));
-  EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_c));
+  EXPECT_STREQ("nonstatic_func hello b",
+               TrySymbolize(reinterpret_cast<void*>(&nonstatic_func)));
 }
 
 // Some versions of Clang with optimizations enabled seem to be able

package/vendor/abseil-cpp/absl/debugging/symbolize_unimplemented.inc

@@ -14,16 +14,16 @@
 
 #include <cstdint>
 
-#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/internal/symbolize.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 namespace debugging_internal {
 
-int InstallSymbolDecorator(SymbolDecorator, void*) { return -1; }
-bool RemoveSymbolDecorator(int) { return false; }
-bool RemoveAllSymbolDecorators(void) { return false; }
+SymbolDecorator::Factory* SetSymbolDecoratorFactory(SymbolDecorator::Factory*) {
+  return nullptr;
+}
 bool RegisterFileMappingHint(const void *, const void *, uint64_t, const char *) {
   return false;
 }

package/vendor/abseil-cpp/absl/flags/BUILD.bazel

@@ -43,6 +43,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
         "//absl/flags:__pkg__",
     ],
     deps = [
@@ -62,6 +63,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
         "//absl/flags:__pkg__",
         "//absl/log:__pkg__",
     ],
@@ -129,7 +131,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
-        "//visibility:private",
+        "//absl:friends",
     ],
     deps = [
         "//absl/base:config",
@@ -151,6 +153,7 @@ cc_library(
         ":commandlineflag_internal",
         "//absl/base:config",
         "//absl/base:fast_type_id",
+        "//absl/base:nullability",
         "//absl/strings",
         "//absl/types:optional",
     ],
@@ -167,6 +170,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
         "//absl/flags:__pkg__",
         "//absl/flags/rust:__pkg__",
     ],
@@ -267,6 +271,7 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
+        "//absl:friends",
         "//absl/flags:__pkg__",
     ],
     deps = [
@@ -410,7 +415,6 @@ cc_test(
         "//absl/numeric:int128",
         "//absl/strings",
         "//absl/time",
-        "//absl/types:optional",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
@@ -436,7 +440,6 @@ cc_binary(
         ":reflection",
         "//absl/strings",
         "//absl/time",
-        "//absl/types:optional",
         "@google_benchmark//:benchmark_main",
     ],
 )

package/vendor/abseil-cpp/absl/flags/CMakeLists.txt

@@ -128,6 +128,7 @@ absl_cc_library(
     absl::config
     absl::fast_type_id
     absl::flags_commandlineflag_internal
+    absl::nullability
     absl::optional
     absl::strings
 )
@@ -351,7 +352,6 @@ absl_cc_test(
     absl::flags_parse
     absl::flags_reflection
     absl::int128
-    absl::optional
     absl::raw_logging_internal
     absl::strings
     absl::time

package/vendor/abseil-cpp/absl/flags/commandlineflag.h

@@ -27,10 +27,12 @@
 #define ABSL_FLAGS_COMMANDLINEFLAG_H_
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/base/config.h"
 #include "absl/base/fast_type_id.h"
+#include "absl/base/nullability.h"
 #include "absl/flags/internal/commandlineflag.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -86,11 +88,11 @@ class CommandLineFlag {
   // absl::CommandLineFlag::TryGet()
   //
   // Attempts to retrieve the flag value. Returns value on success,
-  // absl::nullopt otherwise.
+  // std::nullopt otherwise.
   template <typename T>
-  absl::optional<T> TryGet() const {
+  std::optional<T> TryGet() const {
     if (IsRetired() || !IsOfType<T>()) {
-      return absl::nullopt;
+      return std::nullopt;
     }
 
     // Implementation notes:
@@ -118,7 +120,7 @@ class CommandLineFlag {
     Read(&u.value);
     // allow retired flags to be "read", so we can report invalid access.
     if (IsRetired()) {
-      return absl::nullopt;
+      return std::nullopt;
     }
     return std::move(u.value);
   }
@@ -158,7 +160,7 @@ class CommandLineFlag {
   // Sets the value of the flag based on specified string `value`. If the flag
   // was successfully set to new value, it returns true. Otherwise, sets `error`
   // to indicate the error, leaves the flag unchanged, and returns false.
-  bool ParseFrom(absl::string_view value, std::string* error);
+  bool ParseFrom(absl::string_view value, std::string* absl_nonnull error);
 
  protected:
   ~CommandLineFlag() = default;
@@ -188,7 +190,7 @@ class CommandLineFlag {
 
   // Copy-construct a new value of the flag's type in a memory referenced by
   // the dst based on the current flag's value.
-  virtual void Read(void* dst) const = 0;
+  virtual void Read(void* absl_nonnull dst) const = 0;
 
   // To be deleted. Used to return true if flag's current value originated from
   // command line.

package/vendor/abseil-cpp/absl/flags/commandlineflag_test.cc

@@ -55,7 +55,7 @@ class CommandLineFlagTest : public testing::Test {
 #if ABSL_FLAGS_STRIP_NAMES
     GTEST_SKIP() << "This test requires flag names to be present";
 #endif
-    flag_saver_ = absl::make_unique<absl::FlagSaver>();
+    flag_saver_ = std::make_unique<absl::FlagSaver>();
   }
   void TearDown() override { flag_saver_.reset(); }
 

package/vendor/abseil-cpp/absl/flags/flag_benchmark.cc

@@ -15,6 +15,7 @@
 
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -24,7 +25,6 @@
 #include "absl/flags/reflection.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "benchmark/benchmark.h"
 
 namespace {
@@ -32,10 +32,10 @@ using String = std::string;
 using VectorOfStrings = std::vector<std::string>;
 using AbslDuration = absl::Duration;
 
-// We do not want to take over marshalling for the types absl::optional<int>,
-// absl::optional<std::string> which we do not own. Instead we introduce unique
+// We do not want to take over marshalling for the types std::optional<int>,
+// std::optional<std::string> which we do not own. Instead we introduce unique
 // "aliases" to these types, which we do.
-using AbslOptionalInt = absl::optional<int>;
+using AbslOptionalInt = std::optional<int>;
 struct OptionalInt : AbslOptionalInt {
   using AbslOptionalInt::AbslOptionalInt;
 };
@@ -54,7 +54,7 @@ std::string AbslUnparseFlag(const OptionalInt& flag) {
   return !flag ? "" : absl::UnparseFlag(*flag);
 }
 
-using AbslOptionalString = absl::optional<std::string>;
+using AbslOptionalString = std::optional<std::string>;
 struct OptionalString : AbslOptionalString {
   using AbslOptionalString::AbslOptionalString;
 };