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, array_lengthof(StackTrace));
69 backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
73 // SignalHandler - The signal handler that runs...
74 static RETSIGTYPE SignalHandler(int Sig) {
75 if (FilesToRemove != 0)
76 while (!FilesToRemove->empty()) {
77 FilesToRemove->back().eraseFromDisk(true);
78 FilesToRemove->pop_back();
81 if (DirectoriesToRemove != 0)
82 while (!DirectoriesToRemove->empty()) {
83 DirectoriesToRemove->back().eraseFromDisk(true);
84 DirectoriesToRemove->pop_back();
87 if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) {
88 if (InterruptFunction) {
89 void (*IF)() = InterruptFunction;
90 InterruptFunction = 0;
91 IF(); // run the interrupt function.
94 exit(1); // If this is an interrupt signal, exit the program
98 // Otherwise if it is a fault (like SEGV) output the stacktrace to
99 // STDERR (if we can) and reissue the signal to die...
100 if (StackTraceRequested)
102 signal(Sig, SIG_DFL);
106 static void RegisterHandler(int Signal) {
107 signal(Signal, SignalHandler);
113 void sys::SetInterruptFunction(void (*IF)()) {
114 InterruptFunction = IF;
115 RegisterHandler(SIGINT);
118 // RemoveFileOnSignal - The public API
119 bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
120 if (FilesToRemove == 0)
121 FilesToRemove = new std::vector<sys::Path>;
123 FilesToRemove->push_back(Filename);
125 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
126 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
130 // RemoveDirectoryOnSignal - The public API
131 bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
134 if (0 != stat(path.c_str(), &buf)) {
135 MakeErrMsg(ErrMsg, path.toString() + ": can't get status of file");
139 if (!S_ISDIR(buf.st_mode)) {
141 *ErrMsg = path.toString() + " is not a directory";
145 if (DirectoriesToRemove == 0)
146 DirectoriesToRemove = new std::vector<sys::Path>;
148 DirectoriesToRemove->push_back(path);
150 std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
151 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
155 /// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
156 /// SIGSEGV) is delivered to the process, print a stack trace and then exit.
157 void sys::PrintStackTraceOnErrorSignal() {
158 StackTraceRequested = true;
159 std::for_each(KillSigs, KillSigsEnd, RegisterHandler);