2009-03-05 05:40:23 +08:00
|
|
|
//===- PrettyStackTrace.cpp - Pretty Crash Handling -----------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines some helpful functions for dealing with the possibility of
|
2011-04-15 13:18:47 +08:00
|
|
|
// Unix signals occurring while your program is running.
|
2009-03-05 05:40:23 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
2015-12-18 09:46:52 +08:00
|
|
|
#include "llvm-c/ErrorHandling.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/Config/config.h" // Get autoconf configuration settings
|
2015-01-29 09:23:04 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2010-11-30 02:16:10 +08:00
|
|
|
#include "llvm/Support/Signals.h"
|
2013-03-26 09:27:52 +08:00
|
|
|
#include "llvm/Support/Watchdog.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-06-23 05:01:04 +08:00
|
|
|
|
2016-12-15 03:19:53 +08:00
|
|
|
#include <cstdarg>
|
2017-04-30 07:45:30 +08:00
|
|
|
#include <cstdio>
|
2016-05-27 04:21:55 +08:00
|
|
|
#include <tuple>
|
|
|
|
|
2010-06-23 05:01:04 +08:00
|
|
|
#ifdef HAVE_CRASHREPORTERCLIENT_H
|
|
|
|
#include <CrashReporterClient.h>
|
|
|
|
#endif
|
|
|
|
|
2009-03-05 05:40:23 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2015-01-29 15:35:31 +08:00
|
|
|
// 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.
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2015-01-29 15:35:31 +08:00
|
|
|
|
[LPM] Rip all of ManagedStatic and ThreadLocal out of the pretty stack
tracing code.
Managed static was just insane overhead for this. We took memory fences
and external function calls in every path that pushed a pretty stack
frame. This includes a multitude of layers setting up and tearing down
passes, the parser in Clang, everywhere. For the regression test suite
or low-overhead JITs, this was contributing to really significant
overhead.
Even the LLVM ThreadLocal is really overkill here because it uses
pthread_{set,get}_specific logic, and has careful code to both allocate
and delete the thread local data. We don't actually want any of that,
and this code in particular has problems coping with deallocation. What
we want is a single TLS pointer that is valid to use during global
construction and during global destruction, any time we want. That is
exactly what every host compiler and OS we use has implemented for
a long time, and what was standardized in C++11. Even though not all of
our host compilers support the thread_local keyword, we can directly use
the platform-specific keywords to get the minimal functionality needed.
Provided this limited trial survives the build bots, I will move this to
Compiler.h so it is more widely available as a light weight if limited
alternative to the ThreadLocal class. Many thanks to David Majnemer for
helping me think through the implications across platforms and craft the
MSVC-compatible syntax.
The end result is *substantially* faster. When running llc in a tight
loop over a small IR file targeting the aarch64 backend, this improves
its performance by over 10% for me. It also seems likely to fix the
remaining regressions seen by JIT users with threading enabled.
This may actually have more impact on real-world compile times due to
the use of the pretty stack tracing utility throughout the rest of Clang
or LLVM, but I've not collected any detailed measurements.
llvm-svn: 227300
2015-01-28 17:52:14 +08:00
|
|
|
// 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
|
2015-01-29 09:23:04 +08:00
|
|
|
// thread-local variable.
|
2016-05-27 04:21:55 +08:00
|
|
|
static LLVM_THREAD_LOCAL PrettyStackTraceEntry *PrettyStackTraceHead = nullptr;
|
|
|
|
|
|
|
|
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;
|
|
|
|
PrettyStackTraceEntry *ReversedStack =
|
|
|
|
llvm::ReverseStackTrace(PrettyStackTraceHead);
|
|
|
|
for (const PrettyStackTraceEntry *Entry = ReversedStack; Entry;
|
|
|
|
Entry = Entry->getNextEntry()) {
|
|
|
|
OS << ID++ << ".\t";
|
2013-03-26 09:27:52 +08:00
|
|
|
sys::Watchdog W(5);
|
|
|
|
Entry->print(OS);
|
|
|
|
}
|
2016-05-27 04:21:55 +08:00
|
|
|
llvm::ReverseStackTrace(ReversedStack);
|
2009-03-05 15:03:49 +08:00
|
|
|
}
|
|
|
|
|
2009-03-06 15:19:54 +08:00
|
|
|
/// PrintCurStackTrace - Print the current stack trace to the specified stream.
|
|
|
|
static void PrintCurStackTrace(raw_ostream &OS) {
|
2009-03-05 15:03:49 +08:00
|
|
|
// Don't print an empty trace.
|
[LPM] Rip all of ManagedStatic and ThreadLocal out of the pretty stack
tracing code.
Managed static was just insane overhead for this. We took memory fences
and external function calls in every path that pushed a pretty stack
frame. This includes a multitude of layers setting up and tearing down
passes, the parser in Clang, everywhere. For the regression test suite
or low-overhead JITs, this was contributing to really significant
overhead.
Even the LLVM ThreadLocal is really overkill here because it uses
pthread_{set,get}_specific logic, and has careful code to both allocate
and delete the thread local data. We don't actually want any of that,
and this code in particular has problems coping with deallocation. What
we want is a single TLS pointer that is valid to use during global
construction and during global destruction, any time we want. That is
exactly what every host compiler and OS we use has implemented for
a long time, and what was standardized in C++11. Even though not all of
our host compilers support the thread_local keyword, we can directly use
the platform-specific keywords to get the minimal functionality needed.
Provided this limited trial survives the build bots, I will move this to
Compiler.h so it is more widely available as a light weight if limited
alternative to the ThreadLocal class. Many thanks to David Majnemer for
helping me think through the implications across platforms and craft the
MSVC-compatible syntax.
The end result is *substantially* faster. When running llc in a tight
loop over a small IR file targeting the aarch64 backend, this improves
its performance by over 10% for me. It also seems likely to fix the
remaining regressions seen by JIT users with threading enabled.
This may actually have more impact on real-world compile times due to
the use of the pretty stack tracing utility throughout the rest of Clang
or LLVM, but I've not collected any detailed measurements.
llvm-svn: 227300
2015-01-28 17:52:14 +08:00
|
|
|
if (!PrettyStackTraceHead) return;
|
2009-03-05 15:03:49 +08:00
|
|
|
|
2009-03-05 05:40:23 +08:00
|
|
|
// If there are pretty stack frames registered, walk and emit them.
|
|
|
|
OS << "Stack dump:\n";
|
|
|
|
|
2016-05-27 04:21:55 +08:00
|
|
|
PrintStack(OS);
|
2009-03-05 05:40:23 +08:00
|
|
|
OS.flush();
|
|
|
|
}
|
|
|
|
|
2010-06-29 02:25:51 +08:00
|
|
|
// Integrate with crash reporter libraries.
|
2016-12-08 03:28:22 +08:00
|
|
|
#if defined (__APPLE__) && defined(HAVE_CRASHREPORTERCLIENT_H)
|
2010-06-29 02:25:51 +08:00
|
|
|
// If any clients of llvm try to link to libCrashReporterClient.a themselves,
|
|
|
|
// only one crash info struct will be used.
|
2010-06-29 02:33:48 +08:00
|
|
|
extern "C" {
|
2010-06-29 02:25:51 +08:00
|
|
|
CRASH_REPORTER_CLIENT_HIDDEN
|
|
|
|
struct crashreporter_annotations_t gCRAnnotations
|
|
|
|
__attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION)))
|
Add more initializers to quiet a clang warning
Summary:
`struct crashreporter_annotations_t` gained one more `uint64_t` field in
`CRASHREPORTER_ANNOTATIONS_VERSION` 5
causing an annoying clang warning:
```
llvm/lib/Support/PrettyStackTrace.cpp:92:65: warning: missing field 'abort_cause' initializer [-Wmissing-field-initializers]
= { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };
^
1 warning generated
```
Let's fix it.
Patch by Roman Tereshin
Reviewers: qcolombet, echristo, beanz, dexonsmith
Reviewed By: echristo
Subscribers: dsanders, dexonsmith, beanz, echristo, qcolombet, llvm-commits
Differential Revision: https://reviews.llvm.org/D42268
llvm-svn: 323777
2018-01-31 00:02:32 +08:00
|
|
|
#if CRASHREPORTER_ANNOTATIONS_VERSION < 5
|
2011-10-05 13:00:26 +08:00
|
|
|
= { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };
|
Add more initializers to quiet a clang warning
Summary:
`struct crashreporter_annotations_t` gained one more `uint64_t` field in
`CRASHREPORTER_ANNOTATIONS_VERSION` 5
causing an annoying clang warning:
```
llvm/lib/Support/PrettyStackTrace.cpp:92:65: warning: missing field 'abort_cause' initializer [-Wmissing-field-initializers]
= { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };
^
1 warning generated
```
Let's fix it.
Patch by Roman Tereshin
Reviewers: qcolombet, echristo, beanz, dexonsmith
Reviewed By: echristo
Subscribers: dsanders, dexonsmith, beanz, echristo, qcolombet, llvm-commits
Differential Revision: https://reviews.llvm.org/D42268
llvm-svn: 323777
2018-01-31 00:02:32 +08:00
|
|
|
#else
|
|
|
|
= { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
#endif
|
2010-06-29 02:33:48 +08:00
|
|
|
}
|
2016-12-15 03:09:43 +08:00
|
|
|
#elif defined(__APPLE__) && HAVE_CRASHREPORTER_INFO
|
|
|
|
extern "C" const char *__crashreporter_info__
|
|
|
|
__attribute__((visibility("hidden"))) = 0;
|
2010-05-21 07:50:19 +08:00
|
|
|
asm(".desc ___crashreporter_info__, 0x10");
|
2009-03-06 15:19:54 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/// CrashHandler - This callback is run if a fatal signal is delivered to the
|
|
|
|
/// process, it prints the pretty stack trace.
|
2010-08-08 08:00:34 +08:00
|
|
|
static void CrashHandler(void *) {
|
2009-03-06 15:19:54 +08:00
|
|
|
#ifndef __APPLE__
|
|
|
|
// On non-apple systems, just emit the crash stack trace to stderr.
|
|
|
|
PrintCurStackTrace(errs());
|
|
|
|
#else
|
|
|
|
// Otherwise, emit to a smallvector of chars, send *that* to stderr, but also
|
|
|
|
// put it into __crashreporter_info__.
|
|
|
|
SmallString<2048> TmpStr;
|
|
|
|
{
|
|
|
|
raw_svector_ostream Stream(TmpStr);
|
|
|
|
PrintCurStackTrace(Stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TmpStr.empty()) {
|
2010-12-03 15:45:22 +08:00
|
|
|
#ifdef HAVE_CRASHREPORTERCLIENT_H
|
2010-08-08 08:00:34 +08:00
|
|
|
// Cast to void to avoid warning.
|
|
|
|
(void)CRSetCrashLogMessage(std::string(TmpStr.str()).c_str());
|
2010-12-03 15:45:22 +08:00
|
|
|
#elif HAVE_CRASHREPORTER_INFO
|
|
|
|
__crashreporter_info__ = strdup(std::string(TmpStr.str()).c_str());
|
2010-06-23 05:01:04 +08:00
|
|
|
#endif
|
2009-08-20 04:07:03 +08:00
|
|
|
errs() << TmpStr.str();
|
2009-03-06 15:19:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-10-01 04:04:24 +08:00
|
|
|
// defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2015-01-29 15:35:31 +08:00
|
|
|
#endif
|
|
|
|
|
2009-03-05 05:40:23 +08:00
|
|
|
PrettyStackTraceEntry::PrettyStackTraceEntry() {
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2009-03-05 05:40:23 +08:00
|
|
|
// Link ourselves.
|
[LPM] Rip all of ManagedStatic and ThreadLocal out of the pretty stack
tracing code.
Managed static was just insane overhead for this. We took memory fences
and external function calls in every path that pushed a pretty stack
frame. This includes a multitude of layers setting up and tearing down
passes, the parser in Clang, everywhere. For the regression test suite
or low-overhead JITs, this was contributing to really significant
overhead.
Even the LLVM ThreadLocal is really overkill here because it uses
pthread_{set,get}_specific logic, and has careful code to both allocate
and delete the thread local data. We don't actually want any of that,
and this code in particular has problems coping with deallocation. What
we want is a single TLS pointer that is valid to use during global
construction and during global destruction, any time we want. That is
exactly what every host compiler and OS we use has implemented for
a long time, and what was standardized in C++11. Even though not all of
our host compilers support the thread_local keyword, we can directly use
the platform-specific keywords to get the minimal functionality needed.
Provided this limited trial survives the build bots, I will move this to
Compiler.h so it is more widely available as a light weight if limited
alternative to the ThreadLocal class. Many thanks to David Majnemer for
helping me think through the implications across platforms and craft the
MSVC-compatible syntax.
The end result is *substantially* faster. When running llc in a tight
loop over a small IR file targeting the aarch64 backend, this improves
its performance by over 10% for me. It also seems likely to fix the
remaining regressions seen by JIT users with threading enabled.
This may actually have more impact on real-world compile times due to
the use of the pretty stack tracing utility throughout the rest of Clang
or LLVM, but I've not collected any detailed measurements.
llvm-svn: 227300
2015-01-28 17:52:14 +08:00
|
|
|
NextEntry = PrettyStackTraceHead;
|
|
|
|
PrettyStackTraceHead = this;
|
2015-01-29 15:35:31 +08:00
|
|
|
#endif
|
2009-03-05 05:40:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
PrettyStackTraceEntry::~PrettyStackTraceEntry() {
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
[LPM] Rip all of ManagedStatic and ThreadLocal out of the pretty stack
tracing code.
Managed static was just insane overhead for this. We took memory fences
and external function calls in every path that pushed a pretty stack
frame. This includes a multitude of layers setting up and tearing down
passes, the parser in Clang, everywhere. For the regression test suite
or low-overhead JITs, this was contributing to really significant
overhead.
Even the LLVM ThreadLocal is really overkill here because it uses
pthread_{set,get}_specific logic, and has careful code to both allocate
and delete the thread local data. We don't actually want any of that,
and this code in particular has problems coping with deallocation. What
we want is a single TLS pointer that is valid to use during global
construction and during global destruction, any time we want. That is
exactly what every host compiler and OS we use has implemented for
a long time, and what was standardized in C++11. Even though not all of
our host compilers support the thread_local keyword, we can directly use
the platform-specific keywords to get the minimal functionality needed.
Provided this limited trial survives the build bots, I will move this to
Compiler.h so it is more widely available as a light weight if limited
alternative to the ThreadLocal class. Many thanks to David Majnemer for
helping me think through the implications across platforms and craft the
MSVC-compatible syntax.
The end result is *substantially* faster. When running llc in a tight
loop over a small IR file targeting the aarch64 backend, this improves
its performance by over 10% for me. It also seems likely to fix the
remaining regressions seen by JIT users with threading enabled.
This may actually have more impact on real-world compile times due to
the use of the pretty stack tracing utility throughout the rest of Clang
or LLVM, but I've not collected any detailed measurements.
llvm-svn: 227300
2015-01-28 17:52:14 +08:00
|
|
|
assert(PrettyStackTraceHead == this &&
|
2009-03-05 05:40:23 +08:00
|
|
|
"Pretty stack trace entry destruction is out of order");
|
2016-05-27 04:21:55 +08:00
|
|
|
PrettyStackTraceHead = NextEntry;
|
2015-01-29 15:35:31 +08:00
|
|
|
#endif
|
2009-03-05 05:40:23 +08:00
|
|
|
}
|
|
|
|
|
2016-12-15 03:09:43 +08:00
|
|
|
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);
|
2009-03-05 05:40:23 +08:00
|
|
|
}
|
|
|
|
|
2016-12-15 03:09:43 +08:00
|
|
|
void PrettyStackTraceFormat::print(raw_ostream &OS) const { OS << Str << "\n"; }
|
|
|
|
|
2009-03-05 05:40:23 +08:00
|
|
|
void PrettyStackTraceProgram::print(raw_ostream &OS) const {
|
2009-03-05 14:51:42 +08:00
|
|
|
OS << "Program arguments: ";
|
2009-03-05 05:40:23 +08:00
|
|
|
// Print the argument list.
|
|
|
|
for (unsigned i = 0, e = ArgC; i != e; ++i)
|
|
|
|
OS << ArgV[i] << ' ';
|
|
|
|
OS << '\n';
|
2009-03-05 14:51:42 +08:00
|
|
|
}
|
2013-11-03 08:29:47 +08:00
|
|
|
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2013-11-04 10:22:25 +08:00
|
|
|
static bool RegisterCrashPrinter() {
|
2014-04-07 12:17:22 +08:00
|
|
|
sys::AddSignalHandler(CrashHandler, nullptr);
|
2013-11-04 10:22:25 +08:00
|
|
|
return false;
|
|
|
|
}
|
2015-01-29 15:35:31 +08:00
|
|
|
#endif
|
2013-11-04 10:22:25 +08:00
|
|
|
|
|
|
|
void llvm::EnablePrettyStackTrace() {
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2013-11-04 10:22:25 +08:00
|
|
|
// The first time this is called, we register the crash printer.
|
|
|
|
static bool HandlerRegistered = RegisterCrashPrinter();
|
|
|
|
(void)HandlerRegistered;
|
2015-01-29 15:35:31 +08:00
|
|
|
#endif
|
2013-11-04 10:22:25 +08:00
|
|
|
}
|
|
|
|
|
2016-05-27 04:21:55 +08:00
|
|
|
const void *llvm::SavePrettyStackState() {
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2015-08-08 01:47:03 +08:00
|
|
|
return PrettyStackTraceHead;
|
|
|
|
#else
|
|
|
|
return nullptr;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-05-27 04:21:55 +08:00
|
|
|
void llvm::RestorePrettyStackState(const void *Top) {
|
2016-10-01 04:04:24 +08:00
|
|
|
#if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES
|
2016-05-28 07:04:28 +08:00
|
|
|
PrettyStackTraceHead =
|
|
|
|
static_cast<PrettyStackTraceEntry *>(const_cast<void *>(Top));
|
2015-08-08 01:47:03 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-11-04 10:22:25 +08:00
|
|
|
void LLVMEnablePrettyStackTrace() {
|
|
|
|
EnablePrettyStackTrace();
|
2013-11-03 08:29:47 +08:00
|
|
|
}
|