diff options
| author | arcadia-devtools <[email protected]> | 2022-03-04 14:03:06 +0300 |
|---|---|---|
| committer | arcadia-devtools <[email protected]> | 2022-03-04 14:03:06 +0300 |
| commit | b61be8e632d1cafa8afb229ea0a5b6117ca7125b (patch) | |
| tree | 96a36f21d4064f32d1912cbc85e4135788ff70b3 /contrib/restricted/abseil-cpp-tstring/y_absl/debugging | |
| parent | 7ce58bf82abf75fdc15c2e6fa3aceadcfecfdca1 (diff) | |
intermediate changes
ref:c67faec740b4d59ed47c6dfdc7076c904650af60
Diffstat (limited to 'contrib/restricted/abseil-cpp-tstring/y_absl/debugging')
35 files changed, 316 insertions, 316 deletions
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc index fa6e30f935e..a79d9026230 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc @@ -29,7 +29,7 @@ #include <TargetConditionals.h> #endif -#ifdef ABSL_HAVE_MMAP +#ifdef Y_ABSL_HAVE_MMAP #include <sys/mman.h> #endif @@ -49,18 +49,18 @@ #include "y_absl/debugging/stacktrace.h" #ifndef _WIN32 -#define ABSL_HAVE_SIGACTION +#define Y_ABSL_HAVE_SIGACTION // Apple WatchOS and TVOS don't allow sigaltstack #if !(defined(TARGET_OS_WATCH) && TARGET_OS_WATCH) && \ !(defined(TARGET_OS_TV) && TARGET_OS_TV) -#define ABSL_HAVE_SIGALTSTACK +#define Y_ABSL_HAVE_SIGALTSTACK #endif #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN -ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options; +Y_ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options; // Resets the signal handler for signo to the default action for that // signal, then raises the signal. @@ -72,7 +72,7 @@ static void RaiseToDefaultHandler(int signo) { struct FailureSignalData { const int signo; const char* const as_string; -#ifdef ABSL_HAVE_SIGACTION +#ifdef Y_ABSL_HAVE_SIGACTION struct sigaction previous_action; // StructSigaction is used to silence -Wmissing-field-initializers. using StructSigaction = struct sigaction; @@ -83,7 +83,7 @@ struct FailureSignalData { #endif }; -ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = { +Y_ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = { {SIGSEGV, "SIGSEGV", FSD_PREVIOUS_INIT}, {SIGILL, "SIGILL", FSD_PREVIOUS_INIT}, {SIGFPE, "SIGFPE", FSD_PREVIOUS_INIT}, @@ -101,7 +101,7 @@ static void RaiseToPreviousHandler(int signo) { // Search for the previous handler. for (const auto& it : failure_signal_data) { if (it.signo == signo) { -#ifdef ABSL_HAVE_SIGACTION +#ifdef Y_ABSL_HAVE_SIGACTION sigaction(signo, &it.previous_action, nullptr); #else signal(signo, it.previous_handler); @@ -128,7 +128,7 @@ const char* FailureSignalToString(int signo) { } // namespace debugging_internal -#ifdef ABSL_HAVE_SIGALTSTACK +#ifdef Y_ABSL_HAVE_SIGALTSTACK static bool SetupAlternateStackOnce() { #if defined(__wasm__) || defined (__asjms__) @@ -138,8 +138,8 @@ static bool SetupAlternateStackOnce() { #endif size_t stack_size = (std::max<size_t>(SIGSTKSZ, 65536) + page_mask) & ~page_mask; -#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \ - defined(ABSL_HAVE_MEMORY_SANITIZER) || defined(ABSL_HAVE_THREAD_SANITIZER) +#if defined(Y_ABSL_HAVE_ADDRESS_SANITIZER) || \ + defined(Y_ABSL_HAVE_MEMORY_SANITIZER) || defined(Y_ABSL_HAVE_THREAD_SANITIZER) // Account for sanitizer instrumentation requiring additional stack space. stack_size *= 5; #endif @@ -148,7 +148,7 @@ static bool SetupAlternateStackOnce() { memset(&sigstk, 0, sizeof(sigstk)); sigstk.ss_size = stack_size; -#ifdef ABSL_HAVE_MMAP +#ifdef Y_ABSL_HAVE_MMAP #ifndef MAP_STACK #define MAP_STACK 0 #endif @@ -158,31 +158,31 @@ static bool SetupAlternateStackOnce() { sigstk.ss_sp = mmap(nullptr, sigstk.ss_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0); if (sigstk.ss_sp == MAP_FAILED) { - ABSL_RAW_LOG(FATAL, "mmap() for alternate signal stack failed"); + Y_ABSL_RAW_LOG(FATAL, "mmap() for alternate signal stack failed"); } #else sigstk.ss_sp = malloc(sigstk.ss_size); if (sigstk.ss_sp == nullptr) { - ABSL_RAW_LOG(FATAL, "malloc() for alternate signal stack failed"); + Y_ABSL_RAW_LOG(FATAL, "malloc() for alternate signal stack failed"); } #endif if (sigaltstack(&sigstk, nullptr) != 0) { - ABSL_RAW_LOG(FATAL, "sigaltstack() failed with errno=%d", errno); + Y_ABSL_RAW_LOG(FATAL, "sigaltstack() failed with errno=%d", errno); } return true; } #endif -#ifdef ABSL_HAVE_SIGACTION +#ifdef Y_ABSL_HAVE_SIGACTION // Sets up an alternate stack for signal handlers once. // Returns the appropriate flag for sig_action.sa_flags // if the system supports using an alternate stack. static int MaybeSetupAlternateStack() { -#ifdef ABSL_HAVE_SIGALTSTACK - ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce(); +#ifdef Y_ABSL_HAVE_SIGALTSTACK + Y_ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce(); return SA_ONSTACK; #else return 0; @@ -202,7 +202,7 @@ static void InstallOneFailureHandler(FailureSignalData* data, act.sa_flags |= MaybeSetupAlternateStack(); } act.sa_sigaction = handler; - ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0, + Y_ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0, "sigaction() failed"); } @@ -211,7 +211,7 @@ static void InstallOneFailureHandler(FailureSignalData* data, static void InstallOneFailureHandler(FailureSignalData* data, void (*handler)(int)) { data->previous_handler = signal(data->signo, handler); - ABSL_RAW_CHECK(data->previous_handler != SIG_ERR, "signal() failed"); + Y_ABSL_RAW_CHECK(data->previous_handler != SIG_ERR, "signal() failed"); } #endif @@ -259,7 +259,7 @@ static void WriterFnWrapper(const char* data, void* arg) { // Convenient wrapper around DumpPCAndFrameSizesAndStackTrace() for signal // handlers. "noinline" so that GetStackFrames() skips the top-most stack // frame for this function. -ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace( +Y_ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace( void* ucontext, bool symbolize_stacktrace, void (*writerfn)(const char*, void*), void* writerfn_arg) { constexpr int kNumStackFrames = 32; @@ -300,7 +300,7 @@ static void PortableSleepForSeconds(int seconds) { #endif } -#ifdef ABSL_HAVE_ALARM +#ifdef Y_ABSL_HAVE_ALARM // AbslFailureSignalHandler() installs this as a signal handler for // SIGALRM, then sets an alarm to be delivered to the program after a // set amount of time. If AbslFailureSignalHandler() hangs for more than @@ -314,9 +314,9 @@ static void ImmediateAbortSignalHandler(int) { // y_absl::base_internal::GetTID() returns pid_t on most platforms, but // returns y_absl::base_internal::pid_t on Windows. using GetTidType = decltype(y_absl::base_internal::GetTID()); -ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0); +Y_ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0); -#ifndef ABSL_HAVE_SIGACTION +#ifndef Y_ABSL_HAVE_SIGACTION static void AbslFailureSignalHandler(int signo) { void* ucontext = nullptr; #else @@ -328,7 +328,7 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) { if (!failed_tid.compare_exchange_strong( previous_failed_tid, static_cast<intptr_t>(this_tid), std::memory_order_acq_rel, std::memory_order_relaxed)) { - ABSL_RAW_LOG( + Y_ABSL_RAW_LOG( ERROR, "Signal %d raised at PC=%p while already in AbslFailureSignalHandler()", signo, y_absl::debugging_internal::GetProgramCounter(ucontext)); @@ -347,11 +347,11 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) { // signal was received by doing this as early as possible, i.e. after // verifying that this is not a recursive signal handler invocation. int my_cpu = -1; -#ifdef ABSL_HAVE_SCHED_GETCPU +#ifdef Y_ABSL_HAVE_SCHED_GETCPU my_cpu = sched_getcpu(); #endif -#ifdef ABSL_HAVE_ALARM +#ifdef Y_ABSL_HAVE_ALARM // Set an alarm to abort the program in case this code hangs or deadlocks. if (fsh_options.alarm_on_failure_secs > 0) { alarm(0); // Cancel any existing alarms. @@ -384,5 +384,5 @@ void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) { } } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h index 879df3c4346..b4262642761 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h @@ -41,13 +41,13 @@ // handler installed (which would be triggered if Abseil's failure signal // handler sets `call_previous_handler` to `true`). -#ifndef ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ -#define ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ +#ifndef Y_ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ +#define Y_ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ #include "y_absl/base/config.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN // FailureSignalHandlerOptions // @@ -115,7 +115,7 @@ namespace debugging_internal { const char* FailureSignalToString(int signo); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ +#endif // Y_ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc index df217335eab..669d81f878f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc @@ -20,14 +20,14 @@ #if !defined(__linux__) || defined(__ANDROID__) namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // On platforms other than Linux, just return true. bool AddressIsReadable(const void* /* addr */) { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl #else @@ -44,13 +44,13 @@ ABSL_NAMESPACE_END #include "y_absl/base/internal/raw_logging.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Pack a pid and two file descriptors into a 64-bit word, // using 16, 24, and 24 bits for each respectively. static uint64_t Pack(uint64_t pid, uint64_t read_fd, uint64_t write_fd) { - ABSL_RAW_CHECK((read_fd >> 24) == 0 && (write_fd >> 24) == 0, + Y_ABSL_RAW_CHECK((read_fd >> 24) == 0 && (write_fd >> 24) == 0, "fd out of range"); return (pid << 48) | ((read_fd & 0xffffff) << 24) | (write_fd & 0xffffff); } @@ -93,7 +93,7 @@ bool AddressIsReadable(const void *addr) { int p[2]; // new pipe if (pipe(p) != 0) { - ABSL_RAW_LOG(FATAL, "Failed to create pipe, errno=%d", errno); + Y_ABSL_RAW_LOG(FATAL, "Failed to create pipe, errno=%d", errno); } fcntl(p[0], F_SETFD, FD_CLOEXEC); fcntl(p[1], F_SETFD, FD_CLOEXEC); @@ -133,7 +133,7 @@ bool AddressIsReadable(const void *addr) { } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl #endif diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h index 279dcc640bd..bbda33123f7 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h @@ -12,13 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ -#define ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ #include "y_absl/base/config.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Return whether the byte at *addr is readable, without faulting. @@ -26,7 +26,7 @@ namespace debugging_internal { bool AddressIsReadable(const void *addr); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc index 0a4daa2f5ce..e9319575cb1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc @@ -24,7 +24,7 @@ #include <limits> namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { typedef struct { @@ -1955,5 +1955,5 @@ bool Demangle(const char *mangled, char *out, int out_size) { } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h index a9b42edb451..28d4dfb0e9d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h @@ -50,13 +50,13 @@ // C++ ABI in the future. // -#ifndef ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ -#define ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ #include "y_absl/base/config.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Demangle `mangled`. On success, return true and write the @@ -65,7 +65,7 @@ namespace debugging_internal { bool Demangle(const char *mangled, char *out, int out_size); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc index ba4bbc3855a..1df9cca1b6d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc @@ -17,7 +17,7 @@ #include "y_absl/debugging/internal/elf_mem_image.h" -#ifdef ABSL_HAVE_ELF_MEM_IMAGE // defined in elf_mem_image.h +#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE // defined in elf_mem_image.h #include <string.h> #include <cassert> @@ -39,7 +39,7 @@ #define VERSYM_VERSION 0x7fff namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { namespace { @@ -55,11 +55,11 @@ int ElfType(const ElfW(Sym) *symbol) { return ELF64_ST_TYPE(symbol->st_info); } #else const int kElfClass = -1; int ElfBind(const ElfW(Sym) *) { - ABSL_RAW_LOG(FATAL, "Unexpected word size"); + Y_ABSL_RAW_LOG(FATAL, "Unexpected word size"); return 0; } int ElfType(const ElfW(Sym) *) { - ABSL_RAW_LOG(FATAL, "Unexpected word size"); + Y_ABSL_RAW_LOG(FATAL, "Unexpected word size"); return 0; } #endif @@ -82,7 +82,7 @@ const T *GetTableElement(const ElfW(Ehdr) * ehdr, ElfW(Off) table_offset, const int ElfMemImage::kInvalidBaseSentinel = 0; ElfMemImage::ElfMemImage(const void *base) { - ABSL_RAW_CHECK(base != kInvalidBase, "bad pointer"); + Y_ABSL_RAW_CHECK(base != kInvalidBase, "bad pointer"); Init(base); } @@ -95,17 +95,17 @@ int ElfMemImage::GetNumSymbols() const { } const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const { - ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range"); + Y_ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range"); return dynsym_ + index; } const ElfW(Versym) *ElfMemImage::GetVersym(int index) const { - ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range"); + Y_ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range"); return versym_ + index; } const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const { - ABSL_RAW_CHECK(index < ehdr_->e_phnum, "index out of range"); + Y_ABSL_RAW_CHECK(index < ehdr_->e_phnum, "index out of range"); return GetTableElement<ElfW(Phdr)>(ehdr_, ehdr_->e_phoff, ehdr_->e_phentsize, @@ -113,7 +113,7 @@ const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const { } const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const { - ABSL_RAW_CHECK(offset < strsize_, "offset out of range"); + Y_ABSL_RAW_CHECK(offset < strsize_, "offset out of range"); return dynstr_ + offset; } @@ -122,12 +122,12 @@ const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const { // Symbol corresponds to "special" (e.g. SHN_ABS) section. return reinterpret_cast<const void *>(sym->st_value); } - ABSL_RAW_CHECK(link_base_ < sym->st_value, "symbol out of range"); + Y_ABSL_RAW_CHECK(link_base_ < sym->st_value, "symbol out of range"); return GetTableElement<char>(ehdr_, 0, 1, sym->st_value - link_base_); } const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const { - ABSL_RAW_CHECK(0 <= index && static_cast<size_t>(index) <= verdefnum_, + Y_ABSL_RAW_CHECK(0 <= index && static_cast<size_t>(index) <= verdefnum_, "index out of range"); const ElfW(Verdef) *version_definition = verdef_; while (version_definition->vd_ndx < index && version_definition->vd_next) { @@ -146,7 +146,7 @@ const ElfW(Verdaux) *ElfMemImage::GetVerdefAux( } const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const { - ABSL_RAW_CHECK(offset < strsize_, "offset out of range"); + Y_ABSL_RAW_CHECK(offset < strsize_, "offset out of range"); return dynstr_ + offset; } @@ -176,14 +176,14 @@ void ElfMemImage::Init(const void *base) { } switch (base_as_char[EI_DATA]) { case ELFDATA2LSB: { -#ifndef ABSL_IS_LITTLE_ENDIAN +#ifndef Y_ABSL_IS_LITTLE_ENDIAN assert(false); return; #endif break; } case ELFDATA2MSB: { -#ifndef ABSL_IS_BIG_ENDIAN +#ifndef Y_ABSL_IS_BIG_ENDIAN assert(false); return; #endif @@ -338,7 +338,7 @@ ElfMemImage::SymbolIterator ElfMemImage::end() const { void ElfMemImage::SymbolIterator::Update(int increment) { const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_); - ABSL_RAW_CHECK(image->IsPresent() || increment == 0, ""); + Y_ABSL_RAW_CHECK(image->IsPresent() || increment == 0, ""); if (!image->IsPresent()) { return; } @@ -349,7 +349,7 @@ void ElfMemImage::SymbolIterator::Update(int increment) { } const ElfW(Sym) *symbol = image->GetDynsym(index_); const ElfW(Versym) *version_symbol = image->GetVersym(index_); - ABSL_RAW_CHECK(symbol && version_symbol, ""); + Y_ABSL_RAW_CHECK(symbol && version_symbol, ""); const char *const symbol_name = image->GetDynstr(symbol->st_name); const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION; const ElfW(Verdef) *version_definition = nullptr; @@ -364,7 +364,7 @@ void ElfMemImage::SymbolIterator::Update(int increment) { if (version_definition) { // I am expecting 1 or 2 auxiliary entries: 1 for the version itself, // optional 2nd if the version has a parent. - ABSL_RAW_CHECK( + Y_ABSL_RAW_CHECK( version_definition->vd_cnt == 1 || version_definition->vd_cnt == 2, "wrong number of entries"); const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition); @@ -377,7 +377,7 @@ void ElfMemImage::SymbolIterator::Update(int increment) { } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_HAVE_ELF_MEM_IMAGE +#endif // Y_ABSL_HAVE_ELF_MEM_IMAGE diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h index 13a6b2e664c..c19c0e9f8e1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h @@ -16,8 +16,8 @@ // Allow dynamic symbol lookup for in-memory Elf images. -#ifndef ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_ -#define ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_ // Including this will define the __GLIBC__ macro if glibc is being // used. @@ -27,16 +27,16 @@ // Maybe one day we can rewrite this file not to require the elf // symbol extensions in glibc, but for right now we need them. -#ifdef ABSL_HAVE_ELF_MEM_IMAGE -#error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set +#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE +#error Y_ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set #endif #if defined(__ELF__) && !defined(__native_client__) && !defined(__asmjs__) && \ !defined(__wasm__) -#define ABSL_HAVE_ELF_MEM_IMAGE 1 +#define Y_ABSL_HAVE_ELF_MEM_IMAGE 1 #endif -#ifdef ABSL_HAVE_ELF_MEM_IMAGE +#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE #include <link.h> // for ElfW @@ -45,7 +45,7 @@ #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // An in-memory ELF image (may not exist on disk). @@ -130,9 +130,9 @@ class ElfMemImage { }; } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_HAVE_ELF_MEM_IMAGE +#endif // Y_ABSL_HAVE_ELF_MEM_IMAGE -#endif // ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc index c59d92b6a38..edc926cafd6 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc @@ -34,7 +34,7 @@ #include "y_absl/debugging/symbolize.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Returns the program counter from signal context, nullptr if @@ -53,7 +53,7 @@ void* GetProgramCounter(void* vuc) { #elif defined(__hppa__) return reinterpret_cast<void*>(context->uc_mcontext.sc_iaoq[0]); #elif defined(__i386__) - if (14 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs)) + if (14 < Y_ABSL_ARRAYSIZE(context->uc_mcontext.gregs)) return reinterpret_cast<void*>(context->uc_mcontext.gregs[14]); #elif defined(__ia64__) return reinterpret_cast<void*>(context->uc_mcontext.sc_ip); @@ -78,7 +78,7 @@ void* GetProgramCounter(void* vuc) { #elif defined(__sparc__) && defined(__arch64__) return reinterpret_cast<void*>(context->uc_mcontext.mc_gregs[19]); #elif defined(__x86_64__) - if (16 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs)) + if (16 < Y_ABSL_ARRAYSIZE(context->uc_mcontext.gregs)) return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]); #elif defined(__e2k__) return reinterpret_cast<void*>(context->uc_mcontext.cr0_hi); @@ -199,5 +199,5 @@ void DumpPCAndFrameSizesAndStackTrace( } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h index 32892a11504..4ac2c8358ad 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h @@ -14,13 +14,13 @@ // limitations under the License. // -#ifndef ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ -#define ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ #include "y_absl/base/config.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Returns the program counter from signal context, or nullptr if @@ -36,7 +36,7 @@ void DumpPCAndFrameSizesAndStackTrace( void (*writerfn)(const char*, void*), void* writerfn_arg); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h index 80137ad0eb5..f527eeb1558 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h @@ -15,22 +15,22 @@ // Helper function for measuring stack consumption of signal handlers. -#ifndef ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_ -#define ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_ #include "y_absl/base/config.h" // The code in this module is not portable. // Use this feature test macro to detect its availability. -#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION -#error ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly +#ifdef Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION +#error Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly #elif !defined(__APPLE__) && !defined(_WIN32) && \ (defined(__i386__) || defined(__x86_64__) || defined(__ppc__) || \ defined(__aarch64__) || defined(__riscv)) -#define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1 +#define Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1 namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Returns the stack consumption in bytes for the code exercised by @@ -42,9 +42,9 @@ namespace debugging_internal { int GetSignalHandlerStackConsumption(void (*signal_handler)(int)); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION +#endif // Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION -#endif // ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc index 700f6074885..e225b4dd183 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc @@ -1,5 +1,5 @@ -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ // Generate stack tracer for aarch64 @@ -25,7 +25,7 @@ static const uintptr_t kUnknownFrameSize = 0; // Returns the address of the VDSO __kernel_rt_sigreturn function, if present. static const unsigned char* GetKernelRtSigreturnAddress() { constexpr uintptr_t kImpossibleAddress = 1; - ABSL_CONST_INIT static std::atomic<uintptr_t> memoized{kImpossibleAddress}; + Y_ABSL_CONST_INIT static std::atomic<uintptr_t> memoized{kImpossibleAddress}; uintptr_t address = memoized.load(std::memory_order_relaxed); if (address != kImpossibleAddress) { return reinterpret_cast<const unsigned char*>(address); @@ -33,7 +33,7 @@ static const unsigned char* GetKernelRtSigreturnAddress() { address = reinterpret_cast<uintptr_t>(nullptr); -#ifdef ABSL_HAVE_VDSO_SUPPORT +#ifdef Y_ABSL_HAVE_VDSO_SUPPORT y_absl::debugging_internal::VDSOSupport vdso; if (vdso.IsPresent()) { y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info; @@ -77,8 +77,8 @@ static inline uintptr_t ComputeStackFrameSize(const T* low, // checks (the strictness of which is controlled by the boolean parameter // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. template<bool STRICT_UNWINDING, bool WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static void **NextStackFrame(void **old_frame_pointer, const void *uc) { void **new_frame_pointer = reinterpret_cast<void**>(*old_frame_pointer); bool check_frame_size = true; @@ -128,8 +128,8 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc) { } template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, const void *ucp, int *min_dropped_frames) { #ifdef __GNUC__ @@ -187,13 +187,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc index b73307120ee..d735d1f9339 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc @@ -14,8 +14,8 @@ // // This is inspired by Craig Silverstein's PowerPC stacktrace code. -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ #include <cstdint> @@ -122,13 +122,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return false; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h index 7ba212ab03f..d93c3f1dd99 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h @@ -13,32 +13,32 @@ * See the License for the specific language governing permissions and * limitations under the License. - * Defines ABSL_STACKTRACE_INL_HEADER to the *-inl.h containing + * Defines Y_ABSL_STACKTRACE_INL_HEADER to the *-inl.h containing * actual unwinder implementation. * This header is "private" to stacktrace.cc. * DO NOT include it into any other files. */ -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ #include "y_absl/base/config.h" -#if defined(ABSL_STACKTRACE_INL_HEADER) -#error ABSL_STACKTRACE_INL_HEADER cannot be directly set +#if defined(Y_ABSL_STACKTRACE_INL_HEADER) +#error Y_ABSL_STACKTRACE_INL_HEADER cannot be directly set #elif defined(_WIN32) -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_win32-inl.inc" #elif defined(__APPLE__) -#ifdef ABSL_HAVE_THREAD_LOCAL +#ifdef Y_ABSL_HAVE_THREAD_LOCAL // Thread local support required for UnwindImpl. -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_generic-inl.inc" -#endif // defined(ABSL_HAVE_THREAD_LOCAL) +#endif // defined(Y_ABSL_HAVE_THREAD_LOCAL) #elif defined(__EMSCRIPTEN__) -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_emscripten-inl.inc" #elif defined(__linux__) && !defined(__ANDROID__) @@ -47,31 +47,31 @@ (defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)) // Note: The libunwind-based implementation is not available to open-source // users. -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_libunwind-inl.inc" #define STACKTRACE_USES_LIBUNWIND 1 #elif defined(NO_FRAME_POINTER) && defined(__has_include) #if __has_include(<execinfo.h>) // Note: When using glibc this may require -funwind-tables to function properly. -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_generic-inl.inc" #endif // __has_include(<execinfo.h>) #elif defined(__i386__) || defined(__x86_64__) -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_x86-inl.inc" #elif defined(__ppc__) || defined(__PPC__) -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_powerpc-inl.inc" #elif defined(__aarch64__) -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_aarch64-inl.inc" #elif defined(__riscv) -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_riscv-inl.inc" #elif defined(__has_include) #if __has_include(<execinfo.h>) // Note: When using glibc this may require -funwind-tables to function properly. -#define ABSL_STACKTRACE_INL_HEADER \ +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_generic-inl.inc" #endif // __has_include(<execinfo.h>) #endif // defined(__has_include) @@ -79,9 +79,9 @@ #endif // defined(__linux__) && !defined(__ANDROID__) // Fallback to the empty implementation. -#if !defined(ABSL_STACKTRACE_INL_HEADER) -#define ABSL_STACKTRACE_INL_HEADER \ +#if !defined(Y_ABSL_STACKTRACE_INL_HEADER) +#define Y_ABSL_STACKTRACE_INL_HEADER \ "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc" #endif -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc index cdb55571344..ea86e5b0e10 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc @@ -17,8 +17,8 @@ // Note: The glibc implementation may cause a call to malloc. // This can cause a deadlock in HeapProfiler. -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ #error #include <emscripten.h> @@ -49,7 +49,7 @@ static __thread int recursive = 0; static std::atomic<bool> disable_stacktraces(true); // Disabled until healthy. // Waiting until static initializers run seems to be late enough. // This file is included into stacktrace.cc so this will only run once. -ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() { +Y_ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() { // Check if we can even create stacktraces. If not, bail early and leave // disable_stacktraces set as-is. // clang-format off @@ -100,11 +100,11 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc index fa623aa9548..fd0408fc24f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc @@ -17,8 +17,8 @@ // Note: The glibc implementation may cause a call to malloc. // This can cause a deadlock in HeapProfiler. -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ #include <execinfo.h> #include <atomic> @@ -45,7 +45,7 @@ static __thread int recursive = 0; static std::atomic<bool> disable_stacktraces(true); // Disabled until healthy. // Waiting until static initializers run seems to be late enough. // This file is included into stacktrace.cc so this will only run once. -ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() { +Y_ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() { void* unused_stack[1]; // Force the first backtrace to happen early to get the one-time shared lib // loading (allocation) out of the way. After the first call it is much safer @@ -96,13 +96,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc index 1e41c4ebf2b..635c3dd2a69 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc @@ -18,8 +18,8 @@ // https://www.linux-foundation.org/spec/ELF/ppc64/PPC-elf64abi-1.9.html#STACK // Linux has similar code: http://patchwork.ozlabs.org/linuxppc/patch?id=8882 -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ #if defined(__linux__) #include <asm/ptrace.h> // for PT_NIP. @@ -66,8 +66,8 @@ static inline void *StacktracePowerPCGetLR(void **sp) { // checks (the strictness of which is controlled by the boolean parameter // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. template<bool STRICT_UNWINDING, bool IS_WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static void **NextStackFrame(void **old_sp, const void *uc) { void **new_sp = (void **) *old_sp; enum { kStackAlignment = 16 }; @@ -157,13 +157,13 @@ static void **NextStackFrame(void **old_sp, const void *uc) { } // This ensures that y_absl::GetStackTrace sets up the Link Register properly. -ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() { - ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); +Y_ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() { + Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); } template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, const void *ucp, int *min_dropped_frames) { void **sp; @@ -241,13 +241,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc index 8571c8cbfd6..4072ecc116f 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ // Generate stack trace for riscv @@ -42,7 +42,7 @@ static const uintptr_t kUnknownFrameSize = 0; // Returns the address of the VDSO __kernel_rt_sigreturn function, if present. static const unsigned char *GetKernelRtSigreturnAddress() { constexpr uintptr_t kImpossibleAddress = 0; - ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress); + Y_ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress); uintptr_t address = memoized.load(std::memory_order_relaxed); if (address != kImpossibleAddress) { return reinterpret_cast<const unsigned char *>(address); @@ -50,7 +50,7 @@ static const unsigned char *GetKernelRtSigreturnAddress() { address = reinterpret_cast<uintptr_t>(nullptr); -#if ABSL_HAVE_VDSO_SUPPORT +#if Y_ABSL_HAVE_VDSO_SUPPORT y_absl::debugging_internal::VDSOSupport vdso; if (vdso.IsPresent()) { y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info; @@ -94,8 +94,8 @@ static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) { // strictness of which is controlled by the boolean parameter // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. template <bool STRICT_UNWINDING, bool WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static void ** NextStackFrame(void **old_frame_pointer, const void *uc) { // . // . @@ -167,8 +167,8 @@ static void ** NextStackFrame(void **old_frame_pointer, const void *uc) { } template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, const void *ucp, int *min_dropped_frames) { #if defined(__GNUC__) @@ -224,11 +224,11 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl #endif diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc index 54dccaeae97..b1edc021bd1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc @@ -1,5 +1,5 @@ -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> static int UnwindImpl(void** /* result */, int* /* sizes */, @@ -12,13 +12,13 @@ static int UnwindImpl(void** /* result */, int* /* sizes */, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return false; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc index 69bd7e3f2f4..654990f2060 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc @@ -34,8 +34,8 @@ // This code is inspired by a patch from David Vitek: // https://code.google.com/p/google-perftools/issues/detail?id=83 -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ #include <windows.h> // for GetProcAddress and GetModuleHandle #include <cassert> @@ -81,13 +81,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return false; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc index 8936f8ca70c..6e598bc3592 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc @@ -14,8 +14,8 @@ // // Produce stack trace -#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ -#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ +#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ #if defined(__linux__) && (defined(__i386__) || defined(__x86_64__)) #include <ucontext.h> // for ucontext_t @@ -157,8 +157,8 @@ static uintptr_t GetFP(const void *vuc) { // checks (the strictness of which is controlled by the boolean parameter // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. template <bool STRICT_UNWINDING, bool WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. static void **NextStackFrame(void **old_fp, const void *uc, size_t stack_low, size_t stack_high) { void **new_fp = (void **)*old_fp; @@ -174,7 +174,7 @@ static void **NextStackFrame(void **old_fp, const void *uc, static const unsigned char *kernel_rt_sigreturn_address = nullptr; static const unsigned char *kernel_vsyscall_address = nullptr; if (num_push_instructions == -1) { -#ifdef ABSL_HAVE_VDSO_SUPPORT +#ifdef Y_ABSL_HAVE_VDSO_SUPPORT y_absl::debugging_internal::VDSOSupport vdso; if (vdso.IsPresent()) { y_absl::debugging_internal::VDSOSupport::SymbolInfo @@ -203,9 +203,9 @@ static void **NextStackFrame(void **old_fp, const void *uc, } else { num_push_instructions = 0; } -#else // ABSL_HAVE_VDSO_SUPPORT +#else // Y_ABSL_HAVE_VDSO_SUPPORT num_push_instructions = 0; -#endif // ABSL_HAVE_VDSO_SUPPORT +#endif // Y_ABSL_HAVE_VDSO_SUPPORT } if (num_push_instructions != 0 && kernel_rt_sigreturn_address != nullptr && old_fp[1] == kernel_rt_sigreturn_address) { @@ -302,9 +302,9 @@ static void **NextStackFrame(void **old_fp, const void *uc, } template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> -ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. -ABSL_ATTRIBUTE_NOINLINE +Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack. +Y_ABSL_ATTRIBUTE_NOINLINE static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, const void *ucp, int *min_dropped_frames) { int n = 0; @@ -352,13 +352,13 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, } namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h index e6e2b0724a4..c404b3cf91a 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h @@ -15,8 +15,8 @@ // This file contains internal parts of the Abseil symbolizer. // Do not depend on the anything in this file, it may change at anytime. -#ifndef ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_ -#define ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_ #ifdef __cplusplus @@ -26,11 +26,11 @@ #include "y_absl/base/config.h" #include "y_absl/strings/string_view.h" -#ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE -#error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set +#ifdef Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE +#error Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set #elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \ && !defined(__asmjs__) && !defined(__wasm__) -#define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1 +#define Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1 #include <elf.h> #include <link.h> // For ElfW() macro. @@ -38,7 +38,7 @@ #include <util/generic/string.h> namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // Iterates over all sections, invoking callback on each with the section name @@ -57,25 +57,25 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len, ElfW(Shdr) *out); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE +#endif // Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE -#ifdef ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE -#error ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set +#ifdef Y_ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE +#error Y_ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set #elif defined(__APPLE__) -#define ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1 +#define Y_ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1 #endif -#ifdef ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE -#error ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set +#ifdef Y_ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE +#error Y_ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set #elif defined(__EMSCRIPTEN__) -#define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1 +#define Y_ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1 #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { struct SymbolDecoratorArgs { @@ -135,7 +135,7 @@ bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset, const char** filename); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl #endif // __cplusplus @@ -150,4 +150,4 @@ extern "C" YAbslInternalGetFileMappingHint(const void** start, const void** end, uint64_t* offset, const char** filename); -#endif // ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc index 7905eba32fe..ff28d04d574 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc @@ -18,7 +18,7 @@ #include "y_absl/debugging/internal/vdso_support.h" -#ifdef ABSL_HAVE_VDSO_SUPPORT // defined in vdso_support.h +#ifdef Y_ABSL_HAVE_VDSO_SUPPORT // defined in vdso_support.h #if !defined(__has_include) #define __has_include(header) 0 @@ -35,10 +35,10 @@ #if defined(__GLIBC__) && \ (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16)) -#define ABSL_HAVE_GETAUXVAL +#define Y_ABSL_HAVE_GETAUXVAL #endif -#ifdef ABSL_HAVE_GETAUXVAL +#ifdef Y_ABSL_HAVE_GETAUXVAL #include <sys/auxv.h> #endif @@ -56,10 +56,10 @@ using Elf32_auxv_t = Elf32_Auxinfo; #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { -ABSL_CONST_INIT +Y_ABSL_CONST_INIT std::atomic<const void *> VDSOSupport::vdso_base_( debugging_internal::ElfMemImage::kInvalidBase); @@ -83,7 +83,7 @@ VDSOSupport::VDSOSupport() // the operation should be idempotent. const void *VDSOSupport::Init() { const auto kInvalidBase = debugging_internal::ElfMemImage::kInvalidBase; -#ifdef ABSL_HAVE_GETAUXVAL +#ifdef Y_ABSL_HAVE_GETAUXVAL if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) { errno = 0; const void *const sysinfo_ehdr = @@ -92,7 +92,7 @@ const void *VDSOSupport::Init() { vdso_base_.store(sysinfo_ehdr, std::memory_order_relaxed); } } -#endif // ABSL_HAVE_GETAUXVAL +#endif // Y_ABSL_HAVE_GETAUXVAL if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) { int fd = open("/proc/self/auxv", O_RDONLY); if (fd == -1) { @@ -130,7 +130,7 @@ const void *VDSOSupport::Init() { } const void *VDSOSupport::SetBase(const void *base) { - ABSL_RAW_CHECK(base != debugging_internal::ElfMemImage::kInvalidBase, + Y_ABSL_RAW_CHECK(base != debugging_internal::ElfMemImage::kInvalidBase, "internal error"); const void *old_base = vdso_base_.load(std::memory_order_relaxed); vdso_base_.store(base, std::memory_order_relaxed); @@ -170,14 +170,14 @@ long VDSOSupport::InitAndGetCPU(unsigned *cpu, // NOLINT(runtime/int) void *x, void *y) { Init(); GetCpuFn fn = getcpu_fn_.load(std::memory_order_relaxed); - ABSL_RAW_CHECK(fn != &InitAndGetCPU, "Init() did not set getcpu_fn_"); + Y_ABSL_RAW_CHECK(fn != &InitAndGetCPU, "Init() did not set getcpu_fn_"); return (*fn)(cpu, x, y); } // This function must be very fast, and may be called from very // low level (e.g. tcmalloc). Hence I avoid things like // GoogleOnceInit() and ::operator new. -ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY +Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY int GetCPU() { unsigned cpu; int ret_code = (*VDSOSupport::getcpu_fn_)(&cpu, nullptr, nullptr); @@ -185,7 +185,7 @@ int GetCPU() { } } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_HAVE_VDSO_SUPPORT +#endif // Y_ABSL_HAVE_VDSO_SUPPORT diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h index c0064b9fe10..40a22780d57 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h @@ -36,24 +36,24 @@ // fn = reinterpret_cast<FN>(info.address); // } -#ifndef ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_ -#define ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_ +#ifndef Y_ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_ +#define Y_ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_ #include <atomic> #include "y_absl/base/attributes.h" #include "y_absl/debugging/internal/elf_mem_image.h" -#ifdef ABSL_HAVE_ELF_MEM_IMAGE +#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE -#ifdef ABSL_HAVE_VDSO_SUPPORT -#error ABSL_HAVE_VDSO_SUPPORT cannot be directly set +#ifdef Y_ABSL_HAVE_VDSO_SUPPORT +#error Y_ABSL_HAVE_VDSO_SUPPORT cannot be directly set #else -#define ABSL_HAVE_VDSO_SUPPORT 1 +#define Y_ABSL_HAVE_VDSO_SUPPORT 1 #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { // NOTE: this class may be used from within tcmalloc, and can not @@ -134,7 +134,7 @@ class VDSOSupport { // This function pointer may point to InitAndGetCPU, // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization. - ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_; + Y_ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_; friend int GetCPU(void); // Needs access to getcpu_fn_. @@ -150,9 +150,9 @@ class VDSOSupport { int GetCPU(); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_HAVE_ELF_MEM_IMAGE +#endif // Y_ABSL_HAVE_ELF_MEM_IMAGE -#endif // ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_ +#endif // Y_ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc index ae5cf79fe29..0ac471b9869 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc @@ -22,7 +22,7 @@ #ifndef LEAK_SANITIZER namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN bool HaveLeakSanitizer() { return false; } bool LeakCheckerIsActive() { return false; } void DoIgnoreLeak(const void*) { } @@ -30,22 +30,22 @@ void RegisterLivePointers(const void*, size_t) { } void UnRegisterLivePointers(const void*, size_t) { } LeakCheckDisabler::LeakCheckDisabler() { } LeakCheckDisabler::~LeakCheckDisabler() { } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl #else #include <sanitizer/lsan_interface.h> -#if ABSL_HAVE_ATTRIBUTE_WEAK -extern "C" ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off(); +#if Y_ABSL_HAVE_ATTRIBUTE_WEAK +extern "C" Y_ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off(); #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN bool HaveLeakSanitizer() { return true; } -#if ABSL_HAVE_ATTRIBUTE_WEAK +#if Y_ABSL_HAVE_ATTRIBUTE_WEAK bool LeakCheckerIsActive() { return !(&__lsan_is_turned_off && __lsan_is_turned_off()); } @@ -63,7 +63,7 @@ void UnRegisterLivePointers(const void* ptr, size_t size) { } LeakCheckDisabler::LeakCheckDisabler() { __lsan_disable(); } LeakCheckDisabler::~LeakCheckDisabler() { __lsan_enable(); } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl #endif // LEAK_SANITIZER diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h index d69f08f2487..154fe4805d1 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h @@ -27,15 +27,15 @@ // See https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer // // ----------------------------------------------------------------------------- -#ifndef ABSL_DEBUGGING_LEAK_CHECK_H_ -#define ABSL_DEBUGGING_LEAK_CHECK_H_ +#ifndef Y_ABSL_DEBUGGING_LEAK_CHECK_H_ +#define Y_ABSL_DEBUGGING_LEAK_CHECK_H_ #include <cstddef> #include "y_absl/base/config.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN // HaveLeakSanitizer() // @@ -127,7 +127,7 @@ void RegisterLivePointers(const void* ptr, size_t size); // `RegisterLivePointers()`, enabling leak checking of those pointers. void UnRegisterLivePointers(const void* ptr, size_t size); -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_LEAK_CHECK_H_ +#endif // Y_ABSL_DEBUGGING_LEAK_CHECK_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc index 9263d6a2a8c..7b3e34fc819 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc @@ -42,8 +42,8 @@ #include "y_absl/base/port.h" #include "y_absl/debugging/internal/stacktrace_config.h" -#if defined(ABSL_STACKTRACE_INL_HEADER) -#include ABSL_STACKTRACE_INL_HEADER +#if defined(Y_ABSL_STACKTRACE_INL_HEADER) +#include Y_ABSL_STACKTRACE_INL_HEADER #else # error Cannot calculate stack trace: will need to write for your environment @@ -59,14 +59,14 @@ #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_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, int* sizes, +Y_ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes, int max_depth, int skip_count, const void* uc, int* min_dropped_frames) { @@ -78,19 +78,19 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes, int size = (*f)(result, sizes, max_depth, skip_count + 1, uc, min_dropped_frames); // To disable tail call to (*f)(...) - ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); + Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); return size; } } // anonymous namespace -ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFrames( +Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFrames( void** result, int* sizes, int max_depth, int skip_count) { return Unwind<true, false>(result, sizes, max_depth, skip_count, nullptr, nullptr); } -ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int +Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFramesWithContext(void** result, int* sizes, int max_depth, int skip_count, const void* uc, int* min_dropped_frames) { @@ -98,13 +98,13 @@ GetStackFramesWithContext(void** result, int* sizes, int max_depth, min_dropped_frames); } -ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace( +Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace( void** result, int max_depth, int skip_count) { return Unwind<false, false>(result, nullptr, max_depth, skip_count, nullptr, nullptr); } -ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int +Y_ABSL_ATTRIBUTE_NOINLINE Y_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, max_depth, skip_count, uc, @@ -138,5 +138,5 @@ int DefaultStackUnwinder(void** pcs, int* sizes, int depth, int skip, return n; } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h index cbd48b986b0..3e83d4cc026 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h @@ -28,13 +28,13 @@ // frames consisting of function addresses rather than human-readable function // names. (See symbolize.h for information on symbolizing these values.) -#ifndef ABSL_DEBUGGING_STACKTRACE_H_ -#define ABSL_DEBUGGING_STACKTRACE_H_ +#ifndef Y_ABSL_DEBUGGING_STACKTRACE_H_ +#define Y_ABSL_DEBUGGING_STACKTRACE_H_ #include "y_absl/base/config.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN // GetStackFrames() // @@ -225,7 +225,7 @@ namespace debugging_internal { // working. extern bool StackTraceWorksForTest(); } // namespace debugging_internal -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_STACKTRACE_H_ +#endif // Y_ABSL_DEBUGGING_STACKTRACE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc index 88c92a19ea4..43363339cd5 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc @@ -19,13 +19,13 @@ #if !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)) || \ WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) // UWP doesn't have access to win32 APIs. -#define ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32 +#define Y_ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32 #endif #endif -#if defined(ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE) +#if defined(Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE) #include "y_absl/debugging/symbolize_elf.inc" -#elif defined(ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32) +#elif defined(Y_ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32) // The Windows Symbolizer only works if PDB files containing the debug info // are available to the program at runtime. #include "y_absl/debugging/symbolize_win32.inc" diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h index 2a99f65c834..01131a005a9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h @@ -49,13 +49,13 @@ // return 0; // } // -#ifndef ABSL_DEBUGGING_SYMBOLIZE_H_ -#define ABSL_DEBUGGING_SYMBOLIZE_H_ +#ifndef Y_ABSL_DEBUGGING_SYMBOLIZE_H_ +#define Y_ABSL_DEBUGGING_SYMBOLIZE_H_ #include "y_absl/debugging/internal/symbolize.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN // InitializeSymbolizer() // @@ -93,7 +93,7 @@ void InitializeSymbolizer(const char* argv0); // } bool Symbolize(const void *pc, char *out, int out_size); -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl -#endif // ABSL_DEBUGGING_SYMBOLIZE_H_ +#endif // Y_ABSL_DEBUGGING_SYMBOLIZE_H_ diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc index c5960a79383..f36444f9b7d 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc @@ -25,7 +25,7 @@ #include "y_absl/strings/string_view.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN void InitializeSymbolizer(const char*) {} @@ -97,5 +97,5 @@ bool Symbolize(const void* pc, char* out, int out_size) { return true; } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc index 18297405e3e..343be4f91b9 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc @@ -82,13 +82,13 @@ #endif namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN // Value of argv[0]. Used by MaybeInitializeObjFile(). static char *argv0_value = nullptr; void InitializeSymbolizer(const char *argv0) { -#ifdef ABSL_HAVE_VDSO_SUPPORT +#ifdef Y_ABSL_HAVE_VDSO_SUPPORT // We need to make sure VDSOSupport::Init() is called before any setuid or // chroot calls, so InitializeSymbolizer() should be called very early in the // life of a program. @@ -161,14 +161,14 @@ struct FileMappingHint { // Moreover, we are using only TryLock(), if the decorator list // is being modified (is busy), we skip all decorators, and possibly // loose some info. Sorry, that's the best we could do. -ABSL_CONST_INIT y_absl::base_internal::SpinLock g_decorators_mu( +Y_ABSL_CONST_INIT y_absl::base_internal::SpinLock g_decorators_mu( y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY); const int kMaxFileMappingHints = 8; int g_num_file_mapping_hints; FileMappingHint g_file_mapping_hints[kMaxFileMappingHints]; // Protects g_file_mapping_hints. -ABSL_CONST_INIT y_absl::base_internal::SpinLock g_file_mapping_mu( +Y_ABSL_CONST_INIT y_absl::base_internal::SpinLock g_file_mapping_mu( y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY); // Async-signal-safe function to zero a buffer. @@ -303,12 +303,12 @@ class Symbolizer { int len = strlen(s); char *dst = static_cast<char *>( base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena())); - ABSL_RAW_CHECK(dst != nullptr, "out of memory"); + Y_ABSL_RAW_CHECK(dst != nullptr, "out of memory"); memcpy(dst, s, len + 1); return dst; } ObjFile *FindObjFile(const void *const start, - size_t size) ABSL_ATTRIBUTE_NOINLINE; + size_t size) Y_ABSL_ATTRIBUTE_NOINLINE; static bool RegisterObjFile(const char *filename, const void *const start_addr, const void *const end_addr, uint64_t offset, @@ -388,7 +388,7 @@ static void FreeSymbolizer(Symbolizer *s) { Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) { for (SymbolCacheLine &symbol_cache_line : symbol_cache_) { - for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) { + for (size_t j = 0; j < Y_ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) { symbol_cache_line.pc[j] = nullptr; symbol_cache_line.name[j] = nullptr; symbol_cache_line.age[j] = 0; @@ -422,7 +422,7 @@ static ssize_t ReadPersistent(int fd, void *buf, size_t count) { ssize_t len; NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes)); if (len < 0) { // There was an error other than EINTR. - ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno); + Y_ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno); return -1; } if (len == 0) { // Reached EOF. @@ -441,7 +441,7 @@ static ssize_t ReadFromOffset(const int fd, void *buf, const size_t count, const off_t offset) { off_t off = lseek(fd, offset, SEEK_SET); if (off == (off_t)-1) { - ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd, + Y_ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd, static_cast<uintmax_t>(offset), errno); return -1; } @@ -475,7 +475,7 @@ static int FileGetElfType(const int fd) { // and return true. Otherwise, return false. // To keep stack consumption low, we would like this function to not get // inlined. -static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType( +static Y_ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType( const int fd, ElfW(Half) sh_num, const off_t sh_offset, ElfW(Word) type, ElfW(Shdr) * out, char *tmp_buf, int tmp_buf_size) { ElfW(Shdr) *buf = reinterpret_cast<ElfW(Shdr) *>(tmp_buf); @@ -489,7 +489,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType( const off_t offset = sh_offset + i * sizeof(buf[0]); const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read, offset); if (len % sizeof(buf[0]) != 0) { - ABSL_RAW_LOG( + Y_ABSL_RAW_LOG( WARNING, "Reading %zd bytes from offset %ju returned %zd which is not a " "multiple of %zu.", @@ -560,7 +560,7 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len, ElfW(Shdr) * out) { char header_name[kMaxSectionNameLen]; if (sizeof(header_name) < name_len) { - ABSL_RAW_LOG(WARNING, + Y_ABSL_RAW_LOG(WARNING, "Section name '%s' is too long (%zu); " "section will not be found (even if present).", name, name_len); @@ -659,7 +659,7 @@ static const char *ComputeOffset(const char *base, ptrdiff_t offset) { // If the symbol is not found, SYMBOL_NOT_FOUND is returned; // To keep stack consumption low, we would like this function to not get // inlined. -static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol( +static Y_ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol( const void *const pc, const int fd, char *out, int out_size, ptrdiff_t relocation, const ElfW(Shdr) * strtab, const ElfW(Shdr) * symtab, const ElfW(Shdr) * opd, char *tmp_buf, int tmp_buf_size) { @@ -747,12 +747,12 @@ static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol( const ssize_t n_read = ReadFromOffset(fd, out, out_size, off); if (n_read <= 0) { // This should never happen. - ABSL_RAW_LOG(WARNING, + Y_ABSL_RAW_LOG(WARNING, "Unable to read from fd %d at offset %zu: n_read = %zd", fd, off, n_read); return SYMBOL_NOT_FOUND; } - ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data."); + Y_ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data."); // strtab->sh_offset points into .strtab-like section that contains // NUL-terminated strings: '\0foo\0barbaz\0...". @@ -962,7 +962,7 @@ static bool ShouldUseMapping(const char *const flags) { // Read /proc/self/maps and run "callback" for each mmapped file found. If // "callback" returns false, stop scanning and return true. Else continue // scanning /proc/self/maps. Return true if no parse error is found. -static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( +static Y_ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( bool (*callback)(const char *filename, const void *const start_addr, const void *const end_addr, uint64_t offset, void *arg), void *arg, void *tmp_buf, int tmp_buf_size) { @@ -976,7 +976,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( NO_INTR(maps_fd = open(maps_path, O_RDONLY)); FileDescriptor wrapped_maps_fd(maps_fd); if (wrapped_maps_fd.get() < 0) { - ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno); + Y_ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno); return false; } @@ -1003,7 +1003,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( // Read start address. cursor = GetHex(cursor, eol, &start_address); if (cursor == eol || *cursor != '-') { - ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line); + Y_ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line); return false; } ++cursor; // Skip '-'. @@ -1012,7 +1012,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( const void *end_address; cursor = GetHex(cursor, eol, &end_address); if (cursor == eol || *cursor != ' ') { - ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line); + Y_ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line); return false; } ++cursor; // Skip ' '. @@ -1024,7 +1024,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( } // We expect at least four letters for flags (ex. "r-xp"). if (cursor == eol || cursor < flags_start + 4) { - ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line); + Y_ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line); return false; } @@ -1129,7 +1129,7 @@ bool Symbolizer::RegisterObjFile(const char *filename, if (addr_map_size != 0) { ObjFile *old = impl->addr_map_.At(addr_map_size - 1); if (old->end_addr > end_addr) { - ABSL_RAW_LOG(ERROR, + Y_ABSL_RAW_LOG(ERROR, "Unsorted addr map entry: 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s", reinterpret_cast<uintptr_t>(end_addr), filename, @@ -1139,7 +1139,7 @@ bool Symbolizer::RegisterObjFile(const char *filename, // The same entry appears twice. This sometimes happens for [vdso]. if (old->start_addr != start_addr || strcmp(old->filename, filename) != 0) { - ABSL_RAW_LOG(ERROR, + Y_ABSL_RAW_LOG(ERROR, "Duplicate addr 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s", reinterpret_cast<uintptr_t>(end_addr), filename, reinterpret_cast<uintptr_t>(old->end_addr), old->filename); @@ -1161,7 +1161,7 @@ bool Symbolizer::RegisterObjFile(const char *filename, // where the input symbol is demangled in-place. // To keep stack consumption low, we would like this function to not // get inlined. -static ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size, +static Y_ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size, char *tmp_buf, int tmp_buf_size) { if (Demangle(out, tmp_buf, tmp_buf_size)) { @@ -1193,7 +1193,7 @@ const char *Symbolizer::FindSymbolInCache(const void *const pc) { if (pc == nullptr) return nullptr; SymbolCacheLine *line = GetCacheLine(pc); - for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) { + for (size_t i = 0; i < Y_ABSL_ARRAYSIZE(line->pc); ++i) { if (line->pc[i] == pc) { AgeSymbols(line); line->age[i] = 0; @@ -1210,7 +1210,7 @@ const char *Symbolizer::InsertSymbolInCache(const void *const pc, SymbolCacheLine *line = GetCacheLine(pc); uint32_t max_age = 0; int oldest_index = -1; - for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) { + for (size_t i = 0; i < Y_ABSL_ARRAYSIZE(line->pc); ++i) { if (line->pc[i] == nullptr) { AgeSymbols(line); line->pc[i] = pc; @@ -1225,7 +1225,7 @@ const char *Symbolizer::InsertSymbolInCache(const void *const pc, } AgeSymbols(line); - ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache"); + Y_ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache"); base_internal::LowLevelAlloc::Free(line->name[oldest_index]); line->pc[oldest_index] = pc; line->name[oldest_index] = CopyString(name); @@ -1277,19 +1277,19 @@ static bool MaybeInitializeObjFile(ObjFile *obj) { } if (obj->fd < 0) { - ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno); + Y_ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno); return false; } obj->elf_type = FileGetElfType(obj->fd); if (obj->elf_type < 0) { - ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename, + Y_ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename, obj->elf_type); return false; } if (!ReadFromOffsetExact(obj->fd, &obj->elf_header, sizeof(obj->elf_header), 0)) { - ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename); + Y_ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename); return false; } const int phnum = obj->elf_header.e_phnum; @@ -1299,7 +1299,7 @@ static bool MaybeInitializeObjFile(ObjFile *obj) { for (int j = 0; j < phnum; j++) { ElfW(Phdr) phdr; if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) { - ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d", + Y_ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d", obj->filename, j); return false; } @@ -1312,14 +1312,14 @@ static bool MaybeInitializeObjFile(ObjFile *obj) { if (num_executable_load_segments < obj->phdr.size()) { memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr)); } else { - ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments", + Y_ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments", obj->filename); break; } } if (num_executable_load_segments == 0) { // This object has no "r-x" LOAD segments. That's unexpected. - ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename); + Y_ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename); return false; } } @@ -1361,7 +1361,7 @@ const char *Symbolizer::GetSymbol(const void *const pc) { if (p.p_type != PT_LOAD) { // We only expect PT_LOADs. This must be PT_NULL that we didn't // write over (i.e. we exhausted all interesting PT_LOADs). - ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type"); + Y_ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type"); break; } if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) { @@ -1371,7 +1371,7 @@ const char *Symbolizer::GetSymbol(const void *const pc) { } if (phdr == nullptr) { // That's unexpected. Hope for the best. - ABSL_RAW_LOG( + Y_ABSL_RAW_LOG( WARNING, "%s: unable to find LOAD segment for pc: %p, start_addr: %zx", obj->filename, pc, start_addr); @@ -1393,14 +1393,14 @@ const char *Symbolizer::GetSymbol(const void *const pc) { } } } else { -#if ABSL_HAVE_VDSO_SUPPORT +#if Y_ABSL_HAVE_VDSO_SUPPORT VDSOSupport vdso; if (vdso.IsPresent()) { VDSOSupport::SymbolInfo symbol_info; if (vdso.LookupSymbolByAddress(pc, &symbol_info)) { // All VDSO symbols are known to be short. size_t len = strlen(symbol_info.name); - ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_), + Y_ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_), "VDSO symbol unexpectedly long"); memcpy(symbol_buf_, symbol_info.name, len + 1); } @@ -1493,7 +1493,7 @@ bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset int len = strlen(filename); char *dst = static_cast<char *>( base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena())); - ABSL_RAW_CHECK(dst != nullptr, "out of memory"); + Y_ABSL_RAW_CHECK(dst != nullptr, "out of memory"); memcpy(dst, filename, len + 1); auto &hint = g_file_mapping_hints[g_num_file_mapping_hints++]; @@ -1540,7 +1540,7 @@ bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset, bool Symbolize(const void *pc, char *out, int out_size) { // Symbolization is very slow under tsan. - ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN(); + Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN(); SAFE_ASSERT(out_size >= 0); debugging_internal::Symbolizer *s = debugging_internal::AllocateSymbolizer(); const char *name = s->GetSymbol(pc); @@ -1559,11 +1559,11 @@ bool Symbolize(const void *pc, char *out, int out_size) { } } debugging_internal::FreeSymbolizer(s); - ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END(); + Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END(); return ok; } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl extern "C" bool YAbslInternalGetFileMappingHint(const void **start, diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc index 6ddb5b4a7fc..5aa97cca46e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc @@ -34,11 +34,11 @@ EM_JS(bool, HaveOffsetConverter, (), // clang-format on namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN void InitializeSymbolizer(const char*) { if (!HaveOffsetConverter()) { - ABSL_RAW_LOG(INFO, + Y_ABSL_RAW_LOG(INFO, "Symbolization unavailable. Rebuild with -sWASM=1 " "and -sUSE_OFFSET_CONVERTER=1."); } @@ -68,5 +68,5 @@ bool Symbolize(const void* pc, char* out, int out_size) { return true; } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc index 4e55ed122f8..ec50f589c6e 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc @@ -17,7 +17,7 @@ #include "y_absl/base/internal/raw_logging.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN namespace debugging_internal { @@ -36,5 +36,5 @@ bool GetFileMappingHint(const void **, const void **, uint64_t *, const char **) void InitializeSymbolizer(const char*) {} bool Symbolize(const void *, char *, int) { return false; } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc index 81e0473f88c..ac6748092cc 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc @@ -31,7 +31,7 @@ #include "y_absl/base/internal/raw_logging.h" namespace y_absl { -ABSL_NAMESPACE_BEGIN +Y_ABSL_NAMESPACE_BEGIN static HANDLE process = NULL; @@ -47,10 +47,10 @@ void InitializeSymbolizer(const char*) { SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME); if (!SymInitialize(process, nullptr, true)) { // GetLastError() returns a Win32 DWORD, but we assign to - // unsigned long long to simplify the ABSL_RAW_LOG case below. The uniform + // unsigned long long to simplify the Y_ABSL_RAW_LOG case below. The uniform // initialization guarantees this is not a narrowing conversion. const unsigned long long error{GetLastError()}; // NOLINT(runtime/int) - ABSL_RAW_LOG(FATAL, "SymInitialize() failed: %llu", error); + Y_ABSL_RAW_LOG(FATAL, "SymInitialize() failed: %llu", error); } } @@ -77,5 +77,5 @@ bool Symbolize(const void* pc, char* out, int out_size) { return true; } -ABSL_NAMESPACE_END +Y_ABSL_NAMESPACE_END } // namespace y_absl |