1 //===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines some helpful functions for dealing with the possibility of
11 // Unix signals occuring while your program is running.
13 //===----------------------------------------------------------------------===//
16 #include "llvm/ADT/STLExtras.h"
20 # include <execinfo.h> // For backtrace().
28 #if HAVE_DLFCN_H && __GNUG__
36 static bool StackTraceRequested = false;
38 /// InterruptFunction - The function to call if ctrl-c is pressed.
39 static void (*InterruptFunction)() = 0;
41 static std::vector<sys::Path> *FilesToRemove = 0 ;
42 static std::vector<sys::Path> *DirectoriesToRemove = 0;
44 // IntSigs - Signals that may interrupt the program at any time.
45 static const int IntSigs[] = {
46 SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
48 static const int *const IntSigsEnd =
49 IntSigs + sizeof(IntSigs) / sizeof(IntSigs[0]);
51 // KillSigs - Signals that are synchronous with the program that will cause it
53 static const int KillSigs[] = {
54 SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGSYS, SIGXCPU, SIGXFSZ
59 static const int *const KillSigsEnd =
60 KillSigs + sizeof(KillSigs) / sizeof(KillSigs[0]);
63 static void* StackTrace[256];
66 // PrintStackTrace - In the case of a program crash or fault, print out a stack
67 // trace so that the user has an indication of why and where we died.
69 // On glibc systems we have the 'backtrace' function, which works nicely, but
70 // doesn't demangle symbols.
71 static void PrintStackTrace() {
73 // Use backtrace() to output a backtrace on Linux systems with glibc.
74 int depth = backtrace(StackTrace,
75 static_cast<int>(array_lengthof(StackTrace)));
76 #if HAVE_DLFCN_H && __GNUG__
78 for (int i = 0; i < depth; ++i) {
80 dladdr(StackTrace[i], &dlinfo);
81 char* name = strrchr(dlinfo.dli_fname, '/');
84 if (name == NULL) nwidth = strlen(dlinfo.dli_fname);
85 else nwidth = strlen(name) - 1;
87 if (nwidth > width) width = nwidth;
90 for (int i = 0; i < depth; ++i) {
92 dladdr(StackTrace[i], &dlinfo);
94 fprintf(stderr, "%-3d", i);
96 char* name = strrchr(dlinfo.dli_fname, '/');
97 if (name == NULL) fprintf(stderr, " %-*s", width, dlinfo.dli_fname);
98 else fprintf(stderr, " %-*s", width, name+1);
100 fprintf(stderr, " %#0*x", (int)(sizeof(void*) * 2) + 2, StackTrace[i]);
102 if (dlinfo.dli_sname != NULL) {
105 char* d = abi::__cxa_demangle(dlinfo.dli_sname, NULL, NULL, &res);
106 if (d == NULL) fputs(dlinfo.dli_sname, stderr);
107 else fputs(d, stderr);
110 fprintf(stderr, " + %tu",(char*)StackTrace[i]-(char*)dlinfo.dli_saddr);
115 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
120 // SignalHandler - The signal handler that runs...
121 static RETSIGTYPE SignalHandler(int Sig) {
122 if (FilesToRemove != 0)
123 while (!FilesToRemove->empty()) {
124 FilesToRemove->back().eraseFromDisk(true);
125 FilesToRemove->pop_back();
128 if (DirectoriesToRemove != 0)
129 while (!DirectoriesToRemove->empty()) {
130 DirectoriesToRemove->back().eraseFromDisk(true);
131 DirectoriesToRemove->pop_back();
134 if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) {
135 if (InterruptFunction) {
136 void (*IF)() = InterruptFunction;
137 InterruptFunction = 0;
138 IF(); // run the interrupt function.
141 exit(1); // If this is an interrupt signal, exit the program
145 // Otherwise if it is a fault (like SEGV) output the stacktrace to
146 // STDERR (if we can) and reissue the signal to die...
147 if (StackTraceRequested)
149 signal(Sig, SIG_DFL);
153 static void RegisterHandler(int Signal) {
154 signal(Signal, SignalHandler);
160 void sys::SetInterruptFunction(void (*IF)()) {
161 InterruptFunction = IF;
162 RegisterHandler(SIGINT);
165 // RemoveFileOnSignal - The public API
166 bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
167 if (FilesToRemove == 0)
168 FilesToRemove = new std::vector<sys::Path>;
170 FilesToRemove->push_back(Filename);
172 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
173 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
177 // RemoveDirectoryOnSignal - The public API
178 bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
181 if (0 != stat(path.c_str(), &buf)) {
182 MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file");
186 if (!S_ISDIR(buf.st_mode)) {
188 *ErrMsg = path.toString() + " is not a directory";
192 if (DirectoriesToRemove == 0)
193 DirectoriesToRemove = new std::vector<sys::Path>;
195 DirectoriesToRemove->push_back(path);
197 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
198 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
202 /// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
203 /// SIGSEGV) is delivered to the process, print a stack trace and then exit.
204 void sys::PrintStackTraceOnErrorSignal() {
205 StackTraceRequested = true;
206 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);