re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/numeric/bits_benchmark.cc

@@ -15,10 +15,10 @@
 #include <cstdint>
 #include <vector>
 
-#include "benchmark/benchmark.h"
 #include "absl/base/optimization.h"
 #include "absl/numeric/bits.h"
 #include "absl/random/random.h"
+#include "benchmark/benchmark.h"
 
 namespace absl {
 namespace {

package/vendor/abseil-cpp/absl/numeric/bits_test.cc

@@ -14,6 +14,7 @@
 
 #include "absl/numeric/bits.h"
 
+#include <cstdint>
 #include <limits>
 #include <type_traits>
 
@@ -25,16 +26,37 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace {
 
+template <typename IntT>
+class UnsignedIntegerTypesTest : public ::testing::Test {};
 template <typename IntT>
 class IntegerTypesTest : public ::testing::Test {};
 
+using UnsignedIntegerTypes =
+    ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>;
 using OneByteIntegerTypes = ::testing::Types<
     unsigned char,
     uint8_t
     >;
 
+TYPED_TEST_SUITE(UnsignedIntegerTypesTest, UnsignedIntegerTypes);
 TYPED_TEST_SUITE(IntegerTypesTest, OneByteIntegerTypes);
 
+TYPED_TEST(UnsignedIntegerTypesTest, ReturnTypes) {
+  using UIntType = TypeParam;
+
+  static_assert(std::is_same_v<decltype(byteswap(UIntType{0})), UIntType>);
+  static_assert(std::is_same_v<decltype(rotl(UIntType{0}, 0)), UIntType>);
+  static_assert(std::is_same_v<decltype(rotr(UIntType{0}, 0)), UIntType>);
+  static_assert(std::is_same_v<decltype(countl_zero(UIntType{0})), int>);
+  static_assert(std::is_same_v<decltype(countl_one(UIntType{0})), int>);
+  static_assert(std::is_same_v<decltype(countr_zero(UIntType{0})), int>);
+  static_assert(std::is_same_v<decltype(countr_one(UIntType{0})), int>);
+  static_assert(std::is_same_v<decltype(popcount(UIntType{0})), int>);
+  static_assert(std::is_same_v<decltype(bit_ceil(UIntType{0})), UIntType>);
+  static_assert(std::is_same_v<decltype(bit_floor(UIntType{0})), UIntType>);
+  static_assert(std::is_same_v<decltype(bit_width(UIntType{0})), int>);
+}
+
 TYPED_TEST(IntegerTypesTest, HandlesTypes) {
   using UIntType = TypeParam;
 
@@ -129,6 +151,9 @@ TEST(Rotate, Left) {
   EXPECT_EQ(rotl(uint32_t{0x12345678UL}, -4), uint32_t{0x81234567UL});
   EXPECT_EQ(rotl(uint64_t{0x12345678ABCDEF01ULL}, -4),
             uint64_t{0x112345678ABCDEF0ULL});
+
+  EXPECT_EQ(rotl(uint32_t{1234}, std::numeric_limits<int>::min()),
+            uint32_t{1234});
 }
 
 TEST(Rotate, Right) {
@@ -168,6 +193,9 @@ TEST(Rotate, Right) {
   EXPECT_EQ(rotr(uint32_t{0x12345678UL}, -4), uint32_t{0x23456781UL});
   EXPECT_EQ(rotr(uint64_t{0x12345678ABCDEF01ULL}, -4),
             uint64_t{0x2345678ABCDEF011ULL});
+
+  EXPECT_EQ(rotl(uint32_t{1234}, std::numeric_limits<int>::min()),
+            uint32_t{1234});
 }
 
 TEST(Rotate, Symmetry) {
@@ -636,6 +664,61 @@ static_assert(ABSL_INTERNAL_HAS_CONSTEXPR_CLZ, "clz should be constexpr");
 static_assert(ABSL_INTERNAL_HAS_CONSTEXPR_CTZ, "ctz should be constexpr");
 #endif
 
+TEST(Endian, Comparison) {
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+  static_assert(absl::endian::native == absl::endian::little);
+  static_assert(absl::endian::native != absl::endian::big);
+#endif
+#if defined(ABSL_IS_BIG_ENDIAN)
+  static_assert(absl::endian::native != absl::endian::little);
+  static_assert(absl::endian::native == absl::endian::big);
+#endif
+}
+
+TEST(Byteswap, Constexpr) {
+  static_assert(absl::byteswap<int8_t>(0x12) == 0x12);
+  static_assert(absl::byteswap<int16_t>(0x1234) == 0x3412);
+  static_assert(absl::byteswap<int32_t>(0x12345678) == 0x78563412);
+  static_assert(absl::byteswap<int64_t>(0x123456789abcdef0) ==
+                static_cast<int64_t>(0xf0debc9a78563412));
+  static_assert(absl::byteswap<uint8_t>(0x21) == 0x21);
+  static_assert(absl::byteswap<uint16_t>(0x4321) == 0x2143);
+  static_assert(absl::byteswap<uint32_t>(0x87654321) == 0x21436587);
+  static_assert(absl::byteswap<uint64_t>(0xfedcba9876543210) ==
+                static_cast<uint64_t>(0x1032547698badcfe));
+  static_assert(absl::byteswap<int32_t>(static_cast<int32_t>(0xdeadbeef)) ==
+                static_cast<int32_t>(0xefbeadde));
+}
+
+TEST(Byteswap, NotConstexpr) {
+  int8_t a = 0x12;
+  int16_t b = 0x1234;
+  int32_t c = 0x12345678;
+  int64_t d = 0x123456789abcdef0;
+  uint8_t e = 0x21;
+  uint16_t f = 0x4321;
+  uint32_t g = 0x87654321;
+  uint64_t h = 0xfedcba9876543210;
+  EXPECT_EQ(absl::byteswap<int8_t>(a), 0x12);
+  EXPECT_EQ(absl::byteswap<int16_t>(b), 0x3412);
+  EXPECT_EQ(absl::byteswap(c), 0x78563412);
+  EXPECT_EQ(absl::byteswap(d), 0xf0debc9a78563412);
+  EXPECT_EQ(absl::byteswap<uint8_t>(e), 0x21);
+  EXPECT_EQ(absl::byteswap<uint16_t>(f), 0x2143);
+  EXPECT_EQ(absl::byteswap(g), 0x21436587);
+  EXPECT_EQ(absl::byteswap(h), 0x1032547698badcfe);
+  EXPECT_EQ(absl::byteswap(absl::byteswap<int8_t>(a)), a);
+  EXPECT_EQ(absl::byteswap(absl::byteswap<int16_t>(b)), b);
+  EXPECT_EQ(absl::byteswap(absl::byteswap(c)), c);
+  EXPECT_EQ(absl::byteswap(absl::byteswap(d)), d);
+  EXPECT_EQ(absl::byteswap(absl::byteswap<uint8_t>(e)), e);
+  EXPECT_EQ(absl::byteswap(absl::byteswap<uint16_t>(f)), f);
+  EXPECT_EQ(absl::byteswap(absl::byteswap(g)), g);
+  EXPECT_EQ(absl::byteswap(absl::byteswap(h)), h);
+  EXPECT_EQ(absl::byteswap<uint32_t>(0xdeadbeef), 0xefbeadde);
+  EXPECT_EQ(absl::byteswap<const uint32_t>(0xdeadbeef), 0xefbeadde);
+}
+
 }  // namespace
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/numeric/int128.cc

@@ -342,55 +342,3 @@ std::ostream& operator<<(std::ostream& os, int128 v) {
 
 ABSL_NAMESPACE_END
 }  // namespace absl
-
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-namespace std {
-constexpr bool numeric_limits<absl::uint128>::is_specialized;
-constexpr bool numeric_limits<absl::uint128>::is_signed;
-constexpr bool numeric_limits<absl::uint128>::is_integer;
-constexpr bool numeric_limits<absl::uint128>::is_exact;
-constexpr bool numeric_limits<absl::uint128>::has_infinity;
-constexpr bool numeric_limits<absl::uint128>::has_quiet_NaN;
-constexpr bool numeric_limits<absl::uint128>::has_signaling_NaN;
-constexpr float_denorm_style numeric_limits<absl::uint128>::has_denorm;
-constexpr bool numeric_limits<absl::uint128>::has_denorm_loss;
-constexpr float_round_style numeric_limits<absl::uint128>::round_style;
-constexpr bool numeric_limits<absl::uint128>::is_iec559;
-constexpr bool numeric_limits<absl::uint128>::is_bounded;
-constexpr bool numeric_limits<absl::uint128>::is_modulo;
-constexpr int numeric_limits<absl::uint128>::digits;
-constexpr int numeric_limits<absl::uint128>::digits10;
-constexpr int numeric_limits<absl::uint128>::max_digits10;
-constexpr int numeric_limits<absl::uint128>::radix;
-constexpr int numeric_limits<absl::uint128>::min_exponent;
-constexpr int numeric_limits<absl::uint128>::min_exponent10;
-constexpr int numeric_limits<absl::uint128>::max_exponent;
-constexpr int numeric_limits<absl::uint128>::max_exponent10;
-constexpr bool numeric_limits<absl::uint128>::traps;
-constexpr bool numeric_limits<absl::uint128>::tinyness_before;
-
-constexpr bool numeric_limits<absl::int128>::is_specialized;
-constexpr bool numeric_limits<absl::int128>::is_signed;
-constexpr bool numeric_limits<absl::int128>::is_integer;
-constexpr bool numeric_limits<absl::int128>::is_exact;
-constexpr bool numeric_limits<absl::int128>::has_infinity;
-constexpr bool numeric_limits<absl::int128>::has_quiet_NaN;
-constexpr bool numeric_limits<absl::int128>::has_signaling_NaN;
-constexpr float_denorm_style numeric_limits<absl::int128>::has_denorm;
-constexpr bool numeric_limits<absl::int128>::has_denorm_loss;
-constexpr float_round_style numeric_limits<absl::int128>::round_style;
-constexpr bool numeric_limits<absl::int128>::is_iec559;
-constexpr bool numeric_limits<absl::int128>::is_bounded;
-constexpr bool numeric_limits<absl::int128>::is_modulo;
-constexpr int numeric_limits<absl::int128>::digits;
-constexpr int numeric_limits<absl::int128>::digits10;
-constexpr int numeric_limits<absl::int128>::max_digits10;
-constexpr int numeric_limits<absl::int128>::radix;
-constexpr int numeric_limits<absl::int128>::min_exponent;
-constexpr int numeric_limits<absl::int128>::min_exponent10;
-constexpr int numeric_limits<absl::int128>::max_exponent;
-constexpr int numeric_limits<absl::int128>::max_exponent10;
-constexpr bool numeric_limits<absl::int128>::traps;
-constexpr bool numeric_limits<absl::int128>::tinyness_before;
-}  // namespace std
-#endif

package/vendor/abseil-cpp/absl/numeric/int128_benchmark.cc

@@ -13,31 +13,29 @@
 // limitations under the License.
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <limits>
 #include <random>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
-#include "benchmark/benchmark.h"
 #include "absl/base/config.h"
 #include "absl/numeric/int128.h"
+#include "absl/random/random.h"
+#include "benchmark/benchmark.h"
 
 namespace {
 
 constexpr size_t kSampleSize = 1000000;
 
-std::mt19937 MakeRandomEngine() {
-  std::random_device r;
-  std::seed_seq seed({r(), r(), r(), r(), r(), r(), r(), r()});
-  return std::mt19937(seed);
-}
-
 template <typename T,
           typename H = typename std::conditional<
               std::numeric_limits<T>::is_signed, int64_t, uint64_t>::type>
 std::vector<std::pair<T, T>> GetRandomClass128SampleUniformDivisor() {
   std::vector<std::pair<T, T>> values;
-  std::mt19937 random = MakeRandomEngine();
+  absl::InsecureBitGen random;
   std::uniform_int_distribution<H> uniform_h;
   values.reserve(kSampleSize);
   for (size_t i = 0; i < kSampleSize; ++i) {
@@ -77,7 +75,7 @@ template <typename T,
               std::numeric_limits<T>::is_signed, int64_t, uint64_t>::type>
 std::vector<std::pair<T, H>> GetRandomClass128SampleSmallDivisor() {
   std::vector<std::pair<T, H>> values;
-  std::mt19937 random = MakeRandomEngine();
+  absl::InsecureBitGen random;
   std::uniform_int_distribution<H> uniform_h;
   values.reserve(kSampleSize);
   for (size_t i = 0; i < kSampleSize; ++i) {
@@ -114,7 +112,7 @@ BENCHMARK_TEMPLATE(BM_RemainderClass128SmallDivisor, absl::int128);
 
 std::vector<std::pair<absl::uint128, absl::uint128>> GetRandomClass128Sample() {
   std::vector<std::pair<absl::uint128, absl::uint128>> values;
-  std::mt19937 random = MakeRandomEngine();
+  absl::InsecureBitGen random;
   std::uniform_int_distribution<uint64_t> uniform_uint64;
   values.reserve(kSampleSize);
   for (size_t i = 0; i < kSampleSize; ++i) {
@@ -155,7 +153,8 @@ template <typename T,
 class UniformIntDistribution128 {
  public:
   // NOLINTNEXTLINE: mimicking std::uniform_int_distribution API
-  T operator()(std::mt19937& generator) {
+  template <class URBG>
+  T operator()(URBG& generator) {
     return (static_cast<T>(dist64_(generator)) << 64) | dist64_(generator);
   }
 
@@ -168,7 +167,7 @@ template <typename T,
               std::is_same<T, __int128>::value, int64_t, uint64_t>::type>
 std::vector<std::pair<T, T>> GetRandomIntrinsic128SampleUniformDivisor() {
   std::vector<std::pair<T, T>> values;
-  std::mt19937 random = MakeRandomEngine();
+  absl::InsecureBitGen random;
   UniformIntDistribution128<T> uniform_128;
   values.reserve(kSampleSize);
   for (size_t i = 0; i < kSampleSize; ++i) {
@@ -209,7 +208,7 @@ template <typename T,
               std::is_same<T, __int128>::value, int64_t, uint64_t>::type>
 std::vector<std::pair<T, H>> GetRandomIntrinsic128SampleSmallDivisor() {
   std::vector<std::pair<T, H>> values;
-  std::mt19937 random = MakeRandomEngine();
+  absl::InsecureBitGen random;
   UniformIntDistribution128<T> uniform_int128;
   std::uniform_int_distribution<H> uniform_int64;
   values.reserve(kSampleSize);
@@ -246,9 +245,9 @@ BENCHMARK_TEMPLATE(BM_RemainderIntrinsic128SmallDivisor, unsigned __int128);
 BENCHMARK_TEMPLATE(BM_RemainderIntrinsic128SmallDivisor, __int128);
 
 std::vector<std::pair<unsigned __int128, unsigned __int128>>
-      GetRandomIntrinsic128Sample() {
+GetRandomIntrinsic128Sample() {
   std::vector<std::pair<unsigned __int128, unsigned __int128>> values;
-  std::mt19937 random = MakeRandomEngine();
+  absl::InsecureBitGen random;
   UniformIntDistribution128<unsigned __int128> uniform_uint128;
   values.reserve(kSampleSize);
   for (size_t i = 0; i < kSampleSize; ++i) {

package/vendor/abseil-cpp/absl/numeric/int128_test.cc

@@ -1273,19 +1273,24 @@ TEST(Int128, BitwiseShiftTest) {
     }
   }
 
+  // Signed integer overflow is undefined behavior, so in these cases enough
+  // high bits must be zero to avoid over-shifting.
+  EXPECT_EQ(MAKE_INT128(0x0, 0x123456789abcdef0) << 63,
+            MAKE_INT128(0x91a2b3c4d5e6f78, 0x0));
+  EXPECT_EQ(MAKE_INT128(0x0, 0x123456789abcdef0) << 64,
+            MAKE_INT128(0x123456789abcdef0, 0x0));
+  EXPECT_EQ(MAKE_INT128(0x1, 0xfedcba0987654321) << 63,
+            MAKE_INT128(0xff6e5d04c3b2a190, 0x8000000000000000));
+  EXPECT_EQ(MAKE_INT128(0x0, 0xfedcba0987654321) << 64,
+            MAKE_INT128(0xfedcba0987654321, 0x0));
+  EXPECT_EQ(MAKE_INT128(0x0, 0x0) << 126, MAKE_INT128(0x0, 0x0));
+  EXPECT_EQ(MAKE_INT128(0x0, 0x1) << 126, MAKE_INT128(0x4000000000000000, 0x0));
+
   // Manually calculated cases with shift count for positive (val1) and negative
   // (val2) values
   absl::int128 val1 = MAKE_INT128(0x123456789abcdef0, 0x123456789abcdef0);
   absl::int128 val2 = MAKE_INT128(0xfedcba0987654321, 0xfedcba0987654321);
 
-  EXPECT_EQ(val1 << 63, MAKE_INT128(0x91a2b3c4d5e6f78, 0x0));
-  EXPECT_EQ(val1 << 64, MAKE_INT128(0x123456789abcdef0, 0x0));
-  EXPECT_EQ(val2 << 63, MAKE_INT128(0xff6e5d04c3b2a190, 0x8000000000000000));
-  EXPECT_EQ(val2 << 64, MAKE_INT128(0xfedcba0987654321, 0x0));
-
-  EXPECT_EQ(val1 << 126, MAKE_INT128(0x0, 0x0));
-  EXPECT_EQ(val2 << 126, MAKE_INT128(0x4000000000000000, 0x0));
-
   EXPECT_EQ(val1 >> 63, MAKE_INT128(0x0, 0x2468acf13579bde0));
   EXPECT_EQ(val1 >> 64, MAKE_INT128(0x0, 0x123456789abcdef0));
   EXPECT_EQ(val2 >> 63, MAKE_INT128(0xffffffffffffffff, 0xfdb974130eca8643));

package/vendor/abseil-cpp/absl/numeric/internal/bits.h

@@ -71,25 +71,53 @@ constexpr bool IsPowerOf2(unsigned int x) noexcept {
 }
 
 template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
+[[nodiscard]] ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
     T x, int s) noexcept {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
                 "T must have a power-of-2 size");
 
-  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
+  // Rotate by s mod the number of digits to avoid unnecessary rotations.
+  //
+  // A negative s represents a left rotation instead of a right rotation.
+  // We compute it as an equivalent complementary right rotation by leveraging
+  // its two's complement representation.
+  //
+  // For example, suppose we rotate a 3-bit number by -2.
+  // In that case:
+  //   * s = 0b11111111111111111111111111111110
+  //   * n = 8
+  //   * r = (0b11111111111111111111111111111110 & 0b111) = 0b110
+  //
+  // Instead of rotating by 2 to the left, we rotate by 6 to the right, which
+  // is equivalent.
+  const int n = std::numeric_limits<T>::digits;
+  const int r = s & (n - 1);
+
+  if (r == 0) {
+    return x;
+  } else {
+    return (x >> r) | (x << (n - r));
+  }
 }
 
 template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
+[[nodiscard]] ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
     T x, int s) noexcept {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
                 "T must have a power-of-2 size");
 
-  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
+  // Rotate by s mod the number of digits to avoid unnecessary rotations.
+  // See comment in RotateRight for a detailed explanation of the logic below.
+  const int n = std::numeric_limits<T>::digits;
+  const int r = s & (n - 1);
+
+  if (r == 0) {
+    return x;
+  } else {
+    return (x << r) | (x >> (n - r));
+  }
 }
 
 ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
@@ -126,7 +154,11 @@ Popcount(T x) noexcept {
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
                 "T must have a power-of-2 size");
   static_assert(sizeof(x) <= sizeof(uint64_t), "T is too large");
-  return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x);
+  if constexpr (sizeof(x) <= sizeof(uint32_t)) {
+    return Popcount32(x);
+  } else {
+    return Popcount64(x);
+  }
 }
 
 ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int

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

@@ -12,6 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
 load(
     "//absl:copts/configure_copts.bzl",
     "ABSL_DEFAULT_COPTS",
@@ -49,6 +52,7 @@ cc_library(
 cc_test(
     name = "sample_recorder_test",
     srcs = ["internal/sample_recorder_test.cc"],
+    copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     tags = [
         "no_test_wasm",
@@ -56,6 +60,7 @@ cc_test(
     deps = [
         ":sample_recorder",
         "//absl/base:core_headers",
+        "//absl/random",
         "//absl/synchronization",
         "//absl/synchronization:thread_pool",
         "//absl/time",
@@ -68,6 +73,7 @@ cc_library(
     name = "exponential_biased",
     srcs = ["internal/exponential_biased.cc"],
     hdrs = ["internal/exponential_biased.h"],
+    copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
         "//absl:__subpackages__",
@@ -138,3 +144,44 @@ cc_binary(
         "@google_benchmark//:benchmark_main",
     ],
 )
+
+cc_library(
+    name = "profile_builder",
+    srcs = ["internal/profile_builder.cc"],
+    hdrs = ["internal/profile_builder.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
+    deps = [
+        "//absl/base",
+        "//absl/base:config",
+        "//absl/base:raw_logging_internal",
+        "//absl/container:btree",
+        "//absl/container:flat_hash_map",
+        "//absl/strings",
+        "//absl/types:span",
+    ],
+)
+
+cc_library(
+    name = "hashtable",
+    srcs = ["hashtable.cc"],
+    hdrs = ["hashtable.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
+    deps = [
+        ":profile_builder",
+        "//absl/base:config",
+        "//absl/container:hashtablez_sampler",
+        "//absl/status:statusor",
+        "//absl/strings",
+        "//absl/strings:string_view",
+        "//absl/time",
+        "//absl/types:span",
+    ],
+)

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

@@ -32,6 +32,7 @@ absl_cc_test(
   COPTS
     ${ABSL_TEST_COPTS}
   DEPS
+    absl::random_random
     absl::sample_recorder
     absl::time
     GTest::gmock_main
@@ -91,3 +92,40 @@ absl_cc_test(
     GTest::gmock_main
 )
 
+# Internal-only target, do not depend on directly
+absl_cc_library(
+  NAME
+    profile_builder
+  HDRS
+    "internal/profile_builder.h"
+  SRCS
+    "internal/profile_builder.cc"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::config
+    absl::core_headers
+    absl::raw_logging_internal
+    absl::flat_hash_map
+    absl::btree
+    absl::strings
+    absl::span
+)
+
+absl_cc_library(
+  NAME
+    hashtable_profiler
+  HDRS
+    "hashtable.h"
+  SRCS
+    "hashtable.cc"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::profile_builder
+    absl::config
+    absl::core_headers
+    absl::strings
+    absl::span
+    absl::hashtablez_sampler
+)

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

@@ -0,0 +1,124 @@
+// 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/hashtable.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/container/internal/hashtablez_sampler.h"
+#include "absl/profiling/internal/profile_builder.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+StatusOr<std::string> MarshalHashtableProfile() {
+  return debugging_internal::MarshalHashtableProfile(
+      container_internal::GlobalHashtablezSampler(), Now());
+}
+
+namespace debugging_internal {
+
+StatusOr<std::string> MarshalHashtableProfile(
+    container_internal::HashtablezSampler& sampler, Time now) {
+  static constexpr absl::string_view kDropFrames =
+      "(::)?absl::container_internal::.*|"
+      "(::)?absl::(flat|node)_hash_(map|set).*";
+
+  ProfileBuilder builder;
+  StringId drop_frames_id = builder.InternString(kDropFrames);
+  builder.set_drop_frames_id(drop_frames_id);
+  builder.AddSampleType(builder.InternString("capacity"),
+                        builder.InternString("count"));
+  builder.set_default_sample_type_id(builder.InternString("capacity"));
+
+  const auto capacity_id = builder.InternString("capacity");
+  const auto size_id = builder.InternString("size");
+  const auto num_erases_id = builder.InternString("num_erases");
+  const auto num_rehashes_id = builder.InternString("num_rehashes");
+  const auto max_probe_length_id = builder.InternString("max_probe_length");
+  const auto total_probe_length_id = builder.InternString("total_probe_length");
+  const auto stuck_bits_id = builder.InternString("stuck_bits");
+  const auto inline_element_size_id =
+      builder.InternString("inline_element_size");
+  const auto key_size_id = builder.InternString("key_size");
+  const auto value_size_id = builder.InternString("value_size");
+  const auto soo_capacity_id = builder.InternString("soo_capacity");
+  const auto checksum_id = builder.InternString("checksum");
+  const auto table_age_id = builder.InternString("table_age");
+  const auto max_reserve_id = builder.InternString("max_reserve");
+
+  size_t dropped =
+      sampler.Iterate([&](const container_internal::HashtablezInfo& info) {
+        const size_t capacity = info.capacity.load(std::memory_order_relaxed);
+        std::vector<std::pair<StringId, int64_t>> labels;
+
+        auto add_label = [&](StringId tag, uint64_t value) {
+          if (value == 0) {
+            return;
+          }
+          labels.emplace_back(tag, static_cast<int64_t>(value));
+        };
+
+        add_label(capacity_id, capacity);
+        add_label(size_id, info.size.load(std::memory_order_relaxed));
+        add_label(num_erases_id,
+                  info.num_erases.load(std::memory_order_relaxed));
+        add_label(num_rehashes_id,
+                  info.num_rehashes.load(std::memory_order_relaxed));
+        add_label(max_probe_length_id,
+                  info.max_probe_length.load(std::memory_order_relaxed));
+        add_label(total_probe_length_id,
+                  info.total_probe_length.load(std::memory_order_relaxed));
+        add_label(stuck_bits_id,
+                  (info.hashes_bitwise_and.load(std::memory_order_relaxed) |
+                   ~info.hashes_bitwise_or.load(std::memory_order_relaxed)));
+        add_label(inline_element_size_id, info.inline_element_size);
+        add_label(key_size_id, info.key_size);
+        add_label(value_size_id, info.value_size);
+        add_label(soo_capacity_id, info.soo_capacity);
+        add_label(checksum_id,
+                  info.hashes_bitwise_xor.load(std::memory_order_relaxed));
+        add_label(
+            table_age_id,
+            static_cast<uint64_t>(ToInt64Microseconds(now - info.create_time)));
+        add_label(max_reserve_id,
+                  info.max_reserve.load(std::memory_order_relaxed));
+        builder.AddSample(static_cast<int64_t>(capacity) * info.weight,
+                          MakeSpan(info.stack, info.depth), labels);
+      });
+
+  // TODO(b/262310142): Make this more structured data.
+  StringId comment_id =
+      builder.InternString(StrCat("dropped_samples: ", dropped));
+  builder.set_comment_id(comment_id);
+  builder.AddCurrentMappings();
+  return std::move(builder).Emit();
+}
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl