@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/debugging/leak_check.h

@@ -1,150 +0,0 @@
-// Copyright 2018 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.
-//
-// -----------------------------------------------------------------------------
-// File: leak_check.h
-// -----------------------------------------------------------------------------
-//
-// This file contains functions that affect leak checking behavior within
-// targets built with the LeakSanitizer (LSan), a memory leak detector that is
-// integrated within the AddressSanitizer (ASan) as an additional component, or
-// which can be used standalone. LSan and ASan are included (or can be provided)
-// as additional components for most compilers such as Clang, gcc and MSVC.
-// Note: this leak checking API is not yet supported in MSVC.
-// Leak checking is enabled by default in all ASan builds.
-//
-// https://clang.llvm.org/docs/LeakSanitizer.html
-// https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
-//
-// GCC and Clang both automatically enable LeakSanitizer when AddressSanitizer
-// is enabled. To use the mode, simply pass `-fsanitize=address` to both the
-// compiler and linker. An example Bazel command could be
-//
-//   $ bazel test --copt=-fsanitize=address --linkopt=-fsanitize=address ...
-//
-// GCC and Clang auto support a standalone LeakSanitizer mode (a mode which does
-// not also use AddressSanitizer). To use the mode, simply pass
-// `-fsanitize=leak` to both the compiler and linker. Since GCC does not
-// currently provide a way of detecting this mode at compile-time, GCC users
-// must also pass -DLEAK_SANITIZER to the compiler. An example Bazel command
-// could be
-//
-//   $ bazel test --copt=-DLEAK_SANITIZER --copt=-fsanitize=leak
-//     --linkopt=-fsanitize=leak ...
-//
-// -----------------------------------------------------------------------------
-#ifndef ABSL_DEBUGGING_LEAK_CHECK_H_
-#define ABSL_DEBUGGING_LEAK_CHECK_H_
-
-#include <cstddef>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// HaveLeakSanitizer()
-//
-// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
-// currently built into this target.
-bool HaveLeakSanitizer();
-
-// LeakCheckerIsActive()
-//
-// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
-// currently built into this target and is turned on.
-bool LeakCheckerIsActive();
-
-// DoIgnoreLeak()
-//
-// Implements `IgnoreLeak()` below. This function should usually
-// not be called directly; calling `IgnoreLeak()` is preferred.
-void DoIgnoreLeak(const void* ptr);
-
-// IgnoreLeak()
-//
-// Instruct the leak sanitizer to ignore leak warnings on the object referenced
-// by the passed pointer, as well as all heap objects transitively referenced
-// by it. The passed object pointer can point to either the beginning of the
-// object or anywhere within it.
-//
-// Example:
-//
-//   static T* obj = IgnoreLeak(new T(...));
-//
-// If the passed `ptr` does not point to an actively allocated object at the
-// time `IgnoreLeak()` is called, the call is a no-op; if it is actively
-// allocated, leak sanitizer will assume this object is referenced even if
-// there is no actual reference in user memory.
-//
-template <typename T>
-T* IgnoreLeak(T* ptr) {
-  DoIgnoreLeak(ptr);
-  return ptr;
-}
-
-// FindAndReportLeaks()
-//
-// If any leaks are detected, prints a leak report and returns true.  This
-// function may be called repeatedly, and does not affect end-of-process leak
-// checking.
-//
-// Example:
-// if (FindAndReportLeaks()) {
-//   ... diagnostic already printed. Exit with failure code.
-//   exit(1)
-// }
-bool FindAndReportLeaks();
-
-// LeakCheckDisabler
-//
-// This helper class indicates that any heap allocations done in the code block
-// covered by the scoped object, which should be allocated on the stack, will
-// not be reported as leaks. Leak check disabling will occur within the code
-// block and any nested function calls within the code block.
-//
-// Example:
-//
-//   void Foo() {
-//     LeakCheckDisabler disabler;
-//     ... code that allocates objects whose leaks should be ignored ...
-//   }
-//
-// REQUIRES: Destructor runs in same thread as constructor
-class LeakCheckDisabler {
- public:
-  LeakCheckDisabler();
-  LeakCheckDisabler(const LeakCheckDisabler&) = delete;
-  LeakCheckDisabler& operator=(const LeakCheckDisabler&) = delete;
-  ~LeakCheckDisabler();
-};
-
-// RegisterLivePointers()
-//
-// Registers `ptr[0,size-1]` as pointers to memory that is still actively being
-// referenced and for which leak checking should be ignored. This function is
-// useful if you store pointers in mapped memory, for memory ranges that we know
-// are correct but for which normal analysis would flag as leaked code.
-void RegisterLivePointers(const void* ptr, size_t size);
-
-// UnRegisterLivePointers()
-//
-// Deregisters the pointers previously marked as active in
-// `RegisterLivePointers()`, enabling leak checking of those pointers.
-void UnRegisterLivePointers(const void* ptr, size_t size);
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_LEAK_CHECK_H_

package/deps/abseil-cpp/absl/debugging/leak_check_fail_test.cc

@@ -1,41 +0,0 @@
-// Copyright 2017 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 <memory>
-
-#include "gtest/gtest.h"
-#include "absl/debugging/leak_check.h"
-#include "absl/log/log.h"
-
-namespace {
-
-TEST(LeakCheckTest, LeakMemory) {
-  // This test is expected to cause lsan failures on program exit. Therefore the
-  // test will be run only by leak_check_test.sh, which will verify a
-  // failed exit code.
-
-  char* foo = strdup("lsan should complain about this leaked string");
-  LOG(INFO) << "Should detect leaked string " << foo;
-}
-
-TEST(LeakCheckTest, LeakMemoryAfterDisablerScope) {
-  // This test is expected to cause lsan failures on program exit. Therefore the
-  // test will be run only by external_leak_check_test.sh, which will verify a
-  // failed exit code.
-  { absl::LeakCheckDisabler disabler; }
-  char* foo = strdup("lsan should also complain about this leaked string");
-  LOG(INFO) << "Re-enabled leak detection.Should detect leaked string " << foo;
-}
-
-}  // namespace

package/deps/abseil-cpp/absl/debugging/leak_check_test.cc

@@ -1,41 +0,0 @@
-// Copyright 2017 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 <string>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/debugging/leak_check.h"
-#include "absl/log/log.h"
-
-namespace {
-
-TEST(LeakCheckTest, IgnoreLeakSuppressesLeakedMemoryErrors) {
-  if (!absl::LeakCheckerIsActive()) {
-    GTEST_SKIP() << "LeakChecker is not active";
-  }
-  auto foo = absl::IgnoreLeak(new std::string("some ignored leaked string"));
-  LOG(INFO) << "Ignoring leaked string " << foo;
-}
-
-TEST(LeakCheckTest, LeakCheckDisablerIgnoresLeak) {
-  if (!absl::LeakCheckerIsActive()) {
-    GTEST_SKIP() << "LeakChecker is not active";
-  }
-  absl::LeakCheckDisabler disabler;
-  auto foo = new std::string("some string leaked while checks are disabled");
-  LOG(INFO) << "Ignoring leaked string " << foo;
-}
-
-}  // namespace

package/deps/abseil-cpp/absl/debugging/stacktrace.cc

@@ -1,244 +0,0 @@
-// Copyright 2017 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.
-
-// Produce stack trace.
-//
-// There are three different ways we can try to get the stack trace:
-//
-// 1) Our hand-coded stack-unwinder.  This depends on a certain stack
-//    layout, which is used by gcc (and those systems using a
-//    gcc-compatible ABI) on x86 systems, at least since gcc 2.95.
-//    It uses the frame pointer to do its work.
-//
-// 2) The libunwind library.  This is still in development, and as a
-//    separate library adds a new dependency, but doesn't need a frame
-//    pointer.  It also doesn't call malloc.
-//
-// 3) The gdb unwinder -- also the one used by the c++ exception code.
-//    It's obviously well-tested, but has a fatal flaw: it can call
-//    malloc() from the unwinder.  This is a problem because we're
-//    trying to use the unwinder to instrument malloc().
-//
-// Note: if you add a new implementation here, make sure it works
-// correctly when absl::GetStackTrace() is called with max_depth == 0.
-// Some code may do that.
-
-#include "absl/debugging/stacktrace.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <algorithm>
-#include <atomic>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h"
-#include "absl/debugging/internal/borrowed_fixup_buffer.h"
-#include "absl/debugging/internal/stacktrace_config.h"
-
-#if defined(ABSL_STACKTRACE_INL_HEADER)
-#include ABSL_STACKTRACE_INL_HEADER
-#else
-#error Cannot calculate stack trace: will need to write for your environment
-
-#include "absl/debugging/internal/stacktrace_aarch64-inl.inc"
-#include "absl/debugging/internal/stacktrace_arm-inl.inc"
-#include "absl/debugging/internal/stacktrace_emscripten-inl.inc"
-#include "absl/debugging/internal/stacktrace_generic-inl.inc"
-#include "absl/debugging/internal/stacktrace_powerpc-inl.inc"
-#include "absl/debugging/internal/stacktrace_riscv-inl.inc"
-#include "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
-#include "absl/debugging/internal/stacktrace_win32-inl.inc"
-#include "absl/debugging/internal/stacktrace_x86-inl.inc"
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace {
-
-typedef int (*Unwinder)(void**, int*, int, int, const void*, int*);
-std::atomic<Unwinder> custom;
-
-template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, uintptr_t* frames,
-                                               int* sizes, size_t max_depth,
-                                               int skip_count, const void* uc,
-                                               int* min_dropped_frames,
-                                               bool unwind_with_fixup = true) {
-  unwind_with_fixup =
-      unwind_with_fixup && internal_stacktrace::ShouldFixUpStack();
-
-#ifdef _WIN32
-  if (unwind_with_fixup) {
-    // TODO(b/434184677): Fixups are flaky and not supported on Windows
-    unwind_with_fixup = false;
-#ifndef NDEBUG
-    abort();
-#endif
-  }
-#endif
-
-  // Some implementations of FixUpStack may need to be passed frame
-  // information from Unwind, even if the caller doesn't need that
-  // information. We allocate the necessary buffers for such implementations
-  // here.
-  const internal_stacktrace::BorrowedFixupBuffer fixup_buffer(
-      unwind_with_fixup ? max_depth : 0);
-  if (frames == nullptr) {
-    frames = fixup_buffer.frames();
-  }
-  if (sizes == nullptr) {
-    sizes = fixup_buffer.sizes();
-  }
-
-  Unwinder g = custom.load(std::memory_order_acquire);
-  size_t size;
-  // Add 1 to skip count for the unwinder function itself
-  ++skip_count;
-  if (g != nullptr) {
-    size = static_cast<size_t>((*g)(result, sizes, static_cast<int>(max_depth),
-                                    skip_count, uc, min_dropped_frames));
-    // Frame pointers aren't returned by existing hooks, so clear them.
-    if (frames != nullptr) {
-      std::fill(frames, frames + size, uintptr_t());
-    }
-  } else {
-    size = static_cast<size_t>(
-        unwind_with_fixup
-            ? UnwindImpl<true, IS_WITH_CONTEXT>(
-                  result, frames, sizes, static_cast<int>(max_depth),
-                  skip_count, uc, min_dropped_frames)
-            : UnwindImpl<IS_STACK_FRAMES, IS_WITH_CONTEXT>(
-                  result, frames, sizes, static_cast<int>(max_depth),
-                  skip_count, uc, min_dropped_frames));
-  }
-  if (unwind_with_fixup) {
-    internal_stacktrace::FixUpStack(result, frames, sizes, max_depth, size);
-  }
-
-  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
-  return static_cast<int>(size);
-}
-
-}  // anonymous namespace
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
-internal_stacktrace::GetStackFrames(void** result, uintptr_t* frames,
-                                    int* sizes, int max_depth, int skip_count) {
-  return Unwind<true, false>(result, frames, sizes,
-                             static_cast<size_t>(max_depth), skip_count,
-                             nullptr, nullptr);
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
-internal_stacktrace::GetStackFramesWithContext(void** result, uintptr_t* frames,
-                                               int* sizes, int max_depth,
-                                               int skip_count, const void* uc,
-                                               int* min_dropped_frames) {
-  return Unwind<true, true>(result, frames, sizes,
-                            static_cast<size_t>(max_depth), skip_count, uc,
-                            min_dropped_frames);
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
-internal_stacktrace::GetStackTraceNoFixup(void** result, int max_depth,
-                                          int skip_count) {
-  return Unwind<false, false>(result, nullptr, nullptr,
-                              static_cast<size_t>(max_depth), skip_count,
-                              nullptr, nullptr, /*unwind_with_fixup=*/false);
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace(
-    void** result, int max_depth, int skip_count) {
-  return Unwind<false, false>(result, nullptr, nullptr,
-                              static_cast<size_t>(max_depth), skip_count,
-                              nullptr, nullptr);
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
-GetStackTraceWithContext(void** result, int max_depth, int skip_count,
-                         const void* uc, int* min_dropped_frames) {
-  return Unwind<false, true>(result, nullptr, nullptr,
-                             static_cast<size_t>(max_depth), skip_count, uc,
-                             min_dropped_frames);
-}
-
-void SetStackUnwinder(Unwinder w) {
-  custom.store(w, std::memory_order_release);
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE static inline int DefaultStackUnwinderImpl(
-    void** pcs, uintptr_t* frames, int* sizes, int depth, int skip,
-    const void* uc, int* min_dropped_frames) {
-  skip++;  // For this function
-  decltype(&UnwindImpl<false, false>) f;
-  if (sizes == nullptr) {
-    if (uc == nullptr) {
-      f = &UnwindImpl<false, false>;
-    } else {
-      f = &UnwindImpl<false, true>;
-    }
-  } else {
-    if (uc == nullptr) {
-      f = &UnwindImpl<true, false>;
-    } else {
-      f = &UnwindImpl<true, true>;
-    }
-  }
-  return (*f)(pcs, frames, sizes, depth, skip, uc, min_dropped_frames);
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
-internal_stacktrace::DefaultStackUnwinder(void** pcs, uintptr_t* frames,
-                                          int* sizes, int depth, int skip,
-                                          const void* uc,
-                                          int* min_dropped_frames) {
-  int n = DefaultStackUnwinderImpl(pcs, frames, sizes, depth, skip, uc,
-                                   min_dropped_frames);
-  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
-  return n;
-}
-
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int DefaultStackUnwinder(
-    void** pcs, int* sizes, int depth, int skip, const void* uc,
-    int* min_dropped_frames) {
-  int n = DefaultStackUnwinderImpl(pcs, nullptr, sizes, depth, skip, uc,
-                                   min_dropped_frames);
-  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
-  return n;
-}
-
-ABSL_ATTRIBUTE_WEAK bool internal_stacktrace::ShouldFixUpStack() {
-  return false;
-}
-
-// Fixes up the stack trace of the current thread, in the first `depth` frames
-// of each buffer. The buffers need to be larger than `depth`, to accommodate
-// any newly inserted elements. `depth` is updated to reflect the new number of
-// elements valid across all the buffers. (It is therefore recommended that all
-// buffer sizes be equal.)
-//
-// The `frames` and `sizes` parameters denote the bounds of the stack frame
-// corresponding to each instruction pointer in the `pcs`.
-// Any elements inside these buffers may be zero or null, in which case that
-// information is assumed to be absent/unavailable.
-ABSL_ATTRIBUTE_WEAK void internal_stacktrace::FixUpStack(void**, uintptr_t*,
-                                                         int*, size_t,
-                                                         size_t&) {}
-
-ABSL_NAMESPACE_END
-}  // namespace absl