mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-22 12:33:33 +02:00
6a2cac3b87
This change modifies fatal signal handler used in LLVM tools. Now it attempts to find llvm-symbolizer binary and communicates with it in order to turn instruction addresses into function/file/line info entries. This should significantly improve stack traces readability in Debug builds. This feature only works on selected platforms (including Darwin and Linux). If the symbolization fails for some reason, signal handler will fallback to the original behavior. Reviewed in http://reviews.llvm.org/D5610 llvm-svn: 219354
534 lines
17 KiB
C++
534 lines
17 KiB
C++
//===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===//
|
|
//
|
|
// 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
|
|
// Unix signals occurring while your program is running.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Unix.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/FileUtilities.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/Mutex.h"
|
|
#include "llvm/Support/Program.h"
|
|
#include "llvm/Support/UniqueLock.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <vector>
|
|
#if HAVE_EXECINFO_H
|
|
# include <execinfo.h> // For backtrace().
|
|
#endif
|
|
#if HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#if HAVE_SYS_STAT_H
|
|
#include <sys/stat.h>
|
|
#endif
|
|
#if HAVE_CXXABI_H
|
|
#include <cxxabi.h>
|
|
#endif
|
|
#if HAVE_DLFCN_H
|
|
#include <dlfcn.h>
|
|
#endif
|
|
#if HAVE_MACH_MACH_H
|
|
#include <mach/mach.h>
|
|
#endif
|
|
#if HAVE_LINK_H
|
|
#include <link.h>
|
|
#endif
|
|
|
|
using namespace llvm;
|
|
|
|
static RETSIGTYPE SignalHandler(int Sig); // defined below.
|
|
|
|
static ManagedStatic<SmartMutex<true> > SignalsMutex;
|
|
|
|
/// InterruptFunction - The function to call if ctrl-c is pressed.
|
|
static void (*InterruptFunction)() = nullptr;
|
|
|
|
static ManagedStatic<std::vector<std::string>> FilesToRemove;
|
|
static ManagedStatic<std::vector<std::pair<void (*)(void *), void *>>>
|
|
CallBacksToRun;
|
|
|
|
// IntSigs - Signals that represent requested termination. There's no bug
|
|
// or failure, or if there is, it's not our direct responsibility. For whatever
|
|
// reason, our continued execution is no longer desirable.
|
|
static const int IntSigs[] = {
|
|
SIGHUP, SIGINT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
|
|
};
|
|
|
|
// KillSigs - Signals that represent that we have a bug, and our prompt
|
|
// termination has been ordered.
|
|
static const int KillSigs[] = {
|
|
SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGQUIT
|
|
#ifdef SIGSYS
|
|
, SIGSYS
|
|
#endif
|
|
#ifdef SIGXCPU
|
|
, SIGXCPU
|
|
#endif
|
|
#ifdef SIGXFSZ
|
|
, SIGXFSZ
|
|
#endif
|
|
#ifdef SIGEMT
|
|
, SIGEMT
|
|
#endif
|
|
};
|
|
|
|
static unsigned NumRegisteredSignals = 0;
|
|
static struct {
|
|
struct sigaction SA;
|
|
int SigNo;
|
|
} RegisteredSignalInfo[(sizeof(IntSigs)+sizeof(KillSigs))/sizeof(KillSigs[0])];
|
|
|
|
|
|
static void RegisterHandler(int Signal) {
|
|
assert(NumRegisteredSignals <
|
|
sizeof(RegisteredSignalInfo)/sizeof(RegisteredSignalInfo[0]) &&
|
|
"Out of space for signal handlers!");
|
|
|
|
struct sigaction NewHandler;
|
|
|
|
NewHandler.sa_handler = SignalHandler;
|
|
NewHandler.sa_flags = SA_NODEFER|SA_RESETHAND;
|
|
sigemptyset(&NewHandler.sa_mask);
|
|
|
|
// Install the new handler, save the old one in RegisteredSignalInfo.
|
|
sigaction(Signal, &NewHandler,
|
|
&RegisteredSignalInfo[NumRegisteredSignals].SA);
|
|
RegisteredSignalInfo[NumRegisteredSignals].SigNo = Signal;
|
|
++NumRegisteredSignals;
|
|
}
|
|
|
|
static void RegisterHandlers() {
|
|
// If the handlers are already registered, we're done.
|
|
if (NumRegisteredSignals != 0) return;
|
|
|
|
for (auto S : IntSigs) RegisterHandler(S);
|
|
for (auto S : KillSigs) RegisterHandler(S);
|
|
}
|
|
|
|
static void UnregisterHandlers() {
|
|
// Restore all of the signal handlers to how they were before we showed up.
|
|
for (unsigned i = 0, e = NumRegisteredSignals; i != e; ++i)
|
|
sigaction(RegisteredSignalInfo[i].SigNo,
|
|
&RegisteredSignalInfo[i].SA, nullptr);
|
|
NumRegisteredSignals = 0;
|
|
}
|
|
|
|
|
|
/// RemoveFilesToRemove - Process the FilesToRemove list. This function
|
|
/// should be called with the SignalsMutex lock held.
|
|
/// NB: This must be an async signal safe function. It cannot allocate or free
|
|
/// memory, even in debug builds.
|
|
static void RemoveFilesToRemove() {
|
|
// We avoid iterators in case of debug iterators that allocate or release
|
|
// memory.
|
|
std::vector<std::string>& FilesToRemoveRef = *FilesToRemove;
|
|
for (unsigned i = 0, e = FilesToRemoveRef.size(); i != e; ++i) {
|
|
// We rely on a std::string implementation for which repeated calls to
|
|
// 'c_str()' don't allocate memory. We pre-call 'c_str()' on all of these
|
|
// strings to try to ensure this is safe.
|
|
const char *path = FilesToRemoveRef[i].c_str();
|
|
|
|
// Get the status so we can determine if it's a file or directory. If we
|
|
// can't stat the file, ignore it.
|
|
struct stat buf;
|
|
if (stat(path, &buf) != 0)
|
|
continue;
|
|
|
|
// If this is not a regular file, ignore it. We want to prevent removal of
|
|
// special files like /dev/null, even if the compiler is being run with the
|
|
// super-user permissions.
|
|
if (!S_ISREG(buf.st_mode))
|
|
continue;
|
|
|
|
// Otherwise, remove the file. We ignore any errors here as there is nothing
|
|
// else we can do.
|
|
unlink(path);
|
|
}
|
|
}
|
|
|
|
// SignalHandler - The signal handler that runs.
|
|
static RETSIGTYPE SignalHandler(int Sig) {
|
|
// Restore the signal behavior to default, so that the program actually
|
|
// crashes when we return and the signal reissues. This also ensures that if
|
|
// we crash in our signal handler that the program will terminate immediately
|
|
// instead of recursing in the signal handler.
|
|
UnregisterHandlers();
|
|
|
|
// Unmask all potentially blocked kill signals.
|
|
sigset_t SigMask;
|
|
sigfillset(&SigMask);
|
|
sigprocmask(SIG_UNBLOCK, &SigMask, nullptr);
|
|
|
|
{
|
|
unique_lock<SmartMutex<true>> Guard(*SignalsMutex);
|
|
RemoveFilesToRemove();
|
|
|
|
if (std::find(std::begin(IntSigs), std::end(IntSigs), Sig)
|
|
!= std::end(IntSigs)) {
|
|
if (InterruptFunction) {
|
|
void (*IF)() = InterruptFunction;
|
|
Guard.unlock();
|
|
InterruptFunction = nullptr;
|
|
IF(); // run the interrupt function.
|
|
return;
|
|
}
|
|
|
|
Guard.unlock();
|
|
raise(Sig); // Execute the default handler.
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Otherwise if it is a fault (like SEGV) run any handler.
|
|
std::vector<std::pair<void (*)(void *), void *>>& CallBacksToRunRef =
|
|
*CallBacksToRun;
|
|
for (unsigned i = 0, e = CallBacksToRun->size(); i != e; ++i)
|
|
CallBacksToRunRef[i].first(CallBacksToRunRef[i].second);
|
|
|
|
#ifdef __s390__
|
|
// On S/390, certain signals are delivered with PSW Address pointing to
|
|
// *after* the faulting instruction. Simply returning from the signal
|
|
// handler would continue execution after that point, instead of
|
|
// re-raising the signal. Raise the signal manually in those cases.
|
|
if (Sig == SIGILL || Sig == SIGFPE || Sig == SIGTRAP)
|
|
raise(Sig);
|
|
#endif
|
|
}
|
|
|
|
void llvm::sys::RunInterruptHandlers() {
|
|
sys::SmartScopedLock<true> Guard(*SignalsMutex);
|
|
RemoveFilesToRemove();
|
|
}
|
|
|
|
void llvm::sys::SetInterruptFunction(void (*IF)()) {
|
|
{
|
|
sys::SmartScopedLock<true> Guard(*SignalsMutex);
|
|
InterruptFunction = IF;
|
|
}
|
|
RegisterHandlers();
|
|
}
|
|
|
|
// RemoveFileOnSignal - The public API
|
|
bool llvm::sys::RemoveFileOnSignal(StringRef Filename,
|
|
std::string* ErrMsg) {
|
|
{
|
|
sys::SmartScopedLock<true> Guard(*SignalsMutex);
|
|
std::vector<std::string>& FilesToRemoveRef = *FilesToRemove;
|
|
std::string *OldPtr =
|
|
FilesToRemoveRef.empty() ? nullptr : &FilesToRemoveRef[0];
|
|
FilesToRemoveRef.push_back(Filename);
|
|
|
|
// We want to call 'c_str()' on every std::string in this vector so that if
|
|
// the underlying implementation requires a re-allocation, it happens here
|
|
// rather than inside of the signal handler. If we see the vector grow, we
|
|
// have to call it on every entry. If it remains in place, we only need to
|
|
// call it on the latest one.
|
|
if (OldPtr == &FilesToRemoveRef[0])
|
|
FilesToRemoveRef.back().c_str();
|
|
else
|
|
for (unsigned i = 0, e = FilesToRemoveRef.size(); i != e; ++i)
|
|
FilesToRemoveRef[i].c_str();
|
|
}
|
|
|
|
RegisterHandlers();
|
|
return false;
|
|
}
|
|
|
|
// DontRemoveFileOnSignal - The public API
|
|
void llvm::sys::DontRemoveFileOnSignal(StringRef Filename) {
|
|
sys::SmartScopedLock<true> Guard(*SignalsMutex);
|
|
std::vector<std::string>::reverse_iterator RI =
|
|
std::find(FilesToRemove->rbegin(), FilesToRemove->rend(), Filename);
|
|
std::vector<std::string>::iterator I = FilesToRemove->end();
|
|
if (RI != FilesToRemove->rend())
|
|
I = FilesToRemove->erase(RI.base()-1);
|
|
|
|
// We need to call c_str() on every element which would have been moved by
|
|
// the erase. These elements, in a C++98 implementation where c_str()
|
|
// requires a reallocation on the first call may have had the call to c_str()
|
|
// made on insertion become invalid by being copied down an element.
|
|
for (std::vector<std::string>::iterator E = FilesToRemove->end(); I != E; ++I)
|
|
I->c_str();
|
|
}
|
|
|
|
/// AddSignalHandler - Add a function to be called when a signal is delivered
|
|
/// to the process. The handler can have a cookie passed to it to identify
|
|
/// what instance of the handler it is.
|
|
void llvm::sys::AddSignalHandler(void (*FnPtr)(void *), void *Cookie) {
|
|
CallBacksToRun->push_back(std::make_pair(FnPtr, Cookie));
|
|
RegisterHandlers();
|
|
}
|
|
|
|
#if HAVE_LINK_H
|
|
struct DlIteratePhdrData {
|
|
void **StackTrace;
|
|
int depth;
|
|
bool first;
|
|
const char **modules;
|
|
intptr_t *offsets;
|
|
const char *main_exec_name;
|
|
};
|
|
|
|
static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
|
|
DlIteratePhdrData *data = (DlIteratePhdrData*)arg;
|
|
const char *name = data->first ? data->main_exec_name : info->dlpi_name;
|
|
data->first = false;
|
|
for (int i = 0; i < info->dlpi_phnum; i++) {
|
|
const ElfW(Phdr) *phdr = &info->dlpi_phdr[i];
|
|
if (phdr->p_type != PT_LOAD)
|
|
continue;
|
|
intptr_t beg = info->dlpi_addr + phdr->p_vaddr;
|
|
intptr_t end = beg + phdr->p_memsz;
|
|
for (int j = 0; j < data->depth; j++) {
|
|
if (data->modules[j])
|
|
continue;
|
|
intptr_t addr = (intptr_t)data->StackTrace[j];
|
|
if (beg <= addr && addr < end) {
|
|
data->modules[j] = name;
|
|
data->offsets[j] = addr - info->dlpi_addr;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static bool findModulesAndOffsets(void **StackTrace, int Depth,
|
|
const char **Modules, intptr_t *Offsets,
|
|
const char *MainExecutableName) {
|
|
DlIteratePhdrData data = {StackTrace, Depth, true,
|
|
Modules, Offsets, MainExecutableName};
|
|
dl_iterate_phdr(dl_iterate_phdr_cb, &data);
|
|
return true;
|
|
}
|
|
#else
|
|
static bool findModulesAndOffsets(void **StackTrace, int Depth,
|
|
const char **Modules, intptr_t *Offsets,
|
|
const char *MainExecutableName) {
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
static bool printSymbolizedStackTrace(void **StackTrace, int Depth, FILE *FD) {
|
|
// FIXME: Subtract necessary number from StackTrace entries to turn return addresses
|
|
// into actual instruction addresses.
|
|
// Use llvm-symbolizer tool to symbolize the stack traces.
|
|
std::string LLVMSymbolizerPath = sys::FindProgramByName("llvm-symbolizer");
|
|
if (LLVMSymbolizerPath.empty())
|
|
return false;
|
|
// We don't know argv0 or the address of main() at this point, but try
|
|
// to guess it anyway (it's possible on some platforms).
|
|
std::string MainExecutableName = sys::fs::getMainExecutable(nullptr, nullptr);
|
|
if (MainExecutableName.empty() ||
|
|
MainExecutableName.find("llvm-symbolizer") != std::string::npos)
|
|
return false;
|
|
|
|
std::vector<const char *> Modules(Depth, nullptr);
|
|
std::vector<intptr_t> Offsets(Depth, 0);
|
|
if (!findModulesAndOffsets(StackTrace, Depth, Modules.data(), Offsets.data(),
|
|
MainExecutableName.c_str()))
|
|
return false;
|
|
int InputFD;
|
|
SmallString<32> InputFile, OutputFile;
|
|
sys::fs::createTemporaryFile("symbolizer-input", "", InputFD, InputFile);
|
|
sys::fs::createTemporaryFile("symbolizer-output", "", OutputFile);
|
|
FileRemover InputRemover(InputFile.c_str());
|
|
FileRemover OutputRemover(OutputFile.c_str());
|
|
std::vector<const StringRef *> Redirects(3, nullptr);
|
|
StringRef InputFileStr(InputFile);
|
|
StringRef OutputFileStr(OutputFile);
|
|
StringRef StderrFileStr;
|
|
Redirects[0] = &InputFileStr;
|
|
Redirects[1] = &OutputFileStr;
|
|
Redirects[2] = &StderrFileStr;
|
|
|
|
{
|
|
raw_fd_ostream Input(InputFD, true);
|
|
for (int i = 0; i < Depth; i++) {
|
|
if (Modules[i])
|
|
Input << Modules[i] << " " << (void*)Offsets[i] << "\n";
|
|
}
|
|
}
|
|
|
|
const char *args[] = {"llvm-symbolizer", nullptr};
|
|
int RunResult =
|
|
sys::ExecuteAndWait(LLVMSymbolizerPath, args, nullptr, Redirects.data());
|
|
if (RunResult != 0)
|
|
return false;
|
|
|
|
auto OutputBuf = MemoryBuffer::getFile(OutputFile.c_str());
|
|
if (std::error_code Err = OutputBuf.getError())
|
|
return false;
|
|
StringRef Output = OutputBuf.get()->getBuffer();
|
|
SmallVector<StringRef, 32> Lines;
|
|
Output.split(Lines, "\n");
|
|
auto CurLine = Lines.begin();
|
|
int frame_no = 0;
|
|
for (int i = 0; i < Depth; i++) {
|
|
if (!Modules[i]) {
|
|
fprintf(FD, "#%d %p\n", frame_no++, StackTrace[i]);
|
|
continue;
|
|
}
|
|
// Read pairs of lines (function name and file/line info) until we
|
|
// encounter empty line.
|
|
for (;;) {
|
|
StringRef FunctionName = *CurLine++;
|
|
if (FunctionName.empty())
|
|
break;
|
|
fprintf(FD, "#%d %p ", frame_no++, StackTrace[i]);
|
|
if (!FunctionName.startswith("??"))
|
|
fprintf(FD, "%s ", FunctionName.str().c_str());
|
|
StringRef FileLineInfo = *CurLine++;
|
|
if (!FileLineInfo.startswith("??"))
|
|
fprintf(FD, "%s", FileLineInfo.str().c_str());
|
|
else
|
|
fprintf(FD, "(%s+%p)", Modules[i], (void *)Offsets[i]);
|
|
fprintf(FD, "\n");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// PrintStackTrace - In the case of a program crash or fault, print out a stack
|
|
// trace so that the user has an indication of why and where we died.
|
|
//
|
|
// On glibc systems we have the 'backtrace' function, which works nicely, but
|
|
// doesn't demangle symbols.
|
|
void llvm::sys::PrintStackTrace(FILE *FD) {
|
|
#if defined(HAVE_BACKTRACE) && defined(ENABLE_BACKTRACES)
|
|
static void* StackTrace[256];
|
|
// Use backtrace() to output a backtrace on Linux systems with glibc.
|
|
int depth = backtrace(StackTrace,
|
|
static_cast<int>(array_lengthof(StackTrace)));
|
|
if (printSymbolizedStackTrace(StackTrace, depth, FD))
|
|
return;
|
|
#if HAVE_DLFCN_H && __GNUG__
|
|
int width = 0;
|
|
for (int i = 0; i < depth; ++i) {
|
|
Dl_info dlinfo;
|
|
dladdr(StackTrace[i], &dlinfo);
|
|
const char* name = strrchr(dlinfo.dli_fname, '/');
|
|
|
|
int nwidth;
|
|
if (!name) nwidth = strlen(dlinfo.dli_fname);
|
|
else nwidth = strlen(name) - 1;
|
|
|
|
if (nwidth > width) width = nwidth;
|
|
}
|
|
|
|
for (int i = 0; i < depth; ++i) {
|
|
Dl_info dlinfo;
|
|
dladdr(StackTrace[i], &dlinfo);
|
|
|
|
fprintf(FD, "%-2d", i);
|
|
|
|
const char* name = strrchr(dlinfo.dli_fname, '/');
|
|
if (!name) fprintf(FD, " %-*s", width, dlinfo.dli_fname);
|
|
else fprintf(FD, " %-*s", width, name+1);
|
|
|
|
fprintf(FD, " %#0*lx",
|
|
(int)(sizeof(void*) * 2) + 2, (unsigned long)StackTrace[i]);
|
|
|
|
if (dlinfo.dli_sname != nullptr) {
|
|
fputc(' ', FD);
|
|
# if HAVE_CXXABI_H
|
|
int res;
|
|
char* d = abi::__cxa_demangle(dlinfo.dli_sname, nullptr, nullptr, &res);
|
|
# else
|
|
char* d = NULL;
|
|
# endif
|
|
if (!d) fputs(dlinfo.dli_sname, FD);
|
|
else fputs(d, FD);
|
|
free(d);
|
|
|
|
// FIXME: When we move to C++11, use %t length modifier. It's not in
|
|
// C++03 and causes gcc to issue warnings. Losing the upper 32 bits of
|
|
// the stack offset for a stack dump isn't likely to cause any problems.
|
|
fprintf(FD, " + %u",(unsigned)((char*)StackTrace[i]-
|
|
(char*)dlinfo.dli_saddr));
|
|
}
|
|
fputc('\n', FD);
|
|
}
|
|
#else
|
|
backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static void PrintStackTraceSignalHandler(void *) {
|
|
PrintStackTrace(stderr);
|
|
}
|
|
|
|
/// PrintStackTraceOnErrorSignal - When an error signal (such as SIGABRT or
|
|
/// SIGSEGV) is delivered to the process, print a stack trace and then exit.
|
|
void llvm::sys::PrintStackTraceOnErrorSignal() {
|
|
AddSignalHandler(PrintStackTraceSignalHandler, nullptr);
|
|
|
|
#if defined(__APPLE__) && defined(ENABLE_CRASH_OVERRIDES)
|
|
// Environment variable to disable any kind of crash dialog.
|
|
if (getenv("LLVM_DISABLE_CRASH_REPORT")) {
|
|
mach_port_t self = mach_task_self();
|
|
|
|
exception_mask_t mask = EXC_MASK_CRASH;
|
|
|
|
kern_return_t ret = task_set_exception_ports(self,
|
|
mask,
|
|
MACH_PORT_NULL,
|
|
EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES,
|
|
THREAD_STATE_NONE);
|
|
(void)ret;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/***/
|
|
|
|
// On Darwin, raise sends a signal to the main thread instead of the current
|
|
// thread. This has the unfortunate effect that assert() and abort() will end up
|
|
// bypassing our crash recovery attempts. We work around this for anything in
|
|
// the same linkage unit by just defining our own versions of the assert handler
|
|
// and abort.
|
|
|
|
#if defined(__APPLE__) && defined(ENABLE_CRASH_OVERRIDES)
|
|
|
|
#include <signal.h>
|
|
#include <pthread.h>
|
|
|
|
int raise(int sig) {
|
|
return pthread_kill(pthread_self(), sig);
|
|
}
|
|
|
|
void __assert_rtn(const char *func,
|
|
const char *file,
|
|
int line,
|
|
const char *expr) {
|
|
if (func)
|
|
fprintf(stderr, "Assertion failed: (%s), function %s, file %s, line %d.\n",
|
|
expr, func, file, line);
|
|
else
|
|
fprintf(stderr, "Assertion failed: (%s), file %s, line %d.\n",
|
|
expr, file, line);
|
|
abort();
|
|
}
|
|
|
|
void abort() {
|
|
raise(SIGABRT);
|
|
usleep(1000);
|
|
__builtin_trap();
|
|
}
|
|
|
|
#endif
|