debug.c File Reference

#include "client.h"
#include <dbghelp.h>

Go to the source code of this file.

Macros
#define	MI_SIZE_V1   584
#define	MI_SIZE_V2   1664
#define	MI_SIZE_V3   1672
#define	PRIxx64   "#.16I64x"
#define	PRIxx32   "#.8I32x"
#define	PRIxx   PRIxx32
#define	WORDxx(x)   ((DWORD32)(x))
#define	CRASH_TITLE   PRODUCT " Unhandled Exception"
#define	LL(x)
#define	GPA(x, y)

Typedefs
typedef DWORD(WINAPI *	SETSYMOPTIONS) (DWORD)
typedef BOOL(WINAPI *	SYMGETMODULEINFO64) (HANDLE, DWORD64, PIMAGEHLP_MODULE64)
typedef BOOL(WINAPI *	SYMINITIALIZE) (HANDLE, PSTR, BOOL)
typedef BOOL(WINAPI *	SYMCLEANUP) (HANDLE)
typedef BOOL(WINAPI *	ENUMERATELOADEDMODULES64) (HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID)
typedef BOOL(WINAPI *	STACKWALK64) (DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64)
typedef BOOL(WINAPI *	SYMFROMADDR) (HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO)
typedef PVOID(WINAPI *	SYMFUNCTIONTABLEACCESS64) (HANDLE, DWORD64)
typedef DWORD64(WINAPI *	SYMGETMODULEBASE64) (HANDLE, DWORD64)
typedef BOOL(WINAPI *	GETFILEVERSIONINFOA) (LPCSTR, DWORD, DWORD, PVOID)
typedef BOOL(WINAPI *	VERQUERYVALUEA) (const LPVOID, LPSTR, LPVOID *, PUINT)
typedef HINSTANCE(WINAPI *	SHELLEXECUTEA) (HWND, LPCSTR, LPCSTR, LPCSTR, LPCSTR, INT)

Functions
STATIC VOID	write_report (LPCTSTR fmt,...)
STATIC BOOL CALLBACK	enum_modules_callback (PCSTR ModuleName, DWORD64 ModuleBase, ULONG ModuleSize, PVOID UserContext)
LONG WINAPI	Sys_ExceptionFilter (LPEXCEPTION_POINTERS exceptionInfo)

Variables
STATIC SETSYMOPTIONS	pSymSetOptions
STATIC SYMGETMODULEINFO64	pSymGetModuleInfo64
STATIC SYMINITIALIZE	pSymInitialize
STATIC SYMCLEANUP	pSymCleanup
STATIC ENUMERATELOADEDMODULES64	pEnumerateLoadedModules64
STATIC STACKWALK64	pStackWalk64
STATIC SYMFROMADDR	pSymFromAddr
STATIC SYMFUNCTIONTABLEACCESS64	pSymFunctionTableAccess64
STATIC SYMGETMODULEBASE64	pSymGetModuleBase64
STATIC GETFILEVERSIONINFOA	pGetFileVersionInfoA
STATIC VERQUERYVALUEA	pVerQueryValueA
STATIC SHELLEXECUTEA	pShellExecuteA
STATIC HANDLE	processHandle
STATIC HANDLE	threadHandle
STATIC HANDLE	crashReport
STATIC CHAR	faultyModuleName [MAX_PATH]
STATIC DWORD	moduleInfoSize
STATIC CONST DWORD	tryModuleSizes [4]
static const char	monthNames [12][4]

Macro Definition Documentation

CRASH_TITLE

#define CRASH_TITLE   PRODUCT " Unhandled Exception"

Definition at line 176 of file debug.c.

GPA

#define GPA	(		x,
			y
	)

Value:

    do {                                            \
        p##y = (x)GetProcAddress(moduleHandle, #y); \
        if (!p##y) {                                \
            return EXCEPTION_CONTINUE_SEARCH;       \
        }                                           \
    } while(0)

LL

#define LL

(

x

)

Value:

    do {                                        \
        moduleHandle = LoadLibrary(x);          \
        if (!moduleHandle) {                    \
            return EXCEPTION_CONTINUE_SEARCH;   \
        }                                       \
    } while(0)

MI_SIZE_V1

#define MI_SIZE_V1   584

Definition at line 62 of file debug.c.

MI_SIZE_V2

#define MI_SIZE_V2   1664

Definition at line 63 of file debug.c.

MI_SIZE_V3

#define MI_SIZE_V3   1672

Definition at line 64 of file debug.c.

PRIxx

#define PRIxx   PRIxx32

Definition at line 84 of file debug.c.

PRIxx32

#define PRIxx32   "#.8I32x"

Definition at line 77 of file debug.c.

PRIxx64

#define PRIxx64   "#.16I64x"

Definition at line 76 of file debug.c.

WORDxx

#define WORDxx

(

x

)

((DWORD32)(x))

Definition at line 85 of file debug.c.

Typedef Documentation

ENUMERATELOADEDMODULES64

typedef BOOL(WINAPI * ENUMERATELOADEDMODULES64) (HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID)

Definition at line 31 of file debug.c.

GETFILEVERSIONINFOA

typedef BOOL(WINAPI * GETFILEVERSIONINFOA) (LPCSTR, DWORD, DWORD, PVOID)

Definition at line 39 of file debug.c.

SETSYMOPTIONS

typedef DWORD(WINAPI * SETSYMOPTIONS) (DWORD)

Definition at line 26 of file debug.c.

SHELLEXECUTEA

typedef HINSTANCE(WINAPI * SHELLEXECUTEA) (HWND, LPCSTR, LPCSTR, LPCSTR, LPCSTR, INT)

Definition at line 41 of file debug.c.

STACKWALK64

typedef BOOL(WINAPI * STACKWALK64) (DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64)

Definition at line 33 of file debug.c.

SYMCLEANUP

typedef BOOL(WINAPI * SYMCLEANUP) (HANDLE)

Definition at line 30 of file debug.c.

SYMFROMADDR

typedef BOOL(WINAPI * SYMFROMADDR) (HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO)

Definition at line 36 of file debug.c.

SYMFUNCTIONTABLEACCESS64

typedef PVOID(WINAPI * SYMFUNCTIONTABLEACCESS64) (HANDLE, DWORD64)

Definition at line 37 of file debug.c.

SYMGETMODULEBASE64

typedef DWORD64(WINAPI * SYMGETMODULEBASE64) (HANDLE, DWORD64)

Definition at line 38 of file debug.c.

SYMGETMODULEINFO64

typedef BOOL(WINAPI * SYMGETMODULEINFO64) (HANDLE, DWORD64, PIMAGEHLP_MODULE64)

Definition at line 27 of file debug.c.

SYMINITIALIZE

typedef BOOL(WINAPI * SYMINITIALIZE) (HANDLE, PSTR, BOOL)

Definition at line 29 of file debug.c.

VERQUERYVALUEA

typedef BOOL(WINAPI * VERQUERYVALUEA) (const LPVOID, LPSTR, LPVOID *, PUINT)

Definition at line 40 of file debug.c.

Function Documentation

enum_modules_callback()

STATIC BOOL CALLBACK enum_modules_callback	(	PCSTR	ModuleName,
		DWORD64	ModuleBase,
		ULONG	ModuleSize,
		PVOID	UserContext
	)

Definition at line 105 of file debug.c.

{
    IMAGEHLP_MODULE64 moduleInfo;
    DWORD64 pc = *(DWORD64 *)UserContext;
    BYTE buffer[4096];
    PBYTE data;
    UINT numBytes;
    VS_FIXEDFILEINFO *info;
    char version[64];
    char *symbols, *star;
    int len;
    BOOL ret;
 
    len = lstrlen(ModuleName);
    if (len >= MAX_PATH) {
        return TRUE;
    }
 
    if (pGetFileVersionInfoA(ModuleName, 0, sizeof(buffer), buffer) &&
        pVerQueryValueA(buffer, "\\", (LPVOID *)&data, &numBytes) &&
        numBytes >= sizeof(*info)) {
        info = (VS_FIXEDFILEINFO *)data;
        wsprintf(version, "%u.%u.%u.%u",
                 HIWORD(info->dwFileVersionMS),
                 LOWORD(info->dwFileVersionMS),
                 HIWORD(info->dwFileVersionLS),
                 LOWORD(info->dwFileVersionLS));
    } else {
        CopyMemory(version, "unknown", 8);
    }
 
    moduleInfo.SizeOfStruct = moduleInfoSize;
    ret = pSymGetModuleInfo64(
              processHandle,
              ModuleBase,
              &moduleInfo);
    if (ret) {
        ModuleName = moduleInfo.ModuleName;
        switch (moduleInfo.SymType) {
        case SymNone:       symbols = "none";       break;
        case SymCoff:       symbols = "COFF";       break;
        case SymPdb:        symbols = "PDB";        break;
        case SymExport:     symbols = "export";     break;
        case SymVirtual:    symbols = "virtual";    break;
        default:            symbols = "unknown";    break;
        }
    } else {
        write_report("SymGetModuleInfo64 failed with error %#x\r\n",
                     GetLastError());
        symbols = "failed";
    }
 
    if (pc >= ModuleBase && pc < ModuleBase + ModuleSize) {
        CopyMemory(faultyModuleName, ModuleName, len + 1);
        star = " *";
    } else {
        star = "";
    }
 
    write_report(
        "%"PRIxx" %"PRIxx" %s (version %s, symbols %s)%s\r\n",
        WORDxx(ModuleBase), WORDxx(ModuleBase + ModuleSize),
        ModuleName, version, symbols, star);
 
    return TRUE;
}

Referenced by Sys_ExceptionFilter().

Sys_ExceptionFilter()

LONG WINAPI Sys_ExceptionFilter

(

LPEXCEPTION_POINTERS

exceptionInfo

)

Definition at line 180 of file debug.c.

{
    STACKFRAME64 stackFrame;
    PEXCEPTION_RECORD exception;
    PCONTEXT context;
    DWORD64 pc;
    SYMBOL_INFO *symbol;
    int count, ret, i;
    DWORD64 offset;
    BYTE buffer[sizeof(SYMBOL_INFO) + 256 - 1];
    IMAGEHLP_MODULE64 moduleInfo;
    char path[MAX_PATH];
    char execdir[MAX_PATH];
    HMODULE moduleHandle;
    SYSTEMTIME systemTime;
    OSVERSIONINFO vinfo;
    DWORD len;
    LONG action;
 
    // give previous filter a chance to handle this exception
    if (prevExceptionFilter) {
        action = prevExceptionFilter(exceptionInfo);
        if (action != EXCEPTION_CONTINUE_SEARCH) {
            return action;
        }
    }
 
    // debugger present? not our business
    if (IsDebuggerPresent()) {
        return EXCEPTION_CONTINUE_SEARCH;
    }
 
    // called from different thread? not our business
    if (GetCurrentThread() != mainProcessThread) {
        return EXCEPTION_CONTINUE_SEARCH;
    }
 
#if USE_CLIENT
    //Win_Shutdown();
    VID_Shutdown();
#endif
 
    ret = MessageBox(NULL,
                     PRODUCT " has encountered an unhandled "
                     "exception and needs to be terminated.\n"
                     "Would you like to generate a crash report?",
                     CRASH_TITLE,
                     MB_ICONERROR | MB_YESNO
#if !USE_CLIENT
                     | MB_SERVICE_NOTIFICATION
#endif
                    );
    if (ret == IDNO) {
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
#define LL(x)                                   \
    do {                                        \
        moduleHandle = LoadLibrary(x);          \
        if (!moduleHandle) {                    \
            return EXCEPTION_CONTINUE_SEARCH;   \
        }                                       \
    } while(0)
 
#define GPA(x, y)                                   \
    do {                                            \
        p##y = (x)GetProcAddress(moduleHandle, #y); \
        if (!p##y) {                                \
            return EXCEPTION_CONTINUE_SEARCH;       \
        }                                           \
    } while(0)
 
    LL("dbghelp.dll");
    GPA(SETSYMOPTIONS, SymSetOptions);
    GPA(SYMGETMODULEINFO64, SymGetModuleInfo64);
    GPA(SYMCLEANUP, SymCleanup);
    GPA(SYMINITIALIZE, SymInitialize);
    GPA(ENUMERATELOADEDMODULES64, EnumerateLoadedModules64);
    GPA(STACKWALK64, StackWalk64);
    GPA(SYMFROMADDR, SymFromAddr);
    GPA(SYMFUNCTIONTABLEACCESS64, SymFunctionTableAccess64);
    GPA(SYMGETMODULEBASE64, SymGetModuleBase64);
 
    LL("version.dll");
    GPA(GETFILEVERSIONINFOA, GetFileVersionInfoA);
    GPA(VERQUERYVALUEA, VerQueryValueA);
 
    LL("shell32.dll");
    GPA(SHELLEXECUTEA, ShellExecuteA);
 
    // get base directory to save crash dump to
    len = GetModuleFileName(NULL, execdir, sizeof(execdir));
    if (!len || len >= sizeof(execdir)) {
        return EXCEPTION_CONTINUE_SEARCH;
    }
 
    while (--len) {
        if (execdir[len] == '\\') {
            break;
        }
    }
 
    if (!len || len + 24 >= MAX_PATH) {
        return EXCEPTION_CONTINUE_SEARCH;
    }
 
    execdir[len] = 0;
 
    CopyMemory(path, execdir, len);
    CopyMemory(path + len, "\\Q2RTX_CrashReportXX.txt", 25);
    for (i = 0; i < 100; i++) {
        path[len + 18] = '0' + i / 10;
        path[len + 19] = '0' + i % 10;
        crashReport = CreateFile(
                          path,
                          GENERIC_WRITE,
                          FILE_SHARE_READ,
                          NULL,
                          CREATE_NEW,
                          FILE_ATTRIBUTE_NORMAL,
                          NULL);
 
        if (crashReport != INVALID_HANDLE_VALUE) {
            break;
        }
 
        if (GetLastError() != ERROR_FILE_EXISTS) {
            MessageBox(NULL,
                       "Couldn't create crash report. "
                       "Base directory is not writable.",
                       CRASH_TITLE,
                       MB_ICONERROR);
            return EXCEPTION_EXECUTE_HANDLER;
        }
    }
 
    if (i == 100) {
        MessageBox(NULL,
                   "Couldn't create crash report. "
                   "All report slots are full.\n"
                   "Please remove existing reports from base directory.",
                   CRASH_TITLE,
                   MB_ICONERROR);
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
    pSymSetOptions(
        SYMOPT_LOAD_ANYTHING |
        SYMOPT_DEBUG |
        SYMOPT_FAIL_CRITICAL_ERRORS);
 
    processHandle = GetCurrentProcess();
    threadHandle = GetCurrentThread();
 
    pSymInitialize(processHandle, execdir, TRUE);
 
    GetSystemTime(&systemTime);
    write_report(
        "Crash report generated %s %u %u, %02u:%02u:%02u UTC\r\n",
        monthNames[(systemTime.wMonth - 1) % 12],
        systemTime.wDay,
        systemTime.wYear,
        systemTime.wHour,
        systemTime.wMinute,
        systemTime.wSecond);
    write_report(
        "by " APPLICATION " " VERSION_STRING
        ", built " __DATE__", " __TIME__ "\r\n");
 
#pragma warning(push)
#pragma warning(disable: 4996) // warning C4996: 'GetVersionExA': was declared deprecated
    vinfo.dwOSVersionInfoSize = sizeof(vinfo);
    if (GetVersionEx(&vinfo)) {
        write_report(
            "\r\nWindows version: %u.%u (build %u) %s\r\n",
            vinfo.dwMajorVersion,
            vinfo.dwMinorVersion,
            vinfo.dwBuildNumber,
            vinfo.szCSDVersion);
    } else {
        write_report("GetVersionEx failed with error %#x\r\n",
                     GetLastError());
    }
#pragma warning(pop)
 
    // oh no, dbghelp is not backwards and forwards compatible
    // why in hell is it different from other windows DLLs?
    for (i = 0; i < 4; i++) {
        len = tryModuleSizes[i];
        if (i && len >= sizeof(moduleInfo)) {
            continue;
        }
        moduleInfo.SizeOfStruct = len;
        if (pSymGetModuleInfo64(
                processHandle,
                (DWORD64)((INT_PTR)hGlobalInstance),
                &moduleInfo)) {
            moduleInfoSize = len;
            if (i) {
                write_report(
                    "Module info size is %u (not %u)\r\n",
                    len, tryModuleSizes[0]);
            }
            break;
        }
    }
 
    if (i == 4) {
        // bad luck
        write_report("SymGetModuleInfo64 is fucked up :(");
        moduleInfoSize = sizeof(moduleInfo);
    }
 
    CopyMemory(faultyModuleName, "unknown", 8);
 
    exception = exceptionInfo->ExceptionRecord;
    context = exceptionInfo->ContextRecord;
 
#ifdef _WIN64
    pc = context->Rip;
#else
    pc = (DWORD64)context->Eip;
#endif
 
    write_report("\r\nLoaded modules:\r\n");
    ret = pEnumerateLoadedModules64(
              processHandle,
              enum_modules_callback,
              &pc
          );
    if (!ret) {
        write_report("EnumerateLoadedModules64 failed with error %#x\r\n",
                     GetLastError());
    }
 
    write_report("\r\nException information:\r\n");
    write_report("Code: %#08x\r\n", exception->ExceptionCode);
    write_report("Address: %"PRIxx" (%s)\r\n", WORDxx(pc), faultyModuleName);
 
    write_report("\r\nThread context:\r\n");
#ifdef _WIN64
    write_report("RIP: %"PRIxx64" RBP: %"PRIxx64" RSP: %"PRIxx64"\r\n",
                 context->Rip, context->Rbp, context->Rsp);
    write_report("RAX: %"PRIxx64" RBX: %"PRIxx64" RCX: %"PRIxx64"\r\n",
                 context->Rax, context->Rbx, context->Rcx);
    write_report("RDX: %"PRIxx64" RSI: %"PRIxx64" RDI: %"PRIxx64"\r\n",
                 context->Rdx, context->Rsi, context->Rdi);
    write_report("R8 : %"PRIxx64" R9 : %"PRIxx64" R10: %"PRIxx64"\r\n",
                 context->R8, context->R9, context->R10);
    write_report("R11: %"PRIxx64" R12: %"PRIxx64" R13: %"PRIxx64"\r\n",
                 context->R11, context->R12, context->R13);
    write_report("R14: %"PRIxx64" R15: %"PRIxx64"\r\n",
                 context->R14, context->R15);
#else
    write_report("EIP: %"PRIxx32" EBP: %"PRIxx32" ESP: %"PRIxx32"\r\n",
                 context->Eip, context->Ebp, context->Esp);
    write_report("EAX: %"PRIxx32" EBX: %"PRIxx32" ECX: %"PRIxx32"\r\n",
                 context->Eax, context->Ebx, context->Ecx);
    write_report("EDX: %"PRIxx32" ESI: %"PRIxx32" EDI: %"PRIxx32"\r\n",
                 context->Edx, context->Esi, context->Edi);
#endif
 
    ZeroMemory(&stackFrame, sizeof(stackFrame));
#ifdef _WIN64
    stackFrame.AddrPC.Offset = context->Rip;
    stackFrame.AddrFrame.Offset = context->Rbp;
    stackFrame.AddrStack.Offset = context->Rsp;
#else
    stackFrame.AddrPC.Offset = context->Eip;
    stackFrame.AddrFrame.Offset = context->Ebp;
    stackFrame.AddrStack.Offset = context->Esp;
#endif
    stackFrame.AddrPC.Mode = AddrModeFlat;
    stackFrame.AddrFrame.Mode = AddrModeFlat;
    stackFrame.AddrStack.Mode = AddrModeFlat;
 
    write_report("\r\nStack trace:\r\n");
    count = 0;
    symbol = (SYMBOL_INFO *)buffer;
    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
    symbol->MaxNameLen = 256;
    while (pStackWalk64(
#ifdef _WIN64
               IMAGE_FILE_MACHINE_AMD64,
#else
               IMAGE_FILE_MACHINE_I386,
#endif
               processHandle,
               threadHandle,
               &stackFrame,
               context,
               NULL,
               pSymFunctionTableAccess64,
               pSymGetModuleBase64,
               NULL)) {
        write_report(
            "%d: %"PRIxx" %"PRIxx" %"PRIxx" %"PRIxx" ",
            count,
            WORDxx(stackFrame.Params[0]),
            WORDxx(stackFrame.Params[1]),
            WORDxx(stackFrame.Params[2]),
            WORDxx(stackFrame.Params[3]));
 
        moduleInfo.SizeOfStruct = moduleInfoSize;
        if (pSymGetModuleInfo64(
                processHandle,
                stackFrame.AddrPC.Offset,
                &moduleInfo)) {
            if (moduleInfo.SymType != SymNone &&
                moduleInfo.SymType != SymExport &&
                pSymFromAddr(
                    processHandle,
                    stackFrame.AddrPC.Offset,
                    &offset,
                    symbol)) {
                write_report("%s!%s+%"PRIxx32"\r\n",
                             moduleInfo.ModuleName,
                             symbol->Name, (DWORD32)offset);
            } else {
                write_report("%s!%"PRIxx"\r\n",
                             moduleInfo.ModuleName,
                             WORDxx(stackFrame.AddrPC.Offset));
            }
        } else {
            write_report("%"PRIxx"\r\n",
                         WORDxx(stackFrame.AddrPC.Offset));
        }
 
        count++;
    }
 
    CloseHandle(crashReport);
 
    pSymCleanup(processHandle);
 
    pShellExecuteA(NULL, "open", path, NULL, execdir, SW_SHOW);
 
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by Sys_Init().

write_report()

STATIC VOID write_report	(	LPCTSTR	fmt,
			...
	)

Definition at line 89 of file debug.c.

{
    TCHAR buf[1024];
    va_list argptr;
    int len;
    DWORD written;
 
    va_start(argptr, fmt);
    len = wvsprintf(buf, fmt, argptr);
    va_end(argptr);
 
    if (len > 0 && len < 1024) {
        WriteFile(crashReport, buf, len, &written, NULL);
    }
}

Referenced by enum_modules_callback(), and Sys_ExceptionFilter().

Variable Documentation

crashReport

STATIC HANDLE crashReport

Definition at line 58 of file debug.c.

Referenced by Sys_ExceptionFilter(), and write_report().

faultyModuleName

STATIC CHAR faultyModuleName[MAX_PATH]

Definition at line 59 of file debug.c.

Referenced by enum_modules_callback(), and Sys_ExceptionFilter().

moduleInfoSize

STATIC DWORD moduleInfoSize

Definition at line 60 of file debug.c.

Referenced by enum_modules_callback(), and Sys_ExceptionFilter().

monthNames

const char monthNames[12][4]

static

Initial value:

= {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
}

Definition at line 71 of file debug.c.

Referenced by Sys_ExceptionFilter().

pEnumerateLoadedModules64

STATIC ENUMERATELOADEDMODULES64 pEnumerateLoadedModules64

Definition at line 48 of file debug.c.

Referenced by Sys_ExceptionFilter().

pGetFileVersionInfoA

STATIC GETFILEVERSIONINFOA pGetFileVersionInfoA

Definition at line 53 of file debug.c.

Referenced by enum_modules_callback().

processHandle

STATIC HANDLE processHandle

Definition at line 57 of file debug.c.

Referenced by enum_modules_callback(), and Sys_ExceptionFilter().

pShellExecuteA

STATIC SHELLEXECUTEA pShellExecuteA

Definition at line 55 of file debug.c.

Referenced by Sys_ExceptionFilter().

pStackWalk64

STATIC STACKWALK64 pStackWalk64

Definition at line 49 of file debug.c.

Referenced by Sys_ExceptionFilter().

pSymCleanup

STATIC SYMCLEANUP pSymCleanup

Definition at line 47 of file debug.c.

Referenced by Sys_ExceptionFilter().

pSymFromAddr

STATIC SYMFROMADDR pSymFromAddr

Definition at line 50 of file debug.c.

Referenced by Sys_ExceptionFilter().

pSymFunctionTableAccess64

STATIC SYMFUNCTIONTABLEACCESS64 pSymFunctionTableAccess64

Definition at line 51 of file debug.c.

Referenced by Sys_ExceptionFilter().

pSymGetModuleBase64

STATIC SYMGETMODULEBASE64 pSymGetModuleBase64

Definition at line 52 of file debug.c.

Referenced by Sys_ExceptionFilter().

pSymGetModuleInfo64

STATIC SYMGETMODULEINFO64 pSymGetModuleInfo64

Definition at line 45 of file debug.c.

Referenced by enum_modules_callback(), and Sys_ExceptionFilter().

pSymInitialize

STATIC SYMINITIALIZE pSymInitialize

Definition at line 46 of file debug.c.

Referenced by Sys_ExceptionFilter().

pSymSetOptions

STATIC SETSYMOPTIONS pSymSetOptions

Definition at line 44 of file debug.c.

Referenced by Sys_ExceptionFilter().

pVerQueryValueA

STATIC VERQUERYVALUEA pVerQueryValueA

Definition at line 54 of file debug.c.

Referenced by enum_modules_callback().

threadHandle

STATIC HANDLE threadHandle

Definition at line 57 of file debug.c.

Referenced by Sys_ExceptionFilter().

tryModuleSizes

STATIC CONST DWORD tryModuleSizes[4]

Initial value:

= {
    sizeof(IMAGEHLP_MODULE64), MI_SIZE_V3, MI_SIZE_V2, MI_SIZE_V1
}

Definition at line 67 of file debug.c.

Referenced by Sys_ExceptionFilter().