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*lx",
101 (int)(sizeof(void*) * 2) + 2, (unsigned long)StackTrace[i]);
103 if (dlinfo.dli_sname != NULL) {
106 char* d = abi::__cxa_demangle(dlinfo.dli_sname, NULL, NULL, &res);
107 if (d == NULL) fputs(dlinfo.dli_sname, stderr);
108 else fputs(d, stderr);
111 fprintf(stderr, " + %tu",(char*)StackTrace[i]-(char*)dlinfo.dli_saddr);
116 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
121 // SignalHandler - The signal handler that runs...
122 static RETSIGTYPE SignalHandler(int Sig) {
123 if (FilesToRemove != 0)
124 while (!FilesToRemove->empty()) {
125 FilesToRemove->back().eraseFromDisk(true);
126 FilesToRemove->pop_back();
129 if (DirectoriesToRemove != 0)
130 while (!DirectoriesToRemove->empty()) {
131 DirectoriesToRemove->back().eraseFromDisk(true);
132 DirectoriesToRemove->pop_back();
135 if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) {
136 if (InterruptFunction) {
137 void (*IF)() = InterruptFunction;
138 InterruptFunction = 0;
139 IF(); // run the interrupt function.
142 exit(1); // If this is an interrupt signal, exit the program
146 // Otherwise if it is a fault (like SEGV) output the stacktrace to
147 // STDERR (if we can) and reissue the signal to die...
148 if (StackTraceRequested)
150 signal(Sig, SIG_DFL);
154 static void RegisterHandler(int Signal) {
155 signal(Signal, SignalHandler);
161 void sys::SetInterruptFunction(void (*IF)()) {
162 InterruptFunction = IF;
163 RegisterHandler(SIGINT);
166 // RemoveFileOnSignal - The public API
167 bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
168 if (FilesToRemove == 0)
169 FilesToRemove = new std::vector<sys::Path>;
171 FilesToRemove->push_back(Filename);
173 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
174 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
178 // RemoveDirectoryOnSignal - The public API
179 bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
182 if (0 != stat(path.c_str(), &buf)) {
183 MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file");
187 if (!S_ISDIR(buf.st_mode)) {
189 *ErrMsg = path.toString() + " is not a directory";
193 if (DirectoriesToRemove == 0)
194 DirectoriesToRemove = new std::vector<sys::Path>;
196 DirectoriesToRemove->push_back(path);
198 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
199 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
203 /// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
204 /// SIGSEGV) is delivered to the process, print a stack trace and then exit.
205 void sys::PrintStackTraceOnErrorSignal() {
206 StackTraceRequested = true;
207 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);