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

1 files changed, 313 insertions, 313 deletions

diff --git a/contrib/libs/llvm12/lib/Support/PrettyStackTrace.cpp b/contrib/libs/llvm12/lib/Support/PrettyStackTrace.cpp
index ff80343e0f..5d3d95b5e7 100644
--- a/contrib/libs/llvm12/lib/Support/PrettyStackTrace.cpp
+++ b/contrib/libs/llvm12/lib/Support/PrettyStackTrace.cpp
@@ -1,259 +1,259 @@
-//===- PrettyStackTrace.cpp - Pretty Crash Handling -----------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// This file defines some helpful functions for dealing with the possibility of 
-// Unix signals occurring while your program is running. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#include "llvm/Support/PrettyStackTrace.h" 
-#include "llvm-c/ErrorHandling.h" 
-#include "llvm/ADT/SmallString.h" 
-#include "llvm/Config/config.h" 
-#include "llvm/Support/Compiler.h" 
-#include "llvm/Support/SaveAndRestore.h" 
-#include "llvm/Support/Signals.h" 
-#include "llvm/Support/Watchdog.h" 
-#include "llvm/Support/raw_ostream.h" 
- 
-#include <atomic> 
-#include <cassert> 
-#include <cstdarg> 
-#include <cstdio> 
+//===- PrettyStackTrace.cpp - Pretty Crash Handling -----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines some helpful functions for dealing with the possibility of
+// Unix signals occurring while your program is running.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/PrettyStackTrace.h"
+#include "llvm-c/ErrorHandling.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Config/config.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/Watchdog.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <atomic>
+#include <cassert>
+#include <cstdarg>
+#include <cstdio>
 #include <cstring>
-#include <tuple> 
- 
-#ifdef HAVE_CRASHREPORTERCLIENT_H 
-#include <CrashReporterClient.h> 
-#endif 
- 
-using namespace llvm; 
- 
-static const char *BugReportMsg = 
-    "PLEASE submit a bug report to " BUG_REPORT_URL 
-    " and include the crash backtrace.\n"; 
- 
-// If backtrace support is not enabled, compile out support for pretty stack 
-// traces.  This has the secondary effect of not requiring thread local storage 
-// when backtrace support is disabled. 
-#if ENABLE_BACKTRACES 
- 
-// We need a thread local pointer to manage the stack of our stack trace 
-// objects, but we *really* cannot tolerate destructors running and do not want 
-// to pay any overhead of synchronizing. As a consequence, we use a raw 
-// thread-local variable. 
-static LLVM_THREAD_LOCAL PrettyStackTraceEntry *PrettyStackTraceHead = nullptr; 
- 
-// The use of 'volatile' here is to ensure that any particular thread always 
-// reloads the value of the counter. The 'std::atomic' allows us to specify that 
-// this variable is accessed in an unsychronized way (it's not actually 
-// synchronizing). This does technically mean that the value may not appear to 
-// be the same across threads running simultaneously on different CPUs, but in 
-// practice the worst that will happen is that we won't print a stack trace when 
-// we could have. 
-// 
-// This is initialized to 1 because 0 is used as a sentinel for "not enabled on 
-// the current thread". If the user happens to overflow an 'unsigned' with 
-// SIGINFO requests, it's possible that some threads will stop responding to it, 
-// but the program won't crash. 
-static volatile std::atomic<unsigned> GlobalSigInfoGenerationCounter = 
-    ATOMIC_VAR_INIT(1); 
-static LLVM_THREAD_LOCAL unsigned ThreadLocalSigInfoGenerationCounter = 0; 
- 
-namespace llvm { 
-PrettyStackTraceEntry *ReverseStackTrace(PrettyStackTraceEntry *Head) { 
-  PrettyStackTraceEntry *Prev = nullptr; 
-  while (Head) 
-    std::tie(Prev, Head, Head->NextEntry) = 
-        std::make_tuple(Head, Head->NextEntry, Prev); 
-  return Prev; 
-} 
-} 
- 
-static void PrintStack(raw_ostream &OS) { 
-  // Print out the stack in reverse order. To avoid recursion (which is likely 
-  // to fail if we crashed due to stack overflow), we do an up-front pass to 
-  // reverse the stack, then print it, then reverse it again. 
-  unsigned ID = 0; 
-  SaveAndRestore<PrettyStackTraceEntry *> SavedStack{PrettyStackTraceHead, 
-                                                     nullptr}; 
-  PrettyStackTraceEntry *ReversedStack = ReverseStackTrace(SavedStack.get()); 
-  for (const PrettyStackTraceEntry *Entry = ReversedStack; Entry; 
-       Entry = Entry->getNextEntry()) { 
-    OS << ID++ << ".\t"; 
-    sys::Watchdog W(5); 
-    Entry->print(OS); 
-  } 
-  llvm::ReverseStackTrace(ReversedStack); 
-} 
- 
-/// Print the current stack trace to the specified stream. 
-/// 
-/// Marked NOINLINE so it can be called from debuggers. 
-LLVM_ATTRIBUTE_NOINLINE 
-static void PrintCurStackTrace(raw_ostream &OS) { 
-  // Don't print an empty trace. 
-  if (!PrettyStackTraceHead) return; 
- 
-  // If there are pretty stack frames registered, walk and emit them. 
-  OS << "Stack dump:\n"; 
- 
-  PrintStack(OS); 
-  OS.flush(); 
-} 
- 
-// Integrate with crash reporter libraries. 
-#if defined (__APPLE__) && defined(HAVE_CRASHREPORTERCLIENT_H) 
-//  If any clients of llvm try to link to libCrashReporterClient.a themselves, 
-//  only one crash info struct will be used. 
-extern "C" { 
-CRASH_REPORTER_CLIENT_HIDDEN 
-struct crashreporter_annotations_t gCRAnnotations 
-        __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION))) 
-#if CRASHREPORTER_ANNOTATIONS_VERSION < 5 
-        = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 }; 
-#else 
-        = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0, 0 }; 
-#endif 
-} 
-#elif defined(__APPLE__) && HAVE_CRASHREPORTER_INFO 
-extern "C" const char *__crashreporter_info__ 
-    __attribute__((visibility("hidden"))) = 0; 
-asm(".desc ___crashreporter_info__, 0x10"); 
-#endif 
- 
-static void setCrashLogMessage(const char *msg) LLVM_ATTRIBUTE_UNUSED; 
-static void setCrashLogMessage(const char *msg) { 
-#ifdef HAVE_CRASHREPORTERCLIENT_H 
-  (void)CRSetCrashLogMessage(msg); 
-#elif HAVE_CRASHREPORTER_INFO 
-  __crashreporter_info__ = msg; 
-#endif 
-  // Don't reorder subsequent operations: whatever comes after might crash and 
-  // we want the system crash handling to see the message we just set. 
-  std::atomic_signal_fence(std::memory_order_seq_cst); 
-} 
- 
-#ifdef __APPLE__ 
-using CrashHandlerString = SmallString<2048>; 
-using CrashHandlerStringStorage = 
-    std::aligned_storage<sizeof(CrashHandlerString), 
-                         alignof(CrashHandlerString)>::type; 
-static CrashHandlerStringStorage crashHandlerStringStorage; 
-#endif 
- 
-/// This callback is run if a fatal signal is delivered to the process, it 
-/// prints the pretty stack trace. 
-static void CrashHandler(void *) { 
-  errs() << BugReportMsg ; 
- 
-#ifndef __APPLE__ 
-  // On non-apple systems, just emit the crash stack trace to stderr. 
-  PrintCurStackTrace(errs()); 
-#else 
-  // Emit the crash stack trace to a SmallString, put it where the system crash 
-  // handling will find it, and also send it to stderr. 
-  // 
-  // The SmallString is fairly large in the hope that we don't allocate (we're 
-  // handling a fatal signal, something is already pretty wrong, allocation 
-  // might not work). Further, we don't use a magic static in case that's also 
-  // borked. We leak any allocation that does occur because the program is about 
-  // to die anyways. This is technically racy if we were handling two fatal 
-  // signals, however if we're in that situation a race is the least of our 
-  // worries. 
-  auto &crashHandlerString = 
-      *new (&crashHandlerStringStorage) CrashHandlerString; 
- 
-  // If we crash while trying to print the stack trace, we still want the system 
-  // crash handling to have some partial information. That'll work out as long 
-  // as the SmallString doesn't allocate. If it does allocate then the system 
-  // crash handling will see some garbage because the inline buffer now contains 
-  // a pointer. 
-  setCrashLogMessage(crashHandlerString.c_str()); 
- 
-  { 
-    raw_svector_ostream Stream(crashHandlerString); 
-    PrintCurStackTrace(Stream); 
-  } 
- 
-  if (!crashHandlerString.empty()) { 
-    setCrashLogMessage(crashHandlerString.c_str()); 
-    errs() << crashHandlerString.str(); 
-  } else 
-    setCrashLogMessage("No crash information."); 
-#endif 
-} 
- 
-static void printForSigInfoIfNeeded() { 
-  unsigned CurrentSigInfoGeneration = 
-      GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed); 
-  if (ThreadLocalSigInfoGenerationCounter == 0 || 
-      ThreadLocalSigInfoGenerationCounter == CurrentSigInfoGeneration) { 
-    return; 
-  } 
- 
-  PrintCurStackTrace(errs()); 
-  ThreadLocalSigInfoGenerationCounter = CurrentSigInfoGeneration; 
-} 
- 
-#endif // ENABLE_BACKTRACES 
- 
-void llvm::setBugReportMsg(const char *Msg) { 
-  BugReportMsg = Msg; 
-} 
- 
-const char *llvm::getBugReportMsg() { 
-  return BugReportMsg; 
-} 
- 
-PrettyStackTraceEntry::PrettyStackTraceEntry() { 
-#if ENABLE_BACKTRACES 
-  // Handle SIGINFO first, because we haven't finished constructing yet. 
-  printForSigInfoIfNeeded(); 
-  // Link ourselves. 
-  NextEntry = PrettyStackTraceHead; 
-  PrettyStackTraceHead = this; 
-#endif 
-} 
- 
-PrettyStackTraceEntry::~PrettyStackTraceEntry() { 
-#if ENABLE_BACKTRACES 
-  assert(PrettyStackTraceHead == this && 
-         "Pretty stack trace entry destruction is out of order"); 
-  PrettyStackTraceHead = NextEntry; 
-  // Handle SIGINFO first, because we already started destructing. 
-  printForSigInfoIfNeeded(); 
-#endif 
-} 
- 
-void PrettyStackTraceString::print(raw_ostream &OS) const { OS << Str << "\n"; } 
- 
-PrettyStackTraceFormat::PrettyStackTraceFormat(const char *Format, ...) { 
-  va_list AP; 
-  va_start(AP, Format); 
-  const int SizeOrError = vsnprintf(nullptr, 0, Format, AP); 
-  va_end(AP); 
-  if (SizeOrError < 0) { 
-    return; 
-  } 
- 
-  const int Size = SizeOrError + 1; // '\0' 
-  Str.resize(Size); 
-  va_start(AP, Format); 
-  vsnprintf(Str.data(), Size, Format, AP); 
-  va_end(AP); 
-} 
- 
-void PrettyStackTraceFormat::print(raw_ostream &OS) const { OS << Str << "\n"; } 
- 
-void PrettyStackTraceProgram::print(raw_ostream &OS) const { 
-  OS << "Program arguments: "; 
-  // Print the argument list. 
+#include <tuple>
+
+#ifdef HAVE_CRASHREPORTERCLIENT_H
+#include <CrashReporterClient.h>
+#endif
+
+using namespace llvm;
+
+static const char *BugReportMsg =
+    "PLEASE submit a bug report to " BUG_REPORT_URL
+    " and include the crash backtrace.\n";
+
+// If backtrace support is not enabled, compile out support for pretty stack
+// traces.  This has the secondary effect of not requiring thread local storage
+// when backtrace support is disabled.
+#if ENABLE_BACKTRACES
+
+// We need a thread local pointer to manage the stack of our stack trace
+// objects, but we *really* cannot tolerate destructors running and do not want
+// to pay any overhead of synchronizing. As a consequence, we use a raw
+// thread-local variable.
+static LLVM_THREAD_LOCAL PrettyStackTraceEntry *PrettyStackTraceHead = nullptr;
+
+// The use of 'volatile' here is to ensure that any particular thread always
+// reloads the value of the counter. The 'std::atomic' allows us to specify that
+// this variable is accessed in an unsychronized way (it's not actually
+// synchronizing). This does technically mean that the value may not appear to
+// be the same across threads running simultaneously on different CPUs, but in
+// practice the worst that will happen is that we won't print a stack trace when
+// we could have.
+//
+// This is initialized to 1 because 0 is used as a sentinel for "not enabled on
+// the current thread". If the user happens to overflow an 'unsigned' with
+// SIGINFO requests, it's possible that some threads will stop responding to it,
+// but the program won't crash.
+static volatile std::atomic<unsigned> GlobalSigInfoGenerationCounter =
+    ATOMIC_VAR_INIT(1);
+static LLVM_THREAD_LOCAL unsigned ThreadLocalSigInfoGenerationCounter = 0;
+
+namespace llvm {
+PrettyStackTraceEntry *ReverseStackTrace(PrettyStackTraceEntry *Head) {
+  PrettyStackTraceEntry *Prev = nullptr;
+  while (Head)
+    std::tie(Prev, Head, Head->NextEntry) =
+        std::make_tuple(Head, Head->NextEntry, Prev);
+  return Prev;
+}
+}
+
+static void PrintStack(raw_ostream &OS) {
+  // Print out the stack in reverse order. To avoid recursion (which is likely
+  // to fail if we crashed due to stack overflow), we do an up-front pass to
+  // reverse the stack, then print it, then reverse it again.
+  unsigned ID = 0;
+  SaveAndRestore<PrettyStackTraceEntry *> SavedStack{PrettyStackTraceHead,
+                                                     nullptr};
+  PrettyStackTraceEntry *ReversedStack = ReverseStackTrace(SavedStack.get());
+  for (const PrettyStackTraceEntry *Entry = ReversedStack; Entry;
+       Entry = Entry->getNextEntry()) {
+    OS << ID++ << ".\t";
+    sys::Watchdog W(5);
+    Entry->print(OS);
+  }
+  llvm::ReverseStackTrace(ReversedStack);
+}
+
+/// Print the current stack trace to the specified stream.
+///
+/// Marked NOINLINE so it can be called from debuggers.
+LLVM_ATTRIBUTE_NOINLINE
+static void PrintCurStackTrace(raw_ostream &OS) {
+  // Don't print an empty trace.
+  if (!PrettyStackTraceHead) return;
+
+  // If there are pretty stack frames registered, walk and emit them.
+  OS << "Stack dump:\n";
+
+  PrintStack(OS);
+  OS.flush();
+}
+
+// Integrate with crash reporter libraries.
+#if defined (__APPLE__) && defined(HAVE_CRASHREPORTERCLIENT_H)
+//  If any clients of llvm try to link to libCrashReporterClient.a themselves,
+//  only one crash info struct will be used.
+extern "C" {
+CRASH_REPORTER_CLIENT_HIDDEN
+struct crashreporter_annotations_t gCRAnnotations
+        __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION)))
+#if CRASHREPORTER_ANNOTATIONS_VERSION < 5
+        = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };
+#else
+        = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0, 0 };
+#endif
+}
+#elif defined(__APPLE__) && HAVE_CRASHREPORTER_INFO
+extern "C" const char *__crashreporter_info__
+    __attribute__((visibility("hidden"))) = 0;
+asm(".desc ___crashreporter_info__, 0x10");
+#endif
+
+static void setCrashLogMessage(const char *msg) LLVM_ATTRIBUTE_UNUSED;
+static void setCrashLogMessage(const char *msg) {
+#ifdef HAVE_CRASHREPORTERCLIENT_H
+  (void)CRSetCrashLogMessage(msg);
+#elif HAVE_CRASHREPORTER_INFO
+  __crashreporter_info__ = msg;
+#endif
+  // Don't reorder subsequent operations: whatever comes after might crash and
+  // we want the system crash handling to see the message we just set.
+  std::atomic_signal_fence(std::memory_order_seq_cst);
+}
+
+#ifdef __APPLE__
+using CrashHandlerString = SmallString<2048>;
+using CrashHandlerStringStorage =
+    std::aligned_storage<sizeof(CrashHandlerString),
+                         alignof(CrashHandlerString)>::type;
+static CrashHandlerStringStorage crashHandlerStringStorage;
+#endif
+
+/// This callback is run if a fatal signal is delivered to the process, it
+/// prints the pretty stack trace.
+static void CrashHandler(void *) {
+  errs() << BugReportMsg ;
+
+#ifndef __APPLE__
+  // On non-apple systems, just emit the crash stack trace to stderr.
+  PrintCurStackTrace(errs());
+#else
+  // Emit the crash stack trace to a SmallString, put it where the system crash
+  // handling will find it, and also send it to stderr.
+  //
+  // The SmallString is fairly large in the hope that we don't allocate (we're
+  // handling a fatal signal, something is already pretty wrong, allocation
+  // might not work). Further, we don't use a magic static in case that's also
+  // borked. We leak any allocation that does occur because the program is about
+  // to die anyways. This is technically racy if we were handling two fatal
+  // signals, however if we're in that situation a race is the least of our
+  // worries.
+  auto &crashHandlerString =
+      *new (&crashHandlerStringStorage) CrashHandlerString;
+
+  // If we crash while trying to print the stack trace, we still want the system
+  // crash handling to have some partial information. That'll work out as long
+  // as the SmallString doesn't allocate. If it does allocate then the system
+  // crash handling will see some garbage because the inline buffer now contains
+  // a pointer.
+  setCrashLogMessage(crashHandlerString.c_str());
+
+  {
+    raw_svector_ostream Stream(crashHandlerString);
+    PrintCurStackTrace(Stream);
+  }
+
+  if (!crashHandlerString.empty()) {
+    setCrashLogMessage(crashHandlerString.c_str());
+    errs() << crashHandlerString.str();
+  } else
+    setCrashLogMessage("No crash information.");
+#endif
+}
+
+static void printForSigInfoIfNeeded() {
+  unsigned CurrentSigInfoGeneration =
+      GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed);
+  if (ThreadLocalSigInfoGenerationCounter == 0 ||
+      ThreadLocalSigInfoGenerationCounter == CurrentSigInfoGeneration) {
+    return;
+  }
+
+  PrintCurStackTrace(errs());
+  ThreadLocalSigInfoGenerationCounter = CurrentSigInfoGeneration;
+}
+
+#endif // ENABLE_BACKTRACES
+
+void llvm::setBugReportMsg(const char *Msg) {
+  BugReportMsg = Msg;
+}
+
+const char *llvm::getBugReportMsg() {
+  return BugReportMsg;
+}
+
+PrettyStackTraceEntry::PrettyStackTraceEntry() {
+#if ENABLE_BACKTRACES
+  // Handle SIGINFO first, because we haven't finished constructing yet.
+  printForSigInfoIfNeeded();
+  // Link ourselves.
+  NextEntry = PrettyStackTraceHead;
+  PrettyStackTraceHead = this;
+#endif
+}
+
+PrettyStackTraceEntry::~PrettyStackTraceEntry() {
+#if ENABLE_BACKTRACES
+  assert(PrettyStackTraceHead == this &&
+         "Pretty stack trace entry destruction is out of order");
+  PrettyStackTraceHead = NextEntry;
+  // Handle SIGINFO first, because we already started destructing.
+  printForSigInfoIfNeeded();
+#endif
+}
+
+void PrettyStackTraceString::print(raw_ostream &OS) const { OS << Str << "\n"; }
+
+PrettyStackTraceFormat::PrettyStackTraceFormat(const char *Format, ...) {
+  va_list AP;
+  va_start(AP, Format);
+  const int SizeOrError = vsnprintf(nullptr, 0, Format, AP);
+  va_end(AP);
+  if (SizeOrError < 0) {
+    return;
+  }
+
+  const int Size = SizeOrError + 1; // '\0'
+  Str.resize(Size);
+  va_start(AP, Format);
+  vsnprintf(Str.data(), Size, Format, AP);
+  va_end(AP);
+}
+
+void PrettyStackTraceFormat::print(raw_ostream &OS) const { OS << Str << "\n"; }
+
+void PrettyStackTraceProgram::print(raw_ostream &OS) const {
+  OS << "Program arguments: ";
+  // Print the argument list.
   for (int I = 0; I < ArgC; ++I) {
     const bool HaveSpace = ::strchr(ArgV[I], ' ');
     if (I)
@@ -264,61 +264,61 @@ void PrettyStackTraceProgram::print(raw_ostream &OS) const {
     if (HaveSpace)
       OS << '"';
   }
-  OS << '\n'; 
-} 
- 
-#if ENABLE_BACKTRACES 
-static bool RegisterCrashPrinter() { 
-  sys::AddSignalHandler(CrashHandler, nullptr); 
-  return false; 
-} 
-#endif 
- 
-void llvm::EnablePrettyStackTrace() { 
-#if ENABLE_BACKTRACES 
-  // The first time this is called, we register the crash printer. 
-  static bool HandlerRegistered = RegisterCrashPrinter(); 
-  (void)HandlerRegistered; 
-#endif 
-} 
- 
-void llvm::EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable) { 
-#if ENABLE_BACKTRACES 
-  if (!ShouldEnable) { 
-    ThreadLocalSigInfoGenerationCounter = 0; 
-    return; 
-  } 
- 
-  // The first time this is called, we register the SIGINFO handler. 
-  static bool HandlerRegistered = []{ 
-    sys::SetInfoSignalFunction([]{ 
-      GlobalSigInfoGenerationCounter.fetch_add(1, std::memory_order_relaxed); 
-    }); 
-    return false; 
-  }(); 
-  (void)HandlerRegistered; 
- 
-  // Next, enable it for the current thread. 
-  ThreadLocalSigInfoGenerationCounter = 
-      GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed); 
-#endif 
-} 
- 
-const void *llvm::SavePrettyStackState() { 
-#if ENABLE_BACKTRACES 
-  return PrettyStackTraceHead; 
-#else 
-  return nullptr; 
-#endif 
-} 
- 
-void llvm::RestorePrettyStackState(const void *Top) { 
-#if ENABLE_BACKTRACES 
-  PrettyStackTraceHead = 
-      static_cast<PrettyStackTraceEntry *>(const_cast<void *>(Top)); 
-#endif 
-} 
- 
-void LLVMEnablePrettyStackTrace() { 
-  EnablePrettyStackTrace(); 
-} 
+  OS << '\n';
+}
+
+#if ENABLE_BACKTRACES
+static bool RegisterCrashPrinter() {
+  sys::AddSignalHandler(CrashHandler, nullptr);
+  return false;
+}
+#endif
+
+void llvm::EnablePrettyStackTrace() {
+#if ENABLE_BACKTRACES
+  // The first time this is called, we register the crash printer.
+  static bool HandlerRegistered = RegisterCrashPrinter();
+  (void)HandlerRegistered;
+#endif
+}
+
+void llvm::EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable) {
+#if ENABLE_BACKTRACES
+  if (!ShouldEnable) {
+    ThreadLocalSigInfoGenerationCounter = 0;
+    return;
+  }
+
+  // The first time this is called, we register the SIGINFO handler.
+  static bool HandlerRegistered = []{
+    sys::SetInfoSignalFunction([]{
+      GlobalSigInfoGenerationCounter.fetch_add(1, std::memory_order_relaxed);
+    });
+    return false;
+  }();
+  (void)HandlerRegistered;
+
+  // Next, enable it for the current thread.
+  ThreadLocalSigInfoGenerationCounter =
+      GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed);
+#endif
+}
+
+const void *llvm::SavePrettyStackState() {
+#if ENABLE_BACKTRACES
+  return PrettyStackTraceHead;
+#else
+  return nullptr;
+#endif
+}
+
+void llvm::RestorePrettyStackState(const void *Top) {
+#if ENABLE_BACKTRACES
+  PrettyStackTraceHead =
+      static_cast<PrettyStackTraceEntry *>(const_cast<void *>(Top));
+#endif
+}
+
+void LLVMEnablePrettyStackTrace() {
+  EnablePrettyStackTrace();
+}