[Windows] Implementing backtracing of self

[zturner]

Summary

llvm::sys::PrintBacktrace(FILE*) is supposed to print a backtrace
of the current thread given the current PC.  This function was
unimplemented on Windows, and instead the only time we could
print a backtrace was as the result of an exception through
LLVMUnhandledExceptionFilter.

This patch implements backtracing of self by using setjmp() to
get the current values of the instruction pointer, frame pointer,
and stack pointer, and then calling the same function already
used by LLVM to print backtraces given the same information.

The one difference is that with an exception, we have a full
CONTEXT structure that we can pass to StackWalk64.  MSDN documents
that this is an optional field to StackWalk64, which only provides
the function the ability to handle more situations.  Testing shows
that even without this function, the results are still good.

[rnk]

lgtm

I think this is actually enough information to unwind on x64, so long as the 'Frame' field is set right.

lib/Support/Windows/Signals.inc

388

Zero StackFrame so we don't give uninitialized memory to the unwinder.

[zturner]

lib/Support/Windows/Signals.inc

388

Thanks, I missed that. That led me to find one more improvement, which is that we can set the value of StackFrame.ReturnAddr to _GetReturnAddress(). I don't know how much it'll help, but it certainly won't hurt, so I'll submit the patch with your suggested improvement as well the one to set StackFrame.AddrReturn.

[silvas]

Random thing I noticed:

_JUMP_BUFFER *JumpBuf = reinterpret_cast<__JUMP_BUFFER *>(Buffer);

The cast type has two underscores, but the variable type has one underscore
(__JUMP_BUFFER and _JUMP_BUFFER respectively). A comment would be nice.

• Sean Silva

[zturner]

Thanks for noticing that. the actual type is declared typedef struct
__JUMP_BUFFER
{ ... } _JUMP_BUFFER. So I will just stick with the single underscore
version in both places.

[zturner]

I found a problem with my initial implementation. MSDN says that on x64, a full CONTEXT structure is required. So this patch was broken for x64. Luckily I learned of a new function which I was previously unaware of, RtlCaptureContext(). It captures a context for the current thread which is exactly what we need. This patch is updated to reflect these changes, and we now no longer require setjmp.

Will commit this tomorrow.

[majnemer]

lib/Support/Windows/Signals.inc

15

This is dead now, no?

387–388

You could simplify this a little bit more if you'd like with:

STACKFRAME64 StackFrame = {};
CONTEXT Context = {};

[zturner]

Yes that line is dead. I caught it after uploading the patch, but didn't
think it was worth uploading a new patch over. In any case, I'll remove it
before comitting. Thanks!

[majnemer]

llvm/trunk/lib/Support/Windows/Signals.inc

181–183 ↗

(On Diff #21284)

Might be good to make this guarded by #elif define(_M_IX86).

393 ↗

(On Diff #21284)

This should be #elif defined(_M_IX86)

[zturner]

What's the catch-call case then? Just return from the function and don't
print anything?

[zturner]

catch-all*

[majnemer]

In D8068#135009, @zturner wrote:

What's the catch-call case then? Just return from the function and don't
print anything?

That or #error unimplemented

lib/Support/Windows/Signals.inc

 
 #include "llvm/Support/FileSystem.h"
 #include <algorithm>
+#include <setjmp.h>
 #include <signal.h>
 #include <stdio.h>
 #include <vector>

 // globals which this critical section addresses.
 static CRITICAL_SECTION CriticalSection;
 
+static void PrintStackTraceForThread(FILE *File, HANDLE hProcess,
+                                     HANDLE hThread, STACKFRAME64 &StackFrame,
+                                     CONTEXT *Context) {
+  DWORD machineType;
+#if defined(_M_X64)
+  machineType = IMAGE_FILE_MACHINE_AMD64;
+#else
+  machineType = IMAGE_FILE_MACHINE_I386;
+#endif
+
+  // Initialize the symbol handler.
+  SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES);
+  SymInitialize(hProcess, NULL, TRUE);
+
+  while (true) {
+    if (!StackWalk64(machineType, hProcess, hThread, &StackFrame, Context, NULL,
+                     SymFunctionTableAccess64, SymGetModuleBase64, NULL)) {
+      break;
+    }
+
+    if (StackFrame.AddrFrame.Offset == 0)
+      break;
+
+    // Print the PC in hexadecimal.
+    DWORD64 PC = StackFrame.AddrPC.Offset;
+#if defined(_M_X64)
+    fprintf(File, "0x%016llX", PC);
+#elif defined(_M_IX86)
+    fprintf(File, "0x%08lX", static_cast<DWORD>(PC));
+#endif
+
+// Print the parameters.  Assume there are four.
+#if defined(_M_X64)
+    fprintf(File, " (0x%016llX 0x%016llX 0x%016llX 0x%016llX)",
+            StackFrame.Params[0], StackFrame.Params[1], StackFrame.Params[2],
+            StackFrame.Params[3]);
+#elif defined(_M_IX86)
+    fprintf(File, " (0x%08lX 0x%08lX 0x%08lX 0x%08lX)",
+            static_cast<DWORD>(StackFrame.Params[0]),
+            static_cast<DWORD>(StackFrame.Params[1]),
+            static_cast<DWORD>(StackFrame.Params[2]),
+            static_cast<DWORD>(StackFrame.Params[3]));
+#endif
+    // Verify the PC belongs to a module in this process.
+    if (!SymGetModuleBase64(hProcess, PC)) {
+      fputs(" <unknown module>\n", File);
+      continue;
+    }
+
+    // Print the symbol name.
+    char buffer[512];
+    IMAGEHLP_SYMBOL64 *symbol = reinterpret_cast<IMAGEHLP_SYMBOL64 *>(buffer);
+    memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL64));
+    symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
+    symbol->MaxNameLength = 512 - sizeof(IMAGEHLP_SYMBOL64);
+
+    DWORD64 dwDisp;
+    if (!SymGetSymFromAddr64(hProcess, PC, &dwDisp, symbol)) {
+      fputc('\n', File);
+      continue;
+    }
+
+    buffer[511] = 0;
+    if (dwDisp > 0)
+      fprintf(File, ", %s() + 0x%llX bytes(s)", symbol->Name, dwDisp);
+    else
+      fprintf(File, ", %s", symbol->Name);
+
+    // Print the source file and line number information.
+    IMAGEHLP_LINE64 line;
+    DWORD dwLineDisp;
+    memset(&line, 0, sizeof(line));
+    line.SizeOfStruct = sizeof(line);
+    if (SymGetLineFromAddr64(hProcess, PC, &dwLineDisp, &line)) {
+      fprintf(File, ", %s, line %lu", line.FileName, line.LineNumber);
+      if (dwLineDisp > 0)
+        fprintf(File, " + 0x%lX byte(s)", dwLineDisp);
+    }
+
+    fputc('\n', File);
+  }
+}
+
 namespace llvm {
 
 //===----------------------------------------------------------------------===//

   LeaveCriticalSection(&CriticalSection);
 }
 
-void llvm::sys::PrintStackTrace(FILE *) {
-  // FIXME: Implement.
+void llvm::sys::PrintStackTrace(FILE *File) {
+
+  STACKFRAME64 StackFrame;
+  jmp_buf Buffer;
+  setjmp(Buffer);
+  _JUMP_BUFFER *JumpBuf = reinterpret_cast<__JUMP_BUFFER *>(Buffer);
+#if defined(_M_X64)
+  StackFrame.AddrPC.Offset = JumpBuf->Rip;
+  StackFrame.AddrPC.Mode = AddrModeFlat;
+  StackFrame.AddrStack.Offset = JumpBuf->Rsp;
+  StackFrame.AddrStack.Mode = AddrModeFlat;
+  StackFrame.AddrFrame.Offset = JumpBuf->Frame;
+  StackFrame.AddrFrame.Mode = AddrModeFlat;
+#else
+  StackFrame.AddrPC.Offset = JumpBuf->Eip;
+  StackFrame.AddrPC.Mode = AddrModeFlat;
+  StackFrame.AddrStack.Offset = JumpBuf->Esp;
+  StackFrame.AddrStack.Mode = AddrModeFlat;
+  StackFrame.AddrFrame.Offset = JumpBuf->Ebp;
+  StackFrame.AddrFrame.Mode = AddrModeFlat;
+#endif
+  PrintStackTraceForThread(File, GetCurrentProcess(), GetCurrentThread(),
+                           StackFrame, nullptr);
 }
 
 

   STACKFRAME64 StackFrame;
   memset(&StackFrame, 0, sizeof(StackFrame));
 
-  DWORD machineType;
 #if defined(_M_X64)
-  machineType = IMAGE_FILE_MACHINE_AMD64;
   StackFrame.AddrPC.Offset = ep->ContextRecord->Rip;
   StackFrame.AddrPC.Mode = AddrModeFlat;
   StackFrame.AddrStack.Offset = ep->ContextRecord->Rsp;

   StackFrame.AddrFrame.Offset = ep->ContextRecord->Rbp;
   StackFrame.AddrFrame.Mode = AddrModeFlat;
 #elif defined(_M_IX86)
-  machineType = IMAGE_FILE_MACHINE_I386;
   StackFrame.AddrPC.Offset = ep->ContextRecord->Eip;
   StackFrame.AddrPC.Mode = AddrModeFlat;
   StackFrame.AddrStack.Offset = ep->ContextRecord->Esp;

 
   HANDLE hProcess = GetCurrentProcess();
   HANDLE hThread = GetCurrentThread();
-
-  // Initialize the symbol handler.
-  SymSetOptions(SYMOPT_DEFERRED_LOADS|SYMOPT_LOAD_LINES);
-  SymInitialize(hProcess, NULL, TRUE);
-
-  while (true) {
-    if (!StackWalk64(machineType, hProcess, hThread, &StackFrame,
-                   ep->ContextRecord, NULL, SymFunctionTableAccess64,
-                   SymGetModuleBase64, NULL)) {
-      break;
-    }
-
-    if (StackFrame.AddrFrame.Offset == 0)
-      break;
-
-    // Print the PC in hexadecimal.
-    DWORD64 PC = StackFrame.AddrPC.Offset;
-#if defined(_M_X64)
-    fprintf(stderr, "0x%016llX", PC);
-#elif defined(_M_IX86)
-    fprintf(stderr, "0x%08lX", static_cast<DWORD>(PC));
-#endif
-
-    // Print the parameters.  Assume there are four.
-#if defined(_M_X64)
-    fprintf(stderr, " (0x%016llX 0x%016llX 0x%016llX 0x%016llX)",
-                StackFrame.Params[0],
-                StackFrame.Params[1],
-                StackFrame.Params[2],
-                StackFrame.Params[3]);
-#elif defined(_M_IX86)
-    fprintf(stderr, " (0x%08lX 0x%08lX 0x%08lX 0x%08lX)",
-                static_cast<DWORD>(StackFrame.Params[0]),
-                static_cast<DWORD>(StackFrame.Params[1]),
-                static_cast<DWORD>(StackFrame.Params[2]),
-                static_cast<DWORD>(StackFrame.Params[3]));
-#endif
-    // Verify the PC belongs to a module in this process.
-    if (!SymGetModuleBase64(hProcess, PC)) {
-      fputs(" <unknown module>\n", stderr);
-      continue;
-    }
-
-    // Print the symbol name.
-    char buffer[512];
-    IMAGEHLP_SYMBOL64 *symbol = reinterpret_cast<IMAGEHLP_SYMBOL64 *>(buffer);
-    memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL64));
-    symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
-    symbol->MaxNameLength = 512 - sizeof(IMAGEHLP_SYMBOL64);
-
-    DWORD64 dwDisp;
-    if (!SymGetSymFromAddr64(hProcess, PC, &dwDisp, symbol)) {
-      fputc('\n', stderr);
-      continue;
-    }
-
-    buffer[511] = 0;
-    if (dwDisp > 0)
-      fprintf(stderr, ", %s() + 0x%llX bytes(s)", symbol->Name, dwDisp);
-    else
-      fprintf(stderr, ", %s", symbol->Name);
-
-    // Print the source file and line number information.
-    IMAGEHLP_LINE64 line;
-    DWORD dwLineDisp;
-    memset(&line, 0, sizeof(line));
-    line.SizeOfStruct = sizeof(line);
-    if (SymGetLineFromAddr64(hProcess, PC, &dwLineDisp, &line)) {
-      fprintf(stderr, ", %s, line %lu", line.FileName, line.LineNumber);
-      if (dwLineDisp > 0)
-        fprintf(stderr, " + 0x%lX byte(s)", dwLineDisp);
-    }
-
-    fputc('\n', stderr);
-  }
+  PrintStackTraceForThread(stderr, hProcess, hThread, StackFrame,
+                           ep->ContextRecord);
 
   _exit(ep->ExceptionRecord->ExceptionCode);
 }