re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.cc

@@ -1,118 +0,0 @@
-// 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/debugging/internal/borrowed_fixup_buffer.h"
-
-#include <assert.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <atomic>
-#include <iterator>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/low_level_alloc.h"
-#include "absl/hash/hash.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal_stacktrace {
-
-// A buffer for holding fix-up information for stack traces of common sizes_.
-struct BorrowedFixupBuffer::FixupStackBuffer {
-  static constexpr size_t kMaxStackElements = 128;  // Can be reduced if needed
-  std::atomic_flag in_use{};
-  uintptr_t frames[kMaxStackElements];
-  int sizes[kMaxStackElements];
-
-  ABSL_CONST_INIT static FixupStackBuffer g_instances[kNumStaticBuffers];
-};
-
-ABSL_CONST_INIT BorrowedFixupBuffer::FixupStackBuffer
-    BorrowedFixupBuffer::FixupStackBuffer::g_instances[kNumStaticBuffers] = {};
-
-BorrowedFixupBuffer::~BorrowedFixupBuffer() {
-  if (borrowed_) {
-    std::move(*this).Unlock();
-  } else {
-    base_internal::LowLevelAlloc::Free(frames_);
-  }
-}
-
-BorrowedFixupBuffer::BorrowedFixupBuffer(size_t length)
-    : borrowed_(0 < length && length <= FixupStackBuffer::kMaxStackElements
-                    ? TryLock()
-                    : nullptr) {
-  if (borrowed_) {
-    InitViaBorrow();
-  } else {
-    InitViaAllocation(length);
-  }
-}
-
-void BorrowedFixupBuffer::InitViaBorrow() {
-  assert(borrowed_);
-  frames_ = borrowed_->frames;
-  sizes_ = borrowed_->sizes;
-}
-
-void BorrowedFixupBuffer::InitViaAllocation(size_t length) {
-  static_assert(alignof(decltype(*frames_)) >= alignof(decltype(*sizes_)),
-                "contiguous layout assumes decreasing alignment, otherwise "
-                "padding may be needed in the middle");
-  assert(!borrowed_);
-
-  base_internal::InitSigSafeArena();
-  void* buf = base_internal::LowLevelAlloc::AllocWithArena(
-      length * (sizeof(*frames_) + sizeof(*sizes_)),
-      base_internal::SigSafeArena());
-
-  if (buf == nullptr) {
-    frames_ = nullptr;
-    sizes_ = nullptr;
-    return;
-  }
-
-  frames_ = new (buf) uintptr_t[length];
-  sizes_ = new (static_cast<void*>(static_cast<unsigned char*>(buf) +
-                                   length * sizeof(*frames_))) int[length];
-}
-
-[[nodiscard]] BorrowedFixupBuffer::FixupStackBuffer*
-BorrowedFixupBuffer::TryLock() {
-  constexpr size_t kNumSlots = std::size(FixupStackBuffer::g_instances);
-  const size_t i = absl::Hash<const void*>()(this) % kNumSlots;
-  for (size_t k = 0; k < kNumSlots; ++k) {
-    auto* instance = &FixupStackBuffer::g_instances[(i + k) % kNumSlots];
-    // Use memory_order_acquire to ensure that no reads and writes on the
-    // borrowed buffer are reordered before the borrowing.
-    if (!instance->in_use.test_and_set(std::memory_order_acquire)) {
-      return instance;
-    }
-  }
-  return nullptr;
-}
-
-void BorrowedFixupBuffer::Unlock() && {
-  // Use memory_order_release to ensure that no reads and writes on the borrowed
-  // buffer are reordered after the borrowing.
-  borrowed_->in_use.clear(std::memory_order_release);
-}
-
-}  // namespace internal_stacktrace
-ABSL_NAMESPACE_END
-}  // namespace absl

package/vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.h

@@ -1,71 +0,0 @@
-// 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_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_
-#define ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal_stacktrace {
-
-// An RAII type that temporarily acquires a buffer for stack trace fix-ups from
-// a pool of preallocated buffers, or attempts to allocate a new buffer if no
-// such buffer is available.
-// When destroyed, returns the buffer to the pool if it borrowed successfully,
-// otherwise deallocates any previously allocated buffer.
-class BorrowedFixupBuffer {
- public:
-  static constexpr size_t kNumStaticBuffers = 64;
-  ~BorrowedFixupBuffer();
-
-  // The number of frames to allocate space for. Note that allocations can fail.
-  explicit BorrowedFixupBuffer(size_t length);
-
-  uintptr_t* frames() const { return frames_; }
-  int* sizes() const { return sizes_; }
-
- private:
-  struct FixupStackBuffer;
-
-  uintptr_t* frames_;
-  int* sizes_;
-
-  // The borrowed pre-existing buffer, if any (if we haven't allocated our own)
-  FixupStackBuffer* const borrowed_;
-
-  void InitViaBorrow();
-  void InitViaAllocation(size_t length);
-
-  // Attempts to opportunistically borrow a small buffer in a thread- and
-  // signal-safe manner. Returns nullptr on failure.
-  [[nodiscard]] FixupStackBuffer* TryLock();
-
-  // Returns the borrowed buffer.
-  void Unlock() &&;
-
-  BorrowedFixupBuffer(const BorrowedFixupBuffer&) = delete;
-  BorrowedFixupBuffer& operator=(const BorrowedFixupBuffer&) = delete;
-};
-
-}  // namespace internal_stacktrace
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_

package/vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer_test.cc

@@ -1,97 +0,0 @@
-// 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/debugging/internal/borrowed_fixup_buffer.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <functional>
-#include <memory>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal_stacktrace {
-namespace {
-
-TEST(BorrowedFixupBuffer, ProperReuse) {
-  uintptr_t first_borrowed_frame = 0;
-  uintptr_t first_borrowed_size = 0;
-
-  // Ensure that we borrow the same buffer each time, indicating proper reuse.
-  // Disable loop unrolling. We need all iterations to match exactly, to coax
-  // reuse of the the same underlying buffer.
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC unroll 1  // <= 1 disables unrolling
-#endif
-  for (int i = 0; i < 100; ++i) {
-    BorrowedFixupBuffer buf0(0);
-    EXPECT_EQ(buf0.frames(), nullptr);
-    EXPECT_EQ(buf0.sizes(), nullptr);
-
-    BorrowedFixupBuffer buf1(1);
-    EXPECT_NE(buf1.frames(), nullptr);
-    EXPECT_NE(buf1.sizes(), nullptr);
-    if (first_borrowed_frame == 0) {
-      first_borrowed_frame = reinterpret_cast<uintptr_t>(buf1.frames());
-    } else {
-      EXPECT_EQ(reinterpret_cast<uintptr_t>(buf1.frames()),
-                first_borrowed_frame);
-    }
-    if (first_borrowed_size == 0) {
-      first_borrowed_size = reinterpret_cast<uintptr_t>(buf1.sizes());
-    } else {
-      EXPECT_EQ(reinterpret_cast<uintptr_t>(buf1.sizes()), first_borrowed_size);
-    }
-
-    BorrowedFixupBuffer buf2(2);
-    EXPECT_NE(buf2.frames(), buf1.frames());
-    EXPECT_NE(buf2.sizes(), buf1.sizes());
-    EXPECT_NE(buf2.frames(), nullptr);
-    EXPECT_NE(buf2.sizes(), nullptr);
-  }
-}
-
-TEST(BorrowedFixupBuffer, NoOverlap) {
-  using BufferPtr = std::unique_ptr<BorrowedFixupBuffer>;
-  static constexpr std::less<const void*> less;
-  static constexpr size_t kBufLen = 5;
-  static constexpr size_t kNumBuffers =
-      BorrowedFixupBuffer::kNumStaticBuffers * 37 + 1;
-
-  auto bufs = std::make_unique<BufferPtr[]>(kNumBuffers);
-  for (size_t i = 0; i < kNumBuffers; ++i) {
-    bufs[i] = std::make_unique<BorrowedFixupBuffer>(kBufLen);
-  }
-
-  std::sort(bufs.get(), bufs.get() + kNumBuffers,
-            [](const BufferPtr& a, const BufferPtr& b) {
-              return less(a->frames(), b->frames());
-            });
-
-  // Verify there are no overlaps
-  for (size_t i = 1; i < kNumBuffers; ++i) {
-    EXPECT_FALSE(less(bufs[i]->frames(), bufs[i - 1]->frames() + kBufLen));
-    EXPECT_FALSE(less(bufs[i]->sizes(), bufs[i - 1]->sizes() + kBufLen));
-  }
-}
-
-}  // namespace
-}  // namespace internal_stacktrace
-ABSL_NAMESPACE_END
-}  // namespace absl