re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/profiling/hashtable.h

@@ -0,0 +1,40 @@
+// 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_PROFILING_HASHTABLE_H_
+#define ABSL_PROFILING_HASHTABLE_H_
+
+#include <cstdint>
+#include <string>
+
+#include "absl/container/internal/hashtablez_sampler.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+absl::StatusOr<std::string> MarshalHashtableProfile();
+
+namespace debugging_internal {
+
+absl::StatusOr<std::string> MarshalHashtableProfile(
+    container_internal::HashtablezSampler& sampler, absl::Time now);
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_PROFILING_HASHTABLE_H_

package/vendor/abseil-cpp/absl/profiling/internal/exponential_biased.cc

@@ -66,7 +66,7 @@ int64_t ExponentialBiased::GetSkipCount(int64_t mean) {
   }
   double value = std::rint(interval);
   bias_ = interval - value;
-  return value;
+  return static_cast<int64_t>(value);
 }
 
 int64_t ExponentialBiased::GetStride(int64_t mean) {

package/vendor/abseil-cpp/absl/profiling/internal/profile_builder.cc

@@ -0,0 +1,462 @@
+// 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/profiling/internal/profile_builder.h"
+
+#ifdef __linux__
+#include <elf.h>
+#include <link.h>
+#endif  // __linux__
+
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/casts.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+namespace {
+
+// This file contains a simplified implementation of the pprof profile builder,
+// which avoids a dependency on protobuf.
+//
+// The canonical profile proto definition is at
+// https://github.com/google/pprof/blob/master/proto/profile.proto
+//
+// Wire-format encoding is a simple sequence of (tag, value) pairs. The tag
+// is a varint-encoded integer, where the low 3 bits are the wire type, and the
+// high bits are the field number.
+//
+// For the fields we care about, we'll be using the following wire types:
+//
+// Wire Type 0: Varint-encoded integer.
+// Wire Type 2: Length-delimited. Used for strings and sub-messages.
+enum class WireType {
+  kVarint = 0,
+  kLengthDelimited = 2,
+};
+
+#ifdef __linux__
+// Returns the Phdr of the first segment of the given type.
+const ElfW(Phdr) * GetFirstSegment(const dl_phdr_info* const info,
+                                   const ElfW(Word) segment_type) {
+  for (int i = 0; i < info->dlpi_phnum; ++i) {
+    if (info->dlpi_phdr[i].p_type == segment_type) {
+      return &info->dlpi_phdr[i];
+    }
+  }
+  return nullptr;
+}
+
+// Return DT_SONAME for the given image.  If there is no PT_DYNAMIC or if
+// PT_DYNAMIC does not contain DT_SONAME, return nullptr.
+static const char* GetSoName(const dl_phdr_info* const info) {
+  const ElfW(Phdr)* const pt_dynamic = GetFirstSegment(info, PT_DYNAMIC);
+  if (pt_dynamic == nullptr) {
+    return nullptr;
+  }
+  const ElfW(Dyn)* dyn =
+      reinterpret_cast<ElfW(Dyn)*>(info->dlpi_addr + pt_dynamic->p_vaddr);
+  const ElfW(Dyn)* dt_strtab = nullptr;
+  const ElfW(Dyn)* dt_strsz = nullptr;
+  const ElfW(Dyn)* dt_soname = nullptr;
+  for (; dyn->d_tag != DT_NULL; ++dyn) {
+    if (dyn->d_tag == DT_SONAME) {
+      dt_soname = dyn;
+    } else if (dyn->d_tag == DT_STRTAB) {
+      dt_strtab = dyn;
+    } else if (dyn->d_tag == DT_STRSZ) {
+      dt_strsz = dyn;
+    }
+  }
+  if (dt_soname == nullptr) {
+    return nullptr;
+  }
+  ABSL_RAW_CHECK(dt_strtab != nullptr, "Unexpected nullptr");
+  ABSL_RAW_CHECK(dt_strsz != nullptr, "Unexpected nullptr");
+  const char* const strtab = reinterpret_cast<char*>(
+      info->dlpi_addr + static_cast<ElfW(Word)>(dt_strtab->d_un.d_val));
+  ABSL_RAW_CHECK(dt_soname->d_un.d_val < dt_strsz->d_un.d_val,
+                 "Unexpected order");
+  return strtab + dt_soname->d_un.d_val;
+}
+
+// Helper function to get the build ID of a shared object.
+std::string GetBuildId(const dl_phdr_info* const info) {
+  std::string result;
+
+  // pt_note contains entries (of type ElfW(Nhdr)) starting at
+  //   info->dlpi_addr + pt_note->p_vaddr
+  // with length
+  //   pt_note->p_memsz
+  //
+  // The length of each entry is given by
+  //   Align(sizeof(ElfW(Nhdr)) + nhdr->n_namesz) + Align(nhdr->n_descsz)
+  for (int i = 0; i < info->dlpi_phnum; ++i) {
+    const ElfW(Phdr)* pt_note = &info->dlpi_phdr[i];
+    if (pt_note->p_type != PT_NOTE) continue;
+
+    const char* note =
+        reinterpret_cast<char*>(info->dlpi_addr + pt_note->p_vaddr);
+    const char* const last = note + pt_note->p_filesz;
+    const ElfW(Xword) align = pt_note->p_align;
+    while (note < last) {
+      const ElfW(Nhdr)* const nhdr = reinterpret_cast<const ElfW(Nhdr)*>(note);
+      if (note + sizeof(*nhdr) > last) {
+        // Corrupt PT_NOTE
+        break;
+      }
+
+      // Both the start and end of the descriptor are aligned by sh_addralign
+      // (= p_align).
+      const ElfW(Xword) desc_start =
+          (sizeof(*nhdr) + nhdr->n_namesz + align - 1) & -align;
+      const ElfW(Xword) size =
+          desc_start + ((nhdr->n_descsz + align - 1) & -align);
+
+      // Beware of wrap-around.
+      if (nhdr->n_namesz >= static_cast<ElfW(Word)>(-align) ||
+          nhdr->n_descsz >= static_cast<ElfW(Word)>(-align) ||
+          desc_start < sizeof(*nhdr) || size < desc_start ||
+          size > static_cast<ElfW(Xword)>(last - note)) {
+        // Corrupt PT_NOTE
+        break;
+      }
+
+      if (nhdr->n_type == NT_GNU_BUILD_ID) {
+        const char* const note_name = note + sizeof(*nhdr);
+        // n_namesz is the length of note_name.
+        if (nhdr->n_namesz == 4 && memcmp(note_name, "GNU\0", 4) == 0) {
+          if (!result.empty()) {
+            // Repeated build-ids.  Ignore them.
+            return "";
+          }
+          result = absl::BytesToHexString(
+              absl::string_view(note + desc_start, nhdr->n_descsz));
+        }
+      }
+      note += size;
+    }
+  }
+
+  return result;
+}
+#endif  // __linux__
+
+// A varint-encoded integer.
+struct Varint {
+  explicit Varint(uint64_t v) : value(v) {}
+  explicit Varint(StringId v) : value(static_cast<uint64_t>(v)) {}
+  explicit Varint(LocationId v) : value(static_cast<uint64_t>(v)) {}
+  explicit Varint(MappingId v) : value(static_cast<uint64_t>(v)) {}
+
+  uint64_t value;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const Varint& v) {
+    char buf[10];
+    char* p = buf;
+    uint64_t u = v.value;
+    while (u >= 0x80) {
+      *p++ = static_cast<char>((u & 0x7f) | 0x80);
+      u >>= 7;
+    }
+    *p++ = static_cast<char>(u);
+    sink.Append(absl::string_view(buf, static_cast<size_t>(p - buf)));
+  }
+};
+
+struct Tag {
+  int field_number;
+  WireType wire_type;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const Tag& t) {
+    absl::Format(&sink, "%v",
+                 Varint((static_cast<uint64_t>(t.field_number) << 3) |
+                        static_cast<uint64_t>(t.wire_type)));
+  }
+};
+
+struct LengthDelimited {
+  int field_number;
+  absl::string_view value;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const LengthDelimited& ld) {
+    absl::Format(&sink, "%v%v%v",
+                 Tag{ld.field_number, WireType::kLengthDelimited},
+                 Varint(ld.value.size()), ld.value);
+  }
+};
+
+struct VarintField {
+  int field_number;
+  Varint value;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const VarintField& vf) {
+    absl::Format(&sink, "%v%v", Tag{vf.field_number, WireType::kVarint},
+                 vf.value);
+  }
+};
+
+}  // namespace
+
+StringId ProfileBuilder::InternString(absl::string_view str) {
+  if (str.empty()) return StringId(0);
+  return string_table_.emplace(str, StringId(string_table_.size()))
+      .first->second;
+}
+
+LocationId ProfileBuilder::InternLocation(const void* address) {
+  return location_table_
+      .emplace(absl::bit_cast<uintptr_t>(address),
+               LocationId(location_table_.size() + 1))
+      .first->second;
+}
+
+void ProfileBuilder::AddSample(
+    int64_t value, absl::Span<const void* const> stack,
+    absl::Span<const std::pair<StringId, int64_t>> labels) {
+  std::string sample_proto;
+  absl::StrAppend(
+      &sample_proto,
+      VarintField{SampleProto::kValue, Varint(static_cast<uint64_t>(value))});
+
+  for (const void* addr : stack) {
+    // Profile addresses are raw stack unwind addresses, so they should be
+    // adjusted by -1 to land inside the call instruction (although potentially
+    // misaligned).
+    absl::StrAppend(
+        &sample_proto,
+        VarintField{SampleProto::kLocationId,
+                    Varint(InternLocation(absl::bit_cast<const void*>(
+                        absl::bit_cast<uintptr_t>(addr) - 1)))});
+  }
+
+  for (const auto& label : labels) {
+    std::string label_proto =
+        absl::StrCat(VarintField{LabelProto::kKey, Varint(label.first)},
+                     VarintField{LabelProto::kNum,
+                                 Varint(static_cast<uint64_t>(label.second))});
+    absl::StrAppend(&sample_proto,
+                    LengthDelimited{SampleProto::kLabel, label_proto});
+  }
+  samples_.push_back(std::move(sample_proto));
+}
+
+void ProfileBuilder::AddSampleType(StringId type, StringId unit) {
+  std::string sample_type_proto =
+      absl::StrCat(VarintField{ValueTypeProto::kType, Varint(type)},
+                   VarintField{ValueTypeProto::kUnit, Varint(unit)});
+  sample_types_.push_back(std::move(sample_type_proto));
+}
+
+MappingId ProfileBuilder::AddMapping(uintptr_t memory_start,
+                                     uintptr_t memory_limit,
+                                     uintptr_t file_offset,
+                                     absl::string_view filename,
+                                     absl::string_view build_id) {
+  size_t index = mappings_.size() + 1;
+  auto [it, inserted] = mapping_table_.emplace(memory_start, index);
+  if (!inserted) {
+    return static_cast<MappingId>(it->second);
+  }
+
+  Mapping m;
+  m.start = memory_start;
+  m.limit = memory_limit;
+  m.offset = file_offset;
+  m.filename = std::string(filename);
+  m.build_id = std::string(build_id);
+
+  mappings_.push_back(std::move(m));
+  return static_cast<MappingId>(index);
+}
+
+std::string ProfileBuilder::Emit() && {
+  std::string profile_proto;
+  for (const auto& sample_type : sample_types_) {
+    absl::StrAppend(&profile_proto,
+                    LengthDelimited{ProfileProto::kSampleType, sample_type});
+  }
+  for (const auto& sample : samples_) {
+    absl::StrAppend(&profile_proto,
+                    LengthDelimited{ProfileProto::kSample, sample});
+  }
+
+  // Build mapping table.
+  for (size_t i = 0, n = mappings_.size(); i < n; ++i) {
+    const auto& mapping = mappings_[i];
+    std::string mapping_proto = absl::StrCat(
+        VarintField{MappingProto::kId, Varint(static_cast<uint64_t>(i + 1))},
+        VarintField{MappingProto::kMemoryStart, Varint(mapping.start)},
+        VarintField{MappingProto::kMemoryLimit, Varint(mapping.limit)},
+        VarintField{MappingProto::kFileOffset, Varint(mapping.offset)},
+        VarintField{MappingProto::kFilename,
+                    Varint(InternString(mapping.filename))},
+        VarintField{MappingProto::kBuildId,
+                    Varint(InternString(mapping.build_id))});
+
+    absl::StrAppend(&profile_proto,
+                    LengthDelimited{ProfileProto::kMapping, mapping_proto});
+  }
+
+  // Build location table.
+  for (const auto& [address, id] : location_table_) {
+    std::string location =
+        absl::StrCat(VarintField{LocationProto::kId, Varint(id)},
+                     VarintField{LocationProto::kAddress, Varint(address)});
+
+    if (!mappings_.empty()) {
+      // Find the mapping ID.
+      auto it = mapping_table_.upper_bound(address);
+      if (it != mapping_table_.begin()) {
+        --it;
+      }
+
+      // If *it contains address, add mapping to location.
+      const size_t mapping_index = it->second;
+      const Mapping& mapping = mappings_[mapping_index - 1];
+
+      if (it->first <= address && address < mapping.limit) {
+        absl::StrAppend(
+            &location,
+            VarintField{LocationProto::kMappingId,
+                        Varint(static_cast<uint64_t>(mapping_index))});
+      }
+    }
+
+    absl::StrAppend(&profile_proto,
+                    LengthDelimited{ProfileProto::kLocation, location});
+  }
+
+  std::string string_table_proto;
+  std::vector<absl::string_view> sorted_strings(string_table_.size());
+  for (const auto& p : string_table_) {
+    sorted_strings[static_cast<size_t>(p.second)] = p.first;
+  }
+  for (const auto& s : sorted_strings) {
+    absl::StrAppend(&string_table_proto,
+                    LengthDelimited{ProfileProto::kStringTable, s});
+  }
+  absl::StrAppend(&profile_proto, VarintField{ProfileProto::kDropFrames,
+                                              Varint(drop_frames_id_)});
+  absl::StrAppend(&profile_proto,
+                  VarintField{ProfileProto::kComment, Varint(comment_id_)});
+  absl::StrAppend(&profile_proto, VarintField{ProfileProto::kDefaultSampleType,
+                                              Varint(default_sample_type_id_)});
+  return absl::StrCat(string_table_proto, profile_proto);
+}
+
+void ProfileBuilder::set_drop_frames_id(StringId drop_frames_id) {
+  drop_frames_id_ = drop_frames_id;
+}
+
+void ProfileBuilder::set_comment_id(StringId comment_id) {
+  comment_id_ = comment_id;
+}
+
+void ProfileBuilder::set_default_sample_type_id(
+    StringId default_sample_type_id) {
+  default_sample_type_id_ = default_sample_type_id;
+}
+
+void ProfileBuilder::AddCurrentMappings() {
+#ifdef __linux__
+  dl_iterate_phdr(
+      +[](dl_phdr_info* info, size_t, void* data) {
+        auto& builder = *reinterpret_cast<ProfileBuilder*>(data);
+
+        // Skip dummy entry introduced since glibc 2.18.
+        if (info->dlpi_phdr == nullptr && info->dlpi_phnum == 0) {
+          return 0;
+        }
+
+        const bool is_main_executable = builder.mappings_.empty();
+
+        // Evaluate all the loadable segments.
+        for (int i = 0; i < info->dlpi_phnum; ++i) {
+          if (info->dlpi_phdr[i].p_type != PT_LOAD) {
+            continue;
+          }
+          const ElfW(Phdr)* pt_load = &info->dlpi_phdr[i];
+
+          ABSL_RAW_CHECK(pt_load != nullptr, "Unexpected nullptr");
+
+          // Extract data.
+          const size_t memory_start = info->dlpi_addr + pt_load->p_vaddr;
+          const size_t memory_limit = memory_start + pt_load->p_memsz;
+          const size_t file_offset = pt_load->p_offset;
+
+          // Storage for path to executable as dlpi_name isn't populated for the
+          // main executable.  +1 to allow for the null terminator that readlink
+          // does not add.
+          char self_filename[PATH_MAX + 1];
+          const char* filename = info->dlpi_name;
+          if (filename == nullptr || filename[0] == '\0') {
+            // This is either the main executable or the VDSO.  The main
+            // executable is always the first entry processed by callbacks.
+            if (is_main_executable) {
+              // This is the main executable.
+              ssize_t ret = readlink("/proc/self/exe", self_filename,
+                                     sizeof(self_filename) - 1);
+              if (ret >= 0 &&
+                  static_cast<size_t>(ret) < sizeof(self_filename)) {
+                self_filename[ret] = '\0';
+                filename = self_filename;
+              }
+            } else {
+              // This is the VDSO.
+              filename = GetSoName(info);
+            }
+          }
+
+          char resolved_path[PATH_MAX];
+          absl::string_view resolved_filename;
+          if (realpath(filename, resolved_path)) {
+            resolved_filename = resolved_path;
+          } else {
+            resolved_filename = filename;
+          }
+
+          const std::string build_id = GetBuildId(info);
+
+          // Add to profile.
+          builder.AddMapping(memory_start, memory_limit, file_offset,
+                             resolved_filename, build_id);
+        }
+        // Keep going.
+        return 0;
+      },
+      this);
+#endif  // __linux__
+}
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/profiling/internal/profile_builder.h

@@ -0,0 +1,138 @@
+// 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_PROFILING_INTERNAL_PROFILE_BUILDER_H_
+#define ABSL_PROFILING_INTERNAL_PROFILE_BUILDER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/container/btree_map.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Field numbers for perftools.profiles.Profile.
+// https://github.com/google/pprof/blob/master/proto/profile.proto
+struct ProfileProto {
+  static constexpr int kSampleType = 1;
+  static constexpr int kSample = 2;
+  static constexpr int kMapping = 3;
+  static constexpr int kLocation = 4;
+  static constexpr int kStringTable = 6;
+  static constexpr int kDropFrames = 7;
+  static constexpr int kComment = 13;
+  static constexpr int kDefaultSampleType = 14;
+};
+
+struct ValueTypeProto {
+  static constexpr int kType = 1;
+  static constexpr int kUnit = 2;
+};
+
+struct SampleProto {
+  static constexpr int kLocationId = 1;
+  static constexpr int kValue = 2;
+  static constexpr int kLabel = 3;
+};
+
+struct LabelProto {
+  static constexpr int kKey = 1;
+  static constexpr int kStr = 2;
+  static constexpr int kNum = 3;
+  static constexpr int kNumUnit = 4;
+};
+
+struct MappingProto {
+  static constexpr int kId = 1;
+  static constexpr int kMemoryStart = 2;
+  static constexpr int kMemoryLimit = 3;
+  static constexpr int kFileOffset = 4;
+  static constexpr int kFilename = 5;
+  static constexpr int kBuildId = 6;
+};
+
+struct LocationProto {
+  static constexpr int kId = 1;
+  static constexpr int kMappingId = 2;
+  static constexpr int kAddress = 3;
+};
+
+enum class StringId : size_t {};
+enum class LocationId : size_t {};
+enum class MappingId : size_t {};
+
+// A helper class to build a profile protocol buffer.
+class ProfileBuilder {
+ public:
+  struct Mapping {
+    uint64_t start;
+    uint64_t limit;
+    uint64_t offset;
+    std::string filename;
+    std::string build_id;
+  };
+
+  StringId InternString(absl::string_view str);
+
+  LocationId InternLocation(const void* address);
+
+  void AddSample(int64_t value, absl::Span<const void* const> stack,
+                 absl::Span<const std::pair<StringId, int64_t>> labels);
+
+  void AddSampleType(StringId type, StringId unit);
+
+  // Adds the current process mappings to the profile.
+  void AddCurrentMappings();
+
+  // Adds a single mapping to the profile and to lookup cache and returns the
+  // resulting ID.
+  MappingId AddMapping(uintptr_t memory_start, uintptr_t memory_limit,
+                       uintptr_t file_offset, absl::string_view filename,
+                       absl::string_view build_id);
+
+  std::string Emit() &&;
+
+  void set_drop_frames_id(StringId drop_frames_id);
+  void set_comment_id(StringId comment_id);
+  void set_default_sample_type_id(StringId default_sample_type_id);
+
+ private:
+  absl::flat_hash_map<std::string, StringId> string_table_{{"", StringId(0)}};
+  absl::flat_hash_map<uintptr_t, LocationId> location_table_;
+  // mapping_table_ stores the start address of each mapping in mapping_
+  // to its index.
+  absl::btree_map<uintptr_t, size_t> mapping_table_;
+  std::vector<Mapping> mappings_;
+
+  std::vector<std::string> sample_types_;
+  std::vector<std::string> samples_;
+
+  StringId drop_frames_id_{};
+  StringId comment_id_{};
+  StringId default_sample_type_id_{};
+};
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_PROFILING_INTERNAL_PROFILE_BUILDER_H_