Restoring authorship annotation for <anastasy888@yandex-team.ru>. Commit 1 of 2.

1 files changed, 342 insertions, 342 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc b/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc
index 689e5979e7..42a075efb1 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc
@@ -1,226 +1,226 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "absl/debugging/failure_signal_handler.h"
-
-#include "absl/base/config.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#else
+// 
+// Copyright 2018 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// 
+ 
+#include "absl/debugging/failure_signal_handler.h" 
+ 
+#include "absl/base/config.h" 
+ 
+#ifdef _WIN32 
+#include <windows.h> 
+#else 
 #include <sched.h>
-#include <unistd.h>
-#endif
-
+#include <unistd.h> 
+#endif 
+ 
 #ifdef __APPLE__
 #include <TargetConditionals.h>
 #endif
 
-#ifdef ABSL_HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-#include <algorithm>
-#include <atomic>
-#include <cerrno>
-#include <csignal>
-#include <cstdio>
-#include <cstring>
-#include <ctime>
-
-#include "absl/base/attributes.h"
+#ifdef ABSL_HAVE_MMAP 
+#include <sys/mman.h> 
+#endif 
+ 
+#include <algorithm> 
+#include <atomic> 
+#include <cerrno> 
+#include <csignal> 
+#include <cstdio> 
+#include <cstring> 
+#include <ctime> 
+ 
+#include "absl/base/attributes.h" 
 #include "absl/base/internal/errno_saver.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/sysinfo.h"
-#include "absl/debugging/internal/examine_stack.h"
-#include "absl/debugging/stacktrace.h"
-
-#ifndef _WIN32
-#define ABSL_HAVE_SIGACTION
+#include "absl/base/internal/raw_logging.h" 
+#include "absl/base/internal/sysinfo.h" 
+#include "absl/debugging/internal/examine_stack.h" 
+#include "absl/debugging/stacktrace.h" 
+ 
+#ifndef _WIN32 
+#define 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
+#endif 
 #endif
-#endif
-
-namespace absl {
+ 
+namespace absl { 
 ABSL_NAMESPACE_BEGIN
-
-ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options;
-
-// Resets the signal handler for signo to the default action for that
-// signal, then raises the signal.
-static void RaiseToDefaultHandler(int signo) {
-  signal(signo, SIG_DFL);
-  raise(signo);
-}
-
-struct FailureSignalData {
-  const int signo;
-  const char* const as_string;
-#ifdef ABSL_HAVE_SIGACTION
-  struct sigaction previous_action;
-  // StructSigaction is used to silence -Wmissing-field-initializers.
-  using StructSigaction = struct sigaction;
-  #define FSD_PREVIOUS_INIT FailureSignalData::StructSigaction()
-#else
-  void (*previous_handler)(int);
-  #define FSD_PREVIOUS_INIT SIG_DFL
-#endif
-};
-
-ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = {
-    {SIGSEGV, "SIGSEGV", FSD_PREVIOUS_INIT},
-    {SIGILL, "SIGILL", FSD_PREVIOUS_INIT},
-    {SIGFPE, "SIGFPE", FSD_PREVIOUS_INIT},
-    {SIGABRT, "SIGABRT", FSD_PREVIOUS_INIT},
-    {SIGTERM, "SIGTERM", FSD_PREVIOUS_INIT},
-#ifndef _WIN32
-    {SIGBUS, "SIGBUS", FSD_PREVIOUS_INIT},
-    {SIGTRAP, "SIGTRAP", FSD_PREVIOUS_INIT},
-#endif
-};
-
-#undef FSD_PREVIOUS_INIT
-
-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
-      sigaction(signo, &it.previous_action, nullptr);
-#else
-      signal(signo, it.previous_handler);
-#endif
-      raise(signo);
-      return;
-    }
-  }
-
-  // Not found, use the default handler.
-  RaiseToDefaultHandler(signo);
-}
-
-namespace debugging_internal {
-
-const char* FailureSignalToString(int signo) {
-  for (const auto& it : failure_signal_data) {
-    if (it.signo == signo) {
-      return it.as_string;
-    }
-  }
-  return "";
-}
-
-}  // namespace debugging_internal
-
+ 
+ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options; 
+ 
+// Resets the signal handler for signo to the default action for that 
+// signal, then raises the signal. 
+static void RaiseToDefaultHandler(int signo) { 
+  signal(signo, SIG_DFL); 
+  raise(signo); 
+} 
+ 
+struct FailureSignalData { 
+  const int signo; 
+  const char* const as_string; 
+#ifdef ABSL_HAVE_SIGACTION 
+  struct sigaction previous_action; 
+  // StructSigaction is used to silence -Wmissing-field-initializers. 
+  using StructSigaction = struct sigaction; 
+  #define FSD_PREVIOUS_INIT FailureSignalData::StructSigaction() 
+#else 
+  void (*previous_handler)(int); 
+  #define FSD_PREVIOUS_INIT SIG_DFL 
+#endif 
+}; 
+ 
+ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = { 
+    {SIGSEGV, "SIGSEGV", FSD_PREVIOUS_INIT}, 
+    {SIGILL, "SIGILL", FSD_PREVIOUS_INIT}, 
+    {SIGFPE, "SIGFPE", FSD_PREVIOUS_INIT}, 
+    {SIGABRT, "SIGABRT", FSD_PREVIOUS_INIT}, 
+    {SIGTERM, "SIGTERM", FSD_PREVIOUS_INIT}, 
+#ifndef _WIN32 
+    {SIGBUS, "SIGBUS", FSD_PREVIOUS_INIT}, 
+    {SIGTRAP, "SIGTRAP", FSD_PREVIOUS_INIT}, 
+#endif 
+}; 
+ 
+#undef FSD_PREVIOUS_INIT 
+ 
+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 
+      sigaction(signo, &it.previous_action, nullptr); 
+#else 
+      signal(signo, it.previous_handler); 
+#endif 
+      raise(signo); 
+      return; 
+    } 
+  } 
+ 
+  // Not found, use the default handler. 
+  RaiseToDefaultHandler(signo); 
+} 
+ 
+namespace debugging_internal { 
+ 
+const char* FailureSignalToString(int signo) { 
+  for (const auto& it : failure_signal_data) { 
+    if (it.signo == signo) { 
+      return it.as_string; 
+    } 
+  } 
+  return ""; 
+} 
+ 
+}  // namespace debugging_internal 
+ 
 #ifdef ABSL_HAVE_SIGALTSTACK
-
-static bool SetupAlternateStackOnce() {
-#if defined(__wasm__) || defined (__asjms__)
-  const size_t page_mask = getpagesize() - 1;
-#else
-  const size_t page_mask = sysconf(_SC_PAGESIZE) - 1;
-#endif
+ 
+static bool SetupAlternateStackOnce() { 
+#if defined(__wasm__) || defined (__asjms__) 
+  const size_t page_mask = getpagesize() - 1; 
+#else 
+  const size_t page_mask = sysconf(_SC_PAGESIZE) - 1; 
+#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)
-  // Account for sanitizer instrumentation requiring additional stack space.
-  stack_size *= 5;
-#endif
-
-  stack_t sigstk;
-  memset(&sigstk, 0, sizeof(sigstk));
-  sigstk.ss_size = stack_size;
-
-#ifdef ABSL_HAVE_MMAP
-#ifndef MAP_STACK
-#define MAP_STACK 0
-#endif
-#if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-  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");
-  }
-#else
-  sigstk.ss_sp = malloc(sigstk.ss_size);
-  if (sigstk.ss_sp == nullptr) {
-    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);
-  }
-  return true;
-}
-
-#endif
-
-#ifdef 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() {
+  // Account for sanitizer instrumentation requiring additional stack space. 
+  stack_size *= 5; 
+#endif 
+ 
+  stack_t sigstk; 
+  memset(&sigstk, 0, sizeof(sigstk)); 
+  sigstk.ss_size = stack_size; 
+ 
+#ifdef ABSL_HAVE_MMAP 
+#ifndef MAP_STACK 
+#define MAP_STACK 0 
+#endif 
+#if defined(MAP_ANON) && !defined(MAP_ANONYMOUS) 
+#define MAP_ANONYMOUS MAP_ANON 
+#endif 
+  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"); 
+  } 
+#else 
+  sigstk.ss_sp = malloc(sigstk.ss_size); 
+  if (sigstk.ss_sp == nullptr) { 
+    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); 
+  } 
+  return true; 
+} 
+ 
+#endif 
+ 
+#ifdef 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();
-  return SA_ONSTACK;
-#else
-  return 0;
-#endif
-}
-
-static void InstallOneFailureHandler(FailureSignalData* data,
-                                     void (*handler)(int, siginfo_t*, void*)) {
-  struct sigaction act;
-  memset(&act, 0, sizeof(act));
-  sigemptyset(&act.sa_mask);
-  act.sa_flags |= SA_SIGINFO;
-  // SA_NODEFER is required to handle SIGABRT from
-  // ImmediateAbortSignalHandler().
-  act.sa_flags |= SA_NODEFER;
-  if (fsh_options.use_alternate_stack) {
-    act.sa_flags |= MaybeSetupAlternateStack();
-  }
-  act.sa_sigaction = handler;
-  ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0,
-                 "sigaction() failed");
-}
-
-#else
-
-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");
-}
-
-#endif
-
-static void WriteToStderr(const char* data) {
+  ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce(); 
+  return SA_ONSTACK; 
+#else 
+  return 0; 
+#endif 
+} 
+ 
+static void InstallOneFailureHandler(FailureSignalData* data, 
+                                     void (*handler)(int, siginfo_t*, void*)) { 
+  struct sigaction act; 
+  memset(&act, 0, sizeof(act)); 
+  sigemptyset(&act.sa_mask); 
+  act.sa_flags |= SA_SIGINFO; 
+  // SA_NODEFER is required to handle SIGABRT from 
+  // ImmediateAbortSignalHandler(). 
+  act.sa_flags |= SA_NODEFER; 
+  if (fsh_options.use_alternate_stack) { 
+    act.sa_flags |= MaybeSetupAlternateStack(); 
+  } 
+  act.sa_sigaction = handler; 
+  ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0, 
+                 "sigaction() failed"); 
+} 
+ 
+#else 
+ 
+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"); 
+} 
+ 
+#endif 
+ 
+static void WriteToStderr(const char* data) { 
   absl::base_internal::ErrnoSaver errno_saver;
-  absl::raw_logging_internal::SafeWriteToStderr(data, strlen(data));
-}
-
+  absl::raw_logging_internal::SafeWriteToStderr(data, strlen(data)); 
+} 
+ 
 static void WriteSignalMessage(int signo, int cpu,
                                void (*writerfn)(const char*)) {
   char buf[96];
@@ -228,121 +228,121 @@ static void WriteSignalMessage(int signo, int cpu,
   if (cpu != -1) {
     snprintf(on_cpu, sizeof(on_cpu), " on cpu %d", cpu);
   }
-  const char* const signal_string =
-      debugging_internal::FailureSignalToString(signo);
-  if (signal_string != nullptr && signal_string[0] != '\0') {
+  const char* const signal_string = 
+      debugging_internal::FailureSignalToString(signo); 
+  if (signal_string != nullptr && signal_string[0] != '\0') { 
     snprintf(buf, sizeof(buf), "*** %s received at time=%ld%s ***\n",
-             signal_string,
+             signal_string, 
              static_cast<long>(time(nullptr)),   // NOLINT(runtime/int)
              on_cpu);
-  } else {
+  } else { 
     snprintf(buf, sizeof(buf), "*** Signal %d received at time=%ld%s ***\n",
              signo, static_cast<long>(time(nullptr)),  // NOLINT(runtime/int)
              on_cpu);
-  }
-  writerfn(buf);
-}
-
-// `void*` might not be big enough to store `void(*)(const char*)`.
-struct WriterFnStruct {
-  void (*writerfn)(const char*);
-};
-
-// Many of the absl::debugging_internal::Dump* functions in
-// examine_stack.h take a writer function pointer that has a void* arg
-// for historical reasons. failure_signal_handler_writer only takes a
-// data pointer. This function converts between these types.
-static void WriterFnWrapper(const char* data, void* arg) {
-  static_cast<WriterFnStruct*>(arg)->writerfn(data);
-}
-
-// 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(
-    void* ucontext, bool symbolize_stacktrace,
-    void (*writerfn)(const char*, void*), void* writerfn_arg) {
-  constexpr int kNumStackFrames = 32;
-  void* stack[kNumStackFrames];
-  int frame_sizes[kNumStackFrames];
-  int min_dropped_frames;
-  int depth = absl::GetStackFramesWithContext(
-      stack, frame_sizes, kNumStackFrames,
-      1,  // Do not include this function in stack trace.
-      ucontext, &min_dropped_frames);
-  absl::debugging_internal::DumpPCAndFrameSizesAndStackTrace(
-      absl::debugging_internal::GetProgramCounter(ucontext), stack, frame_sizes,
-      depth, min_dropped_frames, symbolize_stacktrace, writerfn, writerfn_arg);
-}
-
-// Called by AbslFailureSignalHandler() to write the failure info. It is
-// called once with writerfn set to WriteToStderr() and then possibly
-// with writerfn set to the user provided function.
+  } 
+  writerfn(buf); 
+} 
+ 
+// `void*` might not be big enough to store `void(*)(const char*)`. 
+struct WriterFnStruct { 
+  void (*writerfn)(const char*); 
+}; 
+ 
+// Many of the absl::debugging_internal::Dump* functions in 
+// examine_stack.h take a writer function pointer that has a void* arg 
+// for historical reasons. failure_signal_handler_writer only takes a 
+// data pointer. This function converts between these types. 
+static void WriterFnWrapper(const char* data, void* arg) { 
+  static_cast<WriterFnStruct*>(arg)->writerfn(data); 
+} 
+ 
+// 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( 
+    void* ucontext, bool symbolize_stacktrace, 
+    void (*writerfn)(const char*, void*), void* writerfn_arg) { 
+  constexpr int kNumStackFrames = 32; 
+  void* stack[kNumStackFrames]; 
+  int frame_sizes[kNumStackFrames]; 
+  int min_dropped_frames; 
+  int depth = absl::GetStackFramesWithContext( 
+      stack, frame_sizes, kNumStackFrames, 
+      1,  // Do not include this function in stack trace. 
+      ucontext, &min_dropped_frames); 
+  absl::debugging_internal::DumpPCAndFrameSizesAndStackTrace( 
+      absl::debugging_internal::GetProgramCounter(ucontext), stack, frame_sizes, 
+      depth, min_dropped_frames, symbolize_stacktrace, writerfn, writerfn_arg); 
+} 
+ 
+// Called by AbslFailureSignalHandler() to write the failure info. It is 
+// called once with writerfn set to WriteToStderr() and then possibly 
+// with writerfn set to the user provided function. 
 static void WriteFailureInfo(int signo, void* ucontext, int cpu,
-                             void (*writerfn)(const char*)) {
-  WriterFnStruct writerfn_struct{writerfn};
+                             void (*writerfn)(const char*)) { 
+  WriterFnStruct writerfn_struct{writerfn}; 
   WriteSignalMessage(signo, cpu, writerfn);
-  WriteStackTrace(ucontext, fsh_options.symbolize_stacktrace, WriterFnWrapper,
-                  &writerfn_struct);
-}
-
-// absl::SleepFor() can't be used here since AbslInternalSleepFor()
-// may be overridden to do something that isn't async-signal-safe on
-// some platforms.
-static void PortableSleepForSeconds(int seconds) {
-#ifdef _WIN32
-  Sleep(seconds * 1000);
-#else
-  struct timespec sleep_time;
-  sleep_time.tv_sec = seconds;
-  sleep_time.tv_nsec = 0;
-  while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) {}
-#endif
-}
-
-#ifdef 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
-// the alarm timeout, ImmediateAbortSignalHandler() will abort the
-// program.
-static void ImmediateAbortSignalHandler(int) {
-  RaiseToDefaultHandler(SIGABRT);
-}
-#endif
-
-// absl::base_internal::GetTID() returns pid_t on most platforms, but
-// returns absl::base_internal::pid_t on Windows.
-using GetTidType = decltype(absl::base_internal::GetTID());
-ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0);
-
-#ifndef ABSL_HAVE_SIGACTION
-static void AbslFailureSignalHandler(int signo) {
-  void* ucontext = nullptr;
-#else
-static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
-#endif
-
-  const GetTidType this_tid = absl::base_internal::GetTID();
-  GetTidType previous_failed_tid = 0;
-  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(
-        ERROR,
-        "Signal %d raised at PC=%p while already in AbslFailureSignalHandler()",
-        signo, absl::debugging_internal::GetProgramCounter(ucontext));
-    if (this_tid != previous_failed_tid) {
-      // Another thread is already in AbslFailureSignalHandler(), so wait
-      // a bit for it to finish. If the other thread doesn't kill us,
-      // we do so after sleeping.
-      PortableSleepForSeconds(3);
-      RaiseToDefaultHandler(signo);
-      // The recursively raised signal may be blocked until we return.
-      return;
-    }
-  }
-
+  WriteStackTrace(ucontext, fsh_options.symbolize_stacktrace, WriterFnWrapper, 
+                  &writerfn_struct); 
+} 
+ 
+// absl::SleepFor() can't be used here since AbslInternalSleepFor() 
+// may be overridden to do something that isn't async-signal-safe on 
+// some platforms. 
+static void PortableSleepForSeconds(int seconds) { 
+#ifdef _WIN32 
+  Sleep(seconds * 1000); 
+#else 
+  struct timespec sleep_time; 
+  sleep_time.tv_sec = seconds; 
+  sleep_time.tv_nsec = 0; 
+  while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) {} 
+#endif 
+} 
+ 
+#ifdef 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 
+// the alarm timeout, ImmediateAbortSignalHandler() will abort the 
+// program. 
+static void ImmediateAbortSignalHandler(int) { 
+  RaiseToDefaultHandler(SIGABRT); 
+} 
+#endif 
+ 
+// absl::base_internal::GetTID() returns pid_t on most platforms, but 
+// returns absl::base_internal::pid_t on Windows. 
+using GetTidType = decltype(absl::base_internal::GetTID()); 
+ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0); 
+ 
+#ifndef ABSL_HAVE_SIGACTION 
+static void AbslFailureSignalHandler(int signo) { 
+  void* ucontext = nullptr; 
+#else 
+static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) { 
+#endif 
+ 
+  const GetTidType this_tid = absl::base_internal::GetTID(); 
+  GetTidType previous_failed_tid = 0; 
+  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( 
+        ERROR, 
+        "Signal %d raised at PC=%p while already in AbslFailureSignalHandler()", 
+        signo, absl::debugging_internal::GetProgramCounter(ucontext)); 
+    if (this_tid != previous_failed_tid) { 
+      // Another thread is already in AbslFailureSignalHandler(), so wait 
+      // a bit for it to finish. If the other thread doesn't kill us, 
+      // we do so after sleeping. 
+      PortableSleepForSeconds(3); 
+      RaiseToDefaultHandler(signo); 
+      // The recursively raised signal may be blocked until we return. 
+      return; 
+    } 
+  } 
+ 
   // Increase the chance that the CPU we report was the same CPU on which the
   // signal was received by doing this as early as possible, i.e. after
   // verifying that this is not a recursive signal handler invocation.
@@ -351,38 +351,38 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
   my_cpu = sched_getcpu();
 #endif
 
-#ifdef 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.
-    signal(SIGALRM, ImmediateAbortSignalHandler);
-    alarm(fsh_options.alarm_on_failure_secs);
-  }
-#endif
-
-  // First write to stderr.
+#ifdef 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. 
+    signal(SIGALRM, ImmediateAbortSignalHandler); 
+    alarm(fsh_options.alarm_on_failure_secs); 
+  } 
+#endif 
+ 
+  // First write to stderr. 
   WriteFailureInfo(signo, ucontext, my_cpu, WriteToStderr);
-
-  // Riskier code (because it is less likely to be async-signal-safe)
-  // goes after this point.
-  if (fsh_options.writerfn != nullptr) {
+ 
+  // Riskier code (because it is less likely to be async-signal-safe) 
+  // goes after this point. 
+  if (fsh_options.writerfn != nullptr) { 
     WriteFailureInfo(signo, ucontext, my_cpu, fsh_options.writerfn);
     fsh_options.writerfn(nullptr);
-  }
-
-  if (fsh_options.call_previous_handler) {
-    RaiseToPreviousHandler(signo);
-  } else {
-    RaiseToDefaultHandler(signo);
-  }
-}
-
-void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) {
-  fsh_options = options;
-  for (auto& it : failure_signal_data) {
-    InstallOneFailureHandler(&it, AbslFailureSignalHandler);
-  }
-}
-
+  } 
+ 
+  if (fsh_options.call_previous_handler) { 
+    RaiseToPreviousHandler(signo); 
+  } else { 
+    RaiseToDefaultHandler(signo); 
+  } 
+} 
+ 
+void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) { 
+  fsh_options = options; 
+  for (auto& it : failure_signal_data) { 
+    InstallOneFailureHandler(&it, AbslFailureSignalHandler); 
+  } 
+} 
+ 
 ABSL_NAMESPACE_END
-}  // namespace absl
+}  // namespace absl