lib/Support/PrettyStackTrace.cpp

   1 //===- PrettyStackTrace.cpp - Pretty Crash Handling -----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines some helpful functions for dealing with the possibility of
  10 // Unix signals occurring while your program is running.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/PrettyStackTrace.h"
  15 #include "llvm-c/ErrorHandling.h"
  16 #include "llvm/ADT/SmallString.h"
  17 #include "llvm/Config/config.h"
  18 #include "llvm/Support/Compiler.h"
  19 #include "llvm/Support/SaveAndRestore.h"
  20 #include "llvm/Support/Signals.h"
  21 #include "llvm/Support/Watchdog.h"
  22 #include "llvm/Support/raw_ostream.h"
  23
  24 #include <atomic>
  25 #include <cstdarg>
  26 #include <cstdio>
  27 #include <tuple>
  28
  29 #ifdef HAVE_CRASHREPORTERCLIENT_H
  30 #include <CrashReporterClient.h>
  31 #endif
  32
  33 using namespace llvm;
  34
  35 // If backtrace support is not enabled, compile out support for pretty stack
  36 // traces.  This has the secondary effect of not requiring thread local storage
  37 // when backtrace support is disabled.
  38 #if ENABLE_BACKTRACES
  39
  40 // We need a thread local pointer to manage the stack of our stack trace
  41 // objects, but we *really* cannot tolerate destructors running and do not want
  42 // to pay any overhead of synchronizing. As a consequence, we use a raw
  43 // thread-local variable.
  44 static LLVM_THREAD_LOCAL PrettyStackTraceEntry *PrettyStackTraceHead = nullptr;
  45
  46 // The use of 'volatile' here is to ensure that any particular thread always
  47 // reloads the value of the counter. The 'std::atomic' allows us to specify that
  48 // this variable is accessed in an unsychronized way (it's not actually
  49 // synchronizing). This does technically mean that the value may not appear to
  50 // be the same across threads running simultaneously on different CPUs, but in
  51 // practice the worst that will happen is that we won't print a stack trace when
  52 // we could have.
  53 //
  54 // This is initialized to 1 because 0 is used as a sentinel for "not enabled on
  55 // the current thread". If the user happens to overflow an 'unsigned' with
  56 // SIGINFO requests, it's possible that some threads will stop responding to it,
  57 // but the program won't crash.
  58 static volatile std::atomic<unsigned> GlobalSigInfoGenerationCounter =
  59     ATOMIC_VAR_INIT(1);
  60 static LLVM_THREAD_LOCAL unsigned ThreadLocalSigInfoGenerationCounter = 0;
  61
  62 namespace llvm {
  63 PrettyStackTraceEntry *ReverseStackTrace(PrettyStackTraceEntry *Head) {
  64   PrettyStackTraceEntry *Prev = nullptr;
  65   while (Head)
  66     std::tie(Prev, Head, Head->NextEntry) =
  67         std::make_tuple(Head, Head->NextEntry, Prev);
  68   return Prev;
  69 }
  70 }
  71
  72 static void PrintStack(raw_ostream &OS) {
  73   // Print out the stack in reverse order. To avoid recursion (which is likely
  74   // to fail if we crashed due to stack overflow), we do an up-front pass to
  75   // reverse the stack, then print it, then reverse it again.
  76   unsigned ID = 0;
  77   SaveAndRestore<PrettyStackTraceEntry *> SavedStack{PrettyStackTraceHead,
  78                                                      nullptr};
  79   PrettyStackTraceEntry *ReversedStack = ReverseStackTrace(SavedStack.get());
  80   for (const PrettyStackTraceEntry *Entry = ReversedStack; Entry;
  81        Entry = Entry->getNextEntry()) {
  82     OS << ID++ << ".\t";
  83     sys::Watchdog W(5);
  84     Entry->print(OS);
  85   }
  86   llvm::ReverseStackTrace(ReversedStack);
  87 }
  88
  89 /// Print the current stack trace to the specified stream.
  90 ///
  91 /// Marked NOINLINE so it can be called from debuggers.
  92 LLVM_ATTRIBUTE_NOINLINE
  93 static void PrintCurStackTrace(raw_ostream &OS) {
  94   // Don't print an empty trace.
  95   if (!PrettyStackTraceHead) return;
  96
  97   // If there are pretty stack frames registered, walk and emit them.
  98   OS << "Stack dump:\n";
  99
 100   PrintStack(OS);
 101   OS.flush();
 102 }
 103
 104 // Integrate with crash reporter libraries.
 105 #if defined (__APPLE__) && defined(HAVE_CRASHREPORTERCLIENT_H)
 106 //  If any clients of llvm try to link to libCrashReporterClient.a themselves,
 107 //  only one crash info struct will be used.
 108 extern "C" {
 109 CRASH_REPORTER_CLIENT_HIDDEN
 110 struct crashreporter_annotations_t gCRAnnotations
 111         __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION)))
 112 #if CRASHREPORTER_ANNOTATIONS_VERSION < 5
 113         = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };
 114 #else
 115         = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0, 0 };
 116 #endif
 117 }
 118 #elif defined(__APPLE__) && HAVE_CRASHREPORTER_INFO
 119 extern "C" const char *__crashreporter_info__
 120     __attribute__((visibility("hidden"))) = 0;
 121 asm(".desc ___crashreporter_info__, 0x10");
 122 #endif
 123
 124 /// CrashHandler - This callback is run if a fatal signal is delivered to the
 125 /// process, it prints the pretty stack trace.
 126 static void CrashHandler(void *) {
 127 #ifndef __APPLE__
 128   // On non-apple systems, just emit the crash stack trace to stderr.
 129   PrintCurStackTrace(errs());
 130 #else
 131   // Otherwise, emit to a smallvector of chars, send *that* to stderr, but also
 132   // put it into __crashreporter_info__.
 133   SmallString<2048> TmpStr;
 134   {
 135     raw_svector_ostream Stream(TmpStr);
 136     PrintCurStackTrace(Stream);
 137   }
 138
 139   if (!TmpStr.empty()) {
 140 #ifdef HAVE_CRASHREPORTERCLIENT_H
 141     // Cast to void to avoid warning.
 142     (void)CRSetCrashLogMessage(TmpStr.c_str());
 143 #elif HAVE_CRASHREPORTER_INFO
 144     __crashreporter_info__ = strdup(TmpStr.c_str());
 145 #endif
 146     errs() << TmpStr.str();
 147   }
 148
 149 #endif
 150 }
 151
 152 static void printForSigInfoIfNeeded() {
 153   unsigned CurrentSigInfoGeneration =
 154       GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed);
 155   if (ThreadLocalSigInfoGenerationCounter == 0 ||
 156       ThreadLocalSigInfoGenerationCounter == CurrentSigInfoGeneration) {
 157     return;
 158   }
 159
 160   PrintCurStackTrace(errs());
 161   ThreadLocalSigInfoGenerationCounter = CurrentSigInfoGeneration;
 162 }
 163
 164 #endif // ENABLE_BACKTRACES
 165
 166 PrettyStackTraceEntry::PrettyStackTraceEntry() {
 167 #if ENABLE_BACKTRACES
 168   // Handle SIGINFO first, because we haven't finished constructing yet.
 169   printForSigInfoIfNeeded();
 170   // Link ourselves.
 171   NextEntry = PrettyStackTraceHead;
 172   PrettyStackTraceHead = this;
 173 #endif
 174 }
 175
 176 PrettyStackTraceEntry::~PrettyStackTraceEntry() {
 177 #if ENABLE_BACKTRACES
 178   assert(PrettyStackTraceHead == this &&
 179          "Pretty stack trace entry destruction is out of order");
 180   PrettyStackTraceHead = NextEntry;
 181   // Handle SIGINFO first, because we already started destructing.
 182   printForSigInfoIfNeeded();
 183 #endif
 184 }
 185
 186 void PrettyStackTraceString::print(raw_ostream &OS) const { OS << Str << "\n"; }
 187
 188 PrettyStackTraceFormat::PrettyStackTraceFormat(const char *Format, ...) {
 189   va_list AP;
 190   va_start(AP, Format);
 191   const int SizeOrError = vsnprintf(nullptr, 0, Format, AP);
 192   va_end(AP);
 193   if (SizeOrError < 0) {
 194     return;
 195   }
 196
 197   const int Size = SizeOrError + 1; // '\0'
 198   Str.resize(Size);
 199   va_start(AP, Format);
 200   vsnprintf(Str.data(), Size, Format, AP);
 201   va_end(AP);
 202 }
 203
 204 void PrettyStackTraceFormat::print(raw_ostream &OS) const { OS << Str << "\n"; }
 205
 206 void PrettyStackTraceProgram::print(raw_ostream &OS) const {
 207   OS << "Program arguments: ";
 208   // Print the argument list.
 209   for (unsigned i = 0, e = ArgC; i != e; ++i)
 210     OS << ArgV[i] << ' ';
 211   OS << '\n';
 212 }
 213
 214 #if ENABLE_BACKTRACES
 215 static bool RegisterCrashPrinter() {
 216   sys::AddSignalHandler(CrashHandler, nullptr);
 217   return false;
 218 }
 219 #endif
 220
 221 void llvm::EnablePrettyStackTrace() {
 222 #if ENABLE_BACKTRACES
 223   // The first time this is called, we register the crash printer.
 224   static bool HandlerRegistered = RegisterCrashPrinter();
 225   (void)HandlerRegistered;
 226 #endif
 227 }
 228
 229 void llvm::EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable) {
 230 #if ENABLE_BACKTRACES
 231   if (!ShouldEnable) {
 232     ThreadLocalSigInfoGenerationCounter = 0;
 233     return;
 234   }
 235
 236   // The first time this is called, we register the SIGINFO handler.
 237   static bool HandlerRegistered = []{
 238     sys::SetInfoSignalFunction([]{
 239       GlobalSigInfoGenerationCounter.fetch_add(1, std::memory_order_relaxed);
 240     });
 241     return false;
 242   }();
 243   (void)HandlerRegistered;
 244
 245   // Next, enable it for the current thread.
 246   ThreadLocalSigInfoGenerationCounter =
 247       GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed);
 248 #endif
 249 }
 250
 251 const void *llvm::SavePrettyStackState() {
 252 #if ENABLE_BACKTRACES
 253   return PrettyStackTraceHead;
 254 #else
 255   return nullptr;
 256 #endif
 257 }
 258
 259 void llvm::RestorePrettyStackState(const void *Top) {
 260 #if ENABLE_BACKTRACES
 261   PrettyStackTraceHead =
 262       static_cast<PrettyStackTraceEntry *>(const_cast<void *>(Top));
 263 #endif
 264 }
 265
 266 void LLVMEnablePrettyStackTrace() {
 267   EnablePrettyStackTrace();
 268 }