21 switch (exceptioncode) {
22 case EXCEPTION_ACCESS_VIOLATION:
23 return "EXCEPTION_ACCESS_VIOLATION";
24 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
25 return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
26 case EXCEPTION_BREAKPOINT:
27 return "EXCEPTION_BREAKPOINT";
28 case EXCEPTION_DATATYPE_MISALIGNMENT:
29 return "EXCEPTION_DATATYPE_MISALIGNMENT";
30 case EXCEPTION_FLT_DENORMAL_OPERAND:
31 return "EXCEPTION_FLT_DENORMAL_OPERAND";
32 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
33 return "EXCEPTION_FLT_DIVIDE_BY_ZERO";
34 case EXCEPTION_FLT_INEXACT_RESULT:
35 return "EXCEPTION_FLT_INEXACT_RESULT";
36 case EXCEPTION_FLT_INVALID_OPERATION:
37 return "EXCEPTION_FLT_INVALID_OPERATION";
38 case EXCEPTION_FLT_OVERFLOW:
39 return "EXCEPTION_FLT_OVERFLOW";
40 case EXCEPTION_FLT_STACK_CHECK:
41 return "EXCEPTION_FLT_STACK_CHECK";
42 case EXCEPTION_FLT_UNDERFLOW:
43 return "EXCEPTION_FLT_UNDERFLOW";
44 case EXCEPTION_ILLEGAL_INSTRUCTION:
45 return "EXCEPTION_ILLEGAL_INSTRUCTION";
46 case EXCEPTION_IN_PAGE_ERROR:
47 return "EXCEPTION_IN_PAGE_ERROR";
48 case EXCEPTION_INT_DIVIDE_BY_ZERO:
49 return "EXCEPTION_INT_DIVIDE_BY_ZERO";
50 case EXCEPTION_INT_OVERFLOW:
51 return "EXCEPTION_INT_OVERFLOW";
52 case EXCEPTION_INVALID_DISPOSITION:
53 return "EXCEPTION_INVALID_DISPOSITION";
54 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
55 return "EXCEPTION_NONCONTINUABLE_EXCEPTION";
56 case EXCEPTION_PRIV_INSTRUCTION:
57 return "EXCEPTION_PRIV_INSTRUCTION";
58 case EXCEPTION_SINGLE_STEP:
59 return "EXCEPTION_SINGLE_STEP";
60 case EXCEPTION_STACK_OVERFLOW:
61 return "EXCEPTION_STACK_OVERFLOW";
63 return "UNKNOWN EXCEPTION";
71 if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, address, &
mod)) {
83 LPBYTE lpBuffer =
NULL;
84 DWORD verSize = GetFileVersionInfoSize(
file, &verHandle);
86 LPSTR verData = (LPSTR)
MEM_callocN(verSize,
"crash module version");
88 if (GetFileVersionInfo(
file, verHandle, verSize, verData)) {
89 if (VerQueryValue(verData,
"\\", (VOID FAR * FAR *)&lpBuffer, &
size)) {
91 VS_FIXEDFILEINFO *verInfo = (VS_FIXEDFILEINFO *)lpBuffer;
95 if (verInfo->dwSignature == 0xfeef04bd) {
99 (verInfo->dwFileVersionMS >> 16) & 0xffff,
100 (verInfo->dwFileVersionMS >> 0) & 0xffff,
101 (verInfo->dwFileVersionLS >> 16) & 0xffff,
102 (verInfo->dwFileVersionLS >> 0) & 0xffff);
114 fprintf(fp,
"Exception Record:\n\n");
116 "ExceptionCode : %s\n",
118 fprintf(fp,
"Exception Address : 0x%p\n", record->ExceptionAddress);
120 fprintf(fp,
"Exception Module : %s\n",
module);
121 fprintf(fp,
"Exception Flags : 0x%.8x\n", record->ExceptionFlags);
122 fprintf(fp,
"Exception Parameters : 0x%x\n", record->NumberParameters);
123 for (DWORD idx = 0; idx < record->NumberParameters; idx++) {
124 fprintf(fp,
"\tParameters[%d] : 0x%p\n", idx, (LPVOID *)record->ExceptionInformation[idx]);
126 if (record->ExceptionRecord) {
127 fprintf(fp,
"Nested ");
135 const int max_symbol_length = 100;
139 PSYMBOL_INFO symbolinfo =
MEM_callocN(
sizeof(SYMBOL_INFO) + max_symbol_length *
sizeof(
char),
140 "crash Symbol table");
141 symbolinfo->MaxNameLen = max_symbol_length - 1;
142 symbolinfo->SizeOfStruct =
sizeof(SYMBOL_INFO);
144 STACKFRAME frame = {0};
145 frame.AddrPC.Offset =
context->Rip;
146 frame.AddrPC.Mode = AddrModeFlat;
147 frame.AddrFrame.Offset =
context->Rsp;
148 frame.AddrFrame.Mode = AddrModeFlat;
149 frame.AddrStack.Offset =
context->Rsp;
150 frame.AddrStack.Mode = AddrModeFlat;
153 if (StackWalk64(IMAGE_FILE_MACHINE_AMD64,
159 SymFunctionTableAccess64,
162 if (frame.AddrPC.Offset) {
167 if (SymFromAddr(GetCurrentProcess(), (DWORD64)(frame.AddrPC.Offset), 0, symbolinfo)) {
168 fprintf(fp,
"%-20s:0x%p %s",
module, (LPVOID)symbolinfo->Address, symbolinfo->Name);
169 IMAGEHLP_LINE lineinfo;
170 lineinfo.SizeOfStruct =
sizeof(lineinfo);
171 DWORD displacement = 0;
172 if (SymGetLineFromAddr(
173 GetCurrentProcess(), (DWORD64)(frame.AddrPC.Offset), &displacement, &lineinfo)) {
174 fprintf(fp,
" %s:%d", lineinfo.FileName, lineinfo.LineNumber);
182 (LPVOID)frame.AddrPC.Offset,
183 "Symbols not available");
204 context.ContextFlags = CONTEXT_ALL;
207 if (hThread != GetCurrentThread()) {
208 SuspendThread(hThread);
209 bool success = GetThreadContext(hThread, &
context);
210 ResumeThread(hThread);
212 fprintf(fp,
"Cannot get thread context : 0x0%.8x\n", GetLastError());
224 fprintf(fp,
"Loaded Modules :\n");
225 HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, 0);
226 if (hModuleSnap == INVALID_HANDLE_VALUE)
230 me32.dwSize =
sizeof(MODULEENTRY32);
232 if (!Module32First(hModuleSnap, &me32)) {
233 CloseHandle(hModuleSnap);
234 fprintf(fp,
" Error getting module list.\n");
239 if (me32.th32ProcessID == GetCurrentProcessId()) {
240 char version[MAX_PATH];
243 IMAGEHLP_MODULE64 m64;
244 m64.SizeOfStruct =
sizeof(m64);
245 if (SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)me32.modBaseAddr, &m64)) {
247 "0x%p %-20s %s %s %s\n",
252 m64.PdbUnmatched ?
"[unmatched]" :
"");
255 fprintf(fp,
"0x%p %-20s %s\n", me32.modBaseAddr, version, me32.szModule);
258 }
while (Module32Next(hModuleSnap, &me32));
263 fprintf(fp,
"Threads:\n");
264 HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
267 hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
268 if (hThreadSnap == INVALID_HANDLE_VALUE) {
269 fprintf(fp,
"Unable to retrieve threads list.\n");
273 te32.dwSize =
sizeof(THREADENTRY32);
275 if (!Thread32First(hThreadSnap, &te32)) {
276 CloseHandle(hThreadSnap);
280 if (te32.th32OwnerProcessID == GetCurrentProcessId()) {
281 if (GetCurrentThreadId() != te32.th32ThreadID) {
282 fprintf(fp,
"Thread : %.8x\n", te32.th32ThreadID);
283 HANDLE ht = OpenThread(THREAD_ALL_ACCESS,
FALSE, te32.th32ThreadID);
288 }
while (Thread32Next(hThreadSnap, &te32));
289 CloseHandle(hThreadSnap);
294 fprintf(fp,
"Stack trace:\n");
310 IMAGEHLP_MODULE64 m64;
311 m64.SizeOfStruct =
sizeof(m64);
312 if (SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)GetModuleHandle(
NULL), &m64)) {
313 return m64.GlobalSymbols;
325 char pdb_file[MAX_PATH] = {0};
328 if (GetModuleFileNameA(
NULL, pdb_file,
sizeof(pdb_file))) {
330 PathRemoveFileSpecA(pdb_file);
332 PathAppendA(pdb_file,
"blender.pdb");
333 if (PathFileExistsA(pdb_file)) {
334 HMODULE
mod = GetModuleHandle(
NULL);
336 WIN32_FILE_ATTRIBUTE_DATA file_data;
337 if (GetFileAttributesExA(pdb_file, GetFileExInfoStandard, &file_data)) {
340 SymUnloadModule64(GetCurrentProcess(), (DWORD64)
mod);
342 DWORD64 module_base = SymLoadModule(GetCurrentProcess(),
347 (DWORD)file_data.nFileSizeLow);
348 if (module_base == 0) {
350 "Error loading symbols %s\n\terror:0x%.8x\n\tsize = %d\n\tbase=0x%p\n",
353 file_data.nFileSizeLow,
367 SymInitialize(GetCurrentProcess(),
NULL, TRUE);
389 LPVOID address = exception->ExceptionRecord->ExceptionAddress;
390 fprintf(stderr,
"Address : 0x%p\n", address);
392 CHAR modulename[MAX_PATH];
394 fprintf(stderr,
"Module : %s\n", modulename);
395 fprintf(stderr,
"Thread : %.8x\n", GetCurrentThreadId());
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
typedef UINT(API *GHOST_WIN32_GetDpiForWindow)(HWND)
Read Guarded memory(de)allocation.
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
ccl_global float * buffer
void(* MEM_freeN)(void *vmemh)
void *(* MEM_callocN)(size_t len, const char *str)
static struct PyModuleDef module
static void bli_windows_get_module_version(const char *file, char *buffer, size_t buffersize)
static bool bli_windows_system_backtrace_stack_thread(FILE *fp, HANDLE hThread)
static const char * bli_windows_get_exception_description(const DWORD exceptioncode)
static void bli_windows_get_module_name(LPVOID address, PCHAR buffer, size_t size)
static void bli_windows_system_backtrace_modules(FILE *fp)
static void bli_windows_system_backtrace_exception_record(FILE *fp, PEXCEPTION_RECORD record)
static bool bli_private_symbols_loaded()
void BLI_windows_handle_exception(EXCEPTION_POINTERS *exception)
void BLI_system_backtrace(FILE *fp)
static EXCEPTION_POINTERS * current_exception
static void bli_windows_system_backtrace_threads(FILE *fp)
static bool BLI_windows_system_backtrace_stack(FILE *fp)
static void bli_load_symbols()
static bool BLI_windows_system_backtrace_run_trace(FILE *fp, HANDLE hThread, PCONTEXT context)
ccl_device_inline int mod(int x, int m)