Signals.inc revision 1f6efa3996dd1929fbc129203ce5009b620e6969
1//===- Win32/Signals.cpp - Win32 Signals Implementation ---------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file provides the Win32 specific implementation of the Signals class. 11// 12//===----------------------------------------------------------------------===// 13 14#include "Windows.h" 15#include <stdio.h> 16#include <vector> 17#include <algorithm> 18 19#ifdef __MINGW32__ 20 #include <imagehlp.h> 21#else 22 #include <dbghelp.h> 23#endif 24#include <psapi.h> 25 26#ifdef __MINGW32__ 27 #if ((HAVE_LIBIMAGEHLP != 1) || (HAVE_LIBPSAPI != 1)) 28 #error "libimagehlp.a & libpsapi.a should be present" 29 #endif 30#else 31 #pragma comment(lib, "psapi.lib") 32 #pragma comment(lib, "dbghelp.lib") 33#endif 34 35// Forward declare. 36static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep); 37static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType); 38 39// InterruptFunction - The function to call if ctrl-c is pressed. 40static void (*InterruptFunction)() = 0; 41 42static std::vector<llvm::sys::Path> *FilesToRemove = NULL; 43static std::vector<std::pair<void(*)(void*), void*> > *CallBacksToRun = 0; 44static bool RegisteredUnhandledExceptionFilter = false; 45static bool CleanupExecuted = false; 46static bool ExitOnUnhandledExceptions = false; 47static PTOP_LEVEL_EXCEPTION_FILTER OldFilter = NULL; 48 49// Windows creates a new thread to execute the console handler when an event 50// (such as CTRL/C) occurs. This causes concurrency issues with the above 51// globals which this critical section addresses. 52static CRITICAL_SECTION CriticalSection; 53 54namespace llvm { 55 56//===----------------------------------------------------------------------===// 57//=== WARNING: Implementation here must contain only Win32 specific code 58//=== and must not be UNIX code 59//===----------------------------------------------------------------------===// 60 61#ifdef _MSC_VER 62/// CRTReportHook - Function called on a CRT debugging event. 63static int CRTReportHook(int ReportType, char *Message, int *Return) { 64 // Don't cause a DebugBreak() on return. 65 if (Return) 66 *Return = 0; 67 68 switch (ReportType) { 69 default: 70 case _CRT_ASSERT: 71 fprintf(stderr, "CRT assert: %s\n", Message); 72 // FIXME: Is there a way to just crash? Perhaps throw to the unhandled 73 // exception code? Perhaps SetErrorMode() handles this. 74 _exit(3); 75 break; 76 case _CRT_ERROR: 77 fprintf(stderr, "CRT error: %s\n", Message); 78 // FIXME: Is there a way to just crash? Perhaps throw to the unhandled 79 // exception code? Perhaps SetErrorMode() handles this. 80 _exit(3); 81 break; 82 case _CRT_WARN: 83 fprintf(stderr, "CRT warn: %s\n", Message); 84 break; 85 } 86 87 // Don't call _CrtDbgReport. 88 return TRUE; 89} 90#endif 91 92static void RegisterHandler() { 93 if (RegisteredUnhandledExceptionFilter) { 94 EnterCriticalSection(&CriticalSection); 95 return; 96 } 97 98 // Now's the time to create the critical section. This is the first time 99 // through here, and there's only one thread. 100 InitializeCriticalSection(&CriticalSection); 101 102 // Enter it immediately. Now if someone hits CTRL/C, the console handler 103 // can't proceed until the globals are updated. 104 EnterCriticalSection(&CriticalSection); 105 106 RegisteredUnhandledExceptionFilter = true; 107 OldFilter = SetUnhandledExceptionFilter(LLVMUnhandledExceptionFilter); 108 SetConsoleCtrlHandler(LLVMConsoleCtrlHandler, TRUE); 109 110 // Environment variable to disable any kind of crash dialog. 111 if (getenv("LLVM_DISABLE_CRT_DEBUG")) { 112#ifdef _MSC_VER 113 _CrtSetReportHook(CRTReportHook); 114#endif 115 ExitOnUnhandledExceptions = true; 116 } 117 118 // IMPORTANT NOTE: Caller must call LeaveCriticalSection(&CriticalSection) or 119 // else multi-threading problems will ensue. 120} 121 122// RemoveFileOnSignal - The public API 123bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) { 124 RegisterHandler(); 125 126 if (CleanupExecuted) { 127 if (ErrMsg) 128 *ErrMsg = "Process terminating -- cannot register for removal"; 129 return true; 130 } 131 132 if (FilesToRemove == NULL) 133 FilesToRemove = new std::vector<sys::Path>; 134 135 FilesToRemove->push_back(Filename); 136 137 LeaveCriticalSection(&CriticalSection); 138 return false; 139} 140 141// DontRemoveFileOnSignal - The public API 142void sys::DontRemoveFileOnSignal(const sys::Path &Filename) { 143 if (FilesToRemove == NULL) 144 return; 145 146 RegisterHandler(); 147 148 FilesToRemove->push_back(Filename); 149 std::vector<sys::Path>::reverse_iterator I = 150 std::find(FilesToRemove->rbegin(), FilesToRemove->rend(), Filename); 151 if (I != FilesToRemove->rend()) 152 FilesToRemove->erase(I.base()-1); 153 154 LeaveCriticalSection(&CriticalSection); 155} 156 157/// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or 158/// SIGSEGV) is delivered to the process, print a stack trace and then exit. 159void sys::PrintStackTraceOnErrorSignal() { 160 RegisterHandler(); 161 LeaveCriticalSection(&CriticalSection); 162} 163 164 165void sys::SetInterruptFunction(void (*IF)()) { 166 RegisterHandler(); 167 InterruptFunction = IF; 168 LeaveCriticalSection(&CriticalSection); 169} 170 171 172/// AddSignalHandler - Add a function to be called when a signal is delivered 173/// to the process. The handler can have a cookie passed to it to identify 174/// what instance of the handler it is. 175void sys::AddSignalHandler(void (*FnPtr)(void *), void *Cookie) { 176 if (CallBacksToRun == 0) 177 CallBacksToRun = new std::vector<std::pair<void(*)(void*), void*> >(); 178 CallBacksToRun->push_back(std::make_pair(FnPtr, Cookie)); 179 RegisterHandler(); 180 LeaveCriticalSection(&CriticalSection); 181} 182} 183 184static void Cleanup() { 185 EnterCriticalSection(&CriticalSection); 186 187 // Prevent other thread from registering new files and directories for 188 // removal, should we be executing because of the console handler callback. 189 CleanupExecuted = true; 190 191 // FIXME: open files cannot be deleted. 192 193 if (FilesToRemove != NULL) 194 while (!FilesToRemove->empty()) { 195 FilesToRemove->back().eraseFromDisk(); 196 FilesToRemove->pop_back(); 197 } 198 199 if (CallBacksToRun) 200 for (unsigned i = 0, e = CallBacksToRun->size(); i != e; ++i) 201 (*CallBacksToRun)[i].first((*CallBacksToRun)[i].second); 202 203 LeaveCriticalSection(&CriticalSection); 204} 205 206void llvm::sys::RunInterruptHandlers() { 207 Cleanup(); 208} 209 210static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep) { 211 Cleanup(); 212 213#ifdef _WIN64 214 // TODO: provide a x64 friendly version of the following 215#else 216 217 // Initialize the STACKFRAME structure. 218 STACKFRAME StackFrame; 219 memset(&StackFrame, 0, sizeof(StackFrame)); 220 221 StackFrame.AddrPC.Offset = ep->ContextRecord->Eip; 222 StackFrame.AddrPC.Mode = AddrModeFlat; 223 StackFrame.AddrStack.Offset = ep->ContextRecord->Esp; 224 StackFrame.AddrStack.Mode = AddrModeFlat; 225 StackFrame.AddrFrame.Offset = ep->ContextRecord->Ebp; 226 StackFrame.AddrFrame.Mode = AddrModeFlat; 227 228 HANDLE hProcess = GetCurrentProcess(); 229 HANDLE hThread = GetCurrentThread(); 230 231 // Initialize the symbol handler. 232 SymSetOptions(SYMOPT_DEFERRED_LOADS|SYMOPT_LOAD_LINES); 233 SymInitialize(hProcess, NULL, TRUE); 234 235 while (true) { 236 if (!StackWalk(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &StackFrame, 237 ep->ContextRecord, NULL, SymFunctionTableAccess, 238 SymGetModuleBase, NULL)) { 239 break; 240 } 241 242 if (StackFrame.AddrFrame.Offset == 0) 243 break; 244 245 // Print the PC in hexadecimal. 246 DWORD PC = StackFrame.AddrPC.Offset; 247 fprintf(stderr, "%08lX", PC); 248 249 // Print the parameters. Assume there are four. 250 fprintf(stderr, " (0x%08lX 0x%08lX 0x%08lX 0x%08lX)", 251 StackFrame.Params[0], 252 StackFrame.Params[1], StackFrame.Params[2], StackFrame.Params[3]); 253 254 // Verify the PC belongs to a module in this process. 255 if (!SymGetModuleBase(hProcess, PC)) { 256 fputs(" <unknown module>\n", stderr); 257 continue; 258 } 259 260 // Print the symbol name. 261 char buffer[512]; 262 IMAGEHLP_SYMBOL *symbol = reinterpret_cast<IMAGEHLP_SYMBOL *>(buffer); 263 memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL)); 264 symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL); 265 symbol->MaxNameLength = 512 - sizeof(IMAGEHLP_SYMBOL); 266 267 DWORD dwDisp; 268 if (!SymGetSymFromAddr(hProcess, PC, &dwDisp, symbol)) { 269 fputc('\n', stderr); 270 continue; 271 } 272 273 buffer[511] = 0; 274 if (dwDisp > 0) 275 fprintf(stderr, ", %s()+%04lu bytes(s)", symbol->Name, dwDisp); 276 else 277 fprintf(stderr, ", %s", symbol->Name); 278 279 // Print the source file and line number information. 280 IMAGEHLP_LINE line; 281 memset(&line, 0, sizeof(line)); 282 line.SizeOfStruct = sizeof(line); 283 if (SymGetLineFromAddr(hProcess, PC, &dwDisp, &line)) { 284 fprintf(stderr, ", %s, line %lu", line.FileName, line.LineNumber); 285 if (dwDisp > 0) 286 fprintf(stderr, "+%04lu byte(s)", dwDisp); 287 } 288 289 fputc('\n', stderr); 290 } 291 292#endif 293 294 if (ExitOnUnhandledExceptions) 295 _exit(-3); 296 297 // Allow dialog box to pop up allowing choice to start debugger. 298 if (OldFilter) 299 return (*OldFilter)(ep); 300 else 301 return EXCEPTION_CONTINUE_SEARCH; 302} 303 304static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType) { 305 // We are running in our very own thread, courtesy of Windows. 306 EnterCriticalSection(&CriticalSection); 307 Cleanup(); 308 309 // If an interrupt function has been set, go and run one it; otherwise, 310 // the process dies. 311 void (*IF)() = InterruptFunction; 312 InterruptFunction = 0; // Don't run it on another CTRL-C. 313 314 if (IF) { 315 // Note: if the interrupt function throws an exception, there is nothing 316 // to catch it in this thread so it will kill the process. 317 IF(); // Run it now. 318 LeaveCriticalSection(&CriticalSection); 319 return TRUE; // Don't kill the process. 320 } 321 322 // Allow normal processing to take place; i.e., the process dies. 323 LeaveCriticalSection(&CriticalSection); 324 return FALSE; 325} 326