grpc 1.50.0.pre1-x86_64-linux → 1.52.0.pre2-x86_64-linux

data/third_party/abseil-cpp/absl/base/internal/low_level_alloc.h

@@ -1,126 +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.
-//
-
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-
-// A simple thread-safe memory allocator that does not depend on
-// mutexes or thread-specific data.  It is intended to be used
-// sparingly, and only when malloc() would introduce an unwanted
-// dependency, such as inside the heap-checker, or the Mutex
-// implementation.
-
-// IWYU pragma: private, include "base/low_level_alloc.h"
-
-#include <sys/types.h>
-
-#include <cstdint>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-// LowLevelAlloc requires that the platform support low-level
-// allocation of virtual memory. Platforms lacking this cannot use
-// LowLevelAlloc.
-#ifdef ABSL_LOW_LEVEL_ALLOC_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
-#elif !defined(ABSL_HAVE_MMAP) && !defined(_WIN32)
-#define ABSL_LOW_LEVEL_ALLOC_MISSING 1
-#endif
-
-// Using LowLevelAlloc with kAsyncSignalSafe isn't supported on Windows or
-// asm.js / WebAssembly.
-// See https://kripken.github.io/emscripten-site/docs/porting/pthreads.html
-// for more information.
-#ifdef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
-#elif defined(_WIN32) || defined(__asmjs__) || defined(__wasm__)
-#define ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
-#endif
-
-#include <cstddef>
-
-#include "absl/base/port.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class LowLevelAlloc {
- public:
-  struct Arena;       // an arena from which memory may be allocated
-
-  // Returns a pointer to a block of at least "request" bytes
-  // that have been newly allocated from the specific arena.
-  // for Alloc() call the DefaultArena() is used.
-  // Returns 0 if passed request==0.
-  // Does not return 0 under other circumstances; it crashes if memory
-  // is not available.
-  static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-  static void *AllocWithArena(size_t request, Arena *arena)
-      ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // Deallocates a region of memory that was previously allocated with
-  // Alloc().   Does nothing if passed 0.   "s" must be either 0,
-  // or must have been returned from a call to Alloc() and not yet passed to
-  // Free() since that call to Alloc().  The space is returned to the arena
-  // from which it was allocated.
-  static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
-  // are to put all callers of MallocHook::Invoke* in this module
-  // into special section,
-  // so that MallocHook::GetCallerStackTrace can function accurately.
-
-  // Create a new arena.
-  // The root metadata for the new arena is allocated in the
-  // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
-  // These values may be ored into flags:
-  enum {
-    // Report calls to Alloc() and Free() via the MallocHook interface.
-    // Set in the DefaultArena.
-    kCallMallocHook = 0x0001,
-
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-    // Make calls to Alloc(), Free() be async-signal-safe. Not set in
-    // DefaultArena(). Not supported on all platforms.
-    kAsyncSignalSafe = 0x0002,
-#endif
-  };
-  // Construct a new arena.  The allocation of the underlying metadata honors
-  // the provided flags.  For example, the call NewArena(kAsyncSignalSafe)
-  // is itself async-signal-safe, as well as generatating an arena that provides
-  // async-signal-safe Alloc/Free.
-  static Arena *NewArena(int32_t flags);
-
-  // Destroys an arena allocated by NewArena and returns true,
-  // provided no allocated blocks remain in the arena.
-  // If allocated blocks remain in the arena, does nothing and
-  // returns false.
-  // It is illegal to attempt to destroy the DefaultArena().
-  static bool DeleteArena(Arena *arena);
-
-  // The default arena that always exists.
-  static Arena *DefaultArena();
-
- private:
-  LowLevelAlloc();      // no instances
-};
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_

data/third_party/abseil-cpp/absl/base/internal/low_level_scheduling.h

@@ -1,134 +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.
-//
-// Core interfaces and definitions used by by low-level interfaces such as
-// SpinLock.
-
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/macros.h"
-
-// The following two declarations exist so SchedulingGuard may friend them with
-// the appropriate language linkage.  These callbacks allow libc internals, such
-// as function level statics, to schedule cooperatively when locking.
-extern "C" bool __google_disable_rescheduling(void);
-extern "C" void __google_enable_rescheduling(bool disable_result);
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-class CondVar;
-class Mutex;
-
-namespace synchronization_internal {
-int MutexDelay(int32_t c, int mode);
-}  // namespace synchronization_internal
-
-namespace base_internal {
-
-class SchedulingHelper;  // To allow use of SchedulingGuard.
-class SpinLock;          // To allow use of SchedulingGuard.
-
-// SchedulingGuard
-// Provides guard semantics that may be used to disable cooperative rescheduling
-// of the calling thread within specific program blocks.  This is used to
-// protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
-// scheduling depends on.
-//
-// Domain implementations capable of rescheduling in reaction to involuntary
-// kernel thread actions (e.g blocking due to a pagefault or syscall) must
-// guarantee that an annotated thread is not allowed to (cooperatively)
-// reschedule until the annotated region is complete.
-//
-// It is an error to attempt to use a cooperatively scheduled resource (e.g.
-// Mutex) within a rescheduling-disabled region.
-//
-// All methods are async-signal safe.
-class SchedulingGuard {
- public:
-  // Returns true iff the calling thread may be cooperatively rescheduled.
-  static bool ReschedulingIsAllowed();
-  SchedulingGuard(const SchedulingGuard&) = delete;
-  SchedulingGuard& operator=(const SchedulingGuard&) = delete;
-
- private:
-  // Disable cooperative rescheduling of the calling thread.  It may still
-  // initiate scheduling operations (e.g. wake-ups), however, it may not itself
-  // reschedule.  Nestable.  The returned result is opaque, clients should not
-  // attempt to interpret it.
-  // REQUIRES: Result must be passed to a pairing EnableScheduling().
-  static bool DisableRescheduling();
-
-  // Marks the end of a rescheduling disabled region, previously started by
-  // DisableRescheduling().
-  // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
-  static void EnableRescheduling(bool disable_result);
-
-  // A scoped helper for {Disable, Enable}Rescheduling().
-  // REQUIRES: destructor must run in same thread as constructor.
-  struct ScopedDisable {
-    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
-    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
-
-    bool disabled;
-  };
-
-  // A scoped helper to enable rescheduling temporarily.
-  // REQUIRES: destructor must run in same thread as constructor.
-  class ScopedEnable {
-   public:
-    ScopedEnable();
-    ~ScopedEnable();
-
-   private:
-    int scheduling_disabled_depth_;
-  };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class absl::CondVar;
-  friend class absl::Mutex;
-  friend class SchedulingHelper;
-  friend class SpinLock;
-  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
-};
-
-//------------------------------------------------------------------------------
-// End of public interfaces.
-//------------------------------------------------------------------------------
-
-inline bool SchedulingGuard::ReschedulingIsAllowed() {
-  return false;
-}
-
-inline bool SchedulingGuard::DisableRescheduling() {
-  return false;
-}
-
-inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
-  return;
-}
-
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
-inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_

data/third_party/abseil-cpp/absl/base/internal/per_thread_tls.h

@@ -1,52 +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.
-
-#ifndef ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-#define ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-
-// This header defines two macros:
-//
-// If the platform supports thread-local storage:
-//
-// * ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
-//   thread-local variable
-// * ABSL_PER_THREAD_TLS is 1
-//
-// Otherwise:
-//
-// * ABSL_PER_THREAD_TLS_KEYWORD is empty
-// * ABSL_PER_THREAD_TLS is 0
-//
-// Microsoft C supports thread-local storage.
-// GCC supports it if the appropriate version of glibc is available,
-// which the programmer can indicate by defining ABSL_HAVE_TLS
-
-#include "absl/base/port.h"  // For ABSL_HAVE_TLS
-
-#if defined(ABSL_PER_THREAD_TLS)
-#error ABSL_PER_THREAD_TLS cannot be directly set
-#elif defined(ABSL_PER_THREAD_TLS_KEYWORD)
-#error ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
-#elif defined(ABSL_HAVE_TLS)
-#define ABSL_PER_THREAD_TLS_KEYWORD __thread
-#define ABSL_PER_THREAD_TLS 1
-#elif defined(_MSC_VER)
-#define ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
-#define ABSL_PER_THREAD_TLS 1
-#else
-#define ABSL_PER_THREAD_TLS_KEYWORD
-#define ABSL_PER_THREAD_TLS 0
-#endif
-
-#endif  // ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_

data/third_party/abseil-cpp/absl/base/internal/prefetch.h

@@ -1,138 +0,0 @@
-// Copyright 2022 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_BASE_INTERNAL_PREFETCH_H_
-#define ABSL_BASE_INTERNAL_PREFETCH_H_
-
-#include "absl/base/config.h"
-
-#ifdef __SSE__
-#include <xmmintrin.h>
-#endif
-
-#if defined(_MSC_VER) && defined(ABSL_INTERNAL_HAVE_SSE)
-#include <intrin.h>
-#pragma intrinsic(_mm_prefetch)
-#endif
-
-// Compatibility wrappers around __builtin_prefetch, to prefetch data
-// for read if supported by the toolchain.
-
-// Move data into the cache before it is read, or "prefetch" it.
-//
-// The value of `addr` is the address of the memory to prefetch. If
-// the target and compiler support it, data prefetch instructions are
-// generated. If the prefetch is done some time before the memory is
-// read, it may be in the cache by the time the read occurs.
-//
-// The function names specify the temporal locality heuristic applied,
-// using the names of Intel prefetch instructions:
-//
-//   T0 - high degree of temporal locality; data should be left in as
-//        many levels of the cache possible
-//   T1 - moderate degree of temporal locality
-//   T2 - low degree of temporal locality
-//   Nta - no temporal locality, data need not be left in the cache
-//         after the read
-//
-// Incorrect or gratuitous use of these functions can degrade
-// performance, so use them only when representative benchmarks show
-// an improvement.
-//
-// Example usage:
-//
-//   absl::base_internal::PrefetchT0(addr);
-//
-// Currently, the different prefetch calls behave on some Intel
-// architectures as follows:
-//
-//                 SNB..SKL   SKX
-// PrefetchT0()   L1/L2/L3  L1/L2
-// PrefetchT1()      L2/L3     L2
-// PrefetchT2()      L2/L3     L2
-// PrefetchNta()  L1/--/L3  L1*
-//
-// * On SKX PrefetchNta() will bring the line into L1 but will evict
-//   from L3 cache. This might result in surprising behavior.
-//
-// SNB = Sandy Bridge, SKL = Skylake, SKX = Skylake Xeon.
-//
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-void PrefetchT0(const void* addr);
-void PrefetchT1(const void* addr);
-void PrefetchT2(const void* addr);
-void PrefetchNta(const void* addr);
-
-// Implementation details follow.
-
-#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
-
-#define ABSL_INTERNAL_HAVE_PREFETCH 1
-
-// See __builtin_prefetch:
-// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html.
-//
-// These functions speculatively load for read only. This is
-// safe for all currently supported platforms. However, prefetch for
-// store may have problems depending on the target platform.
-//
-inline void PrefetchT0(const void* addr) {
-  // Note: this uses prefetcht0 on Intel.
-  __builtin_prefetch(addr, 0, 3);
-}
-inline void PrefetchT1(const void* addr) {
-  // Note: this uses prefetcht1 on Intel.
-  __builtin_prefetch(addr, 0, 2);
-}
-inline void PrefetchT2(const void* addr) {
-  // Note: this uses prefetcht2 on Intel.
-  __builtin_prefetch(addr, 0, 1);
-}
-inline void PrefetchNta(const void* addr) {
-  // Note: this uses prefetchtnta on Intel.
-  __builtin_prefetch(addr, 0, 0);
-}
-
-#elif defined(ABSL_INTERNAL_HAVE_SSE)
-
-#define ABSL_INTERNAL_HAVE_PREFETCH 1
-
-inline void PrefetchT0(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T0);
-}
-inline void PrefetchT1(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T1);
-}
-inline void PrefetchT2(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T2);
-}
-inline void PrefetchNta(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_NTA);
-}
-
-#else
-inline void PrefetchT0(const void*) {}
-inline void PrefetchT1(const void*) {}
-inline void PrefetchT2(const void*) {}
-inline void PrefetchNta(const void*) {}
-#endif
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_PREFETCH_H_

data/third_party/abseil-cpp/absl/base/internal/raw_logging.cc

@@ -1,249 +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 "absl/base/internal/raw_logging.h"
-
-#include <cstdarg>
-#include <cstddef>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <string>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/atomic_hook.h"
-#include "absl/base/internal/errno_saver.h"
-#include "absl/base/log_severity.h"
-
-// We know how to perform low-level writes to stderr in POSIX and Windows.  For
-// these platforms, we define the token ABSL_LOW_LEVEL_WRITE_SUPPORTED.
-// Much of raw_logging.cc becomes a no-op when we can't output messages,
-// although a FATAL ABSL_RAW_LOG message will still abort the process.
-
-// ABSL_HAVE_POSIX_WRITE is defined when the platform provides posix write()
-// (as from unistd.h)
-//
-// This preprocessor token is also defined in raw_io.cc.  If you need to copy
-// this, consider moving both to config.h instead.
-#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
-    defined(__Fuchsia__) || defined(__native_client__) ||               \
-    defined(__OpenBSD__) || defined(__EMSCRIPTEN__) || defined(__ASYLO__)
-
-#include <unistd.h>
-
-#define ABSL_HAVE_POSIX_WRITE 1
-#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
-#else
-#undef ABSL_HAVE_POSIX_WRITE
-#endif
-
-// ABSL_HAVE_SYSCALL_WRITE is defined when the platform provides the syscall
-//   syscall(SYS_write, /*int*/ fd, /*char* */ buf, /*size_t*/ len);
-// for low level operations that want to avoid libc.
-#if (defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && \
-    !defined(__ANDROID__)
-#include <sys/syscall.h>
-#define ABSL_HAVE_SYSCALL_WRITE 1
-#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
-#else
-#undef ABSL_HAVE_SYSCALL_WRITE
-#endif
-
-#ifdef _WIN32
-#include <io.h>
-
-#define ABSL_HAVE_RAW_IO 1
-#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
-#else
-#undef ABSL_HAVE_RAW_IO
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace raw_logging_internal {
-namespace {
-
-// TODO(gfalcon): We want raw-logging to work on as many platforms as possible.
-// Explicitly `#error` out when not `ABSL_LOW_LEVEL_WRITE_SUPPORTED`, except for
-// a selected set of platforms for which we expect not to be able to raw log.
-
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
-constexpr char kTruncated[] = " ... (message truncated)\n";
-
-// sprintf the format to the buffer, adjusting *buf and *size to reflect the
-// consumed bytes, and return whether the message fit without truncation.  If
-// truncation occurred, if possible leave room in the buffer for the message
-// kTruncated[].
-bool VADoRawLog(char** buf, int* size, const char* format, va_list ap)
-    ABSL_PRINTF_ATTRIBUTE(3, 0);
-bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) {
-  int n = vsnprintf(*buf, *size, format, ap);
-  bool result = true;
-  if (n < 0 || n > *size) {
-    result = false;
-    if (static_cast<size_t>(*size) > sizeof(kTruncated)) {
-      n = *size - sizeof(kTruncated);  // room for truncation message
-    } else {
-      n = 0;  // no room for truncation message
-    }
-  }
-  *size -= n;
-  *buf += n;
-  return result;
-}
-#endif  // ABSL_LOW_LEVEL_WRITE_SUPPORTED
-
-constexpr int kLogBufSize = 3000;
-
-// CAVEAT: vsnprintf called from *DoRawLog below has some (exotic) code paths
-// that invoke malloc() and getenv() that might acquire some locks.
-
-// Helper for RawLog below.
-// *DoRawLog writes to *buf of *size and move them past the written portion.
-// It returns true iff there was no overflow or error.
-bool DoRawLog(char** buf, int* size, const char* format, ...)
-    ABSL_PRINTF_ATTRIBUTE(3, 4);
-bool DoRawLog(char** buf, int* size, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  int n = vsnprintf(*buf, *size, format, ap);
-  va_end(ap);
-  if (n < 0 || n > *size) return false;
-  *size -= n;
-  *buf += n;
-  return true;
-}
-
-bool DefaultLogFilterAndPrefix(absl::LogSeverity, const char* file, int line,
-                               char** buf, int* buf_size) {
-  DoRawLog(buf, buf_size, "[%s : %d] RAW: ", file, line);
-  return true;
-}
-
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-absl::base_internal::AtomicHook<LogFilterAndPrefixHook>
-    log_filter_and_prefix_hook(DefaultLogFilterAndPrefix);
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-absl::base_internal::AtomicHook<AbortHook> abort_hook;
-
-void RawLogVA(absl::LogSeverity severity, const char* file, int line,
-              const char* format, va_list ap) ABSL_PRINTF_ATTRIBUTE(4, 0);
-void RawLogVA(absl::LogSeverity severity, const char* file, int line,
-              const char* format, va_list ap) {
-  char buffer[kLogBufSize];
-  char* buf = buffer;
-  int size = sizeof(buffer);
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
-  bool enabled = true;
-#else
-  bool enabled = false;
-#endif
-
-#ifdef ABSL_MIN_LOG_LEVEL
-  if (severity < static_cast<absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) &&
-      severity < absl::LogSeverity::kFatal) {
-    enabled = false;
-  }
-#endif
-
-  enabled = log_filter_and_prefix_hook(severity, file, line, &buf, &size);
-  const char* const prefix_end = buf;
-
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
-  if (enabled) {
-    bool no_chop = VADoRawLog(&buf, &size, format, ap);
-    if (no_chop) {
-      DoRawLog(&buf, &size, "\n");
-    } else {
-      DoRawLog(&buf, &size, "%s", kTruncated);
-    }
-    AsyncSignalSafeWriteToStderr(buffer, strlen(buffer));
-  }
-#else
-  static_cast<void>(format);
-  static_cast<void>(ap);
-  static_cast<void>(enabled);
-#endif
-
-  // Abort the process after logging a FATAL message, even if the output itself
-  // was suppressed.
-  if (severity == absl::LogSeverity::kFatal) {
-    abort_hook(file, line, buffer, prefix_end, buffer + kLogBufSize);
-    abort();
-  }
-}
-
-// Non-formatting version of RawLog().
-//
-// TODO(gfalcon): When string_view no longer depends on base, change this
-// interface to take its message as a string_view instead.
-void DefaultInternalLog(absl::LogSeverity severity, const char* file, int line,
-                        const std::string& message) {
-  RawLog(severity, file, line, "%.*s", static_cast<int>(message.size()),
-         message.data());
-}
-
-}  // namespace
-
-void AsyncSignalSafeWriteToStderr(const char* s, size_t len) {
-  absl::base_internal::ErrnoSaver errno_saver;
-#if defined(ABSL_HAVE_SYSCALL_WRITE)
-  // We prefer calling write via `syscall` to minimize the risk of libc doing
-  // something "helpful".
-  syscall(SYS_write, STDERR_FILENO, s, len);
-#elif defined(ABSL_HAVE_POSIX_WRITE)
-  write(STDERR_FILENO, s, len);
-#elif defined(ABSL_HAVE_RAW_IO)
-  _write(/* stderr */ 2, s, len);
-#else
-  // stderr logging unsupported on this platform
-  (void) s;
-  (void) len;
-#endif
-}
-
-void RawLog(absl::LogSeverity severity, const char* file, int line,
-            const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  RawLogVA(severity, file, line, format, ap);
-  va_end(ap);
-}
-
-bool RawLoggingFullySupported() {
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
-  return true;
-#else  // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
-  return false;
-#endif  // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
-}
-
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL
-    absl::base_internal::AtomicHook<InternalLogFunction>
-        internal_log_function(DefaultInternalLog);
-
-void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func) {
-  log_filter_and_prefix_hook.Store(func);
-}
-
-void RegisterAbortHook(AbortHook func) { abort_hook.Store(func); }
-
-void RegisterInternalLogFunction(InternalLogFunction func) {
-  internal_log_function.Store(func);
-}
-
-}  // namespace raw_logging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl