| /** |
| * This file has no copyright assigned and is placed in the Public Domain. |
| * This file is part of the mingw-w64 runtime package. |
| * No warranty is given; refer to the file DISCLAIMER.PD within this package. |
| */ |
| #pragma once |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PCSTR FileName,PVOID CallerData); |
| typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE FileHandle,PCWSTR FileName,PVOID CallerData); |
| typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR filename,PVOID context); |
| typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR filename,PVOID context); |
| typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PCSTR FileName,PVOID CallerData); |
| typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE FileHandle,PCWSTR FileName,PVOID CallerData); |
| |
| typedef WINBOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR); |
| typedef WINBOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID); |
| typedef WINBOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID); |
| typedef WINBOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64); |
| typedef WINBOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context); |
| typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)(); |
| typedef WINBOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR); |
| |
| HANDLE IMAGEAPI FindDebugInfoFile(PCSTR FileName,PCSTR SymbolPath,PSTR DebugFilePath); |
| HANDLE IMAGEAPI FindDebugInfoFileEx(PCSTR FileName,PCSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData); |
| HANDLE IMAGEAPI FindDebugInfoFileExW(PCWSTR FileName,PCWSTR SymbolPath,PWSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACKW Callback,PVOID CallerData); |
| WINBOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context); |
| WINBOOL IMAGEAPI SymFindFileInPathW(HANDLE hprocess,PCWSTR SearchPath,PCWSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACKW callback,PVOID context); |
| HANDLE IMAGEAPI FindExecutableImage(PCSTR FileName,PCSTR SymbolPath,PSTR ImageFilePath); |
| HANDLE IMAGEAPI FindExecutableImageEx(PCSTR FileName,PCSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData); |
| HANDLE IMAGEAPI FindExecutableImageExW(PCWSTR FileName,PCWSTR SymbolPath,PWSTR ImageFilePath,PFIND_EXE_FILE_CALLBACKW Callback,PVOID CallerData); |
| PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base); |
| PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader); |
| PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size); |
| PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva); |
| PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection); |
| |
| #define SSRVOPT_CALLBACK 0x0001 |
| #define SSRVOPT_DWORD 0x0002 |
| #define SSRVOPT_DWORDPTR 0x0004 |
| #define SSRVOPT_GUIDPTR 0x0008 |
| #define SSRVOPT_OLDGUIDPTR 0x0010 |
| #define SSRVOPT_UNATTENDED 0x0020 |
| #define SSRVOPT_NOCOPY 0x0040 |
| #define SSRVOPT_PARENTWIN 0x0080 |
| #define SSRVOPT_PARAMTYPE 0x0100 |
| #define SSRVOPT_SECURE 0x0200 |
| #define SSRVOPT_TRACE 0x0400 |
| #define SSRVOPT_SETCONTEXT 0x0800 |
| #define SSRVOPT_PROXY 0x1000 |
| #define SSRVOPT_DOWNSTREAM_STORE 0x2000 |
| #define SSRVOPT_RESET ((ULONG_PTR)-1) |
| |
| #define SSRVACTION_TRACE 1 |
| #define SSRVACTION_QUERYCANCEL 2 |
| #define SSRVACTION_EVENT 3 |
| |
| #ifndef _WIN64 |
| typedef struct _IMAGE_DEBUG_INFORMATION { |
| LIST_ENTRY List; |
| DWORD ReservedSize; |
| PVOID ReservedMappedBase; |
| USHORT ReservedMachine; |
| USHORT ReservedCharacteristics; |
| DWORD ReservedCheckSum; |
| DWORD ImageBase; |
| DWORD SizeOfImage; |
| DWORD ReservedNumberOfSections; |
| PIMAGE_SECTION_HEADER ReservedSections; |
| DWORD ReservedExportedNamesSize; |
| PSTR ReservedExportedNames; |
| DWORD ReservedNumberOfFunctionTableEntries; |
| PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries; |
| DWORD ReservedLowestFunctionStartingAddress; |
| DWORD ReservedHighestFunctionEndingAddress; |
| DWORD ReservedNumberOfFpoTableEntries; |
| PFPO_DATA ReservedFpoTableEntries; |
| DWORD SizeOfCoffSymbols; |
| PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols; |
| DWORD ReservedSizeOfCodeViewSymbols; |
| PVOID ReservedCodeViewSymbols; |
| PSTR ImageFilePath; |
| PSTR ImageFileName; |
| PSTR ReservedDebugFilePath; |
| DWORD ReservedTimeDateStamp; |
| WINBOOL ReservedRomImage; |
| PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory; |
| DWORD ReservedNumberOfDebugDirectories; |
| DWORD ReservedOriginalFunctionTableBaseAddress; |
| DWORD Reserved[2]; |
| } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION; |
| |
| PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase); |
| WINBOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo); |
| #endif |
| |
| typedef WINBOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData); |
| |
| WINBOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer); |
| WINBOOL IMAGEAPI SearchTreeForFileW(PWSTR RootPath,PWSTR InputPathName,PWSTR OutputPathBuffer); |
| WINBOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData); |
| WINBOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath); |
| |
| #define UNDNAME_COMPLETE (0x0000) |
| #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) |
| #define UNDNAME_NO_MS_KEYWORDS (0x0002) |
| #define UNDNAME_NO_FUNCTION_RETURNS (0x0004) |
| #define UNDNAME_NO_ALLOCATION_MODEL (0x0008) |
| #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010) |
| #define UNDNAME_NO_MS_THISTYPE (0x0020) |
| #define UNDNAME_NO_CV_THISTYPE (0x0040) |
| #define UNDNAME_NO_THISTYPE (0x0060) |
| #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) |
| #define UNDNAME_NO_THROW_SIGNATURES (0x0100) |
| #define UNDNAME_NO_MEMBER_TYPE (0x0200) |
| #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400) |
| #define UNDNAME_32_BIT_DECODE (0x0800) |
| #define UNDNAME_NAME_ONLY (0x1000) |
| #define UNDNAME_NO_ARGUMENTS (0x2000) |
| #define UNDNAME_NO_SPECIAL_SYMS (0x4000) |
| |
| #define UNDNAME_NO_ARGUMENTS (0x2000) |
| #define UNDNAME_NO_SPECIAL_SYMS (0x4000) |
| |
| DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags); |
| DWORD IMAGEAPI WINAPI UnDecorateSymbolNameW(PCWSTR DecoratedName,PWSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags); |
| |
| #define DBHHEADER_DEBUGDIRS 0x1 |
| #define DBHHEADER_CVMISC 0x2 |
| |
| typedef struct _MODLOAD_CVMISC { |
| DWORD oCV; |
| size_t cCV; |
| DWORD oMisc; |
| size_t cMisc; |
| DWORD dtImage; |
| DWORD cImage; |
| } MODLOAD_CVMISC, *PMODLOAD_CVMISC; |
| |
| typedef enum { |
| AddrMode1616, |
| AddrMode1632, |
| AddrModeReal, |
| AddrModeFlat |
| } ADDRESS_MODE; |
| |
| typedef struct _tagADDRESS64 { |
| DWORD64 Offset; |
| WORD Segment; |
| ADDRESS_MODE Mode; |
| } ADDRESS64,*LPADDRESS64; |
| |
| #ifdef _IMAGEHLP64 |
| #define ADDRESS ADDRESS64 |
| #define LPADDRESS LPADDRESS64 |
| #else |
| typedef struct _tagADDRESS { |
| DWORD Offset; |
| WORD Segment; |
| ADDRESS_MODE Mode; |
| } ADDRESS,*LPADDRESS; |
| |
| static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) { |
| a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset; |
| a64->Segment = a32->Segment; |
| a64->Mode = a32->Mode; |
| } |
| |
| static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) { |
| a32->Offset = (ULONG)a64->Offset; |
| a32->Segment = a64->Segment; |
| a32->Mode = a64->Mode; |
| } |
| #endif |
| |
| typedef struct _KDHELP64 { |
| DWORD64 Thread; |
| DWORD ThCallbackStack; |
| DWORD ThCallbackBStore; |
| DWORD NextCallback; |
| DWORD FramePointer; |
| DWORD64 KiCallUserMode; |
| DWORD64 KeUserCallbackDispatcher; |
| DWORD64 SystemRangeStart; |
| DWORD64 KiUserExceptionDispatcher; |
| DWORD64 StackBase; |
| DWORD64 StackLimit; |
| DWORD BuildVersion; |
| DWORD RetpolineStubFunctionTableSize; |
| DWORD64 RetpolineStubFunctionTable; |
| DWORD RetpolineStubOffset; |
| DWORD RetpolineStubSize; |
| DWORD64 Reserved0[2]; |
| } KDHELP64,*PKDHELP64; |
| |
| #ifdef _IMAGEHLP64 |
| #define KDHELP KDHELP64 |
| #define PKDHELP PKDHELP64 |
| #else |
| typedef struct _KDHELP { |
| DWORD Thread; |
| DWORD ThCallbackStack; |
| DWORD NextCallback; |
| DWORD FramePointer; |
| DWORD KiCallUserMode; |
| DWORD KeUserCallbackDispatcher; |
| DWORD SystemRangeStart; |
| DWORD ThCallbackBStore; |
| DWORD KiUserExceptionDispatcher; |
| DWORD StackBase; |
| DWORD StackLimit; |
| DWORD Reserved[5]; |
| } KDHELP,*PKDHELP; |
| |
| static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) { |
| p64->Thread = p32->Thread; |
| p64->ThCallbackStack = p32->ThCallbackStack; |
| p64->NextCallback = p32->NextCallback; |
| p64->FramePointer = p32->FramePointer; |
| p64->KiCallUserMode = p32->KiCallUserMode; |
| p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher; |
| p64->SystemRangeStart = p32->SystemRangeStart; |
| p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher; |
| p64->StackBase = p32->StackBase; |
| p64->StackLimit = p32->StackLimit; |
| } |
| #endif |
| |
| typedef struct _tagSTACKFRAME64 { |
| ADDRESS64 AddrPC; |
| ADDRESS64 AddrReturn; |
| ADDRESS64 AddrFrame; |
| ADDRESS64 AddrStack; |
| ADDRESS64 AddrBStore; |
| PVOID FuncTableEntry; |
| DWORD64 Params[4]; |
| WINBOOL Far; |
| WINBOOL Virtual; |
| DWORD64 Reserved[3]; |
| KDHELP64 KdHelp; |
| } STACKFRAME64,*LPSTACKFRAME64; |
| |
| #define INLINE_FRAME_CONTEXT_INIT 0 |
| #define INLINE_FRAME_CONTEXT_IGNORE 0xFFFFFFFF |
| |
| typedef struct _tagSTACKFRAME_EX { |
| ADDRESS64 AddrPC; |
| ADDRESS64 AddrReturn; |
| ADDRESS64 AddrFrame; |
| ADDRESS64 AddrStack; |
| ADDRESS64 AddrBStore; |
| PVOID FuncTableEntry; |
| DWORD64 Params[4]; |
| WINBOOL Far; |
| WINBOOL Virtual; |
| DWORD64 Reserved[3]; |
| KDHELP64 KdHelp; |
| DWORD StackFrameSize; |
| DWORD InlineFrameContext; |
| } STACKFRAME_EX,*LPSTACKFRAME_EX; |
| |
| #ifdef _IMAGEHLP64 |
| #define STACKFRAME STACKFRAME64 |
| #define LPSTACKFRAME LPSTACKFRAME64 |
| #else |
| typedef struct _tagSTACKFRAME { |
| ADDRESS AddrPC; |
| ADDRESS AddrReturn; |
| ADDRESS AddrFrame; |
| ADDRESS AddrStack; |
| PVOID FuncTableEntry; |
| DWORD Params[4]; |
| WINBOOL Far; |
| WINBOOL Virtual; |
| DWORD Reserved[3]; |
| KDHELP KdHelp; |
| ADDRESS AddrBStore; |
| } STACKFRAME,*LPSTACKFRAME; |
| #endif |
| |
| typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead); |
| typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase); |
| typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address); |
| typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr); |
| |
| WINBOOL IMAGEAPI StackWalk64(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); |
| |
| #ifdef _IMAGEHLP64 |
| #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64 |
| #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64 |
| #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64 |
| #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64 |
| #define StackWalk StackWalk64 |
| #else |
| typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead); |
| typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase); |
| typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address); |
| typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr); |
| |
| WINBOOL IMAGEAPI 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); |
| #endif |
| |
| #define API_VERSION_NUMBER 11 |
| |
| typedef struct API_VERSION { |
| USHORT MajorVersion; |
| USHORT MinorVersion; |
| USHORT Revision; |
| USHORT Reserved; |
| } API_VERSION,*LPAPI_VERSION; |
| |
| LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID); |
| LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion); |
| DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module); |
| |
| typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext); |
| typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext); |
| typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext); |
| |
| #ifdef _IMAGEHLP64 |
| #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64 |
| #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64 |
| #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W |
| #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64 |
| #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64 |
| #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64 |
| #else |
| typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR ModuleName,ULONG BaseOfDll,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext); |
| #endif |
| |
| #define SYMFLAG_VALUEPRESENT 0x00000001 |
| #define SYMFLAG_REGISTER 0x00000008 |
| #define SYMFLAG_REGREL 0x00000010 |
| #define SYMFLAG_FRAMEREL 0x00000020 |
| #define SYMFLAG_PARAMETER 0x00000040 |
| #define SYMFLAG_LOCAL 0x00000080 |
| #define SYMFLAG_CONSTANT 0x00000100 |
| #define SYMFLAG_EXPORT 0x00000200 |
| #define SYMFLAG_FORWARDER 0x00000400 |
| #define SYMFLAG_FUNCTION 0x00000800 |
| #define SYMFLAG_VIRTUAL 0x00001000 |
| #define SYMFLAG_THUNK 0x00002000 |
| #define SYMFLAG_TLSREL 0x00004000 |
| #define SYMFLAG_SLOT 0x00008000 |
| #define SYMFLAG_ILREL 0x00010000 |
| #define SYMFLAG_METADATA 0x00020000 |
| #define SYMFLAG_CLR_TOKEN 0x00040000 |
| #define SYMFLAG_NULL 0x00080000 |
| #define SYMFLAG_FUNC_NO_RETURN 0x00100000 |
| #define SYMFLAG_SYNTHETIC_ZEROBASE 0x00200000 |
| #define SYMFLAG_PUBLIC_CODE 0x00400000 |
| #define SYMFLAG_REGREL_ALIASINDIR 0x00800000 |
| #define SYMFLAG_FIXUP_ARM64X 0x01000000 |
| #define SYMFLAG_GLOBAL 0x02000000 |
| #define SYMFLAG_RESET 0x80000000 |
| |
| typedef enum { |
| SymNone = 0, |
| SymCoff, |
| SymCv, |
| SymPdb, |
| SymExport, |
| SymDeferred, |
| SymSym, |
| SymDia, |
| SymVirtual, |
| NumSymTypes |
| } SYM_TYPE; |
| |
| typedef struct _IMAGEHLP_SYMBOL64 { |
| DWORD SizeOfStruct; |
| DWORD64 Address; |
| DWORD Size; |
| DWORD Flags; |
| DWORD MaxNameLength; |
| CHAR Name[1]; |
| } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64; |
| |
| typedef struct _IMAGEHLP_SYMBOL64_PACKAGE { |
| IMAGEHLP_SYMBOL64 sym; |
| CHAR name[MAX_SYM_NAME + 1]; |
| } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE; |
| |
| #ifdef _IMAGEHLP64 |
| |
| #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64 |
| #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64 |
| #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE |
| #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE |
| #else |
| |
| typedef struct _IMAGEHLP_SYMBOL { |
| DWORD SizeOfStruct; |
| DWORD Address; |
| DWORD Size; |
| DWORD Flags; |
| DWORD MaxNameLength; |
| CHAR Name[1]; |
| } IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL; |
| |
| typedef struct _IMAGEHLP_SYMBOL_PACKAGE { |
| IMAGEHLP_SYMBOL sym; |
| CHAR name[MAX_SYM_NAME + 1]; |
| } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE; |
| #endif |
| |
| typedef struct _IMAGEHLP_MODULE64 { |
| DWORD SizeOfStruct; |
| DWORD64 BaseOfImage; |
| DWORD ImageSize; |
| DWORD TimeDateStamp; |
| DWORD CheckSum; |
| DWORD NumSyms; |
| SYM_TYPE SymType; |
| CHAR ModuleName[32]; |
| CHAR ImageName[256]; |
| CHAR LoadedImageName[256]; |
| CHAR LoadedPdbName[256]; |
| DWORD CVSig; |
| CHAR CVData[MAX_PATH*3]; |
| DWORD PdbSig; |
| GUID PdbSig70; |
| DWORD PdbAge; |
| WINBOOL PdbUnmatched; |
| WINBOOL DbgUnmatched; |
| WINBOOL LineNumbers; |
| WINBOOL GlobalSymbols; |
| WINBOOL TypeInfo; |
| WINBOOL SourceIndexed; |
| WINBOOL Publics; |
| DWORD MachineType; |
| DWORD Reserved; |
| } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64; |
| |
| typedef struct _IMAGEHLP_MODULE64_EX { |
| IMAGEHLP_MODULE64 Module; |
| DWORD RegionFlags; |
| } IMAGEHLP_MODULE64_EX,*PIMAGEHLP_MODULE64_EX; |
| |
| typedef struct _IMAGEHLP_MODULE64W { |
| DWORD SizeOfStruct; |
| DWORD64 BaseOfImage; |
| DWORD ImageSize; |
| DWORD TimeDateStamp; |
| DWORD CheckSum; |
| DWORD NumSyms; |
| SYM_TYPE SymType; |
| WCHAR ModuleName[32]; |
| WCHAR ImageName[256]; |
| WCHAR LoadedImageName[256]; |
| WCHAR LoadedPdbName[256]; |
| DWORD CVSig; |
| WCHAR CVData[MAX_PATH*3]; |
| DWORD PdbSig; |
| GUID PdbSig70; |
| DWORD PdbAge; |
| WINBOOL PdbUnmatched; |
| WINBOOL DbgUnmatched; |
| WINBOOL LineNumbers; |
| WINBOOL GlobalSymbols; |
| WINBOOL TypeInfo; |
| WINBOOL SourceIndexed; |
| WINBOOL Publics; |
| DWORD MachineType; |
| DWORD Reserved; |
| } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64; |
| |
| typedef struct _IMAGEHLP_MODULEW64_EX { |
| IMAGEHLP_MODULEW64 Module; |
| DWORD RegionFlags; |
| } IMAGEHLP_MODULEW64_EX,*PIMAGEHLP_MODULEW64_EX; |
| |
| #ifdef _IMAGEHLP64 |
| #define IMAGEHLP_MODULE IMAGEHLP_MODULE64 |
| #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64 |
| #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64 |
| #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64 |
| #else |
| typedef struct _IMAGEHLP_MODULE { |
| DWORD SizeOfStruct; |
| DWORD BaseOfImage; |
| DWORD ImageSize; |
| DWORD TimeDateStamp; |
| DWORD CheckSum; |
| DWORD NumSyms; |
| SYM_TYPE SymType; |
| CHAR ModuleName[32]; |
| CHAR ImageName[256]; |
| CHAR LoadedImageName[256]; |
| } IMAGEHLP_MODULE,*PIMAGEHLP_MODULE; |
| |
| typedef struct _IMAGEHLP_MODULEW { |
| DWORD SizeOfStruct; |
| DWORD BaseOfImage; |
| DWORD ImageSize; |
| DWORD TimeDateStamp; |
| DWORD CheckSum; |
| DWORD NumSyms; |
| SYM_TYPE SymType; |
| WCHAR ModuleName[32]; |
| WCHAR ImageName[256]; |
| WCHAR LoadedImageName[256]; |
| } IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW; |
| #endif |
| |
| typedef struct _IMAGEHLP_LINE64 { |
| DWORD SizeOfStruct; |
| PVOID Key; |
| DWORD LineNumber; |
| PCHAR FileName; |
| DWORD64 Address; |
| } IMAGEHLP_LINE64,*PIMAGEHLP_LINE64; |
| |
| typedef struct _IMAGEHLP_LINEW64 { |
| DWORD SizeOfStruct; |
| PVOID Key; |
| DWORD LineNumber; |
| PWSTR FileName; |
| DWORD64 Address; |
| } IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64; |
| |
| #ifdef _IMAGEHLP64 |
| #define IMAGEHLP_LINE IMAGEHLP_LINE64 |
| #define PIMAGEHLP_LINE PIMAGEHLP_LINE64 |
| #else |
| typedef struct _IMAGEHLP_LINE { |
| DWORD SizeOfStruct; |
| PVOID Key; |
| DWORD LineNumber; |
| PCHAR FileName; |
| DWORD Address; |
| } IMAGEHLP_LINE,*PIMAGEHLP_LINE; |
| |
| typedef struct _IMAGEHLP_LINEW { |
| DWORD SizeOfStruct; |
| PVOID Key; |
| DWORD LineNumber; |
| PWSTR FileName; |
| DWORD Address; |
| } IMAGEHLP_LINEW,*PIMAGEHLP_LINEW; |
| #endif |
| |
| typedef struct _SOURCEFILE { |
| DWORD64 ModBase; |
| PCHAR FileName; |
| } SOURCEFILE,*PSOURCEFILE; |
| |
| typedef struct _SOURCEFILEW { |
| DWORD64 ModBase; |
| PWCHAR FileName; |
| } SOURCEFILEW,*PSOURCEFILEW; |
| |
| #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 |
| #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 |
| #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 |
| #define CBA_SYMBOLS_UNLOADED 0x00000004 |
| #define CBA_DUPLICATE_SYMBOL 0x00000005 |
| #define CBA_READ_MEMORY 0x00000006 |
| #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 |
| #define CBA_SET_OPTIONS 0x00000008 |
| #define CBA_EVENT 0x00000010 |
| #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 |
| #define CBA_DEBUG_INFO 0x10000000 |
| #define CBA_SRCSRV_INFO 0x20000000 |
| #define CBA_SRCSRV_EVENT 0x40000000 |
| |
| typedef struct _IMAGEHLP_CBA_READ_MEMORY { |
| DWORD64 addr; |
| PVOID buf; |
| DWORD bytes; |
| DWORD *bytesread; |
| } IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY; |
| |
| enum { |
| sevInfo = 0, |
| sevProblem, |
| sevAttn, |
| sevFatal, |
| sevMax |
| }; |
| |
| typedef struct _IMAGEHLP_CBA_EVENT { |
| DWORD severity; |
| DWORD code; |
| PCHAR desc; |
| PVOID object; |
| } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT; |
| |
| typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 { |
| DWORD SizeOfStruct; |
| DWORD64 BaseOfImage; |
| DWORD CheckSum; |
| DWORD TimeDateStamp; |
| CHAR FileName[MAX_PATH]; |
| BOOLEAN Reparse; |
| HANDLE hFile; |
| DWORD Flags; |
| } IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; |
| |
| #define DSLFLAG_MISMATCHED_PDB 0x1 |
| #define DSLFLAG_MISMATCHED_DBG 0x2 |
| |
| #ifdef _IMAGEHLP64 |
| #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64 |
| #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 |
| #else |
| typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD { |
| DWORD SizeOfStruct; |
| DWORD BaseOfImage; |
| DWORD CheckSum; |
| DWORD TimeDateStamp; |
| CHAR FileName[MAX_PATH]; |
| BOOLEAN Reparse; |
| HANDLE hFile; |
| } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD; |
| #endif |
| |
| typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 { |
| DWORD SizeOfStruct; |
| DWORD NumberOfDups; |
| PIMAGEHLP_SYMBOL64 Symbol; |
| DWORD SelectedSymbol; |
| } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64; |
| |
| #ifdef _IMAGEHLP64 |
| #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64 |
| #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64 |
| #else |
| typedef struct _IMAGEHLP_DUPLICATE_SYMBOL { |
| DWORD SizeOfStruct; |
| DWORD NumberOfDups; |
| PIMAGEHLP_SYMBOL Symbol; |
| DWORD SelectedSymbol; |
| } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL; |
| #endif |
| |
| typedef struct _SYMSRV_INDEX_INFO { |
| DWORD sizeofstruct; |
| CHAR file[MAX_PATH +1]; |
| WINBOOL stripped; |
| DWORD timestamp; |
| DWORD size; |
| CHAR dbgfile[MAX_PATH +1]; |
| CHAR pdbfile[MAX_PATH + 1]; |
| GUID guid; |
| DWORD sig; |
| DWORD age; |
| } SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO; |
| |
| typedef struct _SYMSRV_INDEX_INFOW { |
| DWORD sizeofstruct; |
| WCHAR file[MAX_PATH +1]; |
| WINBOOL stripped; |
| DWORD timestamp; |
| DWORD size; |
| WCHAR dbgfile[MAX_PATH +1]; |
| WCHAR pdbfile[MAX_PATH + 1]; |
| GUID guid; |
| DWORD sig; |
| DWORD age; |
| } SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW; |
| |
| WINBOOL IMAGEAPI SymSetParentWindow(HWND hwnd); |
| PCHAR IMAGEAPI SymSetHomeDirectory(HANDLE hProcess,PCSTR dir); |
| PCHAR IMAGEAPI SymSetHomeDirectoryW(HANDLE hProcess,PCWSTR dir); |
| PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size); |
| PWCHAR IMAGEAPI SymGetHomeDirectoryW(DWORD type,PWSTR dir,size_t size); |
| |
| #define hdBase 0 |
| #define hdSym 1 |
| #define hdSrc 2 |
| #define hdMax 3 |
| |
| #define SYMOPT_CASE_INSENSITIVE 0x00000001 |
| #define SYMOPT_UNDNAME 0x00000002 |
| #define SYMOPT_DEFERRED_LOADS 0x00000004 |
| #define SYMOPT_NO_CPP 0x00000008 |
| #define SYMOPT_LOAD_LINES 0x00000010 |
| #define SYMOPT_OMAP_FIND_NEAREST 0x00000020 |
| #define SYMOPT_LOAD_ANYTHING 0x00000040 |
| #define SYMOPT_IGNORE_CVREC 0x00000080 |
| #define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100 |
| #define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200 |
| #define SYMOPT_EXACT_SYMBOLS 0x00000400 |
| #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 |
| #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 |
| #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 |
| #define SYMOPT_PUBLICS_ONLY 0x00004000 |
| #define SYMOPT_NO_PUBLICS 0x00008000 |
| #define SYMOPT_AUTO_PUBLICS 0x00010000 |
| #define SYMOPT_NO_IMAGE_SEARCH 0x00020000 |
| #define SYMOPT_SECURE 0x00040000 |
| #define SYMOPT_NO_PROMPTS 0x00080000 |
| #define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000 |
| #define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000 |
| #define SYMOPT_FAVOR_COMPRESSED 0x00800000 |
| #define SYMOPT_FLAT_DIRECTORY 0x00400000 |
| #define SYMOPT_IGNORE_IMAGEDIR 0x00200000 |
| #define SYMOPT_OVERWRITE 0x00100000 |
| |
| #define SYMOPT_DEBUG 0x80000000 |
| |
| DWORD IMAGEAPI SymSetOptions(DWORD SymOptions); |
| DWORD IMAGEAPI SymGetOptions(VOID); |
| WINBOOL IMAGEAPI SymCleanup(HANDLE hProcess); |
| WINBOOL IMAGEAPI SymMatchString(PCSTR string,PCSTR expression,WINBOOL fCase); |
| WINBOOL IMAGEAPI SymMatchStringW(PCWSTR string,PCWSTR expression,WINBOOL fCase); |
| |
| typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW pSourceFile,PVOID UserContext); |
| #define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK |
| |
| WINBOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,PCSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumSourceFilesW(HANDLE hProcess,ULONG64 ModBase,PCWSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumerateModulesW64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,PVOID UserContext); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymEnumerateModules SymEnumerateModules64 |
| #else |
| WINBOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext); |
| #endif |
| |
| WINBOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymEnumerateSymbols SymEnumerateSymbols64 |
| #define SymEnumerateSymbolsW SymEnumerateSymbolsW64 |
| #else |
| WINBOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); |
| #endif |
| |
| WINBOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI EnumerateLoadedModulesW64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,PVOID UserContext); |
| |
| #ifdef _IMAGEHLP64 |
| #define EnumerateLoadedModules EnumerateLoadedModules64 |
| #else |
| WINBOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext); |
| #endif |
| |
| PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymFunctionTableAccess SymFunctionTableAccess64 |
| #else |
| PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo); |
| WINBOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetModuleInfo SymGetModuleInfo64 |
| #define SymGetModuleInfoW SymGetModuleInfoW64 |
| #else |
| WINBOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo); |
| WINBOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo); |
| #endif |
| |
| DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetModuleBase SymGetModuleBase64 |
| #else |
| DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetSymNext SymGetSymNext64 |
| #else |
| WINBOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetSymPrev SymGetSymPrev64 |
| #else |
| WINBOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol); |
| #endif |
| |
| typedef struct _SRCCODEINFO { |
| DWORD SizeOfStruct; |
| PVOID Key; |
| DWORD64 ModBase; |
| CHAR Obj[MAX_PATH + 1]; |
| CHAR FileName[MAX_PATH + 1]; |
| DWORD LineNumber; |
| DWORD64 Address; |
| } SRCCODEINFO,*PSRCCODEINFO; |
| |
| typedef struct _SRCCODEINFOW { |
| DWORD SizeOfStruct; |
| PVOID Key; |
| DWORD64 ModBase; |
| WCHAR Obj[MAX_PATH + 1]; |
| WCHAR FileName[MAX_PATH + 1]; |
| DWORD LineNumber; |
| DWORD64 Address; |
| } SRCCODEINFOW,*PSRCCODEINFOW; |
| |
| typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW LineInfo,PVOID UserContext); |
| |
| WINBOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumLinesW(HANDLE hProcess,ULONG64 Base,PCWSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64); |
| WINBOOL IMAGEAPI SymGetLineFromAddrW64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW64 Line64); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetLineFromAddr SymGetLineFromAddr64 |
| #define SymGetLineFromAddrW SymGetLineFromAddrW64 |
| #else |
| WINBOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line); |
| WINBOOL IMAGEAPI SymGetLineFromAddrW(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW Line); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line); |
| WINBOOL IMAGEAPI SymGetLineFromNameW64(HANDLE hProcess,PCWSTR ModuleName,PCWSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINEW64 Line); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetLineFromName SymGetLineFromName64 |
| #else |
| WINBOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line); |
| WINBOOL IMAGEAPI SymGetLineNextW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetLineNext SymGetLineNext64 |
| #else |
| WINBOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line); |
| WINBOOL IMAGEAPI SymGetLinePrevW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetLinePrev SymGetLinePrev64 |
| #else |
| WINBOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line); |
| #endif |
| |
| WINBOOL IMAGEAPI SymMatchFileName(PCSTR FileName,PCSTR Match,PSTR *FileNameStop,PSTR *MatchStop); |
| WINBOOL IMAGEAPI SymMatchFileNameW(PCWSTR FileName,PCWSTR Match,PWSTR *FileNameStop,PWSTR *MatchStop); |
| WINBOOL IMAGEAPI SymInitialize(HANDLE hProcess,PCSTR UserSearchPath,WINBOOL fInvadeProcess); |
| WINBOOL IMAGEAPI SymInitializeW(HANDLE hProcess,PCWSTR UserSearchPath,WINBOOL fInvadeProcess); |
| WINBOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength); |
| WINBOOL IMAGEAPI SymGetSearchPathW(HANDLE hProcess,PWSTR SearchPath,DWORD SearchPathLength); |
| WINBOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PCSTR SearchPath); |
| WINBOOL IMAGEAPI SymSetSearchPathW(HANDLE hProcess,PCWSTR SearchPath); |
| DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll); |
| |
| #define SLMFLAG_VIRTUAL 0x1 |
| |
| DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags); |
| DWORD64 IMAGEAPI SymLoadModuleExW(HANDLE hProcess,HANDLE hFile,PCWSTR ImageName,PCWSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymLoadModule SymLoadModule64 |
| #else |
| DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll); |
| #endif |
| |
| WINBOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymUnloadModule SymUnloadModule64 |
| #else |
| WINBOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll); |
| #endif |
| |
| WINBOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymUnDName SymUnDName64 |
| #else |
| WINBOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength); |
| #endif |
| |
| WINBOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext); |
| WINBOOL IMAGEAPI SymRegisterCallback64W(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext); |
| |
| WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymRegisterCallback SymRegisterCallback64 |
| #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64 |
| #else |
| WINBOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext); |
| WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext); |
| #endif |
| |
| typedef struct _IMAGEHLP_SYMBOL_SRC { |
| DWORD sizeofstruct; |
| DWORD type; |
| char file[MAX_PATH]; |
| } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC; |
| |
| typedef struct _MODULE_TYPE_INFO { |
| USHORT dataLength; |
| USHORT leaf; |
| BYTE data[1]; |
| } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO; |
| |
| typedef struct _SYMBOL_INFO { |
| ULONG SizeOfStruct; |
| ULONG TypeIndex; |
| ULONG64 Reserved[2]; |
| ULONG info; |
| ULONG Size; |
| ULONG64 ModBase; |
| ULONG Flags; |
| ULONG64 Value; |
| ULONG64 Address; |
| ULONG Register; |
| ULONG Scope; |
| ULONG Tag; |
| ULONG NameLen; |
| ULONG MaxNameLen; |
| CHAR Name[1]; |
| } SYMBOL_INFO,*PSYMBOL_INFO; |
| |
| typedef struct _SYMBOL_INFOW { |
| ULONG SizeOfStruct; |
| ULONG TypeIndex; |
| ULONG64 Reserved[2]; |
| ULONG info; |
| ULONG Size; |
| ULONG64 ModBase; |
| ULONG Flags; |
| ULONG64 Value; |
| ULONG64 Address; |
| ULONG Register; |
| ULONG Scope; |
| ULONG Tag; |
| ULONG NameLen; |
| ULONG MaxNameLen; |
| WCHAR Name[1]; |
| } SYMBOL_INFOW,*PSYMBOL_INFOW; |
| |
| #define SYMFLAG_CLR_TOKEN 0x00040000 |
| #define SYMFLAG_CONSTANT 0x00000100 |
| #define SYMFLAG_EXPORT 0x00000200 |
| #define SYMFLAG_FORWARDER 0x00000400 |
| #define SYMFLAG_FRAMEREL 0x00000020 |
| #define SYMFLAG_FUNCTION 0x00000800 |
| #define SYMFLAG_ILREL 0x00010000 |
| #define SYMFLAG_LOCAL 0x00000080 |
| #define SYMFLAG_METADATA 0x00020000 |
| #define SYMFLAG_PARAMETER 0x00000040 |
| #define SYMFLAG_REGISTER 0x00000008 |
| #define SYMFLAG_REGREL 0x00000010 |
| #define SYMFLAG_SLOT 0x00008000 |
| #define SYMFLAG_THUNK 0x00002000 |
| #define SYMFLAG_TLSREL 0x00004000 |
| #define SYMFLAG_VALUEPRESENT 0x00000001 |
| #define SYMFLAG_VIRTUAL 0x00001000 |
| |
| typedef struct _SYMBOL_INFO_PACKAGE { |
| SYMBOL_INFO si; |
| CHAR name[MAX_SYM_NAME + 1]; |
| } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE; |
| |
| typedef struct _IMAGEHLP_STACK_FRAME { |
| ULONG64 InstructionOffset; |
| ULONG64 ReturnOffset; |
| ULONG64 FrameOffset; |
| ULONG64 StackOffset; |
| ULONG64 BackingStoreOffset; |
| ULONG64 FuncTableEntry; |
| ULONG64 Params[4]; |
| ULONG64 Reserved[5]; |
| WINBOOL Virtual; |
| ULONG Reserved2; |
| } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME; |
| |
| typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT; |
| |
| WINBOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context); |
| WINBOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol); |
| WINBOOL IMAGEAPI SymFromAddrW(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFOW Symbol); |
| WINBOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol); |
| WINBOOL IMAGEAPI SymFromTokenW(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFOW Symbol); |
| WINBOOL IMAGEAPI SymFromName(HANDLE hProcess,PCSTR Name,PSYMBOL_INFO Symbol); |
| WINBOOL IMAGEAPI SymFromNameW(HANDLE hProcess,PCWSTR Name,PSYMBOL_INFOW Symbol); |
| |
| typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext); |
| typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW pSymInfo,ULONG SymbolSize,PVOID UserContext); |
| |
| WINBOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumSymbolsW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumSymbolsForAddrW(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); |
| |
| #define SYMENUMFLAG_FULLSRCH 1 |
| #define SYMENUMFLAG_SPEEDSRCH 2 |
| |
| typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO { |
| TI_GET_SYMTAG, |
| TI_GET_SYMNAME, |
| TI_GET_LENGTH, |
| TI_GET_TYPE, |
| TI_GET_TYPEID, |
| TI_GET_BASETYPE, |
| TI_GET_ARRAYINDEXTYPEID, |
| TI_FINDCHILDREN, |
| TI_GET_DATAKIND, |
| TI_GET_ADDRESSOFFSET, |
| TI_GET_OFFSET, |
| TI_GET_VALUE, |
| TI_GET_COUNT, |
| TI_GET_CHILDRENCOUNT, |
| TI_GET_BITPOSITION, |
| TI_GET_VIRTUALBASECLASS, |
| TI_GET_VIRTUALTABLESHAPEID, |
| TI_GET_VIRTUALBASEPOINTEROFFSET, |
| TI_GET_CLASSPARENTID, |
| TI_GET_NESTED, |
| TI_GET_SYMINDEX, |
| TI_GET_LEXICALPARENT, |
| TI_GET_ADDRESS, |
| TI_GET_THISADJUST, |
| TI_GET_UDTKIND, |
| TI_IS_EQUIV_TO, |
| TI_GET_CALLING_CONVENTION |
| } IMAGEHLP_SYMBOL_TYPE_INFO; |
| |
| typedef struct _TI_FINDCHILDREN_PARAMS { |
| ULONG Count; |
| ULONG Start; |
| ULONG ChildId[1]; |
| } TI_FINDCHILDREN_PARAMS; |
| |
| WINBOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo); |
| WINBOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymEnumTypesW(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); |
| WINBOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,PSYMBOL_INFO Symbol); |
| WINBOOL IMAGEAPI SymGetTypeFromNameW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,PSYMBOL_INFOW Symbol); |
| WINBOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags); |
| WINBOOL IMAGEAPI SymAddSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Size,DWORD Flags); |
| WINBOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags); |
| WINBOOL IMAGEAPI SymDeleteSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Flags); |
| |
| typedef WINBOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData); |
| |
| WINBOOL WINAPI DbgHelpCreateUserDump(LPCSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData); |
| WINBOOL WINAPI DbgHelpCreateUserDumpW(LPCWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData); |
| WINBOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetSymFromAddr SymGetSymFromAddr64 |
| #else |
| WINBOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol); |
| #endif |
| |
| WINBOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL64 Symbol); |
| |
| #ifdef _IMAGEHLP64 |
| #define SymGetSymFromName SymGetSymFromName64 |
| #else |
| WINBOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL Symbol); |
| #endif |
| |
| DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,PSTR FilePath); |
| DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,DWORD one,DWORD two,DWORD three,PSTR FilePath); |
| DBHLP_DEPRECIATED WINBOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #define SYMF_OMAP_GENERATED 0x00000001 |
| #define SYMF_OMAP_MODIFIED 0x00000002 |
| #define SYMF_REGISTER 0x00000008 |
| #define SYMF_REGREL 0x00000010 |
| #define SYMF_FRAMEREL 0x00000020 |
| #define SYMF_PARAMETER 0x00000040 |
| #define SYMF_LOCAL 0x00000080 |
| #define SYMF_CONSTANT 0x00000100 |
| #define SYMF_EXPORT 0x00000200 |
| #define SYMF_FORWARDER 0x00000400 |
| #define SYMF_FUNCTION 0x00000800 |
| #define SYMF_VIRTUAL 0x00001000 |
| #define SYMF_THUNK 0x00002000 |
| #define SYMF_TLSREL 0x00004000 |
| |
| #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1 |
| #define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER |
| #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL |
| #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL |
| #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER |
| #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL |
| #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT |
| #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION |
| #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL |
| #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK |
| #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL |
| |
| #include <pshpack4.h> |
| |
| #define MINIDUMP_SIGNATURE ('PMDM') |
| #define MINIDUMP_VERSION (42899) |
| typedef DWORD RVA; |
| typedef ULONG64 RVA64; |
| |
| typedef struct _MINIDUMP_LOCATION_DESCRIPTOR { |
| ULONG32 DataSize; |
| RVA Rva; |
| } MINIDUMP_LOCATION_DESCRIPTOR; |
| |
| typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 { |
| ULONG64 DataSize; |
| RVA64 Rva; |
| } MINIDUMP_LOCATION_DESCRIPTOR64; |
| |
| typedef struct _MINIDUMP_MEMORY_DESCRIPTOR { |
| ULONG64 StartOfMemoryRange; |
| MINIDUMP_LOCATION_DESCRIPTOR Memory; |
| } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR; |
| |
| typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 { |
| ULONG64 StartOfMemoryRange; |
| ULONG64 DataSize; |
| } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64; |
| |
| typedef struct _MINIDUMP_HEADER { |
| ULONG32 Signature; |
| ULONG32 Version; |
| ULONG32 NumberOfStreams; |
| RVA StreamDirectoryRva; |
| ULONG32 CheckSum; |
| __C89_NAMELESS union { |
| ULONG32 Reserved; |
| ULONG32 TimeDateStamp; |
| }; |
| ULONG64 Flags; |
| } MINIDUMP_HEADER,*PMINIDUMP_HEADER; |
| |
| typedef struct _MINIDUMP_DIRECTORY { |
| ULONG32 StreamType; |
| MINIDUMP_LOCATION_DESCRIPTOR Location; |
| } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY; |
| |
| typedef struct _MINIDUMP_STRING { |
| ULONG32 Length; |
| WCHAR Buffer[0]; |
| } MINIDUMP_STRING,*PMINIDUMP_STRING; |
| |
| typedef enum _MINIDUMP_STREAM_TYPE { |
| UnusedStream = 0, |
| ReservedStream0 = 1, |
| ReservedStream1 = 2, |
| ThreadListStream = 3, |
| ModuleListStream = 4, |
| MemoryListStream = 5, |
| ExceptionStream = 6, |
| SystemInfoStream = 7, |
| ThreadExListStream = 8, |
| Memory64ListStream = 9, |
| CommentStreamA = 10, |
| CommentStreamW = 11, |
| HandleDataStream = 12, |
| FunctionTableStream = 13, |
| UnloadedModuleListStream = 14, |
| MiscInfoStream = 15, |
| MemoryInfoListStream = 16, |
| ThreadInfoListStream = 17, |
| HandleOperationListStream = 18, |
| TokenStream = 19, |
| JavaScriptDataStream = 20, |
| SystemMemoryInfoStream = 21, |
| ProcessVmCountersStream = 22, |
| IptTraceStream = 23, |
| ThreadNamesStream = 24, |
| ceStreamNull = 0x8000, |
| ceStreamSystemInfo = 0x8001, |
| ceStreamException = 0x8002, |
| ceStreamModuleList = 0x8003, |
| ceStreamProcessList = 0x8004, |
| ceStreamThreadList = 0x8005, |
| ceStreamThreadContextList = 0x8006, |
| ceStreamThreadCallStackList = 0x8007, |
| ceStreamMemoryVirtualList = 0x8008, |
| ceStreamMemoryPhysicalList = 0x8009, |
| ceStreamBucketParameters = 0x800a, |
| ceStreamProcessModuleMap = 0x800b, |
| ceStreamDiagnosisList = 0x800c, |
| LastReservedStream = 0xffff |
| } MINIDUMP_STREAM_TYPE; |
| |
| typedef union _CPU_INFORMATION { |
| struct { |
| ULONG32 VendorId[3]; |
| ULONG32 VersionInformation; |
| ULONG32 FeatureInformation; |
| ULONG32 AMDExtendedCpuFeatures; |
| } X86CpuInfo; |
| struct { |
| ULONG64 ProcessorFeatures[2]; |
| } OtherCpuInfo; |
| } CPU_INFORMATION,*PCPU_INFORMATION; |
| |
| typedef struct _MINIDUMP_SYSTEM_INFO { |
| USHORT ProcessorArchitecture; |
| USHORT ProcessorLevel; |
| USHORT ProcessorRevision; |
| __C89_NAMELESS union { |
| USHORT Reserved0; |
| __C89_NAMELESS struct { |
| UCHAR NumberOfProcessors; |
| UCHAR ProductType; |
| }; |
| }; |
| ULONG32 MajorVersion; |
| ULONG32 MinorVersion; |
| ULONG32 BuildNumber; |
| ULONG32 PlatformId; |
| RVA CSDVersionRva; |
| __C89_NAMELESS union { |
| ULONG32 Reserved1; |
| __C89_NAMELESS struct { |
| USHORT SuiteMask; |
| USHORT Reserved2; |
| }; |
| }; |
| CPU_INFORMATION Cpu; |
| } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO; |
| |
| C_ASSERT(sizeof(((PPROCESS_INFORMATION)0)->dwThreadId)==4); |
| |
| typedef struct _MINIDUMP_THREAD { |
| ULONG32 ThreadId; |
| ULONG32 SuspendCount; |
| ULONG32 PriorityClass; |
| ULONG32 Priority; |
| ULONG64 Teb; |
| MINIDUMP_MEMORY_DESCRIPTOR Stack; |
| MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; |
| } MINIDUMP_THREAD,*PMINIDUMP_THREAD; |
| |
| typedef struct _MINIDUMP_THREAD_LIST { |
| ULONG32 NumberOfThreads; |
| MINIDUMP_THREAD Threads[0]; |
| } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST; |
| |
| typedef struct _MINIDUMP_THREAD_EX { |
| ULONG32 ThreadId; |
| ULONG32 SuspendCount; |
| ULONG32 PriorityClass; |
| ULONG32 Priority; |
| ULONG64 Teb; |
| MINIDUMP_MEMORY_DESCRIPTOR Stack; |
| MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; |
| MINIDUMP_MEMORY_DESCRIPTOR BackingStore; |
| } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX; |
| |
| typedef struct _MINIDUMP_THREAD_EX_LIST { |
| ULONG32 NumberOfThreads; |
| MINIDUMP_THREAD_EX Threads[0]; |
| } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST; |
| |
| typedef struct _MINIDUMP_EXCEPTION { |
| ULONG32 ExceptionCode; |
| ULONG32 ExceptionFlags; |
| ULONG64 ExceptionRecord; |
| ULONG64 ExceptionAddress; |
| ULONG32 NumberParameters; |
| ULONG32 __unusedAlignment; |
| ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; |
| } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION; |
| |
| typedef struct MINIDUMP_EXCEPTION_STREAM { |
| ULONG32 ThreadId; |
| ULONG32 __alignment; |
| MINIDUMP_EXCEPTION ExceptionRecord; |
| MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; |
| } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM; |
| |
| typedef struct _MINIDUMP_MODULE { |
| ULONG64 BaseOfImage; |
| ULONG32 SizeOfImage; |
| ULONG32 CheckSum; |
| ULONG32 TimeDateStamp; |
| RVA ModuleNameRva; |
| VS_FIXEDFILEINFO VersionInfo; |
| MINIDUMP_LOCATION_DESCRIPTOR CvRecord; |
| MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; |
| ULONG64 Reserved0; |
| ULONG64 Reserved1; |
| } MINIDUMP_MODULE,*PMINIDUMP_MODULE; |
| |
| typedef struct _MINIDUMP_MODULE_LIST { |
| ULONG32 NumberOfModules; |
| MINIDUMP_MODULE Modules[0]; |
| } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST; |
| |
| typedef struct _MINIDUMP_MEMORY_LIST { |
| ULONG32 NumberOfMemoryRanges; |
| MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[0]; |
| } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST; |
| |
| typedef struct _MINIDUMP_MEMORY64_LIST { |
| ULONG64 NumberOfMemoryRanges; |
| RVA64 BaseRva; |
| MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[0]; |
| } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST; |
| |
| typedef struct _MINIDUMP_EXCEPTION_INFORMATION { |
| DWORD ThreadId; |
| PEXCEPTION_POINTERS ExceptionPointers; |
| WINBOOL ClientPointers; |
| } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION; |
| |
| typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 { |
| DWORD ThreadId; |
| ULONG64 ExceptionRecord; |
| ULONG64 ContextRecord; |
| WINBOOL ClientPointers; |
| } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64; |
| |
| typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE { |
| MiniHandleObjectInformationNone, |
| MiniThreadInformation1, |
| MiniMutantInformation1, |
| MiniMutantInformation2, |
| MiniProcessInformation1, |
| MiniProcessInformation2, |
| MiniEventInformation1, |
| MiniSectionInformation1, |
| MiniSemaphoreInformation1, |
| MiniHandleObjectInformationTypeMax |
| } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE; |
| |
| typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION { |
| RVA NextInfoRva; |
| ULONG32 InfoType; |
| ULONG32 SizeOfInfo; |
| } MINIDUMP_HANDLE_OBJECT_INFORMATION; |
| |
| typedef struct _MINIDUMP_HANDLE_DESCRIPTOR { |
| ULONG64 Handle; |
| RVA TypeNameRva; |
| RVA ObjectNameRva; |
| ULONG32 Attributes; |
| ULONG32 GrantedAccess; |
| ULONG32 HandleCount; |
| ULONG32 PointerCount; |
| } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR; |
| |
| typedef struct _MINIDUMP_HANDLE_DATA_STREAM { |
| ULONG32 SizeOfHeader; |
| ULONG32 SizeOfDescriptor; |
| ULONG32 NumberOfDescriptors; |
| ULONG32 Reserved; |
| } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM; |
| |
| typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR { |
| ULONG64 MinimumAddress; |
| ULONG64 MaximumAddress; |
| ULONG64 BaseAddress; |
| ULONG32 EntryCount; |
| ULONG32 SizeOfAlignPad; |
| } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR; |
| |
| typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM { |
| ULONG32 SizeOfHeader; |
| ULONG32 SizeOfDescriptor; |
| ULONG32 SizeOfNativeDescriptor; |
| ULONG32 SizeOfFunctionEntry; |
| ULONG32 NumberOfDescriptors; |
| ULONG32 SizeOfAlignPad; |
| } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM; |
| |
| typedef struct _MINIDUMP_UNLOADED_MODULE { |
| ULONG64 BaseOfImage; |
| ULONG32 SizeOfImage; |
| ULONG32 CheckSum; |
| ULONG32 TimeDateStamp; |
| RVA ModuleNameRva; |
| } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE; |
| |
| typedef struct _MINIDUMP_UNLOADED_MODULE_LIST { |
| ULONG32 SizeOfHeader; |
| ULONG32 SizeOfEntry; |
| ULONG32 NumberOfEntries; |
| } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST; |
| |
| #define MINIDUMP_MISC1_PROCESS_ID 0x00000001 |
| #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 |
| #define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004 |
| |
| typedef struct _MINIDUMP_MISC_INFO { |
| ULONG32 SizeOfInfo; |
| ULONG32 Flags1; |
| ULONG32 ProcessId; |
| ULONG32 ProcessCreateTime; |
| ULONG32 ProcessUserTime; |
| ULONG32 ProcessKernelTime; |
| } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO; |
| |
| typedef struct _MINIDUMP_USER_RECORD { |
| ULONG32 Type; |
| MINIDUMP_LOCATION_DESCRIPTOR Memory; |
| } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD; |
| |
| typedef struct _MINIDUMP_USER_STREAM { |
| ULONG32 Type; |
| ULONG BufferSize; |
| PVOID Buffer; |
| } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM; |
| |
| typedef struct _MINIDUMP_USER_STREAM_INFORMATION { |
| ULONG UserStreamCount; |
| PMINIDUMP_USER_STREAM UserStreamArray; |
| } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION; |
| |
| typedef enum _MINIDUMP_CALLBACK_TYPE { |
| ModuleCallback, |
| ThreadCallback, |
| ThreadExCallback, |
| IncludeThreadCallback, |
| IncludeModuleCallback, |
| MemoryCallback, |
| CancelCallback, |
| WriteKernelMinidumpCallback, |
| KernelMinidumpStatusCallback, |
| RemoveMemoryCallback, |
| IncludeVmRegionCallback, |
| IoStartCallback, |
| IoWriteAllCallback, |
| IoFinishCallback, |
| ReadMemoryFailureCallback, |
| SecondaryFlagsCallback, |
| IsProcessSnapshotCallback, |
| VmStartCallback, |
| VmQueryCallback, |
| VmPreReadCallback, |
| VmPostReadCallback |
| } MINIDUMP_CALLBACK_TYPE; |
| |
| typedef struct _MINIDUMP_THREAD_CALLBACK { |
| ULONG ThreadId; |
| HANDLE ThreadHandle; |
| #if defined(__aarch64__) |
| ULONG Pad; |
| #endif |
| CONTEXT Context; |
| ULONG SizeOfContext; |
| ULONG64 StackBase; |
| ULONG64 StackEnd; |
| } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK; |
| |
| typedef struct _MINIDUMP_THREAD_EX_CALLBACK { |
| ULONG ThreadId; |
| HANDLE ThreadHandle; |
| #if defined(__aarch64__) |
| ULONG Pad; |
| #endif |
| CONTEXT Context; |
| ULONG SizeOfContext; |
| ULONG64 StackBase; |
| ULONG64 StackEnd; |
| ULONG64 BackingStoreBase; |
| ULONG64 BackingStoreEnd; |
| } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK; |
| |
| typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK { |
| ULONG ThreadId; |
| } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK; |
| |
| typedef enum _THREAD_WRITE_FLAGS { |
| ThreadWriteThread = 0x0001, |
| ThreadWriteStack = 0x0002, |
| ThreadWriteContext = 0x0004, |
| ThreadWriteBackingStore = 0x0008, |
| ThreadWriteInstructionWindow = 0x0010, |
| ThreadWriteThreadData = 0x0020, |
| ThreadWriteThreadInfo = 0x0040 |
| } THREAD_WRITE_FLAGS; |
| |
| typedef struct _MINIDUMP_MODULE_CALLBACK { |
| PWCHAR FullPath; |
| ULONG64 BaseOfImage; |
| ULONG SizeOfImage; |
| ULONG CheckSum; |
| ULONG TimeDateStamp; |
| VS_FIXEDFILEINFO VersionInfo; |
| PVOID CvRecord; |
| ULONG SizeOfCvRecord; |
| PVOID MiscRecord; |
| ULONG SizeOfMiscRecord; |
| } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK; |
| |
| typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK { |
| ULONG64 BaseOfImage; |
| } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK; |
| |
| typedef enum _MODULE_WRITE_FLAGS { |
| ModuleWriteModule = 0x0001, |
| ModuleWriteDataSeg = 0x0002, |
| ModuleWriteMiscRecord = 0x0004, |
| ModuleWriteCvRecord = 0x0008, |
| ModuleReferencedByMemory = 0x0010, |
| ModuleWriteTlsData = 0x0020, |
| ModuleWriteCodeSegs = 0x0040 |
| } MODULE_WRITE_FLAGS; |
| |
| typedef enum _MINIDUMP_SECONDARY_FLAGS { |
| MiniSecondaryWithoutPowerInfo = 0x00000001 |
| } MINIDUMP_SECONDARY_FLAGS; |
| |
| typedef struct _MINIDUMP_CALLBACK_INPUT { |
| ULONG ProcessId; |
| HANDLE ProcessHandle; |
| ULONG CallbackType; |
| __C89_NAMELESS union { |
| MINIDUMP_THREAD_CALLBACK Thread; |
| MINIDUMP_THREAD_EX_CALLBACK ThreadEx; |
| MINIDUMP_MODULE_CALLBACK Module; |
| MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; |
| MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; |
| }; |
| } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT; |
| |
| typedef struct _MINIDUMP_MEMORY_INFO { |
| ULONG64 BaseAddress; |
| ULONG64 AllocationBase; |
| ULONG32 AllocationProtect; |
| ULONG32 __alignment1; |
| ULONG64 RegionSize; |
| ULONG32 State; |
| ULONG32 Protect; |
| ULONG32 Type; |
| ULONG32 __alignment2; |
| } MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO; |
| |
| typedef struct _MINIDUMP_MISC_INFO_2 { |
| ULONG32 SizeOfInfo; |
| ULONG32 Flags1; |
| ULONG32 ProcessId; |
| ULONG32 ProcessCreateTime; |
| ULONG32 ProcessUserTime; |
| ULONG32 ProcessKernelTime; |
| ULONG32 ProcessorMaxMhz; |
| ULONG32 ProcessorCurrentMhz; |
| ULONG32 ProcessorMhzLimit; |
| ULONG32 ProcessorMaxIdleState; |
| ULONG32 ProcessorCurrentIdleState; |
| } MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2; |
| |
| typedef struct _MINIDUMP_MEMORY_INFO_LIST { |
| ULONG SizeOfHeader; |
| ULONG SizeOfEntry; |
| ULONG64 NumberOfEntries; |
| } MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST; |
| |
| typedef struct _MINIDUMP_CALLBACK_OUTPUT { |
| __C89_NAMELESS union { |
| ULONG ModuleWriteFlags; |
| ULONG ThreadWriteFlags; |
| ULONG SecondaryFlags; |
| __C89_NAMELESS struct { |
| ULONG64 MemoryBase; |
| ULONG MemorySize; |
| }; |
| __C89_NAMELESS struct { |
| WINBOOL CheckCancel; |
| WINBOOL Cancel; |
| }; |
| HANDLE Handle; |
| }; |
| __C89_NAMELESS struct { |
| MINIDUMP_MEMORY_INFO VmRegion; |
| WINBOOL Continue; |
| }; |
| HRESULT Status; |
| } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; |
| |
| typedef enum _MINIDUMP_TYPE { |
| MiniDumpNormal = 0x00000000, |
| MiniDumpWithDataSegs = 0x00000001, |
| MiniDumpWithFullMemory = 0x00000002, |
| MiniDumpWithHandleData = 0x00000004, |
| MiniDumpFilterMemory = 0x00000008, |
| MiniDumpScanMemory = 0x00000010, |
| MiniDumpWithUnloadedModules = 0x00000020, |
| MiniDumpWithIndirectlyReferencedMemory = 0x00000040, |
| MiniDumpFilterModulePaths = 0x00000080, |
| MiniDumpWithProcessThreadData = 0x00000100, |
| MiniDumpWithPrivateReadWriteMemory = 0x00000200, |
| MiniDumpWithoutOptionalData = 0x00000400, |
| MiniDumpWithFullMemoryInfo = 0x00000800, |
| MiniDumpWithThreadInfo = 0x00001000, |
| MiniDumpWithCodeSegs = 0x00002000, |
| MiniDumpWithoutAuxiliaryState = 0x00004000, |
| MiniDumpWithFullAuxiliaryState = 0x00008000, |
| MiniDumpWithPrivateWriteCopyMemory = 0x00010000, |
| MiniDumpIgnoreInaccessibleMemory = 0x00020000, |
| MiniDumpWithTokenInformation = 0x00040000, |
| MiniDumpWithModuleHeaders = 0x00080000, |
| MiniDumpFilterTriage = 0x00100000, |
| MiniDumpWithAvxXStateContext = 0x00200000, |
| MiniDumpWithIptTrace = 0x00400000, |
| MiniDumpScanInaccessiblePartialPages = 0x00800000, |
| MiniDumpValidTypeFlags = 0x00ffffff |
| } MINIDUMP_TYPE; |
| |
| #define MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001 |
| #define MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002 |
| #define MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004 |
| #define MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008 |
| #define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010 |
| #define MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020 |
| |
| typedef struct _MINIDUMP_THREAD_INFO { |
| ULONG32 ThreadId; |
| ULONG32 DumpFlags; |
| ULONG32 DumpError; |
| ULONG32 ExitStatus; |
| ULONG64 CreateTime; |
| ULONG64 ExitTime; |
| ULONG64 KernelTime; |
| ULONG64 UserTime; |
| ULONG64 StartAddress; |
| ULONG64 Affinity; |
| } MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO; |
| |
| typedef struct _MINIDUMP_THREAD_INFO_LIST { |
| ULONG SizeOfHeader; |
| ULONG SizeOfEntry; |
| ULONG NumberOfEntries; |
| } MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST; |
| |
| typedef struct _MINIDUMP_HANDLE_OPERATION_LIST { |
| ULONG32 SizeOfHeader; |
| ULONG32 SizeOfEntry; |
| ULONG32 NumberOfEntries; |
| ULONG32 Reserved; |
| } MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST; |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef WINBOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput); |
| |
| typedef struct _MINIDUMP_CALLBACK_INFORMATION { |
| MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; |
| PVOID CallbackParam; |
| } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION; |
| |
| #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva))) |
| |
| WINBOOL 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); |
| WINBOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize); |
| |
| WINBOOL WINAPI EnumerateLoadedModulesEx( |
| HANDLE hProcess, |
| PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, |
| PVOID UserContext |
| ); |
| |
| WINBOOL WINAPI EnumerateLoadedModulesExW( |
| HANDLE hProcess, |
| PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, |
| PVOID UserContext |
| ); |
| |
| WINBOOL WINAPI SymAddSourceStream( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCSTR StreamFile, |
| PBYTE Buffer, |
| size_t Size |
| ); |
| |
| WINBOOL WINAPI SymAddSourceStreamW( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCWSTR StreamFile, |
| PBYTE Buffer, |
| size_t Size |
| ); |
| |
| WINBOOL WINAPI SymEnumSourceLines( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCSTR Obj, |
| PCSTR File, |
| DWORD Line, |
| DWORD Flags, |
| PSYM_ENUMLINES_CALLBACK EnumLinesCallback, |
| PVOID UserContext |
| ); |
| |
| WINBOOL WINAPI SymEnumSourceLinesW( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCWSTR Obj, |
| PCWSTR File, |
| DWORD Line, |
| DWORD Flags, |
| PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, |
| PVOID UserContext |
| ); |
| |
| WINBOOL WINAPI SymEnumTypesByName( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| PCSTR mask, |
| PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, |
| PVOID UserContext |
| ); |
| |
| WINBOOL WINAPI SymEnumTypesByNameW( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| PCSTR mask, |
| PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, |
| PVOID UserContext |
| ); |
| |
| HANDLE WINAPI SymFindDebugInfoFile( |
| HANDLE hProcess, |
| PCSTR FileName, |
| PSTR DebugFilePath, |
| PFIND_DEBUG_FILE_CALLBACK Callback, |
| PVOID CallerData |
| ); |
| |
| HANDLE WINAPI SymFindDebugInfoFileW( |
| HANDLE hProcess, |
| PCWSTR FileName, |
| PWSTR DebugFilePath, |
| PFIND_DEBUG_FILE_CALLBACKW Callback, |
| PVOID CallerData |
| ); |
| |
| HANDLE WINAPI SymFindExecutableImage( |
| HANDLE hProcess, |
| PCSTR FileName, |
| PSTR ImageFilePath, |
| PFIND_EXE_FILE_CALLBACK Callback, |
| PVOID CallerData |
| ); |
| |
| HANDLE WINAPI SymFindExecutableImageW( |
| HANDLE hProcess, |
| PCWSTR FileName, |
| PWSTR ImageFilePath, |
| PFIND_EXE_FILE_CALLBACKW Callback, |
| PVOID CallerData |
| ); |
| |
| WINBOOL WINAPI SymFromIndex( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| DWORD Index, |
| PSYMBOL_INFO Symbol |
| ); |
| |
| WINBOOL WINAPI SymFromIndexW( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| DWORD Index, |
| PSYMBOL_INFOW Symbol |
| ); |
| |
| WINBOOL WINAPI SymGetScope( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| DWORD Index, |
| PSYMBOL_INFO Symbol |
| ); |
| |
| WINBOOL WINAPI SymGetScopeW( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| DWORD Index, |
| PSYMBOL_INFOW Symbol |
| ); |
| |
| WINBOOL WINAPI SymGetSourceFileFromToken( |
| HANDLE hProcess, |
| PVOID Token, |
| PCSTR Params, |
| PSTR FilePath, |
| DWORD Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceFileFromTokenW( |
| HANDLE hProcess, |
| PVOID Token, |
| PCWSTR Params, |
| PWSTR FilePath, |
| DWORD Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceFileToken( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCSTR FileSpec, |
| PVOID *Token, |
| DWORD *Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceFileTokenW( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCWSTR FileSpec, |
| PVOID *Token, |
| DWORD *Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceFile( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCSTR Params, |
| PCSTR FileSpec, |
| PSTR FilePath, |
| DWORD Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceFileW( |
| HANDLE hProcess, |
| ULONG64 Base, |
| PCWSTR Params, |
| PCWSTR FileSpec, |
| PWSTR FilePath, |
| DWORD Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceVarFromToken( |
| HANDLE hProcess, |
| PVOID Token, |
| PCSTR Params, |
| PCSTR VarName, |
| PSTR Value, |
| DWORD Size |
| ); |
| |
| WINBOOL WINAPI SymGetSourceVarFromTokenW( |
| HANDLE hProcess, |
| PVOID Token, |
| PCWSTR Params, |
| PCWSTR VarName, |
| PWSTR Value, |
| DWORD Size |
| ); |
| |
| WINBOOL WINAPI SymGetSymbolFile( |
| HANDLE hProcess, |
| PCSTR SymPath, |
| PCSTR ImageFile, |
| DWORD Type, |
| PSTR SymbolFile, |
| size_t cSymbolFile, |
| PSTR DbgFile, |
| size_t cDbgFile |
| ); |
| |
| WINBOOL WINAPI SymGetSymbolFileW( |
| HANDLE hProcess, |
| PCWSTR SymPath, |
| PCWSTR ImageFile, |
| DWORD Type, |
| PWSTR SymbolFile, |
| size_t cSymbolFile, |
| PWSTR DbgFile, |
| size_t cDbgFile |
| ); |
| |
| WINBOOL WINAPI SymNext( |
| HANDLE hProcess, |
| PSYMBOL_INFO Symbol |
| ); |
| |
| WINBOOL WINAPI SymNextW( |
| HANDLE hProcess, |
| PSYMBOL_INFOW Symbol |
| ); |
| |
| WINBOOL WINAPI SymPrev( |
| HANDLE hProcess, |
| PSYMBOL_INFO Symbol |
| ); |
| |
| WINBOOL WINAPI SymPrevW( |
| HANDLE hProcess, |
| PSYMBOL_INFOW Symbol |
| ); |
| |
| WINBOOL WINAPI SymRefreshModuleList( |
| HANDLE hProcess |
| ); |
| |
| #define SYMSEARCH_MASKOBJS 0x01 |
| #define SYMSEARCH_RECURSE 0x02 |
| #define SYMSEARCH_GLOBALSONLY 0x04 |
| #define SYMSEARCH_ALLITEMS 0x08 |
| |
| WINBOOL WINAPI SymSearch( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| DWORD Index, |
| DWORD SymTag, |
| PCSTR Mask, |
| DWORD64 Address, |
| PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, |
| PVOID UserContext, |
| DWORD Options |
| ); |
| |
| WINBOOL WINAPI SymSearchW( |
| HANDLE hProcess, |
| ULONG64 BaseOfDll, |
| DWORD Index, |
| DWORD SymTag, |
| PCWSTR Mask, |
| DWORD64 Address, |
| PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, |
| PVOID UserContext, |
| DWORD Options |
| ); |
| |
| WINBOOL WINAPI SymSrvGetFileIndexString( |
| HANDLE hProcess, |
| PCSTR SrvPath, |
| PCSTR File, |
| PSTR Index, |
| size_t Size, |
| DWORD Flags |
| ); |
| |
| WINBOOL WINAPI SymSrvGetFileIndexStringW( |
| HANDLE hProcess, |
| PCWSTR SrvPath, |
| PCWSTR File, |
| PWSTR Index, |
| size_t Size, |
| DWORD Flags |
| ); |
| |
| WINBOOL WINAPI SymSrvGetFileIndexInfo( |
| PCSTR File, |
| PSYMSRV_INDEX_INFO Info, |
| DWORD Flags |
| ); |
| |
| WINBOOL WINAPI SymSrvGetFileIndexInfoW( |
| PCWSTR File, |
| PSYMSRV_INDEX_INFOW Info, |
| DWORD Flags |
| ); |
| |
| WINBOOL WINAPI SymSrvGetFileIndexes( |
| PCTSTR File, |
| GUID *Id, |
| DWORD *Val1, |
| DWORD *Val2, |
| DWORD Flags |
| ); |
| |
| WINBOOL WINAPI SymSrvGetFileIndexesW( |
| PCWSTR File, |
| GUID *Id, |
| DWORD *Val1, |
| DWORD *Val2, |
| DWORD Flags |
| ); |
| |
| PCSTR WINAPI SymSrvGetSupplement( |
| HANDLE hProcess, |
| PCSTR SymPath, |
| PCSTR Node, |
| PCSTR File |
| ); |
| |
| PCWSTR WINAPI SymSrvGetSupplementW( |
| HANDLE hProcess, |
| PCWSTR SymPath, |
| PCWSTR Node, |
| PCWSTR File |
| ); |
| |
| WINBOOL WINAPI SymSrvIsStore( |
| HANDLE hProcess, |
| PCSTR path |
| ); |
| |
| WINBOOL WINAPI SymSrvIsStoreW( |
| HANDLE hProcess, |
| PCWSTR path |
| ); |
| |
| PCSTR WINAPI SymSrvStoreFile( |
| HANDLE hProcess, |
| PCSTR SrvPath, |
| PCSTR File, |
| DWORD Flags |
| ); |
| |
| PCWSTR WINAPI SymSrvStoreFileW( |
| HANDLE hProcess, |
| PCWSTR SrvPath, |
| PCWSTR File, |
| DWORD Flags |
| ); |
| |
| #define SYMSTOREOPT_COMPRESS 0x01 |
| #define SYMSTOREOPT_OVERWRITE 0x02 |
| #define SYMSTOREOPT_RETURNINDEX 0x04 |
| #define SYMSTOREOPT_POINTER 0x08 |
| #define SYMSTOREOPT_PASS_IF_EXISTS 0x40 |
| |
| PCSTR WINAPI SymSrvStoreSupplement( |
| HANDLE hProcess, |
| const PCTSTR SymPath, |
| PCSTR Node, |
| PCSTR File, |
| DWORD Flags |
| ); |
| |
| PCWSTR WINAPI SymSrvStoreSupplementW( |
| HANDLE hProcess, |
| const PCWSTR SymPath, |
| PCWSTR Node, |
| PCWSTR File, |
| DWORD Flags |
| ); |
| |
| PCSTR WINAPI SymSrvDeltaName( |
| HANDLE hProcess, |
| PCSTR SymPath, |
| PCSTR Type, |
| PCSTR File1, |
| PCSTR File2 |
| ); |
| |
| PCWSTR WINAPI SymSrvDeltaNameW( |
| HANDLE hProcess, |
| PCWSTR SymPath, |
| PCWSTR Type, |
| PCWSTR File1, |
| PCWSTR File2 |
| ); |
| |
| #ifdef DBGHELP_TRANSLATE_TCHAR |
| #define SymInitialize SymInitializeW |
| #define SymAddSymbol SymAddSymbolW |
| #define SymDeleteSymbol SymDeleteSymbolW |
| #define SearchTreeForFile SearchTreeForFileW |
| #define UnDecorateSymbolName UnDecorateSymbolNameW |
| #define SymGetLineFromName64 SymGetLineFromNameW64 |
| #define SymGetLineFromAddr64 SymGetLineFromAddrW64 |
| #define SymGetLineFromInlineContext SymGetLineFromInlineContextW |
| #define SymGetLineNext64 SymGetLineNextW64 |
| #define SymGetLinePrev64 SymGetLinePrevW64 |
| #define SymFromName SymFromNameW |
| #define SymFindExecutableImage SymFindExecutableImageW |
| #define FindExecutableImageEx FindExecutableImageExW |
| #define SymSearch SymSearchW |
| #define SymEnumLines SymEnumLinesW |
| #define SymEnumSourceLines SymEnumSourceLinesW |
| #define SymGetTypeFromName SymGetTypeFromNameW |
| #define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW |
| #define SymFromAddr SymFromAddrW |
| #define SymFromInlineContext SymFromInlineContextW |
| #define SymMatchString SymMatchStringW |
| #define SymEnumSourceFiles SymEnumSourceFilesW |
| #define SymEnumSymbols SymEnumSymbolsW |
| #define SymEnumSymbolsEx SymEnumSymbolsExW |
| #define SymLoadModuleEx SymLoadModuleExW |
| #define SymSetSearchPath SymSetSearchPathW |
| #define SymGetSearchPath SymGetSearchPathW |
| #define EnumDirTree EnumDirTreeW |
| #define SymFromToken SymFromTokenW |
| #define SymFromIndex SymFromIndexW |
| #define SymGetScope SymGetScopeW |
| #define SymNext SymNextW |
| #define SymPrev SymPrevW |
| #define SymEnumTypes SymEnumTypesW |
| #define SymEnumTypesByName SymEnumTypesByNameW |
| #define SymRegisterCallback64 SymRegisterCallbackW64 |
| #define SymFindDebugInfoFile SymFindDebugInfoFileW |
| #define FindDebugInfoFileEx FindDebugInfoFileExW |
| #define SymFindFileInPath SymFindFileInPathW |
| #define SymEnumerateModules64 SymEnumerateModulesW64 |
| #define SymSetHomeDirectory SymSetHomeDirectoryW |
| #define SymGetHomeDirectory SymGetHomeDirectoryW |
| #define SymGetSourceFile SymGetSourceFileW |
| #define SymGetSourceFileToken SymGetSourceFileTokenW |
| #define SymGetSourceFileFromToken SymGetSourceFileFromTokenW |
| #define SymGetSourceVarFromToken SymGetSourceVarFromTokenW |
| #define SymGetSourceFileTokenByTokenName SymGetSourceFileTokenByTokenNameW |
| #define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64 |
| #define SymFindFileInPath SymFindFileInPathW |
| #define SymMatchFileName SymMatchFileNameW |
| #define SymGetSourceFileFromTokenByTokenName SymGetSourceFileFromTokenByTokenNameW |
| #define SymGetModuleInfo64 SymGetModuleInfoW64 |
| #define SymAddSourceStream SymAddSourceStreamW |
| #define SymSrvIsStore SymSrvIsStoreW |
| #define SymSrvDeltaName SymSrvDeltaNameW |
| #define SymSrvGetSupplement SymSrvGetSupplementW |
| #define SymSrvStoreSupplement SymSrvStoreSupplementW |
| #define SymSrvGetFileIndexes SymSrvGetFileIndexesW |
| #define SymSrvGetFileIndexString SymSrvGetFileIndexStringW |
| #define SymSrvStoreFile SymSrvStoreFileW |
| #define SymGetSymbolFile SymGetSymbolFileW |
| #define EnumerateLoadedModules64 EnumerateLoadedModulesW64 |
| #define EnumerateLoadedModulesEx EnumerateLoadedModulesExW |
| #define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW |
| |
| #define IMAGEHLP_LINE64 IMAGEHLP_LINEW64 |
| #define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64 |
| #define SYMBOL_INFO SYMBOL_INFOW |
| #define PSYMBOL_INFO PSYMBOL_INFOW |
| #define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW |
| #define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW |
| #define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW |
| #define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW |
| #define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW |
| #define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW |
| #define SRCCODEINFO SRCCODEINFOW |
| #define PSRCCODEINFO PSRCCODEINFOW |
| #define SOURCEFILE SOURCEFILEW |
| #define PSOURCEFILE PSOURCEFILEW |
| #define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW |
| #define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW |
| #define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW |
| #define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW |
| #define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW |
| #define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64 |
| #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64 |
| #define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW |
| #define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW |
| #define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64 |
| #define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64 |
| #define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOW |
| #define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW |
| |
| #define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW |
| #define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW |
| |
| #endif /* DBGHELP_TRANSLATE_TCHAR */ |
| |
| #include <poppack.h> |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
