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().
32 static bool StackTraceRequested = false;
34 /// InterruptFunction - The function to call if ctrl-c is pressed.
35 static void (*InterruptFunction)() = 0;
37 static std::vector<sys::Path> *FilesToRemove = 0 ;
38 static std::vector<sys::Path> *DirectoriesToRemove = 0;
40 // IntSigs - Signals that may interrupt the program at any time.
41 static const int IntSigs[] = {
42 SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
44 static const int *IntSigsEnd = IntSigs + sizeof(IntSigs) / sizeof(IntSigs[0]);
46 // KillSigs - Signals that are synchronous with the program that will cause it
48 static const int KillSigs[] = {
49 SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGSYS, SIGXCPU, SIGXFSZ
54 static const int *KillSigsEnd = KillSigs + sizeof(KillSigs) / sizeof(KillSigs[0]);
57 static void* StackTrace[256];
60 // PrintStackTrace - In the case of a program crash or fault, print out a stack
61 // trace so that the user has an indication of why and where we died.
63 // On glibc systems we have the 'backtrace' function, which works nicely, but
64 // doesn't demangle symbols.
65 static void PrintStackTrace() {
67 // Use backtrace() to output a backtrace on Linux systems with glibc.
68 int depth = backtrace(StackTrace,
69 static_cast<int>(array_lengthof(StackTrace)));
70 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
74 // SignalHandler - The signal handler that runs...
75 static RETSIGTYPE SignalHandler(int Sig) {
76 if (FilesToRemove != 0)
77 while (!FilesToRemove->empty()) {
78 FilesToRemove->back().eraseFromDisk(true);
79 FilesToRemove->pop_back();
82 if (DirectoriesToRemove != 0)
83 while (!DirectoriesToRemove->empty()) {
84 DirectoriesToRemove->back().eraseFromDisk(true);
85 DirectoriesToRemove->pop_back();
88 if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) {
89 if (InterruptFunction) {
90 void (*IF)() = InterruptFunction;
91 InterruptFunction = 0;
92 IF(); // run the interrupt function.
95 exit(1); // If this is an interrupt signal, exit the program
99 // Otherwise if it is a fault (like SEGV) output the stacktrace to
100 // STDERR (if we can) and reissue the signal to die...
101 if (StackTraceRequested)
103 signal(Sig, SIG_DFL);
107 static void RegisterHandler(int Signal) {
108 signal(Signal, SignalHandler);
114 void sys::SetInterruptFunction(void (*IF)()) {
115 InterruptFunction = IF;
116 RegisterHandler(SIGINT);
119 // RemoveFileOnSignal - The public API
120 bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
121 if (FilesToRemove == 0)
122 FilesToRemove = new std::vector<sys::Path>;
124 FilesToRemove->push_back(Filename);
126 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
127 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
131 // RemoveDirectoryOnSignal - The public API
132 bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
135 if (0 != stat(path.c_str(), &buf)) {
136 MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file");
140 if (!S_ISDIR(buf.st_mode)) {
142 *ErrMsg = path.toString() + " is not a directory";
146 if (DirectoriesToRemove == 0)
147 DirectoriesToRemove = new std::vector<sys::Path>;
149 DirectoriesToRemove->push_back(path);
151 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
152 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
156 /// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
157 /// SIGSEGV) is delivered to the process, print a stack trace and then exit.
158 void sys::PrintStackTraceOnErrorSignal() {
159 StackTraceRequested = true;
160 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);