Record the last fatal error message for crash reporting on Windows

Author: hjyamauchi

include/swift/Runtime/Debug.h

@@ -60,6 +60,13 @@ static inline const char *CRGetCrashLogMessage() {
 SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
 static inline void CRSetCrashLogMessage(const char *) {}
 
+#if defined(_WIN32)
+extern "C" {
+SWIFT_ATTRIBUTE_FOR_EXPORTS
+extern char* gLastFatalErrorMessage;
+}
+#endif // _WIN32
+
 #endif
 
 namespace swift {

stdlib/public/runtime/CrashReporter.cpp

@@ -33,3 +33,10 @@ struct crashreporter_annotations_t gCRAnnotations __attribute__((
 }
 
 #endif
+
+#if defined(_WIN32)
+extern "C" {
+SWIFT_ATTRIBUTE_FOR_EXPORTS
+char* gLastFatalErrorMessage = nullptr;
+}
+#endif

stdlib/public/runtime/Errors.cpp

@@ -70,6 +70,10 @@
 #include "swift/Runtime/Atomic.h"
 #endif // SWIFT_HAVE_CRASHREPORTERCLIENT
 
+#if defined(_WIN32)
+#include "swift/Runtime/Atomic.h"
+#endif // _WIN32
+
 #include "BacktracePrivate.h"
 
 namespace FatalErrorFlags {
@@ -268,16 +272,15 @@ void swift::printCurrentBacktrace(unsigned framesToSkip) {
     fprintf(stderr, "<backtrace unavailable>\n");
 }
 
-// Report a message to any forthcoming crash log.
-static void
-reportOnCrash(uint32_t flags, const char *message)
-{
-#ifdef SWIFT_HAVE_CRASHREPORTERCLIENT
+#if defined(SWIFT_HAVE_CRASHREPORTERCLIENT) || defined(_WIN32)
+// Update the last fatal error message for crash reporting.
+static void updateLastFatalErrorMessage(void* location,
+                                        const char* message) {
   char *oldMessage = nullptr;
   char *newMessage = nullptr;
 
   oldMessage = std::atomic_load_explicit(
-    (volatile std::atomic<char *> *)&gCRAnnotations.message,
+    (volatile std::atomic<char *> *)location,
     SWIFT_MEMORY_ORDER_CONSUME);
 
   do {
@@ -292,13 +295,25 @@ reportOnCrash(uint32_t flags, const char *message)
       newMessage = strdup(message);
     }
   } while (!std::atomic_compare_exchange_strong_explicit(
-             (volatile std::atomic<char *> *)&gCRAnnotations.message,
+             (volatile std::atomic<char *> *)location,
              &oldMessage, newMessage,
              std::memory_order_release,
              SWIFT_MEMORY_ORDER_CONSUME));
+}
+#endif  // SWIFT_HAVE_CRASHREPORTERCLIENT || _WIN32
+
+// Report a message to any forthcoming crash log.
+static void
+reportOnCrash(uint32_t flags, const char *message)
+{
+#ifdef SWIFT_HAVE_CRASHREPORTERCLIENT
+  updateLastFatalErrorMessage(&gCRAnnotations.message, message);
+#elif defined(_WIN32)
+  // Make the fatal error message accessible for Windows dump tools.
+  updateLastFatalErrorMessage(&gLastFatalErrorMessage, message);
 #else
   // empty
-#endif // SWIFT_HAVE_CRASHREPORTERCLIENT
+#endif // SWIFT_HAVE_CRASHREPORTERCLIENT || _WIN32
 }
 
 // Report a message to system console and stderr.

test/Runtime/fatal-message-crash-dump-win.swift

@@ -0,0 +1,43 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: not %target-run %t/a.out 2>&1 | %FileCheck %s
+// REQUIRES: executable_test
+// REQUIRES: OS=windows-msvc
+
+// CHECK: Fatal error message: a/fatal-message-crash-dump-win.swift:{{[0-9]+}}: Fatal error: Fatal crash!
+
+import WinSDK
+
+func crash() {
+    fatalError("Fatal crash!")
+}
+
+func setupHandler() {
+    SetUnhandledExceptionFilter { exception_pointers in
+        guard let hSwiftCore = GetModuleHandleA("swiftCore.dll") else {
+            return EXCEPTION_EXECUTE_HANDLER
+        }
+        let ppLastFatalErrorMessage = unsafeBitCast(
+            GetProcAddress(hSwiftCore, "gLastFatalErrorMessage"),
+            to: UnsafeMutablePointer<UnsafeMutablePointer<UInt8>>.self)
+        if ppLastFatalErrorMessage == UnsafeMutablePointer<UnsafeMutablePointer<UInt8>>(bitPattern: 0) {
+            return EXCEPTION_EXECUTE_HANDLER
+        }
+        let pLastFatalErrorMessage = ppLastFatalErrorMessage.pointee;
+        if pLastFatalErrorMessage == UnsafeMutablePointer<UInt8>(bitPattern: 0) {
+            return EXCEPTION_EXECUTE_HANDLER
+        }
+        let message = "Fatal error message: \(String(cString: pLastFatalErrorMessage))"
+        message.utf8CString.withUnsafeBufferPointer { buf in
+            let addr = buf.baseAddress!
+            let count = DWORD(buf.count)
+            let stderr = GetStdHandle(STD_ERROR_HANDLE)
+            WriteFile(stderr, addr, count, nil, nil)
+        }
+        return EXCEPTION_EXECUTE_HANDLER
+    }
+}
+
+setupHandler()
+crash()