Mirroristas/rathena
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rathena/src/plugins/dbghelpplug.c

1897 lines
50 KiB
C
Raw Blame History

/*
* 2008 January 19
*
* The author disclaims copyright to this source code. In place of
* a legal notice, here is a blessing:
*
* May you do good and not evil.
* May you find forgiveness for yourself and forgive others.
* May you share freely, never taking more than you give.
*
********************************************************************
*
* DONE:
* - Command line
* - Windows version
* - Exception
* - Registers
* - Stacktrace (frame number starting at 0)
* + Functions:
* - address
* - name
* - offset in the function
* - line number and source file
* - source code of the line (external source)
* - function parameters
* - local function variables
* + Variables/parameters:
* - variable name
* - variable type (char/wchar, integers, floats, enums, arrays,
* pointers, structs, unions, ...)
* - readability of memory
* - value of char/wchar
* - value of integers
* - value of floats
* - value of enums (hex number)
* - values of arrays
* - address of pointers
* - value of simple pointers (not pointing to another pointer)
* - show (char*) and (wchar*) as nul-terminated strings
* - show chars/wchar escaped
* + Modules:
* - base address
* - file
* - version
* - size
*
* TODO:
* + Variables/parameters:
* - structure members
* - union members
* - globals
* - Portability to MinGW
*
* $Id$
*/
#ifdef _WIN32
/////////////////////////////////////////////////////////////////////
// Include files
//
#include <assert.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define _NO_CVCONST_H
#include <dbghelp.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/////////////////////////////////////////////////////////////////////
// Types from Cvconst.h (DIA SDK)
//
#ifdef _NO_CVCONST_H
typedef enum _BasicType
{
btNoType = 0,
btVoid = 1,
btChar = 2,
btWChar = 3,
btInt = 6,
btUInt = 7,
btFloat = 8,
btBCD = 9,
btBool = 10,
btLong = 13,
btULong = 14,
btCurrency = 25,
btDate = 26,
btVariant = 27,
btComplex = 28,
btBit = 29,
btBSTR = 30,
btHresult = 31
} BasicType;
typedef enum _UdtKind
{
UdtStruct,
UdtClass,
UdtUnion
} UdtKind;
/*
typedef enum _SymTag {
SymTagNull = 0,
SymTagExe = 1,
SymTagCompiland = 2,
SymTagCompilandDetails = 3,
SymTagCompilandEnv = 4,
SymTagFunction = 5,
SymTagBlock = 6,
SymTagData = 7,
SymTagAnnotation = 8,
SymTagLabel = 9,
SymTagPublicSymbol = 10,
SymTagUDT = 11,
SymTagEnum = 12,
SymTagFunctionType = 13,
SymTagPointerType = 14,
SymTagArrayType = 15,
SymTagBaseType = 16,
SymTagTypedef = 17,
SymTagBaseClass = 18,
SymTagFriend = 19,
SymTagFunctionArgType = 20,
SymTagFuncDebugStart = 21,
SymTagFuncDebugEnd = 22,
SymTagUsingNamespace = 23,
SymTagVTableShape = 24,
SymTagVTable = 25,
SymTagCustom = 26,
SymTagThunk = 27,
SymTagCustomType = 28,
SymTagManagedType = 29,
SymTagDimension = 30
} SymTag;
*/
#endif /* _NO_CVCONST_H */
/////////////////////////////////////////////////////////////////////
// dbghelp function prototypes
//
typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(
HANDLE hProcess,
DWORD ProcessId,
HANDLE hFile,
MINIDUMP_TYPE DumpType,
CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
typedef BOOL (WINAPI *SYMINITIALIZE)(
HANDLE hProcess,
PSTR UserSearchPath,
BOOL fInvadeProcess
);
typedef DWORD (WINAPI *SYMSETOPTIONS)(
DWORD SymOptions
);
typedef DWORD (WINAPI *SYMGETOPTIONS)(
VOID
);
typedef BOOL (WINAPI *SYMCLEANUP)(
HANDLE hProcess
);
typedef BOOL (WINAPI *SYMGETTYPEINFO)(
HANDLE hProcess,
DWORD64 ModBase,
ULONG TypeId,
IMAGEHLP_SYMBOL_TYPE_INFO GetType,
PVOID pInfo
);
typedef BOOL (WINAPI *SYMGETLINEFROMADDR)(
HANDLE hProcess,
DWORD dwAddr,
PDWORD pdwDisplacement,
PIMAGEHLP_LINE Line
);
typedef BOOL (WINAPI *SYMENUMSYMBOLS)(
HANDLE hProcess,
ULONG64 BaseOfDll,
PCSTR Mask,
PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
PVOID UserContext
);
typedef BOOL (WINAPI *SYMSETCONTEXT)(
HANDLE hProcess,
PIMAGEHLP_STACK_FRAME StackFrame,
PIMAGEHLP_CONTEXT Context
);
typedef BOOL (WINAPI *SYMFROMADDR)(
HANDLE hProcess,
DWORD64 Address,
PDWORD64 Displacement,
PSYMBOL_INFO Symbol
);
typedef BOOL (WINAPI *STACKWALK)(
DWORD MachineType,
HANDLE hProcess,
HANDLE hThread,
LPSTACKFRAME StackFrame,
PVOID ContextRecord,
PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
);
typedef PVOID (WINAPI *SYMFUNCTIONTABLEACCESS)(
HANDLE hProcess,
DWORD AddrBase
);
typedef DWORD (WINAPI *SYMGETMODULEBASE)(
HANDLE hProcess,
DWORD dwAddr
);
/////////////////////////////////////////////////////////////////////
// Custom info
/// Internal structure used to pass some data around
typedef struct _InternalData {
// PrintStacktrace
FILE* log_file;
STACKFRAME* pStackframe;
HANDLE hProcess;
DWORD nr_of_frame;
// PrintFunctionDetail
BOOL as_arg_list;
BOOL log_params;
BOOL log_locals;
BOOL log_globals;
DWORD nr_of_var;
// PrintDataInfo
ULONG64 modBase;
} InterData;
/// dbghelp dll filename
#define DBGHELP_DLL "dbghelp.dll"
// Default report filename, used when the module path is unavailable
#define DBG_DEFAULT_FILENAME "athena"
// Extended information printed in the console
#define DBG_EXTENDED_INFORMATION \
"Please report the crash in the bug tracker:\n" \
"http://www.eathena.ws/board/index.php?autocom=bugtracker\n"
/////////////////////////////////////////////////////////////////////
// Global variables
HANDLE dbghelp_dll = INVALID_HANDLE_VALUE;
MINIDUMPWRITEDUMP MiniDumpWriteDump_ = NULL;
SYMINITIALIZE SymInitialize_ = NULL;
SYMSETOPTIONS SymSetOptions_ = NULL;
SYMGETOPTIONS SymGetOptions_ = NULL;
SYMCLEANUP SymCleanup_ = NULL;
SYMGETTYPEINFO SymGetTypeInfo_ = NULL;
SYMGETLINEFROMADDR SymGetLineFromAddr_ = NULL;
SYMENUMSYMBOLS SymEnumSymbols_ = NULL;
SYMSETCONTEXT SymSetContext_ = NULL;
SYMFROMADDR SymFromAddr_ = NULL;
STACKWALK StackWalk_ = NULL;
SYMFUNCTIONTABLEACCESS SymFunctionTableAccess_ = NULL;
SYMGETMODULEBASE SymGetModuleBase_ = NULL;
/////////////////////////////////////////////////////////////////////
// Code
/// Writes the minidump to file. The callback function will at the
/// same time write the list of modules to the log file.
///
/// @param file Filename of the minidump
/// @param ptrs Exception info
/// @param module_callback Callback for MiniDumpWriteDump
/// @param log_file Log file
static VOID
Dhp__WriteMinidumpFile(
const char* file,
PEXCEPTION_POINTERS ptrs,
MINIDUMP_CALLBACK_ROUTINE module_callback,
FILE* log_file)
{
// open minidump file
HANDLE minidump_file = CreateFileA(
file,
GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if( minidump_file != INVALID_HANDLE_VALUE )
{
MINIDUMP_EXCEPTION_INFORMATION expt_info;
MINIDUMP_CALLBACK_INFORMATION dump_cb_info;
expt_info.ThreadId = GetCurrentThreadId();
expt_info.ExceptionPointers = ptrs;
expt_info.ClientPointers = FALSE;
dump_cb_info.CallbackRoutine = module_callback;
dump_cb_info.CallbackParam = (void*)log_file;
if( module_callback != NULL && log_file != NULL )
fprintf(log_file, "\n\nLoaded modules:\n");
MiniDumpWriteDump_(
GetCurrentProcess(),
GetCurrentProcessId(),
minidump_file,
MiniDumpNormal,
ptrs ? &expt_info : NULL,
NULL,
&dump_cb_info
);
CloseHandle(minidump_file);
}
}
/// Prints module information to the log file.
/// Used as a callback to MiniDumpWriteDump.
///
/// @param data Log file
/// @param callback_input
/// @param callback_output
/// @return
static BOOL CALLBACK
Dhp__PrintModuleInfoCallback(
void* data,
CONST PMINIDUMP_CALLBACK_INPUT callback_input,
PMINIDUMP_CALLBACK_OUTPUT callback_output)
{
if( data != NULL &&
callback_input != NULL &&
callback_input->CallbackType == ModuleCallback)
{
FILE* log_file = (FILE*)data;
MINIDUMP_MODULE_CALLBACK module = callback_input->Module;
fprintf(log_file, "0x%p", module.BaseOfImage);
fprintf(log_file, " %ws", module.FullPath, log_file);
fprintf(log_file, " (%d.%d.%d.%d, %d bytes)\n",
HIWORD(module.VersionInfo.dwFileVersionMS),
LOWORD(module.VersionInfo.dwFileVersionMS),
HIWORD(module.VersionInfo.dwFileVersionLS),
LOWORD(module.VersionInfo.dwFileVersionLS),
module.SizeOfImage);
}
return TRUE;
}
/// Prints details about the current process, platform and exception
/// information to the log file.
///
/// @param exception Exception info
/// @param context Exception context
/// @param log_file Log file
static VOID
Dhp__PrintProcessInfo(
EXCEPTION_RECORD* exception,
CONTEXT* context,
FILE* log_file)
{
OSVERSIONINFOA oi;
LPSTR cmd_line;
fprintf(log_file,
"\nProcess info:\n");
// print the command line
cmd_line = GetCommandLineA();
if( cmd_line )
fprintf(log_file,
"Cmd line: %s\n",
cmd_line);
// print information about the OS
oi.dwOSVersionInfoSize = sizeof(oi);
GetVersionExA(&oi);
fprintf(log_file,
"Platform: Windows OS version %d.%d build %d %s\n",
oi.dwMajorVersion, oi.dwMinorVersion, oi.dwBuildNumber, oi.szCSDVersion);
// print the exception code
if( exception )
{
fprintf(log_file,
"\nException:\n"
"0x%x",
exception->ExceptionCode);
switch( exception->ExceptionCode )
{
#define PRINT(x) case x: fprintf(log_file, " "#x); break
PRINT(EXCEPTION_ACCESS_VIOLATION);
PRINT(EXCEPTION_DATATYPE_MISALIGNMENT);
PRINT(EXCEPTION_BREAKPOINT);
PRINT(EXCEPTION_SINGLE_STEP);
PRINT(EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
PRINT(EXCEPTION_FLT_DENORMAL_OPERAND);
PRINT(EXCEPTION_FLT_DIVIDE_BY_ZERO);
PRINT(EXCEPTION_FLT_INEXACT_RESULT);
PRINT(EXCEPTION_FLT_INVALID_OPERATION);
PRINT(EXCEPTION_FLT_OVERFLOW);
PRINT(EXCEPTION_FLT_STACK_CHECK);
PRINT(EXCEPTION_FLT_UNDERFLOW);
PRINT(EXCEPTION_INT_DIVIDE_BY_ZERO);
PRINT(EXCEPTION_INT_OVERFLOW);
PRINT(EXCEPTION_PRIV_INSTRUCTION);
PRINT(EXCEPTION_IN_PAGE_ERROR);
PRINT(EXCEPTION_ILLEGAL_INSTRUCTION);
PRINT(EXCEPTION_NONCONTINUABLE_EXCEPTION);
PRINT(EXCEPTION_STACK_OVERFLOW);
PRINT(EXCEPTION_INVALID_DISPOSITION);
PRINT(EXCEPTION_GUARD_PAGE);
PRINT(EXCEPTION_INVALID_HANDLE);
#undef PRINT
}
// print where the fault occured
fprintf(log_file, " at location 0x%p", exception->ExceptionAddress);
// if the exception was an access violation, print additional information
if( exception->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && exception->NumberParameters >= 2 )
fprintf(log_file, " %s location 0x%p", exception->ExceptionInformation[0] ? "writing to" : "reading from", exception->ExceptionInformation[1]);
fprintf(log_file, "\n");
}
// print the register info
if( context )
{
#if defined(_M_IX86)
fprintf(log_file,
"\nRegisters:\n");
if( context->ContextFlags & CONTEXT_INTEGER )
{
fprintf(log_file,
"eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
context->Eax, context->Ebx, context->Ecx,
context->Edx, context->Esi, context->Edi);
}
if( context->ContextFlags & CONTEXT_CONTROL )
{
fprintf(log_file,
"eip=%08x esp=%08x ebp=%08x iopl=%1x %s %s %s %s %s %s %s %s %s %s\n",
context->Eip, context->Esp, context->Ebp,
(context->EFlags >> 12) & 3, // IOPL level value
context->EFlags & 0x00100000 ? "vip" : " ", // VIP (virtual interrupt pending)
context->EFlags & 0x00080000 ? "vif" : " ", // VIF (virtual interrupt flag)
context->EFlags & 0x00000800 ? "ov" : "nv", // VIF (virtual interrupt flag)
context->EFlags & 0x00000400 ? "dn" : "up", // OF (overflow flag)
context->EFlags & 0x00000200 ? "ei" : "di", // IF (interrupt enable flag)
context->EFlags & 0x00000080 ? "ng" : "pl", // SF (sign flag)
context->EFlags & 0x00000040 ? "zr" : "nz", // ZF (zero flag)
context->EFlags & 0x00000010 ? "ac" : "na", // AF (aux carry flag)
context->EFlags & 0x00000004 ? "po" : "pe", // PF (parity flag)
context->EFlags & 0x00000001 ? "cy" : "nc"); // CF (carry flag)
}
if( context->ContextFlags & CONTEXT_SEGMENTS )
{
fprintf(log_file,
"cs=%04x ss=%04x ds=%04x es=%04x fs=%04x gs=%04x",
context->SegCs,
context->SegSs,
context->SegDs,
context->SegEs,
context->SegFs,
context->SegGs,
context->EFlags);
if( context->ContextFlags & CONTEXT_CONTROL )
fprintf(log_file,
" efl=%08x",
context->EFlags);
fprintf(log_file, "\n");
}
else if( context->ContextFlags & CONTEXT_CONTROL )
fprintf(log_file,
" efl=%08x\n",
context->EFlags);
#else /* defined(_M_IX86) */
//TODO add more processors
#endif
}
}
/// Prints the typename of the symbol.
///
/// @param typeIndex Type index of the symbol
/// @param symtag Symbol tag
/// @param withParens If brackets are printed around the typename
/// @param interData Inter data
static VOID
Dhp__PrintTypeName(
DWORD typeIndex,
DWORD symtag,
BOOL withParens,
InterData* interData)
{
// inter data
FILE* log_file;
HANDLE hProcess;
ULONG64 modBase;
//
assert( interData != NULL );
log_file = interData->log_file;
hProcess = interData->hProcess;
modBase = interData->modBase;
if( withParens )
fprintf(log_file, "(");
switch( symtag )
{
case SymTagEnum:
{
WCHAR* pwszTypeName;
if( SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_SYMNAME, &pwszTypeName) )
{
fprintf(log_file, "enum %ls", pwszTypeName);
LocalFree(pwszTypeName);
}
else
fprintf(log_file, "enum <symname not found>");
}
break;
case SymTagBaseType:
{
DWORD basetype;
ULONG64 length = 0;
SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_LENGTH, &length);
if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_BASETYPE, &basetype) )
{
fprintf(log_file, "<basetype not found>");
break;
}
switch( basetype )
{
case btVoid: fprintf(log_file, "void"); break;
case btChar: fprintf(log_file, "char"); break;
case btWChar: fprintf(log_file, "wchar"); break;
case btULong: fprintf(log_file, "unsigned "); // next
case btLong: fprintf(log_file, "long"); break;
case btUInt: fprintf(log_file, "unsigned "); // next
case btInt:
if( length == sizeof(char) ) fprintf(log_file, "char");
else if( length == sizeof(short) ) fprintf(log_file, "short");
else if( length == sizeof(int) ) fprintf(log_file, "int");
else if( length == sizeof(long long) ) fprintf(log_file, "long long");
else fprintf(log_file, "<int%d>", length*8);
break;
case btFloat:
if( length == sizeof(float) ) fprintf(log_file, "float");
else if( length == sizeof(double) ) fprintf(log_file, "double");
else if( length == sizeof(long double) ) fprintf(log_file, "long double");
else fprintf(log_file, "<float%d>", length*8);
break;
default: fprintf(log_file, "<TODO name of basetype %d %d>", basetype, length); break;
}
}
break;
case SymTagPointerType:
{
DWORD subtype;
DWORD subtag;
if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_TYPE, &subtype) )
fprintf(log_file, "<type not found>*");
else if( !SymGetTypeInfo_(hProcess, modBase, subtype, TI_GET_SYMTAG, &subtag) )
fprintf(log_file, "<symtag not found>*");
else
{
Dhp__PrintTypeName(subtype, subtag, FALSE, interData);
fprintf(log_file, "*");
}
}
break;
case SymTagArrayType:
{
DWORD childTypeIndex;
DWORD childSymtag;
// print root type
childTypeIndex = typeIndex;
childSymtag = symtag;
for( ; ; )
{
if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_TYPE, &childTypeIndex) )
{
fprintf(log_file, "<child type not found>");
break;
}
if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) )
{
fprintf(log_file, "<child symtag not found>");
break;
}
if( childSymtag != SymTagArrayType )
{
Dhp__PrintTypeName(childTypeIndex, childSymtag, FALSE, interData);
break;
}
// next dimension
}
// print dimensions
childTypeIndex = typeIndex;
childSymtag = symtag;
for( ; childSymtag == SymTagArrayType ; )
{
DWORD childCount;
if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_COUNT, &childCount) )
fprintf(log_file, "[<count not found>]");
else
fprintf(log_file, "[%u]", childCount);
if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_TYPE, &childTypeIndex) )
{
fprintf(log_file, "<child type not found>");
break;
}
if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) )
{
fprintf(log_file, "<child symtag not found>");
break;
}
// next dimension
}
}
break;
default:
{
WCHAR* pSymname;
DWORD udtkind;
if( SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_UDTKIND, &udtkind) )
{
switch( (UdtKind)udtkind )
{
case UdtStruct: fprintf(log_file, "struct "); break;
case UdtClass: fprintf(log_file, "class "); break;
case UdtUnion: fprintf(log_file, "union "); break;
default: fprintf(log_file, "<unknown udtkind %d> ", udtkind); break;
}
}
if( SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_SYMNAME, &pSymname ) )
{
fprintf(log_file, "%ls", pSymname);
LocalFree( pSymname );
}
else
fprintf(log_file, "<TODO typename of symtag %d>", symtag); break;
}
break;
}
if( withParens )
fprintf(log_file, ")");
}
/// Prints the bytes in the target location.
///
/// @param log_file Log file
/// @param p Pointer to the data
/// @param length Length of the data in bytes
static VOID
Dhp__PrintValueBytes(
FILE* log_file,
BYTE* p,
ULONG64 length)
{
ULONG64 i;
fprintf(log_file, "<bytes:");
for( i = 0; i < length; ++i )
{
fprintf(log_file, "%02X", p[i]);
}
fprintf(log_file, ">");
}
/// Prints a wide string/char value.
///
/// @param log_file Log file
/// @param p Pointer to the value
/// @param length Length of the value in bytes
static VOID
Dhp__PrintValueWideChars(
FILE* log_file,
WCHAR* wstr,
ULONG64 length,
BOOL isString)
{
ULONG64 i;
char* buf;
char delim;
length /= sizeof(WCHAR);
delim = ( isString || length > 1 ? '\"' : '\'' );
fprintf(log_file, "%c", delim);
buf = (char *)LocalAlloc(LMEM_FIXED, MB_CUR_MAX+1);
buf[MB_CUR_MAX] = '\0';
for( i = 0; i < length; ++i )
{
int n;
switch( wstr[i] )
{
case L'\"': fprintf(log_file, "\\\""); break;
case L'\'': fprintf(log_file, "\\\'"); break;
case L'\\': fprintf(log_file, "\\\\"); break;
case L'\a': fprintf(log_file, "\\a"); break;
case L'\b': fprintf(log_file, "\\b"); break;
case L'\f': fprintf(log_file, "\\f"); break;
case L'\n': fprintf(log_file, "\\n"); break;
case L'\r': fprintf(log_file, "\\r"); break;
case L'\t': fprintf(log_file, "\\t"); break;
case L'\v': fprintf(log_file, "\\v"); break;
default:
if( iswprint(wstr[i]) && (n=wctomb(buf, wstr[i])) > 0 )
{
buf[n] = '\0';
fprintf(log_file, "%s", buf);
}
else fprintf(log_file, "\\u%04X", wstr[i]);
break;
}
}
LocalFree(buf);
fprintf(log_file, "%c", delim);
}
/// Prints a string/char value.
///
/// @param log_file Log file
/// @param p Pointer to the value
/// @param length Length of the value in bytes
static VOID
Dhp__PrintValueChars(
FILE* log_file,
char* str,
ULONG64 length,
BOOL isString)
{
ULONG64 i;
char delim;
length /= sizeof(char);
delim = ( isString || length > 1 ? '\"' : '\'' );
fprintf(log_file, "%c", delim);
for( i = 0; i < length; ++i )
{
switch( str[i] )
{
case '\"': fprintf(log_file, "\\\""); break;
case '\'': fprintf(log_file, "\\\'"); break;
case '\\': fprintf(log_file, "\\\\"); break;
case '\a': fprintf(log_file, "\\a"); break;
case '\b': fprintf(log_file, "\\b"); break;
case '\f': fprintf(log_file, "\\f"); break;
case '\n': fprintf(log_file, "\\n"); break;
case '\r': fprintf(log_file, "\\r"); break;
case '\t': fprintf(log_file, "\\t"); break;
case '\v': fprintf(log_file, "\\v"); break;
default:
if( isprint((unsigned char)str[i]) ) fprintf(log_file, "%c", str[i]);
else fprintf(log_file, "\\x%02X", (unsigned char)str[i]);
break;
}
}
fprintf(log_file, "%c", delim);
}
/// Prints a float value.
///
/// @param log_file Log file
/// @param p Pointer to the value
/// @param length Length of the value in bytes
static VOID
Dhp__PrintValueFloat(
FILE* log_file,
VOID* p,
ULONG64 length)
{
if( length == sizeof(float) ) fprintf(log_file, "%f", *(float*)p);
else if( length == sizeof(double) ) fprintf(log_file, "%lf", *(double*)p);
else if( length == sizeof(long double) ) fprintf(log_file, "%Lf", *(long double*)p);
else
{
fprintf(log_file, "<unexpected length %I64u>", length);
Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
}
}
/// Prints a hex value.
///
/// @param log_file Log file
/// @param p Pointer to the value
/// @param length Length of the value in bytes
static VOID
Dhp__PrintValueHex(
FILE* log_file,
VOID* p,
ULONG64 length)
{
if( length == sizeof(UINT32) ) fprintf(log_file, "0x%I32X", *(UINT32*)p);
else if( length == sizeof(UINT64) ) fprintf(log_file, "0x%I64X", *(UINT64*)p);
else if( length == sizeof(char) ) fprintf(log_file, "0x%X", *(unsigned char*)p);
else if( length == sizeof(short) ) fprintf(log_file, "0x%X", *(unsigned short*)p);
else if( length == sizeof(int) ) fprintf(log_file, "0x%x", *(unsigned int*)p);
else if( length == sizeof(long) ) fprintf(log_file, "0x%lX", *(unsigned long*)p);
else if( length == sizeof(long long) ) fprintf(log_file, "0x%llX", *(unsigned long long*)p);
else
{
fprintf(log_file, "<unexpected length %I64u>", length);
Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
}
}
/// Prints an unsigned integer value.
///
/// @param log_file Log file
/// @param p Pointer to the value
/// @param length Length of the value in bytes
static VOID
Dhp__PrintValueUnsigned(
FILE* log_file,
VOID* p,
ULONG64 length)
{
if( length == sizeof(INT32) ) fprintf(log_file, "%I32u", *(INT32*)p);
else if( length == sizeof(INT64) ) fprintf(log_file, "%I64u", *(INT64*)p);
else if( length == sizeof(char) ) fprintf(log_file, "%u", *(unsigned char*)p);
else if( length == sizeof(short) ) fprintf(log_file, "%u", *(unsigned short*)p);
else if( length == sizeof(int) ) fprintf(log_file, "%u", *(unsigned int*)p);
else if( length == sizeof(long) ) fprintf(log_file, "%lu", *(unsigned long*)p);
else if( length == sizeof(long long) ) fprintf(log_file, "%llu", *(unsigned long long*)p);
else
{
fprintf(log_file, "<unexpected length %I64u>", length);
Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
}
}
/// Prints a signed integer value.
///
/// @param log_file Log file
/// @param p Pointer to the value
/// @param length Length of the value in bytes
static VOID
Dhp__PrintValueSigned(
FILE* log_file,
VOID* p,
ULONG64 length)
{
if( length == sizeof(INT32) ) fprintf(log_file, "%I32d", *(INT32*)p);
else if( length == sizeof(INT64) ) fprintf(log_file, "%I64d", *(INT64*)p);
else if( length == sizeof(char) ) fprintf(log_file, "%d", *(signed char*)p);
else if( length == sizeof(short) ) fprintf(log_file, "%d", *(signed short*)p);
else if( length == sizeof(int) ) fprintf(log_file, "%d", *(signed int*)p);
else if( length == sizeof(long) ) fprintf(log_file, "%ld", *(signed long*)p);
else if( length == sizeof(long long) ) fprintf(log_file, "%lld", *(signed long long*)p);
else
{
fprintf(log_file, "<unexpected length %I64u>", length);
Dhp__PrintValueBytes(log_file, (BYTE*)p, length);
}
}
/// Prints a nul-terminated wide string value.
/// Checks if the memory can be read from.
///
/// @param log_file Log file
/// @param str Target string
static VOID
Dhp__PrintValueCWideString(
FILE* log_file,
WCHAR* str)
{
ULONG64 length = 0;
// check if memory is readable
__try
{
while( str[length] != L'\0' )
++length;
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
if( length ) Dhp__PrintValueWideChars(log_file, str, length*sizeof(WCHAR), TRUE); // print readable part
fprintf(log_file, "<invalid memory>");
return;
}
// print string
Dhp__PrintValueWideChars(log_file, str, length*sizeof(WCHAR), TRUE);
}
/// Prints a nul-terminated string value.
/// Checks if the memory can be read from.
///
/// @param log_file Log file
/// @param str Target string
static VOID
Dhp__PrintValueCString(
FILE* log_file,
char* str)
{
ULONG64 length = 0;
assert( log_file != NULL );
// check if memory is readable
__try
{
while( str[length] != '\0' )
++length;
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
if( length ) Dhp__PrintValueChars(log_file, str, length*sizeof(char), TRUE); // print readable part
fprintf(log_file, "<invalid memory>");
return;
}
// print string
Dhp__PrintValueChars(log_file, str, length*sizeof(char), TRUE);
}
// forward declaration of Dhp__PrintDataContents
static VOID Dhp__PrintDataContents(DWORD typeIndex, PVOID pVariable, InterData* interData);
/// Prints the value of the data symbol.
/// Checks if the memory can be read from.
///
/// @param typeIndex Type index of the symbol
/// @param symtag Symbol tag
/// @param pVariable Address to the symbol contents
/// @param pInterData Inter data
static VOID
Dhp__PrintDataValue(
DWORD typeIndex,
DWORD symtag,
PVOID pVariable,
InterData* pInterData)
{
// inter data
FILE* log_file;
DWORD64 modBase;
HANDLE hProcess;
//
ULONG64 length = 0;
DWORD basetype;
BOOL isValid = TRUE;
assert( pInterData != NULL );
log_file = pInterData->log_file;
modBase = pInterData->modBase;
hProcess = pInterData->hProcess;
if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_LENGTH, &length) )
{
fprintf(log_file, "<unknown data length>");
return;
}
// check if memory is readable
__try
{
BYTE* p = (BYTE*)pVariable;
ULONG i;
BYTE b = 0;
for( i = 0; i < length; ++i )
b += p[i]; // add to make sure it's not optimized out in release mode
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
fprintf(log_file, "<invalid memory>");
return;
}
switch( symtag )
{
case SymTagBaseType:
{
if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_BASETYPE, &basetype) )
{
fprintf(log_file, "<basetype not found>");
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
switch( basetype )
{
case btInt:
case btLong:
Dhp__PrintValueSigned(log_file, pVariable, length);
break;
case btUInt:
case btULong:
Dhp__PrintValueUnsigned(log_file, pVariable, length);
break;
case btFloat:
Dhp__PrintValueFloat(log_file, pVariable, length);
break;
case btChar:
{
if( length == sizeof(char) ) fprintf(log_file, "%u ", *(unsigned char*)pVariable);
Dhp__PrintValueChars(log_file, (char*)pVariable, length, FALSE);
}
break;
case btWChar:
{
if( length == sizeof(WCHAR) ) fprintf(log_file, "%u ", *(WCHAR*)pVariable);
Dhp__PrintValueWideChars(log_file, (WCHAR*)pVariable, length, FALSE);
}
break;
case btVoid:
if( length > 0 ) Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
default:
fprintf(log_file, "<TODO value of basetype %d>", basetype);
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
}
break;
case SymTagEnum:
Dhp__PrintValueHex(log_file, pVariable, length);
break;
case SymTagPointerType:
{
DWORD childTypeIndex;
DWORD childSymtag;
fprintf(log_file, "0x%p", *(void**)pVariable);
if( SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_TYPE, &childTypeIndex) &&
SymGetTypeInfo_(hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) &&
childSymtag != SymTagPointerType )
{
DWORD childBasetype;
// child isn't a pointer, print the contents
fprintf(log_file, " ");
if( childSymtag == SymTagBaseType &&
SymGetTypeInfo_(hProcess, modBase, childTypeIndex, TI_GET_BASETYPE, &childBasetype) &&
(childBasetype == btChar || childBasetype == btWChar) )
{
// string or wide string
if( childBasetype == btChar ) Dhp__PrintValueCString(log_file, *(char**)pVariable);
else if( childBasetype == btWChar ) Dhp__PrintValueCWideString(log_file, *(WCHAR**)pVariable);
else fprintf(log_file, "<unexpected child basetype %d>", childBasetype);
break;
}
Dhp__PrintDataValue(childTypeIndex, childSymtag, *(PVOID*)pVariable, pInterData);
}
}
break;
case SymTagArrayType:
{
DWORD childTypeIndex;
DWORD childSymtag;
DWORD count;
DWORD i;
if( !SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_TYPE, &childTypeIndex) )
{
fprintf(log_file, "<child type not found>");
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
if( !SymGetTypeInfo_( hProcess, modBase, childTypeIndex, TI_GET_SYMTAG, &childSymtag) )
{
fprintf(log_file, "<child symtag not found>");
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
if( !SymGetTypeInfo_( hProcess, modBase, typeIndex, TI_GET_COUNT, &count) )
{
fprintf(log_file, "<count not found>");
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
// print values
fprintf(log_file, "{");
for( i = 0; i < count; ++i )
{
BYTE* pData = pVariable;
pData += i*(length/count);
if( i > 0 ) fprintf(log_file, ",");
Dhp__PrintDataValue(childTypeIndex, childSymtag, pData, pInterData);
}
fprintf(log_file, "}");
}
break;
default:
#if 0
{//## TODO show children of structs/unions
TI_FINDCHILDREN_PARAMS* children;
DWORD childCount;
DWORD i;
// count children
if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_CHILDRENCOUNT, &childCount) )
{
fprintf(log_file, "<child count not found>");
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
// Prepare to get an array of "TypeIds", representing each of the children.
// SymGetTypeInfo(TI_FINDCHILDREN) expects more memory than just a
// TI_FINDCHILDREN_PARAMS struct has. Use derivation to accomplish this.
children = (TI_FINDCHILDREN_PARAMS*)LocalAlloc(LMEM_FIXED, sizeof(TI_FINDCHILDREN_PARAMS)+childCount*sizeof(ULONG));
children->Count = childCount;
children->Start= 0;
// Get the array of TypeIds, one for each child type
if( !SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_FINDCHILDREN, &children) )
{
fprintf(log_file, "<children not found>");
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
LocalFree(children);
return;
}
// Iterate through each of the children
fprintf(log_file, "{");
for( i = 0; i < childCount; ++i )
{
DWORD childOffset;
DWORD childTypeid;
WCHAR* childName;
DWORD_PTR pData;
if( i > 0 ) fprintf(log_file, ",");
// Get the offset of the child member, relative to its parent
if( !SymGetTypeInfo_(hProcess, modBase, children->ChildId[i], TI_GET_OFFSET, &childOffset) )
{
fprintf(log_file, "<child offset not found>");
continue;
}
// Get the real "TypeId" of the child.
if( !SymGetTypeInfo_(hProcess, modBase, children->ChildId[i], TI_GET_TYPEID, &childTypeid) )
{
fprintf(log_file, "<child typeid not found>");
continue;
}
// Calculate the address of the member
pData = (DWORD_PTR)pVariable;
pData += childOffset;
// print name of the child
if( !SymGetTypeInfo_(hProcess, modBase, childTypeid, TI_GET_SYMNAME, &childName) )
{
fprintf(log_file, "<child symname not found>");
continue;
}
fprintf(log_file, "%ws=", childName);
LocalFree(childName);
// print contents of the child
Dhp__PrintDataContents(childTypeid, (PVOID)pData, interData);
}
fprintf(log_file, "}");
LocalFree(children);
}
#endif
Dhp__PrintValueBytes(log_file, (BYTE*)pVariable, length);
break;
}
}
/// Prints the contents of the data symbol. (type and value)
///
/// @param typeIndex Type index of the symbol
/// @param pVariable Address of the symbol contents
/// @param pInterData Inter data
static VOID
Dhp__PrintDataContents(
DWORD typeIndex,
PVOID pVariable,
InterData* pInterData)
{
// inter data
FILE* log_file;
HANDLE hProcess;
DWORD64 modBase;
//
DWORD symtag;
assert( pInterData != NULL );
log_file = pInterData->log_file;
hProcess = pInterData->hProcess;
modBase = pInterData->modBase;
if( SymGetTypeInfo_(hProcess, modBase, typeIndex, TI_GET_SYMTAG, &symtag) )
{
// print type
Dhp__PrintTypeName(typeIndex, symtag, TRUE, pInterData);
// print value
Dhp__PrintDataValue(typeIndex, symtag, pVariable, pInterData);
}
else
fprintf(log_file, "<symtag not found>");
}
/// Prints information about the data symbol.
///
/// @param pSymInfo Symbol info
/// @param pInterData Inter data
static VOID
Dhp__PrintDataInfo(
PSYMBOL_INFO pSymInfo,
InterData* pInterData)
{
// inter data
FILE* log_file;
STACKFRAME* pStackframe;
BOOL as_arg_list;
BOOL log_params;
BOOL log_locals;
BOOL log_globals;
int nr_of_var;
// my data
DWORD_PTR pVariable = 0;
enum{ UNKNOWN, PARAM, LOCAL, GLOBAL } scope = UNKNOWN;
assert( pSymInfo != NULL );
assert( pInterData != NULL );
assert( pSymInfo->Tag == SymTagData );
log_file = pInterData->log_file;
pStackframe = pInterData->pStackframe;
as_arg_list = pInterData->as_arg_list;
log_params = pInterData->log_params;
log_locals = pInterData->log_locals;
log_globals = pInterData->log_globals;
nr_of_var = pInterData->nr_of_var;
// Determine the scope and address of the variable
if( pSymInfo->Flags & SYMFLAG_REGREL )
{
pVariable = pStackframe->AddrFrame.Offset;
pVariable += (DWORD_PTR)pSymInfo->Address;
if( pSymInfo->Flags & SYMFLAG_PARAMETER )
scope = PARAM; // parameter
else if( pSymInfo->Flags & SYMFLAG_LOCAL )
{
scope = LOCAL; // local
#if defined(_M_IX86)
if( (LONG64)pSymInfo->Address > 0) scope = PARAM; // parameter as local (bug in DBGHELP 5.1)
#endif
}
}
else if( pSymInfo->Flags & SYMFLAG_REGISTER )
{
scope = ( pSymInfo->Flags & SYMFLAG_PARAMETER ? PARAM : LOCAL ); // register, optimized out(?)
}
else
{
pVariable = (DWORD_PTR)pSymInfo->Address;
scope = GLOBAL; // It must be a global variable
}
// check if we should to log the variable
if( (scope == PARAM && log_params) ||
(scope == LOCAL && log_locals) ||
(scope == GLOBAL && log_globals) )
{
// print prefix and name
if( as_arg_list )
fprintf(log_file, "%s%s=", (nr_of_var ? ", " : ""), pSymInfo->Name);
else
fprintf(log_file, "\t%s = ", pSymInfo->Name);
// print value
if( !(pSymInfo->Flags & SYMFLAG_REGREL) && (pSymInfo->Flags & SYMF_REGISTER) )
fprintf(log_file, "<value optimized out>");
else
{
pInterData->modBase = pSymInfo->ModBase;
Dhp__PrintDataContents(pSymInfo->TypeIndex, (PVOID)pVariable, pInterData);
}
// print postfix
if( !as_arg_list )
fprintf(log_file, "\n");
pInterData->nr_of_var = ++nr_of_var;
}
}
/// Prints information about the symbol.
///
/// @param pSymInfo Symbol info
/// @param pInterData Inter data
static VOID
Dhp__PrintSymbolInfo(
PSYMBOL_INFO pSymInfo,
InterData* pInterData)
{
assert( pSymInfo != NULL );
assert( pInterData != NULL );
switch( pSymInfo->Tag )
{
case SymTagData: Dhp__PrintDataInfo( pSymInfo, pInterData ); break;
default: /*fprintf(pInterData->log_file, "<unsupported symtag %d>", pSymInfo->Tag);*/ break;
}
}
/// Prints the details of one symbol to the log file.
/// Used as a callback for SymEnumSymbols.
///
/// @param pSymInfo Symbol info
/// @param symSize Size of the symbol info structure
/// @param pData Inter data
static BOOL WINAPI
Dhp__EnumSymbolsCallback(
PSYMBOL_INFO pSymInfo,
ULONG symSize,
PVOID pData)
{
if( pSymInfo == NULL )
return TRUE; // try other symbols
if( pData == NULL )
{
printf("Dhp__EnumSymbolsCallback: pData is NULL\n");
return FALSE;
}
Dhp__PrintSymbolInfo(pSymInfo, (InterData*)pData);
return TRUE;
}
/// Prints the source code of the target line.
/// Searches for the target file in the original path,
/// in the last src folder of the original path (relative)
/// and in the current directory.
///
/// @param filename Original source file
/// @param line Target line
/// @param log_file Log file
static VOID
Dhp__PrintSourceLine(
FILE* log_file,
char* filename,
DWORD line)
{
char path[MAX_PATH*3];
char pathBuffer[MAX_PATH+1];
char* p;
assert( filename != NULL );
assert( log_file != NULL );
// generate search paths
strcpy(path, filename); // original path
p = strrchr(path, '\\');
if( p )
{
memcpy(p, ";\0", 2);
p = strstr(filename, "\\src\\");
if( p )
{
while( strstr(p+1, "\\src\\") )
p = strstr(p+1, "\\src\\");
strcat(path, p+1); // last src folder path
p = strrchr(path, '\\');
memcpy(p, ";\0", 2);
}
filename = strrchr(filename, '\\')+1;
}
else
*path = '\0'; // no path
strcat(path, "."); // current directoy
// search for file and line
if( SearchPathA(path, filename, NULL, MAX_PATH, pathBuffer, NULL) )
{
char code[1024+1];
DWORD i = 1;
FILE* fp;
fp = fopen(pathBuffer, "rt");
if( fp == NULL )
return;
code[1024] = '\0';
while( fgets(code, 1024, fp) )
{
if( i == line )
{// found line
char* term = strchr(code, '\n');
if( term && term != code && term[-1] == '\r' ) --term;
if( term ) *term = '\0';
fprintf(log_file, "%d\t%s\n", line, code);
break;
}
if( strchr(code, '\n') )
++i;
}
fclose(fp);
}
}
/// Prints details of one function to the log file.
///
/// @param interData Inter data
static VOID
Dhp__PrintFunctionDetails(
InterData* pInterData)
{
// inter data
HANDLE hProcess;
STACKFRAME* pStackframe;
FILE* log_file;
int nr_of_frame;
//
PSYMBOL_INFO pSymbolInfo;
DWORD64 funcDisplacement=0;
IMAGEHLP_STACK_FRAME imagehlpStackFrame;
IMAGEHLP_LINE imagehlpLine;
DWORD lineDisplacement=0;
assert( pInterData != NULL );
hProcess = pInterData->hProcess;
pStackframe = pInterData->pStackframe;
log_file = pInterData->log_file;
nr_of_frame = pInterData->nr_of_frame;
// frame info
fprintf(log_file,
"#%d 0x%p",
nr_of_frame, (void*)(DWORD_PTR)pStackframe->AddrPC.Offset);
// restrict symbol enumeration to this frame only
ZeroMemory(&imagehlpStackFrame, sizeof(IMAGEHLP_STACK_FRAME));
imagehlpStackFrame.InstructionOffset = pStackframe->AddrPC.Offset;
SymSetContext_(hProcess, &imagehlpStackFrame, 0);
// function name and displacement
pSymbolInfo = (PSYMBOL_INFO)LocalAlloc(LMEM_FIXED, sizeof(SYMBOL_INFO)+1024);
pSymbolInfo->SizeOfStruct = sizeof(SYMBOL_INFO);
pSymbolInfo->MaxNameLen = 1024;
if( SymFromAddr_(hProcess, pStackframe->AddrPC.Offset, &funcDisplacement, pSymbolInfo) == TRUE )
{
fprintf(log_file,
" in %.1024s+0x%I64X (",
pSymbolInfo->Name, funcDisplacement);
// log all function parameters
pInterData->as_arg_list = TRUE;
pInterData->log_params = TRUE;
pInterData->log_locals = FALSE;
pInterData->log_globals = FALSE;
pInterData->nr_of_var = 0;
SymEnumSymbols_(hProcess, 0, 0, Dhp__EnumSymbolsCallback, pInterData);
fprintf(log_file,
")");
}
else
fprintf(log_file,
"in <unknown function>");
// find the source line for this function.
imagehlpLine.SizeOfStruct = sizeof(IMAGEHLP_LINE);
if( SymGetLineFromAddr_(hProcess, pStackframe->AddrPC.Offset, &lineDisplacement, &imagehlpLine) != 0 )
{
char* filename = imagehlpLine.FileName;
DWORD line = imagehlpLine.LineNumber;
fprintf(log_file,
" at %s:%d\n",
filename, line);
Dhp__PrintSourceLine(log_file, filename, line);
}
else
fprintf(log_file,
"\n");
// log all function local variables
pInterData->as_arg_list = FALSE;
pInterData->log_params = FALSE;
pInterData->log_locals = TRUE;
pInterData->log_globals = FALSE;
pInterData->nr_of_var = 0;
SymEnumSymbols_(hProcess, 0, 0, Dhp__EnumSymbolsCallback, pInterData);
pInterData->nr_of_frame = ++nr_of_frame;
LocalFree(pSymbolInfo);
}
/// Walks over the stack and prints all relevant information to the log file.
///
/// @param context Exception context
/// @param log_file Log file
static VOID
Dhp__PrintStacktrace(
CONTEXT *context,
FILE *log_file)
{
HANDLE hProcess = GetCurrentProcess();
STACKFRAME stackframe;
DWORD machine;
CONTEXT ctx;
InterData interData;
int skip = 0;
int i;
assert( log_file != NULL );
fprintf(log_file,
"\nStacktrace:\n");
// Use thread information - if not supplied.
if( context == NULL )
{
// If no context is supplied, skip 1 frame
skip = 1;
ctx.ContextFlags = CONTEXT_FULL;
if( GetThreadContext(GetCurrentThread(), &ctx) )
context = &ctx;
}
if( context == NULL )
return;
// Write the stack trace
ZeroMemory(&stackframe, sizeof(STACKFRAME));
stackframe.AddrPC.Mode = AddrModeFlat;
stackframe.AddrStack.Mode = AddrModeFlat;
stackframe.AddrFrame.Mode = AddrModeFlat;
#if defined(_M_IX86)
machine = IMAGE_FILE_MACHINE_I386;
stackframe.AddrPC.Offset = context->Eip;
stackframe.AddrStack.Offset = context->Esp;
stackframe.AddrFrame.Offset = context->Ebp;
#else /* defined(_M_IX86) */
#error FIXME add more processors
some compilers don't stop on #error, this line makes sure it errors out
#endif
interData.hProcess = hProcess;
interData.log_file = log_file;
interData.pStackframe = &stackframe;
interData.nr_of_frame = 0;
for( i = 0; ; ++i )
{
if( !StackWalk_(machine, hProcess, GetCurrentThread(),
&stackframe, context, NULL, SymFunctionTableAccess_,
SymGetModuleBase_, NULL))
{
break;
}
if( i >= skip )
{
// Check that the address is not zero.
// Sometimes StackWalk returns TRUE with a frame of zero.
if( stackframe.AddrPC.Offset != 0 )
Dhp__PrintFunctionDetails(&interData);
}
}
}
typedef BOOL (WINAPI *ISDEBUGGERPRESENT)(void);
/// Checks if a debugger is attached to this process
///
/// @return TRUE is a debugger is present
static BOOL
Dhp__IsDebuggerPresent()
{
HANDLE kernel32_dll;
ISDEBUGGERPRESENT IsDebuggerPresent_;
BOOL result;
kernel32_dll = LoadLibraryA("kernel32.dll");
if( kernel32_dll == NULL )
return FALSE;
IsDebuggerPresent_ = (ISDEBUGGERPRESENT)GetProcAddress(kernel32_dll, "IsDebuggerPresent");
if( IsDebuggerPresent_ )
result = IsDebuggerPresent_();
else
result = FALSE;
FreeLibrary(kernel32_dll);
return result;
}
/// Loads the dbghelp.dll library.
///
/// @return TRUE is sucessfull
static BOOL
Dhp__LoadDbghelpDll()
{
dbghelp_dll = LoadLibraryA(DBGHELP_DLL);
if( dbghelp_dll != INVALID_HANDLE_VALUE )
{
DWORD opts;
// load the functions
MiniDumpWriteDump_ = (MINIDUMPWRITEDUMP)GetProcAddress(dbghelp_dll, "MiniDumpWriteDump");
SymInitialize_ = (SYMINITIALIZE)GetProcAddress(dbghelp_dll, "SymInitialize");
SymSetOptions_ = (SYMSETOPTIONS)GetProcAddress(dbghelp_dll, "SymSetOptions");
SymGetOptions_ = (SYMGETOPTIONS)GetProcAddress(dbghelp_dll, "SymGetOptions");
SymCleanup_ = (SYMCLEANUP)GetProcAddress(dbghelp_dll, "SymCleanup");
SymGetTypeInfo_ = (SYMGETTYPEINFO)GetProcAddress(dbghelp_dll, "SymGetTypeInfo");
SymGetLineFromAddr_ = (SYMGETLINEFROMADDR)GetProcAddress(dbghelp_dll, "SymGetLineFromAddr");
SymEnumSymbols_ = (SYMENUMSYMBOLS)GetProcAddress(dbghelp_dll, "SymEnumSymbols");
SymSetContext_ = (SYMSETCONTEXT)GetProcAddress(dbghelp_dll, "SymSetContext");
SymFromAddr_ = (SYMFROMADDR)GetProcAddress(dbghelp_dll, "SymFromAddr");
StackWalk_ = (STACKWALK)GetProcAddress(dbghelp_dll, "StackWalk");
SymFunctionTableAccess_ = (SYMFUNCTIONTABLEACCESS)GetProcAddress(dbghelp_dll, "SymFunctionTableAccess");
SymGetModuleBase_ = (SYMGETMODULEBASE)GetProcAddress(dbghelp_dll, "SymGetModuleBase");
if( MiniDumpWriteDump_ &&
SymInitialize_ && SymSetOptions_ && SymGetOptions_ &&
SymCleanup_ && SymGetTypeInfo_ && SymGetLineFromAddr_ &&
SymEnumSymbols_ && SymSetContext_ && SymFromAddr_ && StackWalk_ &&
SymFunctionTableAccess_ && SymGetModuleBase_ )
{
// initialize the symbol loading code
opts = SymGetOptions_();
// Set the 'load lines' option to retrieve line number information.
// Set the 'deferred loads' option to map the debug info in memory only when needed.
SymSetOptions_(opts | SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS);
// Initialize the dbghelp DLL with the default path and automatic
// module enumeration (and loading of symbol tables) for this process.
SymInitialize_(GetCurrentProcess(), NULL, TRUE);
return TRUE;
}
}
if( dbghelp_dll )
{
FreeLibrary(dbghelp_dll);
dbghelp_dll = NULL;
}
return FALSE;
}
/// Unloads the dbghelp.dll library.
static VOID
Dhp__UnloadDbghlpDll()
{
SymCleanup_(GetCurrentProcess());
FreeLibrary(dbghelp_dll);
dbghelp_dll = NULL;
}
/// Creates the report and minidump files.
/// Puts the resulting pathnames in the arguments.
/// The buffers must be at least MAX_PATH+1 in size.
///
/// @param out_lpszLogFileName Buffer for the report filename
/// @param out_lpszDmpFileName Buffer for the minidump filename
/// @return TRUE if the files were created
static BOOL
Dhp__CreateFiles(
char* out_logFileName,
char* out_dmpFileName)
{
#define LEN_TIMESTAMP 14 // "YYYYMMDDhhmmss"
#define LEN_EXT 4 // ".rpt" or ".dmp"
char baseFileName[MAX_PATH+1];
char timestamp[LEN_TIMESTAMP+1];
FILE* fp;
time_t now;
// Generate base filename for the report/minidump
ZeroMemory(baseFileName, sizeof(baseFileName));
if( GetModuleFileName(NULL, baseFileName, MAX_PATH-LEN_TIMESTAMP-LEN_EXT) )
{
char* pTerm = strrchr(baseFileName, '\\');
if( pTerm == NULL ) pTerm = baseFileName;
pTerm = strrchr(pTerm, '.');
if( pTerm ) *pTerm = '\0'; // remove extension
}
else if( GetTempPathA(MAX_PATH-6-LEN_TIMESTAMP-LEN_EXT, baseFileName) )
{// in temp folder
strcat(baseFileName, DBG_DEFAULT_FILENAME);
}
else
{// in current folder
strcpy(baseFileName, DBG_DEFAULT_FILENAME);
}
time(&now);
#if 0
szTimestamp[0] = '\0';
#else
strftime(timestamp, sizeof(timestamp), "%Y%m%d%H%M%S", localtime(&now));
#endif
timestamp[LEN_TIMESTAMP] = '\0';
sprintf(out_logFileName, "%s%s.rpt", baseFileName, timestamp);
fp = fopen(out_logFileName, "w");
if( fp == NULL )
return FALSE; // failed to create log file
fclose(fp);
sprintf(out_dmpFileName, "%s%s.dmp", baseFileName, timestamp);
fp = fopen(out_dmpFileName, "w");
if( fp == NULL)
return FALSE; // failed to create dump file
fclose(fp);
return TRUE; // success
#undef LEN_EXT
#undef LEN_TIMESTAMP
}
/// Unhandled exception handler. Where the magic starts... ;D
///
/// @param ptrs Exception information
/// @return What to do with the exception
LONG WINAPI
Dhp__UnhandledExceptionFilter(PEXCEPTION_POINTERS ptrs)
{
char szLogFileName[MAX_PATH+1];
char szDmpFileName[MAX_PATH+1];
FILE* log_file;
// check if the crash handler was already loaded (crash while handling the crash)
if( dbghelp_dll != INVALID_HANDLE_VALUE )
return EXCEPTION_CONTINUE_SEARCH;
// don't log anything if we're running inside a debugger ...
if( Dhp__IsDebuggerPresent() == TRUE )
return EXCEPTION_CONTINUE_SEARCH;
// ... or if we can't load dbghelp.dll ...
if( Dhp__LoadDbghelpDll() == FALSE )
return EXCEPTION_CONTINUE_SEARCH;
// ... or if we can't create the log files
if( Dhp__CreateFiles(szLogFileName, szDmpFileName) == FALSE )
return EXCEPTION_CONTINUE_SEARCH;
// open log file
log_file = fopen(szLogFileName, "wt");
// print information about the process
Dhp__PrintProcessInfo(
ptrs ? ptrs->ExceptionRecord : NULL,
ptrs ? ptrs->ContextRecord : NULL,
log_file);
// print the stacktrace
Dhp__PrintStacktrace(
ptrs ? ptrs->ContextRecord : NULL,
log_file);
// write the minidump file and use the callback to print the list of modules to the log file
Dhp__WriteMinidumpFile(
szDmpFileName,
ptrs,
Dhp__PrintModuleInfoCallback,
log_file);
fclose(log_file);
Dhp__UnloadDbghlpDll();
// inform the user
fprintf(stderr,
"\n"
"This application has halted due to an unexpected error.\n"
"A crash report and minidump file were saved to disk, you can find them here:\n"
"%s\n"
"%s\n"
DBG_EXTENDED_INFORMATION
"\n"
"NOTE: The crash report and minidump files can contain sensitive information\n"
"(filenames, partial file content, usernames and passwords etc.)\n",
szLogFileName,
szDmpFileName);
// terminate the application
return EXCEPTION_EXECUTE_HANDLER;
}
/////////////////////////////////////////////////////////////////////
// DLL stuff
#if !defined(DBG_EMBEDDED)
/// Previous exception filter.
static LPTOP_LEVEL_EXCEPTION_FILTER previousFilter;
#if defined(__GNUC__)
// GNU : define DLL load/unload functions
static void Dhp__OnStartup(void) __attribute__((constructor));
static void Dhp__OnExit(void) __attribute__((destructor));
#endif /* defined(__GNUC__) */
/// Installs as the unhandled exception handler.
void Dhp__OnStartup(void)
{
// Install the unhandled exception filter function
previousFilter = SetUnhandledExceptionFilter(Dhp__UnhandledExceptionFilter);
}
/// Uninstalls the handler.
void Dhp__OnExit(void)
{
SetUnhandledExceptionFilter(previousFilter);
}
#if !defined(__GNUC__)
// Windows : invoke DLL load/unload functions
BOOL APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
switch( dwReason )
{
case DLL_PROCESS_ATTACH: Dhp__OnStartup(); break;
case DLL_PROCESS_DETACH: Dhp__OnExit(); break;
}
return TRUE;
}
#endif /* !defined(__GNUC__) */
#endif /* !defined(DBG_EMBEDDED) */
#endif /* _WIN32 */
Reference in New Issue View Git Blame Copy Permalink