lib/Support/Windows/Signals.inc

   1 //===- Win32/Signals.cpp - Win32 Signals Implementation ---------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file provides the Win32 specific implementation of the Signals class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 #include "llvm/Support/ConvertUTF.h"
  13 #include "llvm/Support/FileSystem.h"
  14 #include "llvm/Support/Path.h"
  15 #include "llvm/Support/Process.h"
  16 #include "llvm/Support/WindowsError.h"
  17 #include <algorithm>
  18 #include <io.h>
  19 #include <signal.h>
  20 #include <stdio.h>
  21
  22 #include "llvm/Support/Format.h"
  23 #include "llvm/Support/raw_ostream.h"
  24
  25 // The Windows.h header must be after LLVM and standard headers.
  26 #include "WindowsSupport.h"
  27
  28 #ifdef __MINGW32__
  29  #include <imagehlp.h>
  30 #else
  31  #include <crtdbg.h>
  32  #include <dbghelp.h>
  33 #endif
  34 #include <psapi.h>
  35
  36 #ifdef _MSC_VER
  37  #pragma comment(lib, "psapi.lib")
  38 #elif __MINGW32__
  39  // The version of g++ that comes with MinGW does *not* properly understand
  40  // the ll format specifier for printf. However, MinGW passes the format
  41  // specifiers on to the MSVCRT entirely, and the CRT understands the ll
  42  // specifier. So these warnings are spurious in this case. Since we compile
  43  // with -Wall, this will generate these warnings which should be ignored. So
  44  // we will turn off the warnings for this just file. However, MinGW also does
  45  // not support push and pop for diagnostics, so we have to manually turn it
  46  // back on at the end of the file.
  47  #pragma GCC diagnostic ignored "-Wformat"
  48  #pragma GCC diagnostic ignored "-Wformat-extra-args"
  49
  50  #if !defined(__MINGW64_VERSION_MAJOR)
  51  // MinGW.org does not have updated support for the 64-bit versions of the
  52  // DebugHlp APIs. So we will have to load them manually. The structures and
  53  // method signatures were pulled from DbgHelp.h in the Windows Platform SDK,
  54  // and adjusted for brevity.
  55  typedef struct _IMAGEHLP_LINE64 {
  56    DWORD    SizeOfStruct;
  57    PVOID    Key;
  58    DWORD    LineNumber;
  59    PCHAR    FileName;
  60    DWORD64  Address;
  61  } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
  62
  63  typedef struct _IMAGEHLP_SYMBOL64 {
  64    DWORD   SizeOfStruct;
  65    DWORD64 Address;
  66    DWORD   Size;
  67    DWORD   Flags;
  68    DWORD   MaxNameLength;
  69    CHAR    Name[1];
  70  } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
  71
  72  typedef struct _tagADDRESS64 {
  73    DWORD64       Offset;
  74    WORD          Segment;
  75    ADDRESS_MODE  Mode;
  76  } ADDRESS64, *LPADDRESS64;
  77
  78  typedef struct _KDHELP64 {
  79    DWORD64   Thread;
  80    DWORD   ThCallbackStack;
  81    DWORD   ThCallbackBStore;
  82    DWORD   NextCallback;
  83    DWORD   FramePointer;
  84    DWORD64   KiCallUserMode;
  85    DWORD64   KeUserCallbackDispatcher;
  86    DWORD64   SystemRangeStart;
  87    DWORD64   KiUserExceptionDispatcher;
  88    DWORD64   StackBase;
  89    DWORD64   StackLimit;
  90    DWORD64   Reserved[5];
  91  } KDHELP64, *PKDHELP64;
  92
  93  typedef struct _tagSTACKFRAME64 {
  94    ADDRESS64   AddrPC;
  95    ADDRESS64   AddrReturn;
  96    ADDRESS64   AddrFrame;
  97    ADDRESS64   AddrStack;
  98    ADDRESS64   AddrBStore;
  99    PVOID       FuncTableEntry;
 100    DWORD64     Params[4];
 101    BOOL        Far;
 102    BOOL        Virtual;
 103    DWORD64     Reserved[3];
 104    KDHELP64    KdHelp;
 105  } STACKFRAME64, *LPSTACKFRAME64;
 106  #endif // !defined(__MINGW64_VERSION_MAJOR)
 107 #endif // __MINGW32__
 108
 109 typedef BOOL (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,
 110                       DWORD64 qwBaseAddress, PVOID lpBuffer, DWORD nSize,
 111                       LPDWORD lpNumberOfBytesRead);
 112
 113 typedef PVOID (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)( HANDLE ahProcess,
 114                       DWORD64 AddrBase);
 115
 116 typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,
 117                       DWORD64 Address);
 118
 119 typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,
 120                       HANDLE hThread, LPADDRESS64 lpaddr);
 121
 122 typedef BOOL(WINAPI *fpMiniDumpWriteDump)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
 123                                           PMINIDUMP_EXCEPTION_INFORMATION,
 124                                           PMINIDUMP_USER_STREAM_INFORMATION,
 125                                           PMINIDUMP_CALLBACK_INFORMATION);
 126 static fpMiniDumpWriteDump fMiniDumpWriteDump;
 127
 128 typedef BOOL (WINAPI *fpStackWalk64)(DWORD, HANDLE, HANDLE, LPSTACKFRAME64,
 129                       PVOID, PREAD_PROCESS_MEMORY_ROUTINE64,
 130                       PFUNCTION_TABLE_ACCESS_ROUTINE64,
 131                       PGET_MODULE_BASE_ROUTINE64,
 132                       PTRANSLATE_ADDRESS_ROUTINE64);
 133 static fpStackWalk64 fStackWalk64;
 134
 135 typedef DWORD64 (WINAPI *fpSymGetModuleBase64)(HANDLE, DWORD64);
 136 static fpSymGetModuleBase64 fSymGetModuleBase64;
 137
 138 typedef BOOL (WINAPI *fpSymGetSymFromAddr64)(HANDLE, DWORD64,
 139                       PDWORD64, PIMAGEHLP_SYMBOL64);
 140 static fpSymGetSymFromAddr64 fSymGetSymFromAddr64;
 141
 142 typedef BOOL (WINAPI *fpSymGetLineFromAddr64)(HANDLE, DWORD64,
 143                       PDWORD, PIMAGEHLP_LINE64);
 144 static fpSymGetLineFromAddr64 fSymGetLineFromAddr64;
 145
 146 typedef BOOL(WINAPI *fpSymGetModuleInfo64)(HANDLE hProcess, DWORD64 dwAddr,
 147                                            PIMAGEHLP_MODULE64 ModuleInfo);
 148 static fpSymGetModuleInfo64 fSymGetModuleInfo64;
 149
 150 typedef PVOID (WINAPI *fpSymFunctionTableAccess64)(HANDLE, DWORD64);
 151 static fpSymFunctionTableAccess64 fSymFunctionTableAccess64;
 152
 153 typedef DWORD (WINAPI *fpSymSetOptions)(DWORD);
 154 static fpSymSetOptions fSymSetOptions;
 155
 156 typedef BOOL (WINAPI *fpSymInitialize)(HANDLE, PCSTR, BOOL);
 157 static fpSymInitialize fSymInitialize;
 158
 159 typedef BOOL (WINAPI *fpEnumerateLoadedModules)(HANDLE,PENUMLOADED_MODULES_CALLBACK64,PVOID);
 160 static fpEnumerateLoadedModules fEnumerateLoadedModules;
 161
 162 static bool load64BitDebugHelp(void) {
 163   HMODULE hLib = ::LoadLibraryW(L"Dbghelp.dll");
 164   if (hLib) {
 165     fMiniDumpWriteDump = (fpMiniDumpWriteDump)
 166                       ::GetProcAddress(hLib, "MiniDumpWriteDump");
 167     fStackWalk64 = (fpStackWalk64)
 168                       ::GetProcAddress(hLib, "StackWalk64");
 169     fSymGetModuleBase64 = (fpSymGetModuleBase64)
 170                       ::GetProcAddress(hLib, "SymGetModuleBase64");
 171     fSymGetSymFromAddr64 = (fpSymGetSymFromAddr64)
 172                       ::GetProcAddress(hLib, "SymGetSymFromAddr64");
 173     fSymGetLineFromAddr64 = (fpSymGetLineFromAddr64)
 174                       ::GetProcAddress(hLib, "SymGetLineFromAddr64");
 175     fSymGetModuleInfo64 = (fpSymGetModuleInfo64)
 176                       ::GetProcAddress(hLib, "SymGetModuleInfo64");
 177     fSymFunctionTableAccess64 = (fpSymFunctionTableAccess64)
 178                      ::GetProcAddress(hLib, "SymFunctionTableAccess64");
 179     fSymSetOptions = (fpSymSetOptions)::GetProcAddress(hLib, "SymSetOptions");
 180     fSymInitialize = (fpSymInitialize)::GetProcAddress(hLib, "SymInitialize");
 181     fEnumerateLoadedModules = (fpEnumerateLoadedModules)
 182       ::GetProcAddress(hLib, "EnumerateLoadedModules64");
 183   }
 184   return fStackWalk64 && fSymInitialize && fSymSetOptions && fMiniDumpWriteDump;
 185 }
 186
 187 using namespace llvm;
 188
 189 // Forward declare.
 190 static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep);
 191 static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType);
 192
 193 // The function to call if ctrl-c is pressed.
 194 static void (*InterruptFunction)() = 0;
 195
 196 static std::vector<std::string> *FilesToRemove = NULL;
 197 static bool RegisteredUnhandledExceptionFilter = false;
 198 static bool CleanupExecuted = false;
 199 static PTOP_LEVEL_EXCEPTION_FILTER OldFilter = NULL;
 200
 201 // Windows creates a new thread to execute the console handler when an event
 202 // (such as CTRL/C) occurs.  This causes concurrency issues with the above
 203 // globals which this critical section addresses.
 204 static CRITICAL_SECTION CriticalSection;
 205 static bool CriticalSectionInitialized = false;
 206
 207 static StringRef Argv0;
 208
 209 enum {
 210 #if defined(_M_X64)
 211   NativeMachineType = IMAGE_FILE_MACHINE_AMD64
 212 #elif defined(_M_ARM64)
 213   NativeMachineType = IMAGE_FILE_MACHINE_ARM64
 214 #elif defined(_M_IX86)
 215   NativeMachineType = IMAGE_FILE_MACHINE_I386
 216 #elif defined(_M_ARM)
 217   NativeMachineType = IMAGE_FILE_MACHINE_ARMNT
 218 #else
 219   NativeMachineType = IMAGE_FILE_MACHINE_UNKNOWN
 220 #endif
 221 };
 222
 223 static bool printStackTraceWithLLVMSymbolizer(llvm::raw_ostream &OS,
 224                                               HANDLE hProcess, HANDLE hThread,
 225                                               STACKFRAME64 &StackFrameOrig,
 226                                               CONTEXT *ContextOrig) {
 227   // StackWalk64 modifies the incoming stack frame and context, so copy them.
 228   STACKFRAME64 StackFrame = StackFrameOrig;
 229
 230   // Copy the register context so that we don't modify it while we unwind. We
 231   // could use InitializeContext + CopyContext, but that's only required to get
 232   // at AVX registers, which typically aren't needed by StackWalk64. Reduce the
 233   // flag set to indicate that there's less data.
 234   CONTEXT Context = *ContextOrig;
 235   Context.ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
 236
 237   static void *StackTrace[256];
 238   size_t Depth = 0;
 239   while (fStackWalk64(NativeMachineType, hProcess, hThread, &StackFrame,
 240                       &Context, 0, fSymFunctionTableAccess64,
 241                       fSymGetModuleBase64, 0)) {
 242     if (StackFrame.AddrFrame.Offset == 0)
 243       break;
 244     StackTrace[Depth++] = (void *)(uintptr_t)StackFrame.AddrPC.Offset;
 245     if (Depth >= array_lengthof(StackTrace))
 246       break;
 247   }
 248
 249   return printSymbolizedStackTrace(Argv0, &StackTrace[0], Depth, OS);
 250 }
 251
 252 namespace {
 253 struct FindModuleData {
 254   void **StackTrace;
 255   int Depth;
 256   const char **Modules;
 257   intptr_t *Offsets;
 258   StringSaver *StrPool;
 259 };
 260 }
 261
 262 static BOOL CALLBACK findModuleCallback(PCSTR ModuleName,
 263                                         DWORD64 ModuleBase, ULONG ModuleSize,
 264                                         void *VoidData) {
 265   FindModuleData *Data = (FindModuleData*)VoidData;
 266   intptr_t Beg = ModuleBase;
 267   intptr_t End = Beg + ModuleSize;
 268   for (int I = 0; I < Data->Depth; I++) {
 269     if (Data->Modules[I])
 270       continue;
 271     intptr_t Addr = (intptr_t)Data->StackTrace[I];
 272     if (Beg <= Addr && Addr < End) {
 273       Data->Modules[I] = Data->StrPool->save(ModuleName).data();
 274       Data->Offsets[I] = Addr - Beg;
 275     }
 276   }
 277   return TRUE;
 278 }
 279
 280 static bool findModulesAndOffsets(void **StackTrace, int Depth,
 281                                   const char **Modules, intptr_t *Offsets,
 282                                   const char *MainExecutableName,
 283                                   StringSaver &StrPool) {
 284   if (!fEnumerateLoadedModules)
 285     return false;
 286   FindModuleData Data;
 287   Data.StackTrace = StackTrace;
 288   Data.Depth = Depth;
 289   Data.Modules = Modules;
 290   Data.Offsets = Offsets;
 291   Data.StrPool = &StrPool;
 292   fEnumerateLoadedModules(GetCurrentProcess(), findModuleCallback, &Data);
 293   return true;
 294 }
 295
 296 static void PrintStackTraceForThread(llvm::raw_ostream &OS, HANDLE hProcess,
 297                                      HANDLE hThread, STACKFRAME64 &StackFrame,
 298                                      CONTEXT *Context) {
 299   // Initialize the symbol handler.
 300   fSymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES);
 301   fSymInitialize(hProcess, NULL, TRUE);
 302
 303   // Try llvm-symbolizer first. llvm-symbolizer knows how to deal with both PDBs
 304   // and DWARF, so it should do a good job regardless of what debug info or
 305   // linker is in use.
 306   if (printStackTraceWithLLVMSymbolizer(OS, hProcess, hThread, StackFrame,
 307                                         Context)) {
 308     return;
 309   }
 310
 311   while (true) {
 312     if (!fStackWalk64(NativeMachineType, hProcess, hThread, &StackFrame,
 313                       Context, 0, fSymFunctionTableAccess64,
 314                       fSymGetModuleBase64, 0)) {
 315       break;
 316     }
 317
 318     if (StackFrame.AddrFrame.Offset == 0)
 319       break;
 320
 321     using namespace llvm;
 322     // Print the PC in hexadecimal.
 323     DWORD64 PC = StackFrame.AddrPC.Offset;
 324 #if defined(_M_X64) || defined(_M_ARM64)
 325     OS << format("0x%016llX", PC);
 326 #elif defined(_M_IX86) || defined(_M_ARM)
 327     OS << format("0x%08lX", static_cast<DWORD>(PC));
 328 #endif
 329
 330 // Print the parameters.  Assume there are four.
 331 #if defined(_M_X64) || defined(_M_ARM64)
 332     OS << format(" (0x%016llX 0x%016llX 0x%016llX 0x%016llX)",
 333             StackFrame.Params[0], StackFrame.Params[1], StackFrame.Params[2],
 334             StackFrame.Params[3]);
 335 #elif defined(_M_IX86) || defined(_M_ARM)
 336     OS << format(" (0x%08lX 0x%08lX 0x%08lX 0x%08lX)",
 337             static_cast<DWORD>(StackFrame.Params[0]),
 338             static_cast<DWORD>(StackFrame.Params[1]),
 339             static_cast<DWORD>(StackFrame.Params[2]),
 340             static_cast<DWORD>(StackFrame.Params[3]));
 341 #endif
 342     // Verify the PC belongs to a module in this process.
 343     if (!fSymGetModuleBase64(hProcess, PC)) {
 344       OS << " <unknown module>\n";
 345       continue;
 346     }
 347
 348     // Print the symbol name.
 349     char buffer[512];
 350     IMAGEHLP_SYMBOL64 *symbol = reinterpret_cast<IMAGEHLP_SYMBOL64 *>(buffer);
 351     memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL64));
 352     symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
 353     symbol->MaxNameLength = 512 - sizeof(IMAGEHLP_SYMBOL64);
 354
 355     DWORD64 dwDisp;
 356     if (!fSymGetSymFromAddr64(hProcess, PC, &dwDisp, symbol)) {
 357       OS << '\n';
 358       continue;
 359     }
 360
 361     buffer[511] = 0;
 362     if (dwDisp > 0)
 363       OS << format(", %s() + 0x%llX bytes(s)", (const char*)symbol->Name,
 364                    dwDisp);
 365     else
 366       OS << format(", %s", (const char*)symbol->Name);
 367
 368     // Print the source file and line number information.
 369     IMAGEHLP_LINE64 line = {};
 370     DWORD dwLineDisp;
 371     line.SizeOfStruct = sizeof(line);
 372     if (fSymGetLineFromAddr64(hProcess, PC, &dwLineDisp, &line)) {
 373       OS << format(", %s, line %lu", line.FileName, line.LineNumber);
 374       if (dwLineDisp > 0)
 375         OS << format(" + 0x%lX byte(s)", dwLineDisp);
 376     }
 377
 378     OS << '\n';
 379   }
 380 }
 381
 382 namespace llvm {
 383
 384 //===----------------------------------------------------------------------===//
 385 //=== WARNING: Implementation here must contain only Win32 specific code
 386 //===          and must not be UNIX code
 387 //===----------------------------------------------------------------------===//
 388
 389 #ifdef _MSC_VER
 390 /// Emulates hitting "retry" from an "abort, retry, ignore" CRT debug report
 391 /// dialog. "retry" raises an exception which ultimately triggers our stack
 392 /// dumper.
 393 static LLVM_ATTRIBUTE_UNUSED int
 394 AvoidMessageBoxHook(int ReportType, char *Message, int *Return) {
 395   // Set *Return to the retry code for the return value of _CrtDbgReport:
 396   // http://msdn.microsoft.com/en-us/library/8hyw4sy7(v=vs.71).aspx
 397   // This may also trigger just-in-time debugging via DebugBreak().
 398   if (Return)
 399     *Return = 1;
 400   // Don't call _CrtDbgReport.
 401   return TRUE;
 402 }
 403
 404 #endif
 405
 406 extern "C" void HandleAbort(int Sig) {
 407   if (Sig == SIGABRT) {
 408     LLVM_BUILTIN_TRAP;
 409   }
 410 }
 411
 412 static void InitializeThreading() {
 413   if (CriticalSectionInitialized)
 414     return;
 415
 416   // Now's the time to create the critical section. This is the first time
 417   // through here, and there's only one thread.
 418   InitializeCriticalSection(&CriticalSection);
 419   CriticalSectionInitialized = true;
 420 }
 421
 422 static void RegisterHandler() {
 423   // If we cannot load up the APIs (which would be unexpected as they should
 424   // exist on every version of Windows we support), we will bail out since
 425   // there would be nothing to report.
 426   if (!load64BitDebugHelp()) {
 427     assert(false && "These APIs should always be available");
 428     return;
 429   }
 430
 431   if (RegisteredUnhandledExceptionFilter) {
 432     EnterCriticalSection(&CriticalSection);
 433     return;
 434   }
 435
 436   InitializeThreading();
 437
 438   // Enter it immediately.  Now if someone hits CTRL/C, the console handler
 439   // can't proceed until the globals are updated.
 440   EnterCriticalSection(&CriticalSection);
 441
 442   RegisteredUnhandledExceptionFilter = true;
 443   OldFilter = SetUnhandledExceptionFilter(LLVMUnhandledExceptionFilter);
 444   SetConsoleCtrlHandler(LLVMConsoleCtrlHandler, TRUE);
 445
 446   // IMPORTANT NOTE: Caller must call LeaveCriticalSection(&CriticalSection) or
 447   // else multi-threading problems will ensue.
 448 }
 449
 450 // The public API
 451 bool sys::RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg) {
 452   RegisterHandler();
 453
 454   if (CleanupExecuted) {
 455     if (ErrMsg)
 456       *ErrMsg = "Process terminating -- cannot register for removal";
 457     return true;
 458   }
 459
 460   if (FilesToRemove == NULL)
 461     FilesToRemove = new std::vector<std::string>;
 462
 463   FilesToRemove->push_back(Filename);
 464
 465   LeaveCriticalSection(&CriticalSection);
 466   return false;
 467 }
 468
 469 // The public API
 470 void sys::DontRemoveFileOnSignal(StringRef Filename) {
 471   if (FilesToRemove == NULL)
 472     return;
 473
 474   RegisterHandler();
 475
 476   std::vector<std::string>::reverse_iterator I =
 477       find(reverse(*FilesToRemove), Filename);
 478   if (I != FilesToRemove->rend())
 479     FilesToRemove->erase(I.base()-1);
 480
 481   LeaveCriticalSection(&CriticalSection);
 482 }
 483
 484 void sys::DisableSystemDialogsOnCrash() {
 485   // Crash to stack trace handler on abort.
 486   signal(SIGABRT, HandleAbort);
 487
 488   // The following functions are not reliably accessible on MinGW.
 489 #ifdef _MSC_VER
 490   // We're already handling writing a "something went wrong" message.
 491   _set_abort_behavior(0, _WRITE_ABORT_MSG);
 492   // Disable Dr. Watson.
 493   _set_abort_behavior(0, _CALL_REPORTFAULT);
 494   _CrtSetReportHook(AvoidMessageBoxHook);
 495 #endif
 496
 497   // Disable standard error dialog box.
 498   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
 499                SEM_NOOPENFILEERRORBOX);
 500   _set_error_mode(_OUT_TO_STDERR);
 501 }
 502
 503 /// When an error signal (such as SIGABRT or SIGSEGV) is delivered to the
 504 /// process, print a stack trace and then exit.
 505 void sys::PrintStackTraceOnErrorSignal(StringRef Argv0,
 506                                        bool DisableCrashReporting) {
 507   ::Argv0 = Argv0;
 508
 509   if (DisableCrashReporting || getenv("LLVM_DISABLE_CRASH_REPORT"))
 510     Process::PreventCoreFiles();
 511
 512   DisableSystemDialogsOnCrash();
 513   RegisterHandler();
 514   LeaveCriticalSection(&CriticalSection);
 515 }
 516 }
 517
 518 #if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
 519 // Provide a prototype for RtlCaptureContext, mingw32 from mingw.org is
 520 // missing it but mingw-w64 has it.
 521 extern "C" VOID WINAPI RtlCaptureContext(PCONTEXT ContextRecord);
 522 #endif
 523
 524 void llvm::sys::PrintStackTrace(raw_ostream &OS) {
 525   STACKFRAME64 StackFrame = {};
 526   CONTEXT Context = {};
 527   ::RtlCaptureContext(&Context);
 528 #if defined(_M_X64)
 529   StackFrame.AddrPC.Offset = Context.Rip;
 530   StackFrame.AddrStack.Offset = Context.Rsp;
 531   StackFrame.AddrFrame.Offset = Context.Rbp;
 532 #elif defined(_M_IX86)
 533   StackFrame.AddrPC.Offset = Context.Eip;
 534   StackFrame.AddrStack.Offset = Context.Esp;
 535   StackFrame.AddrFrame.Offset = Context.Ebp;
 536 #elif defined(_M_ARM64)
 537   StackFrame.AddrPC.Offset = Context.Pc;
 538   StackFrame.AddrStack.Offset = Context.Sp;
 539   StackFrame.AddrFrame.Offset = Context.Fp;
 540 #elif defined(_M_ARM)
 541   StackFrame.AddrPC.Offset = Context.Pc;
 542   StackFrame.AddrStack.Offset = Context.Sp;
 543   StackFrame.AddrFrame.Offset = Context.R11;
 544 #endif
 545   StackFrame.AddrPC.Mode = AddrModeFlat;
 546   StackFrame.AddrStack.Mode = AddrModeFlat;
 547   StackFrame.AddrFrame.Mode = AddrModeFlat;
 548   PrintStackTraceForThread(OS, GetCurrentProcess(), GetCurrentThread(),
 549                            StackFrame, &Context);
 550 }
 551
 552
 553 void llvm::sys::SetInterruptFunction(void (*IF)()) {
 554   RegisterHandler();
 555   InterruptFunction = IF;
 556   LeaveCriticalSection(&CriticalSection);
 557 }
 558
 559 void llvm::sys::SetInfoSignalFunction(void (*Handler)()) {
 560   // Unimplemented.
 561 }
 562
 563
 564 /// Add a function to be called when a signal is delivered to the process. The
 565 /// handler can have a cookie passed to it to identify what instance of the
 566 /// handler it is.
 567 void llvm::sys::AddSignalHandler(sys::SignalHandlerCallback FnPtr,
 568                                  void *Cookie) {
 569   insertSignalHandler(FnPtr, Cookie);
 570   RegisterHandler();
 571   LeaveCriticalSection(&CriticalSection);
 572 }
 573
 574 static void Cleanup() {
 575   if (CleanupExecuted)
 576     return;
 577
 578   EnterCriticalSection(&CriticalSection);
 579
 580   // Prevent other thread from registering new files and directories for
 581   // removal, should we be executing because of the console handler callback.
 582   CleanupExecuted = true;
 583
 584   // FIXME: open files cannot be deleted.
 585   if (FilesToRemove != NULL)
 586     while (!FilesToRemove->empty()) {
 587       llvm::sys::fs::remove(FilesToRemove->back());
 588       FilesToRemove->pop_back();
 589     }
 590   llvm::sys::RunSignalHandlers();
 591   LeaveCriticalSection(&CriticalSection);
 592 }
 593
 594 void llvm::sys::RunInterruptHandlers() {
 595   // The interrupt handler may be called from an interrupt, but it may also be
 596   // called manually (such as the case of report_fatal_error with no registered
 597   // error handler). We must ensure that the critical section is properly
 598   // initialized.
 599   InitializeThreading();
 600   Cleanup();
 601 }
 602
 603 /// Find the Windows Registry Key for a given location.
 604 ///
 605 /// \returns a valid HKEY if the location exists, else NULL.
 606 static HKEY FindWERKey(const llvm::Twine &RegistryLocation) {
 607   HKEY Key;
 608   if (ERROR_SUCCESS != ::RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 609                                        RegistryLocation.str().c_str(), 0,
 610                                        KEY_QUERY_VALUE | KEY_READ, &Key))
 611     return NULL;
 612
 613   return Key;
 614 }
 615
 616 /// Populate ResultDirectory with the value for "DumpFolder" for a given
 617 /// Windows Registry key.
 618 ///
 619 /// \returns true if a valid value for DumpFolder exists, false otherwise.
 620 static bool GetDumpFolder(HKEY Key,
 621                           llvm::SmallVectorImpl<char> &ResultDirectory) {
 622   using llvm::sys::windows::UTF16ToUTF8;
 623
 624   if (!Key)
 625     return false;
 626
 627   DWORD BufferLengthBytes = 0;
 628
 629   if (ERROR_SUCCESS != ::RegGetValueW(Key, 0, L"DumpFolder", REG_EXPAND_SZ,
 630                                       NULL, NULL, &BufferLengthBytes))
 631     return false;
 632
 633   SmallVector<wchar_t, MAX_PATH> Buffer(BufferLengthBytes);
 634
 635   if (ERROR_SUCCESS != ::RegGetValueW(Key, 0, L"DumpFolder", REG_EXPAND_SZ,
 636                                       NULL, Buffer.data(), &BufferLengthBytes))
 637     return false;
 638
 639   DWORD ExpandBufferSize = ::ExpandEnvironmentStringsW(Buffer.data(), NULL, 0);
 640
 641   if (!ExpandBufferSize)
 642     return false;
 643
 644   SmallVector<wchar_t, MAX_PATH> ExpandBuffer(ExpandBufferSize);
 645
 646   if (ExpandBufferSize != ::ExpandEnvironmentStringsW(Buffer.data(),
 647                                                       ExpandBuffer.data(),
 648                                                       ExpandBufferSize))
 649     return false;
 650
 651   if (UTF16ToUTF8(ExpandBuffer.data(), ExpandBufferSize - 1, ResultDirectory))
 652     return false;
 653
 654   return true;
 655 }
 656
 657 /// Populate ResultType with a valid MINIDUMP_TYPE based on the value of
 658 /// "DumpType" for a given Windows Registry key.
 659 ///
 660 /// According to
 661 /// https://msdn.microsoft.com/en-us/library/windows/desktop/bb787181(v=vs.85).aspx
 662 /// valid values for DumpType are:
 663 ///   * 0: Custom dump
 664 ///   * 1: Mini dump
 665 ///   * 2: Full dump
 666 /// If "Custom dump" is specified then the "CustomDumpFlags" field is read
 667 /// containing a bitwise combination of MINIDUMP_TYPE values.
 668 ///
 669 /// \returns true if a valid value for ResultType can be set, false otherwise.
 670 static bool GetDumpType(HKEY Key, MINIDUMP_TYPE &ResultType) {
 671   if (!Key)
 672     return false;
 673
 674   DWORD DumpType;
 675   DWORD TypeSize = sizeof(DumpType);
 676   if (ERROR_SUCCESS != ::RegGetValueW(Key, NULL, L"DumpType", RRF_RT_REG_DWORD,
 677                                       NULL, &DumpType,
 678                                       &TypeSize))
 679     return false;
 680
 681   switch (DumpType) {
 682   case 0: {
 683     DWORD Flags = 0;
 684     if (ERROR_SUCCESS != ::RegGetValueW(Key, NULL, L"CustomDumpFlags",
 685                                         RRF_RT_REG_DWORD, NULL, &Flags,
 686                                         &TypeSize))
 687       return false;
 688
 689     ResultType = static_cast<MINIDUMP_TYPE>(Flags);
 690     break;
 691   }
 692   case 1:
 693     ResultType = MiniDumpNormal;
 694     break;
 695   case 2:
 696     ResultType = MiniDumpWithFullMemory;
 697     break;
 698   default:
 699     return false;
 700   }
 701   return true;
 702 }
 703
 704 /// Write a Windows dump file containing process information that can be
 705 /// used for post-mortem debugging.
 706 ///
 707 /// \returns zero error code if a mini dump created, actual error code
 708 /// otherwise.
 709 static std::error_code WINAPI
 710 WriteWindowsDumpFile(PMINIDUMP_EXCEPTION_INFORMATION ExceptionInfo) {
 711   using namespace llvm;
 712   using namespace llvm::sys;
 713
 714   std::string MainExecutableName = fs::getMainExecutable(nullptr, nullptr);
 715   StringRef ProgramName;
 716
 717   if (MainExecutableName.empty()) {
 718     // If we can't get the executable filename,
 719     // things are in worse shape than we realize
 720     // and we should just bail out.
 721     return mapWindowsError(::GetLastError());
 722   }
 723
 724   ProgramName = path::filename(MainExecutableName.c_str());
 725
 726   // The Windows Registry location as specified at
 727   // https://msdn.microsoft.com/en-us/library/windows/desktop/bb787181%28v=vs.85%29.aspx
 728   // "Collecting User-Mode Dumps" that may optionally be set to collect crash
 729   // dumps in a specified location.
 730   StringRef LocalDumpsRegistryLocation =
 731       "SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps";
 732
 733   // The key pointing to the Registry location that may contain global crash
 734   // dump settings.  This will be NULL if the location can not be found.
 735   ScopedRegHandle DefaultLocalDumpsKey(FindWERKey(LocalDumpsRegistryLocation));
 736
 737   // The key pointing to the Registry location that may contain
 738   // application-specific crash dump settings.  This will be NULL if the
 739   // location can not be found.
 740   ScopedRegHandle AppSpecificKey(
 741       FindWERKey(Twine(LocalDumpsRegistryLocation) + "\\" + ProgramName));
 742
 743   // Look to see if a dump type is specified in the registry; first with the
 744   // app-specific key and failing that with the global key.  If none are found
 745   // default to a normal dump (GetDumpType will return false either if the key
 746   // is NULL or if there is no valid DumpType value at its location).
 747   MINIDUMP_TYPE DumpType;
 748   if (!GetDumpType(AppSpecificKey, DumpType))
 749     if (!GetDumpType(DefaultLocalDumpsKey, DumpType))
 750       DumpType = MiniDumpNormal;
 751
 752   // Look to see if a dump location is specified in the registry; first with the
 753   // app-specific key and failing that with the global key.  If none are found
 754   // we'll just create the dump file in the default temporary file location
 755   // (GetDumpFolder will return false either if the key is NULL or if there is
 756   // no valid DumpFolder value at its location).
 757   bool ExplicitDumpDirectorySet = true;
 758   SmallString<MAX_PATH> DumpDirectory;
 759   if (!GetDumpFolder(AppSpecificKey, DumpDirectory))
 760     if (!GetDumpFolder(DefaultLocalDumpsKey, DumpDirectory))
 761       ExplicitDumpDirectorySet = false;
 762
 763   int FD;
 764   SmallString<MAX_PATH> DumpPath;
 765
 766   if (ExplicitDumpDirectorySet) {
 767     if (std::error_code EC = fs::create_directories(DumpDirectory))
 768       return EC;
 769     if (std::error_code EC = fs::createUniqueFile(
 770             Twine(DumpDirectory) + "\\" + ProgramName + ".%%%%%%.dmp", FD,
 771             DumpPath))
 772       return EC;
 773   } else if (std::error_code EC =
 774                  fs::createTemporaryFile(ProgramName, "dmp", FD, DumpPath))
 775     return EC;
 776
 777   // Our support functions return a file descriptor but Windows wants a handle.
 778   ScopedCommonHandle FileHandle(reinterpret_cast<HANDLE>(_get_osfhandle(FD)));
 779
 780   if (!fMiniDumpWriteDump(::GetCurrentProcess(), ::GetCurrentProcessId(),
 781                           FileHandle, DumpType, ExceptionInfo, NULL, NULL))
 782     return mapWindowsError(::GetLastError());
 783
 784   llvm::errs() << "Wrote crash dump file \"" << DumpPath << "\"\n";
 785   return std::error_code();
 786 }
 787
 788 static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep) {
 789   Cleanup();
 790
 791   // We'll automatically write a Minidump file here to help diagnose
 792   // the nasty sorts of crashes that aren't 100% reproducible from a set of
 793   // inputs (or in the event that the user is unable or unwilling to provide a
 794   // reproducible case).
 795   if (!llvm::sys::Process::AreCoreFilesPrevented()) {
 796     MINIDUMP_EXCEPTION_INFORMATION ExceptionInfo;
 797     ExceptionInfo.ThreadId = ::GetCurrentThreadId();
 798     ExceptionInfo.ExceptionPointers = ep;
 799     ExceptionInfo.ClientPointers = FALSE;
 800
 801     if (std::error_code EC = WriteWindowsDumpFile(&ExceptionInfo))
 802       llvm::errs() << "Could not write crash dump file: " << EC.message()
 803                    << "\n";
 804   }
 805
 806   // Initialize the STACKFRAME structure.
 807   STACKFRAME64 StackFrame = {};
 808
 809 #if defined(_M_X64)
 810   StackFrame.AddrPC.Offset = ep->ContextRecord->Rip;
 811   StackFrame.AddrPC.Mode = AddrModeFlat;
 812   StackFrame.AddrStack.Offset = ep->ContextRecord->Rsp;
 813   StackFrame.AddrStack.Mode = AddrModeFlat;
 814   StackFrame.AddrFrame.Offset = ep->ContextRecord->Rbp;
 815   StackFrame.AddrFrame.Mode = AddrModeFlat;
 816 #elif defined(_M_IX86)
 817   StackFrame.AddrPC.Offset = ep->ContextRecord->Eip;
 818   StackFrame.AddrPC.Mode = AddrModeFlat;
 819   StackFrame.AddrStack.Offset = ep->ContextRecord->Esp;
 820   StackFrame.AddrStack.Mode = AddrModeFlat;
 821   StackFrame.AddrFrame.Offset = ep->ContextRecord->Ebp;
 822   StackFrame.AddrFrame.Mode = AddrModeFlat;
 823 #elif defined(_M_ARM64) || defined(_M_ARM)
 824   StackFrame.AddrPC.Offset = ep->ContextRecord->Pc;
 825   StackFrame.AddrPC.Mode = AddrModeFlat;
 826   StackFrame.AddrStack.Offset = ep->ContextRecord->Sp;
 827   StackFrame.AddrStack.Mode = AddrModeFlat;
 828 #if defined(_M_ARM64)
 829   StackFrame.AddrFrame.Offset = ep->ContextRecord->Fp;
 830 #else
 831   StackFrame.AddrFrame.Offset = ep->ContextRecord->R11;
 832 #endif
 833   StackFrame.AddrFrame.Mode = AddrModeFlat;
 834 #endif
 835
 836   HANDLE hProcess = GetCurrentProcess();
 837   HANDLE hThread = GetCurrentThread();
 838   PrintStackTraceForThread(llvm::errs(), hProcess, hThread, StackFrame,
 839                            ep->ContextRecord);
 840
 841   _exit(ep->ExceptionRecord->ExceptionCode);
 842 }
 843
 844 static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType) {
 845   // We are running in our very own thread, courtesy of Windows.
 846   EnterCriticalSection(&CriticalSection);
 847   Cleanup();
 848
 849   // If an interrupt function has been set, go and run one it; otherwise,
 850   // the process dies.
 851   void (*IF)() = InterruptFunction;
 852   InterruptFunction = 0;      // Don't run it on another CTRL-C.
 853
 854   if (IF) {
 855     // Note: if the interrupt function throws an exception, there is nothing
 856     // to catch it in this thread so it will kill the process.
 857     IF();                     // Run it now.
 858     LeaveCriticalSection(&CriticalSection);
 859     return TRUE;              // Don't kill the process.
 860   }
 861
 862   // Allow normal processing to take place; i.e., the process dies.
 863   LeaveCriticalSection(&CriticalSection);
 864   return FALSE;
 865 }
 866
 867 #if __MINGW32__
 868  // We turned these warnings off for this file so that MinGW-g++ doesn't
 869  // complain about the ll format specifiers used.  Now we are turning the
 870  // warnings back on.  If MinGW starts to support diagnostic stacks, we can
 871  // replace this with a pop.
 872  #pragma GCC diagnostic warning "-Wformat"
 873  #pragma GCC diagnostic warning "-Wformat-extra-args"
 874 #endif