LLVM  10.0.0svn
PrettyStackTrace.cpp
Go to the documentation of this file.
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 
15 #include "llvm-c/ErrorHandling.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/Config/config.h"
18 #include "llvm/Support/Compiler.h"
20 #include "llvm/Support/Signals.h"
21 #include "llvm/Support/Watchdog.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.
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);
61 
62 namespace llvm {
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;
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.
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.
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);
156  ThreadLocalSigInfoGenerationCounter == CurrentSigInfoGeneration) {
157  return;
158  }
159 
161  ThreadLocalSigInfoGenerationCounter = CurrentSigInfoGeneration;
162 }
163 
164 #endif // ENABLE_BACKTRACES
165 
167 #if ENABLE_BACKTRACES
168  // Handle SIGINFO first, because we haven't finished constructing yet.
170  // Link ourselves.
171  NextEntry = PrettyStackTraceHead;
172  PrettyStackTraceHead = this;
173 #endif
174 }
175 
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.
183 #endif
184 }
185 
186 void PrettyStackTraceString::print(raw_ostream &OS) const { OS << Str << "\n"; }
187 
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 
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() {
217  return false;
218 }
219 #endif
220 
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 
230 #if ENABLE_BACKTRACES
231  if (!ShouldEnable) {
233  return;
234  }
235 
236  // The first time this is called, we register the SIGINFO handler.
237  static bool HandlerRegistered = []{
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.
247  GlobalSigInfoGenerationCounter.load(std::memory_order_relaxed);
248 #endif
249 }
250 
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
262  static_cast<PrettyStackTraceEntry *>(const_cast<void *>(Top));
263 #endif
264 }
265 
268 }
void RestorePrettyStackState(const void *State)
Restores the topmost element of the "pretty" stack state to State, which should come from a previous ...
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static void printForSigInfoIfNeeded()
static LLVM_THREAD_LOCAL unsigned ThreadLocalSigInfoGenerationCounter
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:509
static volatile std::atomic< unsigned > GlobalSigInfoGenerationCounter
This class provides an abstraction for a timeout around an operation that must complete in a given am...
Definition: Watchdog.h:25
void EnablePrettyStackTrace()
Enables dumping a "pretty" stack trace when the program crashes.
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:266
void SetInfoSignalFunction(void(*Handler)())
Registers a function to be called when an "info" signal is delivered to the process.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
#define LLVM_THREAD_LOCAL
LLVM_THREAD_LOCAL A thread-local storage specifier which can be used with globals, extern globals, and static globals.
Definition: Compiler.h:512
void print(raw_ostream &OS) const override
print - Emit information about this stack frame to OS.
static LLVM_ATTRIBUTE_NOINLINE void PrintCurStackTrace(raw_ostream &OS)
Print the current stack trace to the specified stream.
void LLVMEnablePrettyStackTrace()
Enable LLVM&#39;s built-in stack trace code.
PrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is d...
const void * SavePrettyStackState()
Returns the topmost element of the "pretty" stack state.
static void PrintStack(raw_ostream &OS)
#define LLVM_ATTRIBUTE_NOINLINE
LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, mark a method "not for inl...
Definition: Compiler.h:201
PrettyStackTraceFormat(const char *Format,...)
static LLVM_THREAD_LOCAL PrettyStackTraceEntry * PrettyStackTraceHead
static bool RegisterCrashPrinter()
void print(raw_ostream &OS) const override
print - Emit information about this stack frame to OS.
A utility class that uses RAII to save and restore the value of a variable.
static void CrashHandler(void *)
CrashHandler - This callback is run if a fatal signal is delivered to the process, it prints the pretty stack trace.
void print(raw_ostream &OS) const override
print - Emit information about this stack frame to OS.
void EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable=true)
Enables (or disables) dumping a "pretty" stack trace when the user sends SIGINFO or SIGUSR1 to the cu...
PrettyStackTraceEntry * ReverseStackTrace(PrettyStackTraceEntry *Head)
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
const char * c_str()
Definition: SmallString.h:269
uint32_t Size
Definition: Profile.cpp:46
void AddSignalHandler(SignalHandlerCallback FnPtr, void *Cookie)
Add a function to be called when an abort/kill signal is delivered to the process.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides utility classes that use RAII to save and restore values.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45