diff --git a/.github/workflows/msvc.yml b/.github/workflows/msvc.yml index 241cc551d6..6e12b8c075 100644 --- a/.github/workflows/msvc.yml +++ b/.github/workflows/msvc.yml @@ -11,16 +11,16 @@ jobs: fail-fast: false matrix: platform: - - { name: Windows (x64), flags: -A x64, project: VisualC/SDL.sln, projectflags: '/p:Platform=x64' } - - { name: Windows (x86), flags: -A Win32, project: VisualC/SDL.sln, projectflags: '/p:Platform=Win32' } - - { name: Windows static VCRT (x64), flags: -A x64 -DSDL_FORCE_STATIC_VCRT=ON } - - { name: Windows static VCRT (x86), flags: -A Win32 -DSDL_FORCE_STATIC_VCRT=ON } - - { name: Windows (clang-cl x64), flags: -T ClangCL -A x64 } - - { name: Windows (clang-cl x86), flags: -T ClangCL -A Win32 } - - { name: Windows (ARM), flags: -A ARM } - - { name: Windows (ARM64), flags: -A ARM64 } + - { name: Windows (x64), flags: -A x64, project: VisualC/SDL.sln, projectflags: '/p:Platform=x64', artifact: 'SDL-VC-x64' } + - { name: Windows (x86), flags: -A Win32, project: VisualC/SDL.sln, projectflags: '/p:Platform=Win32', artifact: 'SDL-VC-x86' } + - { name: Windows static VCRT (x64), flags: -A x64 -DSDL_FORCE_STATIC_VCRT=ON, artifact: 'SDL-static-crt-x64' } + - { name: Windows static VCRT (x86), flags: -A Win32 -DSDL_FORCE_STATIC_VCRT=ON, artifact: 'SDL-static-crt-x86' } + - { name: Windows (clang-cl x64), flags: -T ClangCL -A x64, artifact: 'SDL-clang-cl-x64' } + - { name: Windows (clang-cl x86), flags: -T ClangCL -A Win32, artifact: 'SDL-clang-cl-x86' } + - { name: Windows (ARM), flags: -A ARM, artifact: 'SDL-VC-arm32' } + - { name: Windows (ARM64), flags: -A ARM64, artifact: 'SDL-VC-arm64' } - { name: UWP (x64), flags: -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0" -DSDL_TESTS=OFF, nowerror: true, - project: VisualC-WinRT/SDL-UWP.sln, projectflags: '/p:Platform=x64 /p:WindowsTargetPlatformVersion=10.0.17763.0' } + project: VisualC-WinRT/SDL-UWP.sln, projectflags: '/p:Platform=x64 /p:WindowsTargetPlatformVersion=10.0.17763.0', artifact: 'SDL-VC-UWP' } steps: - uses: actions/checkout@v4 @@ -51,11 +51,13 @@ jobs: -DSDL_INSTALL_TESTS=ON ` -DSDL_VENDOR_INFO="Github Workflow" ` -DSDL2_DISABLE_INSTALL=OFF ` + -DSDLTEST_PROCDUMP=ON ` ${{ matrix.platform.flags }} ` -DCMAKE_INSTALL_PREFIX=prefix - name: Build (CMake) run: cmake --build build/ --config Release --parallel - name: Run build-time tests + id: tests if: "! contains(matrix.platform.name, 'ARM')" run: | $env:SDL_TESTS_QUICK=1 @@ -71,10 +73,19 @@ jobs: -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} ` ${{ matrix.platform.flags }} cmake --build cmake_config_build --config Release - - name: Add msbuild to PATH if: ${{ matrix.platform.project != '' }} uses: microsoft/setup-msbuild@v2 - name: Build msbuild if: ${{ matrix.platform.project != '' }} run: msbuild ${{ matrix.platform.project }} /m /p:BuildInParallel=true /p:Configuration=Release ${{ matrix.platform.projectflags }} + - uses: actions/upload-artifact@v4 + if: ${{ always() && steps.tests.outcome == 'failure' }} + with: + if-no-files-found: ignore + name: '${{ matrix.platform.artifact }}-minidumps' + path: | + build/**/*.dmp + build/**/*.exe + build/**/*.dll + build/**/*.pdb diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 93ea43b67a..a395107029 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -9,6 +9,16 @@ set(SDL_TEST_EXECUTABLES) set(SDL_TESTS_NONINTERACTIVE) set(SDL_TESTS_NEEDS_RESOURCES) +if(WIN32 AND NOT WINDOWS_STORE) + option(SDLTEST_PROCDUMP "Run tests using sdlprocdump for minidump generation" OFF) + add_executable(sdlprocdump win32/sdlprocdump.c) + if(SDLTEST_PROCDUMP) + set(CMAKE_TEST_LAUNCHER "$") + else() + set_property(TARGET sdlprocdump PROPERTY EXCLUDE_FROM_ALL "1") + endif() +endif() + set(SDLTEST_TARGETS ) macro(sdltest_link_librararies) diff --git a/test/win32/sdlprocdump.c b/test/win32/sdlprocdump.c new file mode 100644 index 0000000000..08409ab314 --- /dev/null +++ b/test/win32/sdlprocdump.c @@ -0,0 +1,624 @@ +#include +#include + +#include +#include +#include +#include + +#define DUMP_FOLDER "minidumps" +#define APPNAME "SDLPROCDUMP" + +#if defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) ||defined( __i386) || defined(_M_IX86) +#define SDLPROCDUMP_CPU_X86 1 +#elif defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64) +#define SDLPROCDUMP_CPU_X64 1 +#elif defined(__aarch64__) || defined(_M_ARM64) +#define SDLPROCDUMP_CPU_ARM64 1 +#elif defined(__arm__) || defined(_M_ARM) +#define SDLPROCDUMP_CPU_ARM32 1 +#endif + +#if defined(SDLPROCDUMP_CPU_X86) || defined(SDLPROCDUMP_CPU_X64) || defined(SDLPROCDUMP_CPU_ARM32) || defined(SDLPROCDUMP_CPU_ARM64) +#define SDLPROCDUMP_PRINTSTACK +#else +#pragma message("Unsupported architecture: don't know how to StackWalk") +#endif + +#ifndef EXCEPTION_SOFTWARE_ORIGINATE +#define EXCEPTION_SOFTWARE_ORIGINATE 0x80 +#endif + +static void printf_message(const char *format, ...) { + va_list ap; + fprintf(stderr, "[" APPNAME "] "); + va_start(ap, format); + vfprintf(stderr, format, ap); + va_end(ap); + fprintf(stderr, "\n"); +} + +static void printf_windows_message(const char *format, ...) { + va_list ap; + char win_msg[512]; + size_t win_msg_len; + + FormatMessageA( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + win_msg, sizeof(win_msg)/sizeof(*win_msg), + NULL); + win_msg_len = strlen(win_msg); + while (win_msg[win_msg_len-1] == '\r' || win_msg[win_msg_len-1] == '\n' || win_msg[win_msg_len-1] == ' ') { + win_msg[win_msg_len-1] = '\0'; + win_msg_len--; + } + fprintf(stderr, "[" APPNAME "] "); + va_start(ap, format); + vfprintf(stderr, format, ap); + va_end(ap); + fprintf(stderr, " (%s)\n", win_msg); +} + +struct { + HMODULE module; + BOOL (WINAPI *pSymInitialize)(HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess); + BOOL (WINAPI *pSymCleanup)(HANDLE hProcess); + BOOL (WINAPI *pMiniDumpWriteDump)( + HANDLE hProcess, + DWORD ProcessId, + HANDLE hFile, + MINIDUMP_TYPE DumpType, + PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, + PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, + PMINIDUMP_CALLBACK_INFORMATION CallbackParam); + BOOL (WINAPI *pSymFromAddr)(HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFO Symbol); + BOOL (WINAPI *pSymGetLineFromAddr64)(HANDLE hProcess, DWORD64 qwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line); + BOOL (WINAPI *pStackWalk64)(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, + PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, + PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, + PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress); + PVOID (WINAPI *pSymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase); + DWORD64 (WINAPI *pSymGetModuleBase64)(HANDLE hProcess, DWORD64 qwAddr); + BOOL (WINAPI *pSymGetModuleInfo64)(HANDLE hProcess, DWORD64 qwAddr, PIMAGEHLP_MODULE64 ModuleInfo); + BOOL (WINAPI *pSymRefreshModuleList)(HANDLE hProcess); +} dyn_dbghelp; + +static void load_dbghelp(void) { + if (dyn_dbghelp.module) { + return; + } + dyn_dbghelp.module = LoadLibraryA("dbghelp.dll"); + if (!dyn_dbghelp.module) { + printf_message("Failed to load dbghelp.dll"); + goto failed; + } + dyn_dbghelp.pSymInitialize = (void *)GetProcAddress(dyn_dbghelp.module, "SymInitialize"); + dyn_dbghelp.pSymCleanup = (void *)GetProcAddress(dyn_dbghelp.module, "SymCleanup"); + dyn_dbghelp.pMiniDumpWriteDump = (void *)GetProcAddress(dyn_dbghelp.module, "MiniDumpWriteDump"); + dyn_dbghelp.pSymFromAddr = (void *)GetProcAddress(dyn_dbghelp.module, "SymFromAddr"); + dyn_dbghelp.pStackWalk64 = (void *)GetProcAddress(dyn_dbghelp.module, "StackWalk64"); + dyn_dbghelp.pSymGetLineFromAddr64 = (void *)GetProcAddress(dyn_dbghelp.module, "SymGetLineFromAddr64"); + dyn_dbghelp.pSymFunctionTableAccess64 = (void *)GetProcAddress(dyn_dbghelp.module, "SymFunctionTableAccess64"); + dyn_dbghelp.pSymGetModuleBase64 = (void *)GetProcAddress(dyn_dbghelp.module, "SymGetModuleBase64"); + dyn_dbghelp.pSymGetModuleInfo64 = (void *)GetProcAddress(dyn_dbghelp.module, "SymGetModuleInfo64"); + dyn_dbghelp.pSymRefreshModuleList = (void *)GetProcAddress(dyn_dbghelp.module, "SymRefreshModuleList"); + return; +failed: + if (dyn_dbghelp.module) { + FreeLibrary(dyn_dbghelp.module); + dyn_dbghelp.module = NULL; + } +} + +static void unload_dbghelp(void) { + if (!dyn_dbghelp.module) { + return; + } + FreeLibrary(dyn_dbghelp.module); + memset(&dyn_dbghelp, 0, sizeof(dyn_dbghelp)); +} + +#define FOREACH_EXCEPTION_CODES(X) \ + X(EXCEPTION_ACCESS_VIOLATION) \ + X(EXCEPTION_DATATYPE_MISALIGNMENT) \ + X(EXCEPTION_BREAKPOINT) \ + X(EXCEPTION_SINGLE_STEP) \ + X(EXCEPTION_ARRAY_BOUNDS_EXCEEDED) \ + X(EXCEPTION_FLT_DENORMAL_OPERAND) \ + X(EXCEPTION_FLT_DIVIDE_BY_ZERO) \ + X(EXCEPTION_FLT_INEXACT_RESULT) \ + X(EXCEPTION_FLT_INVALID_OPERATION) \ + X(EXCEPTION_FLT_OVERFLOW) \ + X(EXCEPTION_FLT_STACK_CHECK) \ + X(EXCEPTION_FLT_UNDERFLOW) \ + X(EXCEPTION_INT_DIVIDE_BY_ZERO) \ + X(EXCEPTION_INT_OVERFLOW) \ + X(EXCEPTION_PRIV_INSTRUCTION) \ + X(EXCEPTION_IN_PAGE_ERROR) \ + X(EXCEPTION_ILLEGAL_INSTRUCTION) \ + X(EXCEPTION_NONCONTINUABLE_EXCEPTION) \ + X(EXCEPTION_STACK_OVERFLOW) \ + X(EXCEPTION_INVALID_DISPOSITION) \ + X(EXCEPTION_GUARD_PAGE) \ + X(EXCEPTION_INVALID_HANDLE) \ + X(STATUS_HEAP_CORRUPTION) + +#define FOREACH_EXCEPTION_FLAGS(X) \ + X(EXCEPTION_NONCONTINUABLE) \ + X(EXCEPTION_UNWINDING) \ + X(EXCEPTION_EXIT_UNWIND) \ + X(EXCEPTION_STACK_INVALID) \ + X(EXCEPTION_NESTED_CALL) \ + X(EXCEPTION_TARGET_UNWIND) \ + X(EXCEPTION_COLLIDED_UNWIND) \ + X(EXCEPTION_SOFTWARE_ORIGINATE) + +static const char *exceptionCode_to_string(DWORD dwCode) { +#define SWITCH_CODE_STR(V) case V: return #V; + switch (dwCode) { + case 0xe06d7363: return "MS Visual C++ Exception"; + FOREACH_EXCEPTION_CODES(SWITCH_CODE_STR) + default: { + return "unknown"; + } + } +#undef SWITCH_CODE_STR +} + +static const char *exceptionFlags_to_string(DWORD dwFlags, char *buffer, size_t buffer_length) { + buffer[0] = '\0'; + +#define APPEND_OR_STR(CODE) \ + if (dwFlags & (CODE)) { \ + if (buffer[0]) { \ + strcat_s(buffer, buffer_length, "|"); \ + } \ + strcat_s(buffer, buffer_length, #CODE); \ + } + + FOREACH_EXCEPTION_FLAGS(APPEND_OR_STR) + return buffer; +} + +static BOOL IsCXXException(DWORD dwCode) { + /* https://devblogs.microsoft.com/oldnewthing/20100730-00/?p=13273 */ + return dwCode == 0xe06d7363; /* FOURCC(0xe0, 'm', 's', 'c') */ +} + +static BOOL IsFatalExceptionCode(DWORD dwCode) { + switch (dwCode) { + case EXCEPTION_ACCESS_VIOLATION: + case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: + case EXCEPTION_IN_PAGE_ERROR: + case EXCEPTION_ILLEGAL_INSTRUCTION: + case EXCEPTION_INT_DIVIDE_BY_ZERO: + case EXCEPTION_STACK_OVERFLOW: + case STATUS_HEAP_CORRUPTION: + case STATUS_STACK_BUFFER_OVERRUN: + case EXCEPTION_GUARD_PAGE: + case EXCEPTION_INVALID_HANDLE: + return TRUE; + default: + return FALSE; + } +} + +static const char *get_simple_basename(const char *path) { + const char *pos = strrchr(path, '\\'); + if (pos) { + return pos + 1; + } + pos = strrchr(path, '/'); + if (pos) { + return pos + 1; + } + return path; +} + +static void write_minidump(const char *child_file_path, const LPPROCESS_INFORMATION process_information, DWORD dwThreadId, PEXCEPTION_RECORD exception_record, PCONTEXT context) { + BOOL success; + char dump_file_path[MAX_PATH]; + char child_file_name[64]; + EXCEPTION_POINTERS exception_pointers; + HANDLE hFile = INVALID_HANDLE_VALUE; + HMODULE dbghelp_module = NULL; + MINIDUMP_EXCEPTION_INFORMATION minidump_exception_information; + SYSTEMTIME system_time; + + if (!dyn_dbghelp.pMiniDumpWriteDump) { + printf_message("Cannot find pMiniDumpWriteDump in dbghelp.dll: no minidump"); + return; + } + + success = CreateDirectoryA(DUMP_FOLDER, NULL); + if (!success && GetLastError() != ERROR_ALREADY_EXISTS) { + printf_windows_message("Failed to create minidump directory"); + goto post_dump; + } + _splitpath_s(child_file_path, NULL, 0, NULL, 0, child_file_name, sizeof(child_file_name), NULL, 0); + GetLocalTime(&system_time); + + snprintf(dump_file_path, sizeof(dump_file_path), "minidumps/%s_%04d-%02d-%02d_%d-%02d-%02d.dmp", + child_file_name, + system_time.wYear, system_time.wMonth, system_time.wDay, + system_time.wHour, system_time.wMinute, system_time.wSecond); + printf_message(""); + printf_message("Writing minidump to \"%s\"", dump_file_path); + hFile = CreateFileA( + dump_file_path, + GENERIC_WRITE, + FILE_SHARE_WRITE, + NULL, + CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, + NULL); + if (hFile == INVALID_HANDLE_VALUE) { + printf_windows_message("Failed to open file for minidump"); + goto post_dump; + } + memset(&exception_pointers, 0, sizeof(exception_pointers)); + exception_pointers.ContextRecord = context; + exception_pointers.ExceptionRecord = exception_record; + minidump_exception_information.ClientPointers = FALSE; + minidump_exception_information.ExceptionPointers = &exception_pointers; + minidump_exception_information.ThreadId = dwThreadId; + success = dyn_dbghelp.pMiniDumpWriteDump( + process_information->hProcess, /* HANDLE hProcess */ + process_information->dwProcessId, /* DWORD ProcessId */ + hFile, /* HANDLE hFile */ + MiniDumpWithFullMemory, /* MINIDUMP_TYPE DumpType */ + &minidump_exception_information, /* PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam */ + NULL, /* PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam */ + NULL); /* PMINIDUMP_CALLBACK_INFORMATION CallbackParam */ + if (!success) { + printf_windows_message("Failed to write minidump"); + } +post_dump: + if (hFile != INVALID_HANDLE_VALUE) { + CloseHandle(hFile); + } + if (dbghelp_module != NULL) { + FreeLibrary(dbghelp_module); + } +} + +static void print_stacktrace(const LPPROCESS_INFORMATION process_information, PCONTEXT context, LPVOID address) { + STACKFRAME64 stack_frame; + DWORD machine_type; + + if (!context) { + printf_message("Cannot create a stacktrace without a context"); + return; + } + if (!dyn_dbghelp.pStackWalk64) { + printf_message("Cannot find StackWalk64 in dbghelp.dll: no stacktrace"); + return; + } + if (!dyn_dbghelp.pSymFunctionTableAccess64) { + printf_message("Cannot find SymFunctionTableAccess64 in dbghelp.dll: no stacktrace"); + return; + } + if (!dyn_dbghelp.pSymGetModuleBase64) { + printf_message("Cannot find SymGetModuleBase64 in dbghelp.dll: no stacktrace"); + return; + } + if (!dyn_dbghelp.pSymFromAddr) { + printf_message("Cannot find pSymFromAddr in dbghelp.dll: no stacktrace"); + return; + } + if (!dyn_dbghelp.pSymGetLineFromAddr64) { + printf_message("Cannot find SymGetLineFromAddr64 in dbghelp.dll: no stacktrace"); + return; + } + if (!dyn_dbghelp.pSymGetModuleInfo64) { + printf_message("Cannot find SymGetModuleInfo64 in dbghelp.dll: no stacktrace"); + return; + } + + if (!dyn_dbghelp.pSymRefreshModuleList || !dyn_dbghelp.pSymRefreshModuleList(process_information->hProcess)) { + printf_windows_message("SymRefreshModuleList failed: maybe no stacktrace"); + } + + memset(&stack_frame, 0, sizeof(stack_frame)); + + stack_frame.AddrPC.Mode = AddrModeFlat; + stack_frame.AddrFrame.Mode = AddrModeFlat; + stack_frame.AddrStack.Mode = AddrModeFlat; + +#if defined(SDLPROCDUMP_CPU_X86) + machine_type = IMAGE_FILE_MACHINE_I386; + stack_frame.AddrFrame.Offset = context->Ebp; + stack_frame.AddrStack.Offset = context->Esp; + stack_frame.AddrPC.Offset = context->Eip; +#elif defined(SDLPROCDUMP_CPU_X64) + machine_type = IMAGE_FILE_MACHINE_AMD64; + stack_frame.AddrFrame.Offset = context->Rbp; + stack_frame.AddrStack.Offset = context->Rsp; + stack_frame.AddrPC.Offset = context->Rip; +#elif defined(SDLPROCDUMP_CPU_ARM32) + machine_type = IMAGE_FILE_MACHINE_ARM; + stack_frame.AddrFrame.Offset = context->Lr; + stack_frame.AddrStack.Offset = context->Sp; + stack_frame.AddrPC.Offset = context->Pc; +#elif defined(SDLPROCDUMP_CPU_ARM64) + machine_type = IMAGE_FILE_MACHINE_ARM64; + stack_frame.AddrFrame.Offset = context->Fp; + stack_frame.AddrStack.Offset = context->Sp; + stack_frame.AddrPC.Offset = context->Pc; +#endif + while (dyn_dbghelp.pStackWalk64(machine_type, /* DWORD MachineType */ + process_information->hProcess, /* HANDLE hProcess */ + process_information->hThread, /* HANDLE hThread */ + &stack_frame, /* LPSTACKFRAME64 StackFrame */ + &context, /* PVOID ContextRecord */ + NULL, /* PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine */ + dyn_dbghelp.pSymFunctionTableAccess64, /* PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine */ + dyn_dbghelp.pSymGetModuleBase64, /* PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine */ + NULL)) { /* PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress */ + + IMAGEHLP_MODULE64 module_info; + union { + char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(CHAR)]; + SYMBOL_INFO symbol_info; + } symbol; + DWORD64 dwDisplacement; + DWORD lineColumn = 0; + IMAGEHLP_LINE64 line; + const char *image_file_name; + const char *symbol_name; + const char *file_name; + char line_number[16]; + + if (stack_frame.AddrPC.Offset == stack_frame.AddrReturn.Offset) { + printf_message("PC == Return Address => Possible endless callstack"); + break; + } + + memset(&module_info, 0, sizeof(module_info)); + module_info.SizeOfStruct = sizeof(module_info); + if (!dyn_dbghelp.pSymGetModuleInfo64(process_information->hProcess, stack_frame.AddrPC.Offset, &module_info)) { + image_file_name = "?"; + } else { + image_file_name = get_simple_basename(module_info.ImageName); + } + + memset(&symbol, 0, sizeof(symbol)); + symbol.symbol_info.SizeOfStruct = sizeof(symbol.symbol_info); + symbol.symbol_info.MaxNameLen = MAX_SYM_NAME; + if (!dyn_dbghelp.pSymFromAddr(process_information->hProcess, (DWORD64)(uintptr_t)stack_frame.AddrPC.Offset, &dwDisplacement, &symbol.symbol_info)) { + symbol_name = "???"; + dwDisplacement = 0; + } else { + symbol_name = symbol.symbol_info.Name; + } + + line.SizeOfStruct = sizeof(line); + if (!dyn_dbghelp.pSymGetLineFromAddr64(process_information->hProcess, (DWORD64)(uintptr_t)stack_frame.AddrPC.Offset, &lineColumn, &line)) { + file_name = ""; + line_number[0] = '\0'; + } else { + file_name = line.FileName; + snprintf(line_number, sizeof(line_number), "Line %u", (unsigned int)line.LineNumber); + } + printf_message("%s!%s+0x%x %s %s", image_file_name, symbol_name, dwDisplacement, file_name, line_number); + } +} + +static PCONTEXT FillInThreadContext(LPPROCESS_INFORMATION process_information, PCONTEXT context_buffer) { + HANDLE thread_handle = NULL; + + thread_handle = OpenThread(THREAD_ALL_ACCESS, FALSE, process_information->dwThreadId); + if (!thread_handle) { + printf_windows_message("OpenThread failed: no stacktrace"); + return NULL; + } + + memset(context_buffer, 0, sizeof(*context_buffer)); + context_buffer->ContextFlags = CONTEXT_ALL; + if (!GetThreadContext(thread_handle, context_buffer)) { + printf_windows_message("GetThreadContext failed: no stacktrace"); + CloseHandle(thread_handle); + return NULL; + } + CloseHandle(thread_handle); + return context_buffer; +} + +static void GetMSCExceptionName(HANDLE hProcess, ULONG_PTR *parameters, DWORD count_parameters, char *buffer, size_t buffer_size) { + +#define FIXUP_DWORD_POINTER(ADDR) ((sizeof(void *) == 8) ? (parameters[3] + (ADDR)) : (ADDR)) +#define CHECKED_ReadProcessMemory(PROCESS, ADDRESS, BUFFER, COUNT, WHAT) \ + do { \ + SIZE_T actual_count; \ + BOOL res = ReadProcessMemory((PROCESS), (ADDRESS), (BUFFER), (COUNT), &actual_count); \ + if (!res) { \ + printf_windows_message(WHAT ": ReadProcessMemory failed"); \ + strncpy_s(buffer, buffer_size, "", buffer_size); \ + return; \ + } \ + if ((COUNT) != (actual_count)) { \ + printf_message(WHAT ": ReadProcessMemory did not read enough data actual=%lu expected=%lu", \ + (unsigned long) (actual_count), (unsigned long) (COUNT)); \ + strncpy_s(buffer, buffer_size, "", buffer_size); \ + return; \ + } \ + } while (0) + + DWORD depth0; + char *ptr_depth0; + DWORD depth1; + char *ptr_depth1; + DWORD depth2; + char *ptr_depth2; + + CHECKED_ReadProcessMemory(hProcess, (void *)(parameters[2] + 3 * sizeof(DWORD)), &depth0, sizeof(depth0), "depth 0"); + ptr_depth0 = (char *)FIXUP_DWORD_POINTER(depth0); + CHECKED_ReadProcessMemory(hProcess, ptr_depth0 + 1 * sizeof(DWORD), &depth1, sizeof(depth1), "depth 1"); + ptr_depth1 = (char *)FIXUP_DWORD_POINTER(depth1); + CHECKED_ReadProcessMemory(hProcess, ptr_depth1 + 1 * sizeof(DWORD), &depth2, sizeof(depth2), "depth 2"); + ptr_depth2 = (char *)FIXUP_DWORD_POINTER(depth2); + CHECKED_ReadProcessMemory(hProcess, ptr_depth2 + 2 * sizeof(void*), buffer, buffer_size, "data"); + buffer[buffer_size - 1] = '\0'; + +#undef FIXUP_DWORD_POINTER +#undef CHECKED_ReadProcessMemory +} + +int main(int argc, char *argv[]) { + int i; + size_t command_line_len = 0; + char *command_line; + STARTUPINFOA startup_info; + PROCESS_INFORMATION process_information; + BOOL success; + BOOL debugger_present; + DWORD exit_code; + DWORD creation_flags; + + if (argc < 2) { + fprintf(stderr, "Usage: %s PROGRAM [ARG1 [ARG2 [ARG3 ... ]]]\n", argv[0]); + return 1; + } + + for (i = 1; i < argc; i++) { + command_line_len += strlen(argv[i]) + 1; + } + command_line = malloc(command_line_len + 1); + if (!command_line) { + printf_message("Failed to allocate memory for command line"); + return 1; + } + command_line[0] = '\0'; + for (i = 1; i < argc; i++) { + strcat_s(command_line, command_line_len, argv[i]); + if (i != argc - 1) { + strcat_s(command_line, command_line_len, " "); + } + } + + memset(&startup_info, 0, sizeof(startup_info)); + startup_info.cb = sizeof(startup_info); + + debugger_present = IsDebuggerPresent(); + creation_flags = NORMAL_PRIORITY_CLASS; + if (!debugger_present) { + creation_flags |= DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS; + } + success = CreateProcessA( + argv[1], /* LPCSTR lpApplicationName, */ + command_line, /* LPSTR lpCommandLine, */ + NULL, /* LPSECURITY_ATTRIBUTES lpProcessAttributes, */ + NULL, /* LPSECURITY_ATTRIBUTES lpThreadAttributes, */ + TRUE, /* BOOL bInheritHandles, */ + creation_flags, /* DWORD dwCreationFlags, */ + NULL, /* LPVOID lpEnvironment, */ + NULL, /* LPCSTR lpCurrentDirectory, */ + &startup_info, /* LPSTARTUPINFOA lpStartupInfo, */ + &process_information); /* LPPROCESS_INFORMATION lpProcessInformation */ + + if (!success) { + printf_windows_message("Failed to start application"); + return 1; + } + + if (debugger_present) { + WaitForSingleObject(process_information.hProcess, INFINITE); + } else { + int process_alive = 1; + DEBUG_EVENT event; + while (process_alive) { + DWORD continue_status = DBG_CONTINUE; + success = WaitForDebugEvent(&event, INFINITE); + if (!success) { + printf_message("Failed to get a debug event"); + return 1; + } + switch (event.dwDebugEventCode) { + case EXCEPTION_DEBUG_EVENT: + { + const BOOL cxx_exception = IsCXXException(event.u.Exception.ExceptionRecord.ExceptionCode); + const BOOL is_fatal = !cxx_exception && (IsFatalExceptionCode(event.u.Exception.ExceptionRecord.ExceptionCode) || (event.u.Exception.ExceptionRecord.ExceptionFlags & EXCEPTION_NONCONTINUABLE)); + if (cxx_exception || is_fatal) { + char flag_buffer[256]; + printf_message("EXCEPTION_DEBUG_EVENT"); + printf_message(" ExceptionCode: 0x%08lx (%s)", + event.u.Exception.ExceptionRecord.ExceptionCode, + exceptionCode_to_string(event.u.Exception.ExceptionRecord.ExceptionCode)); + printf_message(" ExceptionFlags: 0x%08lx (%s)", + event.u.Exception.ExceptionRecord.ExceptionFlags, + exceptionFlags_to_string(event.u.Exception.ExceptionRecord.ExceptionFlags, flag_buffer, sizeof(flag_buffer))); + + printf_message(" FirstChance: %ld", event.u.Exception.dwFirstChance); + printf_message(" ExceptionAddress: 0x%08lx", + event.u.Exception.ExceptionRecord.ExceptionAddress); + } + if (cxx_exception) { + char exception_name[256]; + GetMSCExceptionName(process_information.hProcess, event.u.Exception.ExceptionRecord.ExceptionInformation, event.u.Exception.ExceptionRecord.NumberParameters, + exception_name, sizeof(exception_name)); + printf_message(" Exception name: %s", exception_name); + } else if (is_fatal) { + CONTEXT context_buffer; + PCONTEXT context; + + printf_message(" (Non-continuable exception debug event)"); + context = FillInThreadContext(&process_information, &context_buffer); + write_minidump(argv[1], &process_information, event.dwThreadId, &event.u.Exception.ExceptionRecord, context); + printf_message(""); +#ifdef SDLPROCDUMP_PRINTSTACK + print_stacktrace(&process_information, event.u.Exception.ExceptionRecord.ExceptionAddress, context); +#else + printf_message("No support for printing stacktrack for current architecture"); +#endif + DebugActiveProcessStop(event.dwProcessId); + } + continue_status = DBG_EXCEPTION_NOT_HANDLED; + break; + } + case CREATE_PROCESS_DEBUG_EVENT: + load_dbghelp(); + if (!dyn_dbghelp.pSymInitialize) { + printf_message("Cannot find pSymInitialize in dbghelp.dll: no stacktrace"); + break; + } + /* Don't invade process on CI: downloading symbols will cause test timeouts */ + if (!dyn_dbghelp.pSymInitialize(process_information.hProcess, NULL, FALSE)) { + printf_windows_message("pSymInitialize failed: no stacktrace"); + break; + } + break; + case EXIT_PROCESS_DEBUG_EVENT: + exit_code = event.u.ExitProcess.dwExitCode; + if (event.dwProcessId == process_information.dwProcessId) { + process_alive = 0; + DebugActiveProcessStop(event.dwProcessId); + } + break; + } + success = ContinueDebugEvent(event.dwProcessId, event.dwThreadId, continue_status); + if (!process_alive) { + DebugActiveProcessStop(event.dwProcessId); + } + } + } + if (dyn_dbghelp.pSymCleanup) { + dyn_dbghelp.pSymCleanup(process_information.hProcess); + } + unload_dbghelp(); + + exit_code = 1; + success = GetExitCodeProcess(process_information.hProcess, &exit_code); + + if (!success) { + printf_message("Failed to get process exit code"); + return 1; + } + + CloseHandle(process_information.hThread); + CloseHandle(process_information.hProcess); + + return exit_code; +}