_dbg_common.h (70710B) - Raw
1 /** 2 * This file has no copyright assigned and is placed in the Public Domain. 3 * This file is part of the mingw-w64 runtime package. 4 * No warranty is given; refer to the file DISCLAIMER.PD within this package. 5 */ 6 #pragma once 7 8 #ifdef __cplusplus 9 extern "C" { 10 #endif 11 12 typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PCSTR FileName,PVOID CallerData); 13 typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE FileHandle,PCWSTR FileName,PVOID CallerData); 14 typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR filename,PVOID context); 15 typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR filename,PVOID context); 16 typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PCSTR FileName,PVOID CallerData); 17 typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE FileHandle,PCWSTR FileName,PVOID CallerData); 18 19 typedef WINBOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR); 20 typedef WINBOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID); 21 typedef WINBOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID); 22 typedef WINBOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64); 23 typedef WINBOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context); 24 typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)(); 25 typedef WINBOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR); 26 27 HANDLE IMAGEAPI FindDebugInfoFile(PCSTR FileName,PCSTR SymbolPath,PSTR DebugFilePath); 28 HANDLE IMAGEAPI FindDebugInfoFileEx(PCSTR FileName,PCSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData); 29 HANDLE IMAGEAPI FindDebugInfoFileExW(PCWSTR FileName,PCWSTR SymbolPath,PWSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACKW Callback,PVOID CallerData); 30 WINBOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context); 31 WINBOOL IMAGEAPI SymFindFileInPathW(HANDLE hprocess,PCWSTR SearchPath,PCWSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACKW callback,PVOID context); 32 HANDLE IMAGEAPI FindExecutableImage(PCSTR FileName,PCSTR SymbolPath,PSTR ImageFilePath); 33 HANDLE IMAGEAPI FindExecutableImageEx(PCSTR FileName,PCSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData); 34 HANDLE IMAGEAPI FindExecutableImageExW(PCWSTR FileName,PCWSTR SymbolPath,PWSTR ImageFilePath,PFIND_EXE_FILE_CALLBACKW Callback,PVOID CallerData); 35 PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base); 36 PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader); 37 PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size); 38 PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva); 39 PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection); 40 41 #define SSRVOPT_CALLBACK 0x0001 42 #define SSRVOPT_DWORD 0x0002 43 #define SSRVOPT_DWORDPTR 0x0004 44 #define SSRVOPT_GUIDPTR 0x0008 45 #define SSRVOPT_OLDGUIDPTR 0x0010 46 #define SSRVOPT_UNATTENDED 0x0020 47 #define SSRVOPT_NOCOPY 0x0040 48 #define SSRVOPT_PARENTWIN 0x0080 49 #define SSRVOPT_PARAMTYPE 0x0100 50 #define SSRVOPT_SECURE 0x0200 51 #define SSRVOPT_TRACE 0x0400 52 #define SSRVOPT_SETCONTEXT 0x0800 53 #define SSRVOPT_PROXY 0x1000 54 #define SSRVOPT_DOWNSTREAM_STORE 0x2000 55 #define SSRVOPT_RESET ((ULONG_PTR)-1) 56 57 #define SSRVACTION_TRACE 1 58 #define SSRVACTION_QUERYCANCEL 2 59 #define SSRVACTION_EVENT 3 60 61 #ifndef _WIN64 62 typedef struct _IMAGE_DEBUG_INFORMATION { 63 LIST_ENTRY List; 64 DWORD ReservedSize; 65 PVOID ReservedMappedBase; 66 USHORT ReservedMachine; 67 USHORT ReservedCharacteristics; 68 DWORD ReservedCheckSum; 69 DWORD ImageBase; 70 DWORD SizeOfImage; 71 DWORD ReservedNumberOfSections; 72 PIMAGE_SECTION_HEADER ReservedSections; 73 DWORD ReservedExportedNamesSize; 74 PSTR ReservedExportedNames; 75 DWORD ReservedNumberOfFunctionTableEntries; 76 PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries; 77 DWORD ReservedLowestFunctionStartingAddress; 78 DWORD ReservedHighestFunctionEndingAddress; 79 DWORD ReservedNumberOfFpoTableEntries; 80 PFPO_DATA ReservedFpoTableEntries; 81 DWORD SizeOfCoffSymbols; 82 PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols; 83 DWORD ReservedSizeOfCodeViewSymbols; 84 PVOID ReservedCodeViewSymbols; 85 PSTR ImageFilePath; 86 PSTR ImageFileName; 87 PSTR ReservedDebugFilePath; 88 DWORD ReservedTimeDateStamp; 89 WINBOOL ReservedRomImage; 90 PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory; 91 DWORD ReservedNumberOfDebugDirectories; 92 DWORD ReservedOriginalFunctionTableBaseAddress; 93 DWORD Reserved[2]; 94 } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION; 95 96 PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase); 97 WINBOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo); 98 #endif 99 100 typedef WINBOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData); 101 102 WINBOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer); 103 WINBOOL IMAGEAPI SearchTreeForFileW(PWSTR RootPath,PWSTR InputPathName,PWSTR OutputPathBuffer); 104 WINBOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData); 105 WINBOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath); 106 107 #define UNDNAME_COMPLETE (0x0000) 108 #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) 109 #define UNDNAME_NO_MS_KEYWORDS (0x0002) 110 #define UNDNAME_NO_FUNCTION_RETURNS (0x0004) 111 #define UNDNAME_NO_ALLOCATION_MODEL (0x0008) 112 #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010) 113 #define UNDNAME_NO_MS_THISTYPE (0x0020) 114 #define UNDNAME_NO_CV_THISTYPE (0x0040) 115 #define UNDNAME_NO_THISTYPE (0x0060) 116 #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) 117 #define UNDNAME_NO_THROW_SIGNATURES (0x0100) 118 #define UNDNAME_NO_MEMBER_TYPE (0x0200) 119 #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400) 120 #define UNDNAME_32_BIT_DECODE (0x0800) 121 #define UNDNAME_NAME_ONLY (0x1000) 122 #define UNDNAME_NO_ARGUMENTS (0x2000) 123 #define UNDNAME_NO_SPECIAL_SYMS (0x4000) 124 125 #define UNDNAME_NO_ARGUMENTS (0x2000) 126 #define UNDNAME_NO_SPECIAL_SYMS (0x4000) 127 128 DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags); 129 DWORD IMAGEAPI WINAPI UnDecorateSymbolNameW(PCWSTR DecoratedName,PWSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags); 130 131 #define DBHHEADER_DEBUGDIRS 0x1 132 #define DBHHEADER_CVMISC 0x2 133 134 typedef struct _MODLOAD_CVMISC { 135 DWORD oCV; 136 size_t cCV; 137 DWORD oMisc; 138 size_t cMisc; 139 DWORD dtImage; 140 DWORD cImage; 141 } MODLOAD_CVMISC, *PMODLOAD_CVMISC; 142 143 typedef enum { 144 AddrMode1616, 145 AddrMode1632, 146 AddrModeReal, 147 AddrModeFlat 148 } ADDRESS_MODE; 149 150 typedef struct _tagADDRESS64 { 151 DWORD64 Offset; 152 WORD Segment; 153 ADDRESS_MODE Mode; 154 } ADDRESS64,*LPADDRESS64; 155 156 #ifdef _IMAGEHLP64 157 #define ADDRESS ADDRESS64 158 #define LPADDRESS LPADDRESS64 159 #else 160 typedef struct _tagADDRESS { 161 DWORD Offset; 162 WORD Segment; 163 ADDRESS_MODE Mode; 164 } ADDRESS,*LPADDRESS; 165 166 static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) { 167 a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset; 168 a64->Segment = a32->Segment; 169 a64->Mode = a32->Mode; 170 } 171 172 static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) { 173 a32->Offset = (ULONG)a64->Offset; 174 a32->Segment = a64->Segment; 175 a32->Mode = a64->Mode; 176 } 177 #endif 178 179 typedef struct _KDHELP64 { 180 DWORD64 Thread; 181 DWORD ThCallbackStack; 182 DWORD ThCallbackBStore; 183 DWORD NextCallback; 184 DWORD FramePointer; 185 DWORD64 KiCallUserMode; 186 DWORD64 KeUserCallbackDispatcher; 187 DWORD64 SystemRangeStart; 188 DWORD64 KiUserExceptionDispatcher; 189 DWORD64 StackBase; 190 DWORD64 StackLimit; 191 DWORD BuildVersion; 192 DWORD RetpolineStubFunctionTableSize; 193 DWORD64 RetpolineStubFunctionTable; 194 DWORD RetpolineStubOffset; 195 DWORD RetpolineStubSize; 196 DWORD64 Reserved0[2]; 197 } KDHELP64,*PKDHELP64; 198 199 #ifdef _IMAGEHLP64 200 #define KDHELP KDHELP64 201 #define PKDHELP PKDHELP64 202 #else 203 typedef struct _KDHELP { 204 DWORD Thread; 205 DWORD ThCallbackStack; 206 DWORD NextCallback; 207 DWORD FramePointer; 208 DWORD KiCallUserMode; 209 DWORD KeUserCallbackDispatcher; 210 DWORD SystemRangeStart; 211 DWORD ThCallbackBStore; 212 DWORD KiUserExceptionDispatcher; 213 DWORD StackBase; 214 DWORD StackLimit; 215 DWORD Reserved[5]; 216 } KDHELP,*PKDHELP; 217 218 static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) { 219 p64->Thread = p32->Thread; 220 p64->ThCallbackStack = p32->ThCallbackStack; 221 p64->NextCallback = p32->NextCallback; 222 p64->FramePointer = p32->FramePointer; 223 p64->KiCallUserMode = p32->KiCallUserMode; 224 p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher; 225 p64->SystemRangeStart = p32->SystemRangeStart; 226 p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher; 227 p64->StackBase = p32->StackBase; 228 p64->StackLimit = p32->StackLimit; 229 } 230 #endif 231 232 typedef struct _tagSTACKFRAME64 { 233 ADDRESS64 AddrPC; 234 ADDRESS64 AddrReturn; 235 ADDRESS64 AddrFrame; 236 ADDRESS64 AddrStack; 237 ADDRESS64 AddrBStore; 238 PVOID FuncTableEntry; 239 DWORD64 Params[4]; 240 WINBOOL Far; 241 WINBOOL Virtual; 242 DWORD64 Reserved[3]; 243 KDHELP64 KdHelp; 244 } STACKFRAME64,*LPSTACKFRAME64; 245 246 #define INLINE_FRAME_CONTEXT_INIT 0 247 #define INLINE_FRAME_CONTEXT_IGNORE 0xFFFFFFFF 248 249 typedef struct _tagSTACKFRAME_EX { 250 ADDRESS64 AddrPC; 251 ADDRESS64 AddrReturn; 252 ADDRESS64 AddrFrame; 253 ADDRESS64 AddrStack; 254 ADDRESS64 AddrBStore; 255 PVOID FuncTableEntry; 256 DWORD64 Params[4]; 257 WINBOOL Far; 258 WINBOOL Virtual; 259 DWORD64 Reserved[3]; 260 KDHELP64 KdHelp; 261 DWORD StackFrameSize; 262 DWORD InlineFrameContext; 263 } STACKFRAME_EX,*LPSTACKFRAME_EX; 264 265 #ifdef _IMAGEHLP64 266 #define STACKFRAME STACKFRAME64 267 #define LPSTACKFRAME LPSTACKFRAME64 268 #else 269 typedef struct _tagSTACKFRAME { 270 ADDRESS AddrPC; 271 ADDRESS AddrReturn; 272 ADDRESS AddrFrame; 273 ADDRESS AddrStack; 274 PVOID FuncTableEntry; 275 DWORD Params[4]; 276 WINBOOL Far; 277 WINBOOL Virtual; 278 DWORD Reserved[3]; 279 KDHELP KdHelp; 280 ADDRESS AddrBStore; 281 } STACKFRAME,*LPSTACKFRAME; 282 #endif 283 284 typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead); 285 typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase); 286 typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address); 287 typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr); 288 289 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 290 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress); 291 292 #ifdef _IMAGEHLP64 293 #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64 294 #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64 295 #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64 296 #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64 297 #define StackWalk StackWalk64 298 #else 299 typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead); 300 typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase); 301 typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address); 302 typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr); 303 304 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 305 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE TranslateAddress); 306 #endif 307 308 #define API_VERSION_NUMBER 11 309 310 typedef struct API_VERSION { 311 USHORT MajorVersion; 312 USHORT MinorVersion; 313 USHORT Revision; 314 USHORT Reserved; 315 } API_VERSION,*LPAPI_VERSION; 316 317 LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID); 318 LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion); 319 DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module); 320 321 typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext); 322 typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext); 323 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext); 324 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext); 325 typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext); 326 typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext); 327 typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext); 328 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext); 329 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext); 330 331 #ifdef _IMAGEHLP64 332 #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64 333 #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64 334 #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W 335 #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64 336 #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64 337 #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64 338 #else 339 typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR ModuleName,ULONG BaseOfDll,PVOID UserContext); 340 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext); 341 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext); 342 typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext); 343 typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext); 344 #endif 345 346 #define SYMFLAG_VALUEPRESENT 0x00000001 347 #define SYMFLAG_REGISTER 0x00000008 348 #define SYMFLAG_REGREL 0x00000010 349 #define SYMFLAG_FRAMEREL 0x00000020 350 #define SYMFLAG_PARAMETER 0x00000040 351 #define SYMFLAG_LOCAL 0x00000080 352 #define SYMFLAG_CONSTANT 0x00000100 353 #define SYMFLAG_EXPORT 0x00000200 354 #define SYMFLAG_FORWARDER 0x00000400 355 #define SYMFLAG_FUNCTION 0x00000800 356 #define SYMFLAG_VIRTUAL 0x00001000 357 #define SYMFLAG_THUNK 0x00002000 358 #define SYMFLAG_TLSREL 0x00004000 359 #define SYMFLAG_SLOT 0x00008000 360 #define SYMFLAG_ILREL 0x00010000 361 #define SYMFLAG_METADATA 0x00020000 362 #define SYMFLAG_CLR_TOKEN 0x00040000 363 #define SYMFLAG_NULL 0x00080000 364 #define SYMFLAG_FUNC_NO_RETURN 0x00100000 365 #define SYMFLAG_SYNTHETIC_ZEROBASE 0x00200000 366 #define SYMFLAG_PUBLIC_CODE 0x00400000 367 #define SYMFLAG_REGREL_ALIASINDIR 0x00800000 368 #define SYMFLAG_FIXUP_ARM64X 0x01000000 369 #define SYMFLAG_GLOBAL 0x02000000 370 #define SYMFLAG_RESET 0x80000000 371 372 typedef enum { 373 SymNone = 0, 374 SymCoff, 375 SymCv, 376 SymPdb, 377 SymExport, 378 SymDeferred, 379 SymSym, 380 SymDia, 381 SymVirtual, 382 NumSymTypes 383 } SYM_TYPE; 384 385 typedef struct _IMAGEHLP_SYMBOL64 { 386 DWORD SizeOfStruct; 387 DWORD64 Address; 388 DWORD Size; 389 DWORD Flags; 390 DWORD MaxNameLength; 391 CHAR Name[1]; 392 } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64; 393 394 typedef struct _IMAGEHLP_SYMBOL64_PACKAGE { 395 IMAGEHLP_SYMBOL64 sym; 396 CHAR name[MAX_SYM_NAME + 1]; 397 } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE; 398 399 #ifdef _IMAGEHLP64 400 401 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64 402 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64 403 #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE 404 #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE 405 #else 406 407 typedef struct _IMAGEHLP_SYMBOL { 408 DWORD SizeOfStruct; 409 DWORD Address; 410 DWORD Size; 411 DWORD Flags; 412 DWORD MaxNameLength; 413 CHAR Name[1]; 414 } IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL; 415 416 typedef struct _IMAGEHLP_SYMBOL_PACKAGE { 417 IMAGEHLP_SYMBOL sym; 418 CHAR name[MAX_SYM_NAME + 1]; 419 } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE; 420 #endif 421 422 typedef struct _IMAGEHLP_MODULE64 { 423 DWORD SizeOfStruct; 424 DWORD64 BaseOfImage; 425 DWORD ImageSize; 426 DWORD TimeDateStamp; 427 DWORD CheckSum; 428 DWORD NumSyms; 429 SYM_TYPE SymType; 430 CHAR ModuleName[32]; 431 CHAR ImageName[256]; 432 CHAR LoadedImageName[256]; 433 CHAR LoadedPdbName[256]; 434 DWORD CVSig; 435 CHAR CVData[MAX_PATH*3]; 436 DWORD PdbSig; 437 GUID PdbSig70; 438 DWORD PdbAge; 439 WINBOOL PdbUnmatched; 440 WINBOOL DbgUnmatched; 441 WINBOOL LineNumbers; 442 WINBOOL GlobalSymbols; 443 WINBOOL TypeInfo; 444 WINBOOL SourceIndexed; 445 WINBOOL Publics; 446 DWORD MachineType; 447 DWORD Reserved; 448 } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64; 449 450 typedef struct _IMAGEHLP_MODULE64_EX { 451 IMAGEHLP_MODULE64 Module; 452 DWORD RegionFlags; 453 } IMAGEHLP_MODULE64_EX,*PIMAGEHLP_MODULE64_EX; 454 455 typedef struct _IMAGEHLP_MODULE64W { 456 DWORD SizeOfStruct; 457 DWORD64 BaseOfImage; 458 DWORD ImageSize; 459 DWORD TimeDateStamp; 460 DWORD CheckSum; 461 DWORD NumSyms; 462 SYM_TYPE SymType; 463 WCHAR ModuleName[32]; 464 WCHAR ImageName[256]; 465 WCHAR LoadedImageName[256]; 466 WCHAR LoadedPdbName[256]; 467 DWORD CVSig; 468 WCHAR CVData[MAX_PATH*3]; 469 DWORD PdbSig; 470 GUID PdbSig70; 471 DWORD PdbAge; 472 WINBOOL PdbUnmatched; 473 WINBOOL DbgUnmatched; 474 WINBOOL LineNumbers; 475 WINBOOL GlobalSymbols; 476 WINBOOL TypeInfo; 477 WINBOOL SourceIndexed; 478 WINBOOL Publics; 479 DWORD MachineType; 480 DWORD Reserved; 481 } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64; 482 483 typedef struct _IMAGEHLP_MODULEW64_EX { 484 IMAGEHLP_MODULEW64 Module; 485 DWORD RegionFlags; 486 } IMAGEHLP_MODULEW64_EX,*PIMAGEHLP_MODULEW64_EX; 487 488 #ifdef _IMAGEHLP64 489 #define IMAGEHLP_MODULE IMAGEHLP_MODULE64 490 #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64 491 #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64 492 #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64 493 #else 494 typedef struct _IMAGEHLP_MODULE { 495 DWORD SizeOfStruct; 496 DWORD BaseOfImage; 497 DWORD ImageSize; 498 DWORD TimeDateStamp; 499 DWORD CheckSum; 500 DWORD NumSyms; 501 SYM_TYPE SymType; 502 CHAR ModuleName[32]; 503 CHAR ImageName[256]; 504 CHAR LoadedImageName[256]; 505 } IMAGEHLP_MODULE,*PIMAGEHLP_MODULE; 506 507 typedef struct _IMAGEHLP_MODULEW { 508 DWORD SizeOfStruct; 509 DWORD BaseOfImage; 510 DWORD ImageSize; 511 DWORD TimeDateStamp; 512 DWORD CheckSum; 513 DWORD NumSyms; 514 SYM_TYPE SymType; 515 WCHAR ModuleName[32]; 516 WCHAR ImageName[256]; 517 WCHAR LoadedImageName[256]; 518 } IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW; 519 #endif 520 521 typedef struct _IMAGEHLP_LINE64 { 522 DWORD SizeOfStruct; 523 PVOID Key; 524 DWORD LineNumber; 525 PCHAR FileName; 526 DWORD64 Address; 527 } IMAGEHLP_LINE64,*PIMAGEHLP_LINE64; 528 529 typedef struct _IMAGEHLP_LINEW64 { 530 DWORD SizeOfStruct; 531 PVOID Key; 532 DWORD LineNumber; 533 PWSTR FileName; 534 DWORD64 Address; 535 } IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64; 536 537 #ifdef _IMAGEHLP64 538 #define IMAGEHLP_LINE IMAGEHLP_LINE64 539 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64 540 #else 541 typedef struct _IMAGEHLP_LINE { 542 DWORD SizeOfStruct; 543 PVOID Key; 544 DWORD LineNumber; 545 PCHAR FileName; 546 DWORD Address; 547 } IMAGEHLP_LINE,*PIMAGEHLP_LINE; 548 549 typedef struct _IMAGEHLP_LINEW { 550 DWORD SizeOfStruct; 551 PVOID Key; 552 DWORD LineNumber; 553 PWSTR FileName; 554 DWORD Address; 555 } IMAGEHLP_LINEW,*PIMAGEHLP_LINEW; 556 #endif 557 558 typedef struct _SOURCEFILE { 559 DWORD64 ModBase; 560 PCHAR FileName; 561 } SOURCEFILE,*PSOURCEFILE; 562 563 typedef struct _SOURCEFILEW { 564 DWORD64 ModBase; 565 PWCHAR FileName; 566 } SOURCEFILEW,*PSOURCEFILEW; 567 568 #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 569 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 570 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 571 #define CBA_SYMBOLS_UNLOADED 0x00000004 572 #define CBA_DUPLICATE_SYMBOL 0x00000005 573 #define CBA_READ_MEMORY 0x00000006 574 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 575 #define CBA_SET_OPTIONS 0x00000008 576 #define CBA_EVENT 0x00000010 577 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 578 #define CBA_DEBUG_INFO 0x10000000 579 #define CBA_SRCSRV_INFO 0x20000000 580 #define CBA_SRCSRV_EVENT 0x40000000 581 582 typedef struct _IMAGEHLP_CBA_READ_MEMORY { 583 DWORD64 addr; 584 PVOID buf; 585 DWORD bytes; 586 DWORD *bytesread; 587 } IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY; 588 589 enum { 590 sevInfo = 0, 591 sevProblem, 592 sevAttn, 593 sevFatal, 594 sevMax 595 }; 596 597 typedef struct _IMAGEHLP_CBA_EVENT { 598 DWORD severity; 599 DWORD code; 600 PCHAR desc; 601 PVOID object; 602 } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT; 603 604 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 { 605 DWORD SizeOfStruct; 606 DWORD64 BaseOfImage; 607 DWORD CheckSum; 608 DWORD TimeDateStamp; 609 CHAR FileName[MAX_PATH]; 610 BOOLEAN Reparse; 611 HANDLE hFile; 612 DWORD Flags; 613 } IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; 614 615 #define DSLFLAG_MISMATCHED_PDB 0x1 616 #define DSLFLAG_MISMATCHED_DBG 0x2 617 618 #ifdef _IMAGEHLP64 619 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64 620 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 621 #else 622 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD { 623 DWORD SizeOfStruct; 624 DWORD BaseOfImage; 625 DWORD CheckSum; 626 DWORD TimeDateStamp; 627 CHAR FileName[MAX_PATH]; 628 BOOLEAN Reparse; 629 HANDLE hFile; 630 } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD; 631 #endif 632 633 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 { 634 DWORD SizeOfStruct; 635 DWORD NumberOfDups; 636 PIMAGEHLP_SYMBOL64 Symbol; 637 DWORD SelectedSymbol; 638 } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64; 639 640 #ifdef _IMAGEHLP64 641 #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64 642 #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64 643 #else 644 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL { 645 DWORD SizeOfStruct; 646 DWORD NumberOfDups; 647 PIMAGEHLP_SYMBOL Symbol; 648 DWORD SelectedSymbol; 649 } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL; 650 #endif 651 652 typedef struct _SYMSRV_INDEX_INFO { 653 DWORD sizeofstruct; 654 CHAR file[MAX_PATH +1]; 655 WINBOOL stripped; 656 DWORD timestamp; 657 DWORD size; 658 CHAR dbgfile[MAX_PATH +1]; 659 CHAR pdbfile[MAX_PATH + 1]; 660 GUID guid; 661 DWORD sig; 662 DWORD age; 663 } SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO; 664 665 typedef struct _SYMSRV_INDEX_INFOW { 666 DWORD sizeofstruct; 667 WCHAR file[MAX_PATH +1]; 668 WINBOOL stripped; 669 DWORD timestamp; 670 DWORD size; 671 WCHAR dbgfile[MAX_PATH +1]; 672 WCHAR pdbfile[MAX_PATH + 1]; 673 GUID guid; 674 DWORD sig; 675 DWORD age; 676 } SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW; 677 678 WINBOOL IMAGEAPI SymSetParentWindow(HWND hwnd); 679 PCHAR IMAGEAPI SymSetHomeDirectory(HANDLE hProcess,PCSTR dir); 680 PCHAR IMAGEAPI SymSetHomeDirectoryW(HANDLE hProcess,PCWSTR dir); 681 PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size); 682 PWCHAR IMAGEAPI SymGetHomeDirectoryW(DWORD type,PWSTR dir,size_t size); 683 684 #define hdBase 0 685 #define hdSym 1 686 #define hdSrc 2 687 #define hdMax 3 688 689 #define SYMOPT_CASE_INSENSITIVE 0x00000001 690 #define SYMOPT_UNDNAME 0x00000002 691 #define SYMOPT_DEFERRED_LOADS 0x00000004 692 #define SYMOPT_NO_CPP 0x00000008 693 #define SYMOPT_LOAD_LINES 0x00000010 694 #define SYMOPT_OMAP_FIND_NEAREST 0x00000020 695 #define SYMOPT_LOAD_ANYTHING 0x00000040 696 #define SYMOPT_IGNORE_CVREC 0x00000080 697 #define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100 698 #define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200 699 #define SYMOPT_EXACT_SYMBOLS 0x00000400 700 #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 701 #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 702 #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 703 #define SYMOPT_PUBLICS_ONLY 0x00004000 704 #define SYMOPT_NO_PUBLICS 0x00008000 705 #define SYMOPT_AUTO_PUBLICS 0x00010000 706 #define SYMOPT_NO_IMAGE_SEARCH 0x00020000 707 #define SYMOPT_SECURE 0x00040000 708 #define SYMOPT_NO_PROMPTS 0x00080000 709 #define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000 710 #define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000 711 #define SYMOPT_FAVOR_COMPRESSED 0x00800000 712 #define SYMOPT_FLAT_DIRECTORY 0x00400000 713 #define SYMOPT_IGNORE_IMAGEDIR 0x00200000 714 #define SYMOPT_OVERWRITE 0x00100000 715 716 #define SYMOPT_DEBUG 0x80000000 717 718 DWORD IMAGEAPI SymSetOptions(DWORD SymOptions); 719 DWORD IMAGEAPI SymGetOptions(VOID); 720 WINBOOL IMAGEAPI SymCleanup(HANDLE hProcess); 721 WINBOOL IMAGEAPI SymMatchString(PCSTR string,PCSTR expression,WINBOOL fCase); 722 WINBOOL IMAGEAPI SymMatchStringW(PCWSTR string,PCWSTR expression,WINBOOL fCase); 723 724 typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext); 725 typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW pSourceFile,PVOID UserContext); 726 #define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK 727 728 WINBOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,PCSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,PVOID UserContext); 729 WINBOOL IMAGEAPI SymEnumSourceFilesW(HANDLE hProcess,ULONG64 ModBase,PCWSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,PVOID UserContext); 730 WINBOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext); 731 WINBOOL IMAGEAPI SymEnumerateModulesW64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,PVOID UserContext); 732 733 #ifdef _IMAGEHLP64 734 #define SymEnumerateModules SymEnumerateModules64 735 #else 736 WINBOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext); 737 #endif 738 739 WINBOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext); 740 WINBOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext); 741 742 #ifdef _IMAGEHLP64 743 #define SymEnumerateSymbols SymEnumerateSymbols64 744 #define SymEnumerateSymbolsW SymEnumerateSymbolsW64 745 #else 746 WINBOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 747 WINBOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); 748 #endif 749 750 WINBOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext); 751 WINBOOL IMAGEAPI EnumerateLoadedModulesW64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,PVOID UserContext); 752 753 #ifdef _IMAGEHLP64 754 #define EnumerateLoadedModules EnumerateLoadedModules64 755 #else 756 WINBOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext); 757 #endif 758 759 PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase); 760 761 #ifdef _IMAGEHLP64 762 #define SymFunctionTableAccess SymFunctionTableAccess64 763 #else 764 PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase); 765 #endif 766 767 WINBOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo); 768 WINBOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo); 769 770 #ifdef _IMAGEHLP64 771 #define SymGetModuleInfo SymGetModuleInfo64 772 #define SymGetModuleInfoW SymGetModuleInfoW64 773 #else 774 WINBOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo); 775 WINBOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo); 776 #endif 777 778 DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr); 779 780 #ifdef _IMAGEHLP64 781 #define SymGetModuleBase SymGetModuleBase64 782 #else 783 DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr); 784 #endif 785 786 WINBOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol); 787 788 #ifdef _IMAGEHLP64 789 #define SymGetSymNext SymGetSymNext64 790 #else 791 WINBOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol); 792 #endif 793 794 WINBOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol); 795 796 #ifdef _IMAGEHLP64 797 #define SymGetSymPrev SymGetSymPrev64 798 #else 799 WINBOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol); 800 #endif 801 802 typedef struct _SRCCODEINFO { 803 DWORD SizeOfStruct; 804 PVOID Key; 805 DWORD64 ModBase; 806 CHAR Obj[MAX_PATH + 1]; 807 CHAR FileName[MAX_PATH + 1]; 808 DWORD LineNumber; 809 DWORD64 Address; 810 } SRCCODEINFO,*PSRCCODEINFO; 811 812 typedef struct _SRCCODEINFOW { 813 DWORD SizeOfStruct; 814 PVOID Key; 815 DWORD64 ModBase; 816 WCHAR Obj[MAX_PATH + 1]; 817 WCHAR FileName[MAX_PATH + 1]; 818 DWORD LineNumber; 819 DWORD64 Address; 820 } SRCCODEINFOW,*PSRCCODEINFOW; 821 822 typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext); 823 typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW LineInfo,PVOID UserContext); 824 825 WINBOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext); 826 WINBOOL IMAGEAPI SymEnumLinesW(HANDLE hProcess,ULONG64 Base,PCWSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,PVOID UserContext); 827 WINBOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64); 828 WINBOOL IMAGEAPI SymGetLineFromAddrW64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW64 Line64); 829 830 #ifdef _IMAGEHLP64 831 #define SymGetLineFromAddr SymGetLineFromAddr64 832 #define SymGetLineFromAddrW SymGetLineFromAddrW64 833 #else 834 WINBOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line); 835 WINBOOL IMAGEAPI SymGetLineFromAddrW(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW Line); 836 #endif 837 838 WINBOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line); 839 WINBOOL IMAGEAPI SymGetLineFromNameW64(HANDLE hProcess,PCWSTR ModuleName,PCWSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINEW64 Line); 840 841 #ifdef _IMAGEHLP64 842 #define SymGetLineFromName SymGetLineFromName64 843 #else 844 WINBOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line); 845 #endif 846 847 WINBOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line); 848 WINBOOL IMAGEAPI SymGetLineNextW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line); 849 850 #ifdef _IMAGEHLP64 851 #define SymGetLineNext SymGetLineNext64 852 #else 853 WINBOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line); 854 #endif 855 856 WINBOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line); 857 WINBOOL IMAGEAPI SymGetLinePrevW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line); 858 859 #ifdef _IMAGEHLP64 860 #define SymGetLinePrev SymGetLinePrev64 861 #else 862 WINBOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line); 863 #endif 864 865 WINBOOL IMAGEAPI SymMatchFileName(PCSTR FileName,PCSTR Match,PSTR *FileNameStop,PSTR *MatchStop); 866 WINBOOL IMAGEAPI SymMatchFileNameW(PCWSTR FileName,PCWSTR Match,PWSTR *FileNameStop,PWSTR *MatchStop); 867 WINBOOL IMAGEAPI SymInitialize(HANDLE hProcess,PCSTR UserSearchPath,WINBOOL fInvadeProcess); 868 WINBOOL IMAGEAPI SymInitializeW(HANDLE hProcess,PCWSTR UserSearchPath,WINBOOL fInvadeProcess); 869 WINBOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength); 870 WINBOOL IMAGEAPI SymGetSearchPathW(HANDLE hProcess,PWSTR SearchPath,DWORD SearchPathLength); 871 WINBOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PCSTR SearchPath); 872 WINBOOL IMAGEAPI SymSetSearchPathW(HANDLE hProcess,PCWSTR SearchPath); 873 DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll); 874 875 #define SLMFLAG_VIRTUAL 0x1 876 877 DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags); 878 DWORD64 IMAGEAPI SymLoadModuleExW(HANDLE hProcess,HANDLE hFile,PCWSTR ImageName,PCWSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags); 879 880 #ifdef _IMAGEHLP64 881 #define SymLoadModule SymLoadModule64 882 #else 883 DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll); 884 #endif 885 886 WINBOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll); 887 888 #ifdef _IMAGEHLP64 889 #define SymUnloadModule SymUnloadModule64 890 #else 891 WINBOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll); 892 #endif 893 894 WINBOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength); 895 896 #ifdef _IMAGEHLP64 897 #define SymUnDName SymUnDName64 898 #else 899 WINBOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength); 900 #endif 901 902 WINBOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext); 903 WINBOOL IMAGEAPI SymRegisterCallbackW64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext); 904 905 WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext); 906 907 #ifdef _IMAGEHLP64 908 #define SymRegisterCallback SymRegisterCallback64 909 #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64 910 #else 911 WINBOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext); 912 WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext); 913 #endif 914 915 typedef struct _IMAGEHLP_SYMBOL_SRC { 916 DWORD sizeofstruct; 917 DWORD type; 918 char file[MAX_PATH]; 919 } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC; 920 921 typedef struct _MODULE_TYPE_INFO { 922 USHORT dataLength; 923 USHORT leaf; 924 BYTE data[1]; 925 } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO; 926 927 typedef struct _SYMBOL_INFO { 928 ULONG SizeOfStruct; 929 ULONG TypeIndex; 930 ULONG64 Reserved[2]; 931 ULONG info; 932 ULONG Size; 933 ULONG64 ModBase; 934 ULONG Flags; 935 ULONG64 Value; 936 ULONG64 Address; 937 ULONG Register; 938 ULONG Scope; 939 ULONG Tag; 940 ULONG NameLen; 941 ULONG MaxNameLen; 942 CHAR Name[1]; 943 } SYMBOL_INFO,*PSYMBOL_INFO; 944 945 typedef struct _SYMBOL_INFOW { 946 ULONG SizeOfStruct; 947 ULONG TypeIndex; 948 ULONG64 Reserved[2]; 949 ULONG info; 950 ULONG Size; 951 ULONG64 ModBase; 952 ULONG Flags; 953 ULONG64 Value; 954 ULONG64 Address; 955 ULONG Register; 956 ULONG Scope; 957 ULONG Tag; 958 ULONG NameLen; 959 ULONG MaxNameLen; 960 WCHAR Name[1]; 961 } SYMBOL_INFOW,*PSYMBOL_INFOW; 962 963 #define SYMFLAG_CLR_TOKEN 0x00040000 964 #define SYMFLAG_CONSTANT 0x00000100 965 #define SYMFLAG_EXPORT 0x00000200 966 #define SYMFLAG_FORWARDER 0x00000400 967 #define SYMFLAG_FRAMEREL 0x00000020 968 #define SYMFLAG_FUNCTION 0x00000800 969 #define SYMFLAG_ILREL 0x00010000 970 #define SYMFLAG_LOCAL 0x00000080 971 #define SYMFLAG_METADATA 0x00020000 972 #define SYMFLAG_PARAMETER 0x00000040 973 #define SYMFLAG_REGISTER 0x00000008 974 #define SYMFLAG_REGREL 0x00000010 975 #define SYMFLAG_SLOT 0x00008000 976 #define SYMFLAG_THUNK 0x00002000 977 #define SYMFLAG_TLSREL 0x00004000 978 #define SYMFLAG_VALUEPRESENT 0x00000001 979 #define SYMFLAG_VIRTUAL 0x00001000 980 981 typedef struct _SYMBOL_INFO_PACKAGE { 982 SYMBOL_INFO si; 983 CHAR name[MAX_SYM_NAME + 1]; 984 } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE; 985 986 typedef struct _IMAGEHLP_STACK_FRAME { 987 ULONG64 InstructionOffset; 988 ULONG64 ReturnOffset; 989 ULONG64 FrameOffset; 990 ULONG64 StackOffset; 991 ULONG64 BackingStoreOffset; 992 ULONG64 FuncTableEntry; 993 ULONG64 Params[4]; 994 ULONG64 Reserved[5]; 995 WINBOOL Virtual; 996 ULONG Reserved2; 997 } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME; 998 999 typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT; 1000 1001 WINBOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context); 1002 WINBOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol); 1003 WINBOOL IMAGEAPI SymFromAddrW(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFOW Symbol); 1004 WINBOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol); 1005 WINBOOL IMAGEAPI SymFromTokenW(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFOW Symbol); 1006 WINBOOL IMAGEAPI SymFromName(HANDLE hProcess,PCSTR Name,PSYMBOL_INFO Symbol); 1007 WINBOOL IMAGEAPI SymFromNameW(HANDLE hProcess,PCWSTR Name,PSYMBOL_INFOW Symbol); 1008 1009 typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext); 1010 typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW pSymInfo,ULONG SymbolSize,PVOID UserContext); 1011 1012 WINBOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 1013 WINBOOL IMAGEAPI SymEnumSymbolsW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); 1014 WINBOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 1015 WINBOOL IMAGEAPI SymEnumSymbolsForAddrW(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); 1016 1017 #define SYMENUMFLAG_FULLSRCH 1 1018 #define SYMENUMFLAG_SPEEDSRCH 2 1019 1020 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO { 1021 TI_GET_SYMTAG, 1022 TI_GET_SYMNAME, 1023 TI_GET_LENGTH, 1024 TI_GET_TYPE, 1025 TI_GET_TYPEID, 1026 TI_GET_BASETYPE, 1027 TI_GET_ARRAYINDEXTYPEID, 1028 TI_FINDCHILDREN, 1029 TI_GET_DATAKIND, 1030 TI_GET_ADDRESSOFFSET, 1031 TI_GET_OFFSET, 1032 TI_GET_VALUE, 1033 TI_GET_COUNT, 1034 TI_GET_CHILDRENCOUNT, 1035 TI_GET_BITPOSITION, 1036 TI_GET_VIRTUALBASECLASS, 1037 TI_GET_VIRTUALTABLESHAPEID, 1038 TI_GET_VIRTUALBASEPOINTEROFFSET, 1039 TI_GET_CLASSPARENTID, 1040 TI_GET_NESTED, 1041 TI_GET_SYMINDEX, 1042 TI_GET_LEXICALPARENT, 1043 TI_GET_ADDRESS, 1044 TI_GET_THISADJUST, 1045 TI_GET_UDTKIND, 1046 TI_IS_EQUIV_TO, 1047 TI_GET_CALLING_CONVENTION 1048 } IMAGEHLP_SYMBOL_TYPE_INFO; 1049 1050 typedef struct _TI_FINDCHILDREN_PARAMS { 1051 ULONG Count; 1052 ULONG Start; 1053 ULONG ChildId[1]; 1054 } TI_FINDCHILDREN_PARAMS; 1055 1056 WINBOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo); 1057 WINBOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 1058 WINBOOL IMAGEAPI SymEnumTypesW(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); 1059 WINBOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,PSYMBOL_INFO Symbol); 1060 WINBOOL IMAGEAPI SymGetTypeFromNameW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,PSYMBOL_INFOW Symbol); 1061 WINBOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags); 1062 WINBOOL IMAGEAPI SymAddSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Size,DWORD Flags); 1063 WINBOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags); 1064 WINBOOL IMAGEAPI SymDeleteSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Flags); 1065 1066 typedef WINBOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData); 1067 1068 WINBOOL WINAPI DbgHelpCreateUserDump(LPCSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData); 1069 WINBOOL WINAPI DbgHelpCreateUserDumpW(LPCWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData); 1070 WINBOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol); 1071 1072 #ifdef _IMAGEHLP64 1073 #define SymGetSymFromAddr SymGetSymFromAddr64 1074 #else 1075 WINBOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol); 1076 #endif 1077 1078 WINBOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL64 Symbol); 1079 1080 #ifdef _IMAGEHLP64 1081 #define SymGetSymFromName SymGetSymFromName64 1082 #else 1083 WINBOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL Symbol); 1084 #endif 1085 1086 DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,PSTR FilePath); 1087 DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,DWORD one,DWORD two,DWORD three,PSTR FilePath); 1088 DBHLP_DEPRECIATED WINBOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 1089 1090 #ifdef __cplusplus 1091 } 1092 #endif 1093 1094 #define SYMF_OMAP_GENERATED 0x00000001 1095 #define SYMF_OMAP_MODIFIED 0x00000002 1096 #define SYMF_REGISTER 0x00000008 1097 #define SYMF_REGREL 0x00000010 1098 #define SYMF_FRAMEREL 0x00000020 1099 #define SYMF_PARAMETER 0x00000040 1100 #define SYMF_LOCAL 0x00000080 1101 #define SYMF_CONSTANT 0x00000100 1102 #define SYMF_EXPORT 0x00000200 1103 #define SYMF_FORWARDER 0x00000400 1104 #define SYMF_FUNCTION 0x00000800 1105 #define SYMF_VIRTUAL 0x00001000 1106 #define SYMF_THUNK 0x00002000 1107 #define SYMF_TLSREL 0x00004000 1108 1109 #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1 1110 #define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER 1111 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL 1112 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL 1113 #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER 1114 #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL 1115 #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT 1116 #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION 1117 #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL 1118 #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK 1119 #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL 1120 1121 #include <pshpack4.h> 1122 1123 #define MINIDUMP_SIGNATURE ('PMDM') 1124 #define MINIDUMP_VERSION (42899) 1125 typedef DWORD RVA; 1126 typedef ULONG64 RVA64; 1127 1128 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR { 1129 ULONG32 DataSize; 1130 RVA Rva; 1131 } MINIDUMP_LOCATION_DESCRIPTOR; 1132 1133 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 { 1134 ULONG64 DataSize; 1135 RVA64 Rva; 1136 } MINIDUMP_LOCATION_DESCRIPTOR64; 1137 1138 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR { 1139 ULONG64 StartOfMemoryRange; 1140 MINIDUMP_LOCATION_DESCRIPTOR Memory; 1141 } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR; 1142 1143 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 { 1144 ULONG64 StartOfMemoryRange; 1145 ULONG64 DataSize; 1146 } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64; 1147 1148 typedef struct _MINIDUMP_HEADER { 1149 ULONG32 Signature; 1150 ULONG32 Version; 1151 ULONG32 NumberOfStreams; 1152 RVA StreamDirectoryRva; 1153 ULONG32 CheckSum; 1154 __C89_NAMELESS union { 1155 ULONG32 Reserved; 1156 ULONG32 TimeDateStamp; 1157 }; 1158 ULONG64 Flags; 1159 } MINIDUMP_HEADER,*PMINIDUMP_HEADER; 1160 1161 typedef struct _MINIDUMP_DIRECTORY { 1162 ULONG32 StreamType; 1163 MINIDUMP_LOCATION_DESCRIPTOR Location; 1164 } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY; 1165 1166 typedef struct _MINIDUMP_STRING { 1167 ULONG32 Length; 1168 WCHAR Buffer[0]; 1169 } MINIDUMP_STRING,*PMINIDUMP_STRING; 1170 1171 typedef enum _MINIDUMP_STREAM_TYPE { 1172 UnusedStream = 0, 1173 ReservedStream0 = 1, 1174 ReservedStream1 = 2, 1175 ThreadListStream = 3, 1176 ModuleListStream = 4, 1177 MemoryListStream = 5, 1178 ExceptionStream = 6, 1179 SystemInfoStream = 7, 1180 ThreadExListStream = 8, 1181 Memory64ListStream = 9, 1182 CommentStreamA = 10, 1183 CommentStreamW = 11, 1184 HandleDataStream = 12, 1185 FunctionTableStream = 13, 1186 UnloadedModuleListStream = 14, 1187 MiscInfoStream = 15, 1188 MemoryInfoListStream = 16, 1189 ThreadInfoListStream = 17, 1190 HandleOperationListStream = 18, 1191 TokenStream = 19, 1192 JavaScriptDataStream = 20, 1193 SystemMemoryInfoStream = 21, 1194 ProcessVmCountersStream = 22, 1195 IptTraceStream = 23, 1196 ThreadNamesStream = 24, 1197 ceStreamNull = 0x8000, 1198 ceStreamSystemInfo = 0x8001, 1199 ceStreamException = 0x8002, 1200 ceStreamModuleList = 0x8003, 1201 ceStreamProcessList = 0x8004, 1202 ceStreamThreadList = 0x8005, 1203 ceStreamThreadContextList = 0x8006, 1204 ceStreamThreadCallStackList = 0x8007, 1205 ceStreamMemoryVirtualList = 0x8008, 1206 ceStreamMemoryPhysicalList = 0x8009, 1207 ceStreamBucketParameters = 0x800a, 1208 ceStreamProcessModuleMap = 0x800b, 1209 ceStreamDiagnosisList = 0x800c, 1210 LastReservedStream = 0xffff 1211 } MINIDUMP_STREAM_TYPE; 1212 1213 typedef union _CPU_INFORMATION { 1214 struct { 1215 ULONG32 VendorId[3]; 1216 ULONG32 VersionInformation; 1217 ULONG32 FeatureInformation; 1218 ULONG32 AMDExtendedCpuFeatures; 1219 } X86CpuInfo; 1220 struct { 1221 ULONG64 ProcessorFeatures[2]; 1222 } OtherCpuInfo; 1223 } CPU_INFORMATION,*PCPU_INFORMATION; 1224 1225 typedef struct _MINIDUMP_SYSTEM_INFO { 1226 USHORT ProcessorArchitecture; 1227 USHORT ProcessorLevel; 1228 USHORT ProcessorRevision; 1229 __C89_NAMELESS union { 1230 USHORT Reserved0; 1231 __C89_NAMELESS struct { 1232 UCHAR NumberOfProcessors; 1233 UCHAR ProductType; 1234 }; 1235 }; 1236 ULONG32 MajorVersion; 1237 ULONG32 MinorVersion; 1238 ULONG32 BuildNumber; 1239 ULONG32 PlatformId; 1240 RVA CSDVersionRva; 1241 __C89_NAMELESS union { 1242 ULONG32 Reserved1; 1243 __C89_NAMELESS struct { 1244 USHORT SuiteMask; 1245 USHORT Reserved2; 1246 }; 1247 }; 1248 CPU_INFORMATION Cpu; 1249 } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO; 1250 1251 C_ASSERT(sizeof(((PPROCESS_INFORMATION)0)->dwThreadId)==4); 1252 1253 typedef struct _MINIDUMP_THREAD { 1254 ULONG32 ThreadId; 1255 ULONG32 SuspendCount; 1256 ULONG32 PriorityClass; 1257 ULONG32 Priority; 1258 ULONG64 Teb; 1259 MINIDUMP_MEMORY_DESCRIPTOR Stack; 1260 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; 1261 } MINIDUMP_THREAD,*PMINIDUMP_THREAD; 1262 1263 typedef struct _MINIDUMP_THREAD_LIST { 1264 ULONG32 NumberOfThreads; 1265 MINIDUMP_THREAD Threads[0]; 1266 } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST; 1267 1268 typedef struct _MINIDUMP_THREAD_EX { 1269 ULONG32 ThreadId; 1270 ULONG32 SuspendCount; 1271 ULONG32 PriorityClass; 1272 ULONG32 Priority; 1273 ULONG64 Teb; 1274 MINIDUMP_MEMORY_DESCRIPTOR Stack; 1275 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; 1276 MINIDUMP_MEMORY_DESCRIPTOR BackingStore; 1277 } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX; 1278 1279 typedef struct _MINIDUMP_THREAD_EX_LIST { 1280 ULONG32 NumberOfThreads; 1281 MINIDUMP_THREAD_EX Threads[0]; 1282 } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST; 1283 1284 typedef struct _MINIDUMP_EXCEPTION { 1285 ULONG32 ExceptionCode; 1286 ULONG32 ExceptionFlags; 1287 ULONG64 ExceptionRecord; 1288 ULONG64 ExceptionAddress; 1289 ULONG32 NumberParameters; 1290 ULONG32 __unusedAlignment; 1291 ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; 1292 } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION; 1293 1294 typedef struct MINIDUMP_EXCEPTION_STREAM { 1295 ULONG32 ThreadId; 1296 ULONG32 __alignment; 1297 MINIDUMP_EXCEPTION ExceptionRecord; 1298 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; 1299 } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM; 1300 1301 typedef struct _MINIDUMP_MODULE { 1302 ULONG64 BaseOfImage; 1303 ULONG32 SizeOfImage; 1304 ULONG32 CheckSum; 1305 ULONG32 TimeDateStamp; 1306 RVA ModuleNameRva; 1307 VS_FIXEDFILEINFO VersionInfo; 1308 MINIDUMP_LOCATION_DESCRIPTOR CvRecord; 1309 MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; 1310 ULONG64 Reserved0; 1311 ULONG64 Reserved1; 1312 } MINIDUMP_MODULE,*PMINIDUMP_MODULE; 1313 1314 typedef struct _MINIDUMP_MODULE_LIST { 1315 ULONG32 NumberOfModules; 1316 MINIDUMP_MODULE Modules[0]; 1317 } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST; 1318 1319 typedef struct _MINIDUMP_MEMORY_LIST { 1320 ULONG32 NumberOfMemoryRanges; 1321 MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[0]; 1322 } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST; 1323 1324 typedef struct _MINIDUMP_MEMORY64_LIST { 1325 ULONG64 NumberOfMemoryRanges; 1326 RVA64 BaseRva; 1327 MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[0]; 1328 } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST; 1329 1330 typedef struct _MINIDUMP_EXCEPTION_INFORMATION { 1331 DWORD ThreadId; 1332 PEXCEPTION_POINTERS ExceptionPointers; 1333 WINBOOL ClientPointers; 1334 } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION; 1335 1336 typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 { 1337 DWORD ThreadId; 1338 ULONG64 ExceptionRecord; 1339 ULONG64 ContextRecord; 1340 WINBOOL ClientPointers; 1341 } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64; 1342 1343 typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE { 1344 MiniHandleObjectInformationNone, 1345 MiniThreadInformation1, 1346 MiniMutantInformation1, 1347 MiniMutantInformation2, 1348 MiniProcessInformation1, 1349 MiniProcessInformation2, 1350 MiniEventInformation1, 1351 MiniSectionInformation1, 1352 MiniSemaphoreInformation1, 1353 MiniHandleObjectInformationTypeMax 1354 } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE; 1355 1356 typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION { 1357 RVA NextInfoRva; 1358 ULONG32 InfoType; 1359 ULONG32 SizeOfInfo; 1360 } MINIDUMP_HANDLE_OBJECT_INFORMATION; 1361 1362 typedef struct _MINIDUMP_HANDLE_DESCRIPTOR { 1363 ULONG64 Handle; 1364 RVA TypeNameRva; 1365 RVA ObjectNameRva; 1366 ULONG32 Attributes; 1367 ULONG32 GrantedAccess; 1368 ULONG32 HandleCount; 1369 ULONG32 PointerCount; 1370 } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR; 1371 1372 typedef struct _MINIDUMP_HANDLE_DATA_STREAM { 1373 ULONG32 SizeOfHeader; 1374 ULONG32 SizeOfDescriptor; 1375 ULONG32 NumberOfDescriptors; 1376 ULONG32 Reserved; 1377 } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM; 1378 1379 typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR { 1380 ULONG64 MinimumAddress; 1381 ULONG64 MaximumAddress; 1382 ULONG64 BaseAddress; 1383 ULONG32 EntryCount; 1384 ULONG32 SizeOfAlignPad; 1385 } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR; 1386 1387 typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM { 1388 ULONG32 SizeOfHeader; 1389 ULONG32 SizeOfDescriptor; 1390 ULONG32 SizeOfNativeDescriptor; 1391 ULONG32 SizeOfFunctionEntry; 1392 ULONG32 NumberOfDescriptors; 1393 ULONG32 SizeOfAlignPad; 1394 } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM; 1395 1396 typedef struct _MINIDUMP_UNLOADED_MODULE { 1397 ULONG64 BaseOfImage; 1398 ULONG32 SizeOfImage; 1399 ULONG32 CheckSum; 1400 ULONG32 TimeDateStamp; 1401 RVA ModuleNameRva; 1402 } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE; 1403 1404 typedef struct _MINIDUMP_UNLOADED_MODULE_LIST { 1405 ULONG32 SizeOfHeader; 1406 ULONG32 SizeOfEntry; 1407 ULONG32 NumberOfEntries; 1408 } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST; 1409 1410 #define MINIDUMP_MISC1_PROCESS_ID 0x00000001 1411 #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 1412 #define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004 1413 1414 typedef struct _MINIDUMP_MISC_INFO { 1415 ULONG32 SizeOfInfo; 1416 ULONG32 Flags1; 1417 ULONG32 ProcessId; 1418 ULONG32 ProcessCreateTime; 1419 ULONG32 ProcessUserTime; 1420 ULONG32 ProcessKernelTime; 1421 } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO; 1422 1423 typedef struct _MINIDUMP_USER_RECORD { 1424 ULONG32 Type; 1425 MINIDUMP_LOCATION_DESCRIPTOR Memory; 1426 } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD; 1427 1428 typedef struct _MINIDUMP_USER_STREAM { 1429 ULONG32 Type; 1430 ULONG BufferSize; 1431 PVOID Buffer; 1432 } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM; 1433 1434 typedef struct _MINIDUMP_USER_STREAM_INFORMATION { 1435 ULONG UserStreamCount; 1436 PMINIDUMP_USER_STREAM UserStreamArray; 1437 } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION; 1438 1439 typedef enum _MINIDUMP_CALLBACK_TYPE { 1440 ModuleCallback, 1441 ThreadCallback, 1442 ThreadExCallback, 1443 IncludeThreadCallback, 1444 IncludeModuleCallback, 1445 MemoryCallback, 1446 CancelCallback, 1447 WriteKernelMinidumpCallback, 1448 KernelMinidumpStatusCallback, 1449 RemoveMemoryCallback, 1450 IncludeVmRegionCallback, 1451 IoStartCallback, 1452 IoWriteAllCallback, 1453 IoFinishCallback, 1454 ReadMemoryFailureCallback, 1455 SecondaryFlagsCallback, 1456 IsProcessSnapshotCallback, 1457 VmStartCallback, 1458 VmQueryCallback, 1459 VmPreReadCallback, 1460 VmPostReadCallback 1461 } MINIDUMP_CALLBACK_TYPE; 1462 1463 typedef struct _MINIDUMP_THREAD_CALLBACK { 1464 ULONG ThreadId; 1465 HANDLE ThreadHandle; 1466 #if defined(__aarch64__) 1467 ULONG Pad; 1468 #endif 1469 CONTEXT Context; 1470 ULONG SizeOfContext; 1471 ULONG64 StackBase; 1472 ULONG64 StackEnd; 1473 } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK; 1474 1475 typedef struct _MINIDUMP_THREAD_EX_CALLBACK { 1476 ULONG ThreadId; 1477 HANDLE ThreadHandle; 1478 #if defined(__aarch64__) 1479 ULONG Pad; 1480 #endif 1481 CONTEXT Context; 1482 ULONG SizeOfContext; 1483 ULONG64 StackBase; 1484 ULONG64 StackEnd; 1485 ULONG64 BackingStoreBase; 1486 ULONG64 BackingStoreEnd; 1487 } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK; 1488 1489 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK { 1490 ULONG ThreadId; 1491 } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK; 1492 1493 typedef enum _THREAD_WRITE_FLAGS { 1494 ThreadWriteThread = 0x0001, 1495 ThreadWriteStack = 0x0002, 1496 ThreadWriteContext = 0x0004, 1497 ThreadWriteBackingStore = 0x0008, 1498 ThreadWriteInstructionWindow = 0x0010, 1499 ThreadWriteThreadData = 0x0020, 1500 ThreadWriteThreadInfo = 0x0040 1501 } THREAD_WRITE_FLAGS; 1502 1503 typedef struct _MINIDUMP_MODULE_CALLBACK { 1504 PWCHAR FullPath; 1505 ULONG64 BaseOfImage; 1506 ULONG SizeOfImage; 1507 ULONG CheckSum; 1508 ULONG TimeDateStamp; 1509 VS_FIXEDFILEINFO VersionInfo; 1510 PVOID CvRecord; 1511 ULONG SizeOfCvRecord; 1512 PVOID MiscRecord; 1513 ULONG SizeOfMiscRecord; 1514 } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK; 1515 1516 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK { 1517 ULONG64 BaseOfImage; 1518 } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK; 1519 1520 typedef enum _MODULE_WRITE_FLAGS { 1521 ModuleWriteModule = 0x0001, 1522 ModuleWriteDataSeg = 0x0002, 1523 ModuleWriteMiscRecord = 0x0004, 1524 ModuleWriteCvRecord = 0x0008, 1525 ModuleReferencedByMemory = 0x0010, 1526 ModuleWriteTlsData = 0x0020, 1527 ModuleWriteCodeSegs = 0x0040 1528 } MODULE_WRITE_FLAGS; 1529 1530 typedef enum _MINIDUMP_SECONDARY_FLAGS { 1531 MiniSecondaryWithoutPowerInfo = 0x00000001 1532 } MINIDUMP_SECONDARY_FLAGS; 1533 1534 typedef struct _MINIDUMP_CALLBACK_INPUT { 1535 ULONG ProcessId; 1536 HANDLE ProcessHandle; 1537 ULONG CallbackType; 1538 __C89_NAMELESS union { 1539 MINIDUMP_THREAD_CALLBACK Thread; 1540 MINIDUMP_THREAD_EX_CALLBACK ThreadEx; 1541 MINIDUMP_MODULE_CALLBACK Module; 1542 MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; 1543 MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; 1544 }; 1545 } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT; 1546 1547 typedef struct _MINIDUMP_MEMORY_INFO { 1548 ULONG64 BaseAddress; 1549 ULONG64 AllocationBase; 1550 ULONG32 AllocationProtect; 1551 ULONG32 __alignment1; 1552 ULONG64 RegionSize; 1553 ULONG32 State; 1554 ULONG32 Protect; 1555 ULONG32 Type; 1556 ULONG32 __alignment2; 1557 } MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO; 1558 1559 typedef struct _MINIDUMP_MISC_INFO_2 { 1560 ULONG32 SizeOfInfo; 1561 ULONG32 Flags1; 1562 ULONG32 ProcessId; 1563 ULONG32 ProcessCreateTime; 1564 ULONG32 ProcessUserTime; 1565 ULONG32 ProcessKernelTime; 1566 ULONG32 ProcessorMaxMhz; 1567 ULONG32 ProcessorCurrentMhz; 1568 ULONG32 ProcessorMhzLimit; 1569 ULONG32 ProcessorMaxIdleState; 1570 ULONG32 ProcessorCurrentIdleState; 1571 } MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2; 1572 1573 typedef struct _MINIDUMP_MEMORY_INFO_LIST { 1574 ULONG SizeOfHeader; 1575 ULONG SizeOfEntry; 1576 ULONG64 NumberOfEntries; 1577 } MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST; 1578 1579 typedef struct _MINIDUMP_CALLBACK_OUTPUT { 1580 __C89_NAMELESS union { 1581 ULONG ModuleWriteFlags; 1582 ULONG ThreadWriteFlags; 1583 ULONG SecondaryFlags; 1584 __C89_NAMELESS struct { 1585 ULONG64 MemoryBase; 1586 ULONG MemorySize; 1587 }; 1588 __C89_NAMELESS struct { 1589 WINBOOL CheckCancel; 1590 WINBOOL Cancel; 1591 }; 1592 HANDLE Handle; 1593 }; 1594 __C89_NAMELESS struct { 1595 MINIDUMP_MEMORY_INFO VmRegion; 1596 WINBOOL Continue; 1597 }; 1598 HRESULT Status; 1599 } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; 1600 1601 typedef enum _MINIDUMP_TYPE { 1602 MiniDumpNormal = 0x00000000, 1603 MiniDumpWithDataSegs = 0x00000001, 1604 MiniDumpWithFullMemory = 0x00000002, 1605 MiniDumpWithHandleData = 0x00000004, 1606 MiniDumpFilterMemory = 0x00000008, 1607 MiniDumpScanMemory = 0x00000010, 1608 MiniDumpWithUnloadedModules = 0x00000020, 1609 MiniDumpWithIndirectlyReferencedMemory = 0x00000040, 1610 MiniDumpFilterModulePaths = 0x00000080, 1611 MiniDumpWithProcessThreadData = 0x00000100, 1612 MiniDumpWithPrivateReadWriteMemory = 0x00000200, 1613 MiniDumpWithoutOptionalData = 0x00000400, 1614 MiniDumpWithFullMemoryInfo = 0x00000800, 1615 MiniDumpWithThreadInfo = 0x00001000, 1616 MiniDumpWithCodeSegs = 0x00002000, 1617 MiniDumpWithoutAuxiliaryState = 0x00004000, 1618 MiniDumpWithFullAuxiliaryState = 0x00008000, 1619 MiniDumpWithPrivateWriteCopyMemory = 0x00010000, 1620 MiniDumpIgnoreInaccessibleMemory = 0x00020000, 1621 MiniDumpWithTokenInformation = 0x00040000, 1622 MiniDumpWithModuleHeaders = 0x00080000, 1623 MiniDumpFilterTriage = 0x00100000, 1624 MiniDumpWithAvxXStateContext = 0x00200000, 1625 MiniDumpWithIptTrace = 0x00400000, 1626 MiniDumpScanInaccessiblePartialPages = 0x00800000, 1627 MiniDumpValidTypeFlags = 0x00ffffff 1628 } MINIDUMP_TYPE; 1629 1630 #define MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001 1631 #define MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002 1632 #define MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004 1633 #define MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008 1634 #define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010 1635 #define MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020 1636 1637 typedef struct _MINIDUMP_THREAD_INFO { 1638 ULONG32 ThreadId; 1639 ULONG32 DumpFlags; 1640 ULONG32 DumpError; 1641 ULONG32 ExitStatus; 1642 ULONG64 CreateTime; 1643 ULONG64 ExitTime; 1644 ULONG64 KernelTime; 1645 ULONG64 UserTime; 1646 ULONG64 StartAddress; 1647 ULONG64 Affinity; 1648 } MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO; 1649 1650 typedef struct _MINIDUMP_THREAD_INFO_LIST { 1651 ULONG SizeOfHeader; 1652 ULONG SizeOfEntry; 1653 ULONG NumberOfEntries; 1654 } MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST; 1655 1656 typedef struct _MINIDUMP_HANDLE_OPERATION_LIST { 1657 ULONG32 SizeOfHeader; 1658 ULONG32 SizeOfEntry; 1659 ULONG32 NumberOfEntries; 1660 ULONG32 Reserved; 1661 } MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST; 1662 1663 #ifdef __cplusplus 1664 extern "C" { 1665 #endif 1666 1667 typedef WINBOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput); 1668 1669 typedef struct _MINIDUMP_CALLBACK_INFORMATION { 1670 MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; 1671 PVOID CallbackParam; 1672 } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION; 1673 1674 #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva))) 1675 1676 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); 1677 WINBOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize); 1678 1679 WINBOOL WINAPI EnumerateLoadedModulesEx( 1680 HANDLE hProcess, 1681 PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, 1682 PVOID UserContext 1683 ); 1684 1685 WINBOOL WINAPI EnumerateLoadedModulesExW( 1686 HANDLE hProcess, 1687 PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, 1688 PVOID UserContext 1689 ); 1690 1691 WINBOOL WINAPI SymAddSourceStream( 1692 HANDLE hProcess, 1693 ULONG64 Base, 1694 PCSTR StreamFile, 1695 PBYTE Buffer, 1696 size_t Size 1697 ); 1698 1699 WINBOOL WINAPI SymAddSourceStreamW( 1700 HANDLE hProcess, 1701 ULONG64 Base, 1702 PCWSTR StreamFile, 1703 PBYTE Buffer, 1704 size_t Size 1705 ); 1706 1707 WINBOOL WINAPI SymEnumSourceLines( 1708 HANDLE hProcess, 1709 ULONG64 Base, 1710 PCSTR Obj, 1711 PCSTR File, 1712 DWORD Line, 1713 DWORD Flags, 1714 PSYM_ENUMLINES_CALLBACK EnumLinesCallback, 1715 PVOID UserContext 1716 ); 1717 1718 WINBOOL WINAPI SymEnumSourceLinesW( 1719 HANDLE hProcess, 1720 ULONG64 Base, 1721 PCWSTR Obj, 1722 PCWSTR File, 1723 DWORD Line, 1724 DWORD Flags, 1725 PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, 1726 PVOID UserContext 1727 ); 1728 1729 WINBOOL WINAPI SymEnumTypesByName( 1730 HANDLE hProcess, 1731 ULONG64 BaseOfDll, 1732 PCSTR mask, 1733 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, 1734 PVOID UserContext 1735 ); 1736 1737 WINBOOL WINAPI SymEnumTypesByNameW( 1738 HANDLE hProcess, 1739 ULONG64 BaseOfDll, 1740 PCSTR mask, 1741 PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, 1742 PVOID UserContext 1743 ); 1744 1745 HANDLE WINAPI SymFindDebugInfoFile( 1746 HANDLE hProcess, 1747 PCSTR FileName, 1748 PSTR DebugFilePath, 1749 PFIND_DEBUG_FILE_CALLBACK Callback, 1750 PVOID CallerData 1751 ); 1752 1753 HANDLE WINAPI SymFindDebugInfoFileW( 1754 HANDLE hProcess, 1755 PCWSTR FileName, 1756 PWSTR DebugFilePath, 1757 PFIND_DEBUG_FILE_CALLBACKW Callback, 1758 PVOID CallerData 1759 ); 1760 1761 HANDLE WINAPI SymFindExecutableImage( 1762 HANDLE hProcess, 1763 PCSTR FileName, 1764 PSTR ImageFilePath, 1765 PFIND_EXE_FILE_CALLBACK Callback, 1766 PVOID CallerData 1767 ); 1768 1769 HANDLE WINAPI SymFindExecutableImageW( 1770 HANDLE hProcess, 1771 PCWSTR FileName, 1772 PWSTR ImageFilePath, 1773 PFIND_EXE_FILE_CALLBACKW Callback, 1774 PVOID CallerData 1775 ); 1776 1777 WINBOOL WINAPI SymFromIndex( 1778 HANDLE hProcess, 1779 ULONG64 BaseOfDll, 1780 DWORD Index, 1781 PSYMBOL_INFO Symbol 1782 ); 1783 1784 WINBOOL WINAPI SymFromIndexW( 1785 HANDLE hProcess, 1786 ULONG64 BaseOfDll, 1787 DWORD Index, 1788 PSYMBOL_INFOW Symbol 1789 ); 1790 1791 WINBOOL WINAPI SymGetScope( 1792 HANDLE hProcess, 1793 ULONG64 BaseOfDll, 1794 DWORD Index, 1795 PSYMBOL_INFO Symbol 1796 ); 1797 1798 WINBOOL WINAPI SymGetScopeW( 1799 HANDLE hProcess, 1800 ULONG64 BaseOfDll, 1801 DWORD Index, 1802 PSYMBOL_INFOW Symbol 1803 ); 1804 1805 WINBOOL WINAPI SymGetSourceFileFromToken( 1806 HANDLE hProcess, 1807 PVOID Token, 1808 PCSTR Params, 1809 PSTR FilePath, 1810 DWORD Size 1811 ); 1812 1813 WINBOOL WINAPI SymGetSourceFileFromTokenW( 1814 HANDLE hProcess, 1815 PVOID Token, 1816 PCWSTR Params, 1817 PWSTR FilePath, 1818 DWORD Size 1819 ); 1820 1821 WINBOOL WINAPI SymGetSourceFileToken( 1822 HANDLE hProcess, 1823 ULONG64 Base, 1824 PCSTR FileSpec, 1825 PVOID *Token, 1826 DWORD *Size 1827 ); 1828 1829 WINBOOL WINAPI SymGetSourceFileTokenW( 1830 HANDLE hProcess, 1831 ULONG64 Base, 1832 PCWSTR FileSpec, 1833 PVOID *Token, 1834 DWORD *Size 1835 ); 1836 1837 WINBOOL WINAPI SymGetSourceFile( 1838 HANDLE hProcess, 1839 ULONG64 Base, 1840 PCSTR Params, 1841 PCSTR FileSpec, 1842 PSTR FilePath, 1843 DWORD Size 1844 ); 1845 1846 WINBOOL WINAPI SymGetSourceFileW( 1847 HANDLE hProcess, 1848 ULONG64 Base, 1849 PCWSTR Params, 1850 PCWSTR FileSpec, 1851 PWSTR FilePath, 1852 DWORD Size 1853 ); 1854 1855 WINBOOL WINAPI SymGetSourceVarFromToken( 1856 HANDLE hProcess, 1857 PVOID Token, 1858 PCSTR Params, 1859 PCSTR VarName, 1860 PSTR Value, 1861 DWORD Size 1862 ); 1863 1864 WINBOOL WINAPI SymGetSourceVarFromTokenW( 1865 HANDLE hProcess, 1866 PVOID Token, 1867 PCWSTR Params, 1868 PCWSTR VarName, 1869 PWSTR Value, 1870 DWORD Size 1871 ); 1872 1873 WINBOOL WINAPI SymGetSymbolFile( 1874 HANDLE hProcess, 1875 PCSTR SymPath, 1876 PCSTR ImageFile, 1877 DWORD Type, 1878 PSTR SymbolFile, 1879 size_t cSymbolFile, 1880 PSTR DbgFile, 1881 size_t cDbgFile 1882 ); 1883 1884 WINBOOL WINAPI SymGetSymbolFileW( 1885 HANDLE hProcess, 1886 PCWSTR SymPath, 1887 PCWSTR ImageFile, 1888 DWORD Type, 1889 PWSTR SymbolFile, 1890 size_t cSymbolFile, 1891 PWSTR DbgFile, 1892 size_t cDbgFile 1893 ); 1894 1895 WINBOOL WINAPI SymNext( 1896 HANDLE hProcess, 1897 PSYMBOL_INFO Symbol 1898 ); 1899 1900 WINBOOL WINAPI SymNextW( 1901 HANDLE hProcess, 1902 PSYMBOL_INFOW Symbol 1903 ); 1904 1905 WINBOOL WINAPI SymPrev( 1906 HANDLE hProcess, 1907 PSYMBOL_INFO Symbol 1908 ); 1909 1910 WINBOOL WINAPI SymPrevW( 1911 HANDLE hProcess, 1912 PSYMBOL_INFOW Symbol 1913 ); 1914 1915 WINBOOL WINAPI SymRefreshModuleList( 1916 HANDLE hProcess 1917 ); 1918 1919 #define SYMSEARCH_MASKOBJS 0x01 1920 #define SYMSEARCH_RECURSE 0x02 1921 #define SYMSEARCH_GLOBALSONLY 0x04 1922 #define SYMSEARCH_ALLITEMS 0x08 1923 1924 WINBOOL WINAPI SymSearch( 1925 HANDLE hProcess, 1926 ULONG64 BaseOfDll, 1927 DWORD Index, 1928 DWORD SymTag, 1929 PCSTR Mask, 1930 DWORD64 Address, 1931 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, 1932 PVOID UserContext, 1933 DWORD Options 1934 ); 1935 1936 WINBOOL WINAPI SymSearchW( 1937 HANDLE hProcess, 1938 ULONG64 BaseOfDll, 1939 DWORD Index, 1940 DWORD SymTag, 1941 PCWSTR Mask, 1942 DWORD64 Address, 1943 PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, 1944 PVOID UserContext, 1945 DWORD Options 1946 ); 1947 1948 WINBOOL WINAPI SymSrvGetFileIndexString( 1949 HANDLE hProcess, 1950 PCSTR SrvPath, 1951 PCSTR File, 1952 PSTR Index, 1953 size_t Size, 1954 DWORD Flags 1955 ); 1956 1957 WINBOOL WINAPI SymSrvGetFileIndexStringW( 1958 HANDLE hProcess, 1959 PCWSTR SrvPath, 1960 PCWSTR File, 1961 PWSTR Index, 1962 size_t Size, 1963 DWORD Flags 1964 ); 1965 1966 WINBOOL WINAPI SymSrvGetFileIndexInfo( 1967 PCSTR File, 1968 PSYMSRV_INDEX_INFO Info, 1969 DWORD Flags 1970 ); 1971 1972 WINBOOL WINAPI SymSrvGetFileIndexInfoW( 1973 PCWSTR File, 1974 PSYMSRV_INDEX_INFOW Info, 1975 DWORD Flags 1976 ); 1977 1978 WINBOOL WINAPI SymSrvGetFileIndexes( 1979 PCTSTR File, 1980 GUID *Id, 1981 DWORD *Val1, 1982 DWORD *Val2, 1983 DWORD Flags 1984 ); 1985 1986 WINBOOL WINAPI SymSrvGetFileIndexesW( 1987 PCWSTR File, 1988 GUID *Id, 1989 DWORD *Val1, 1990 DWORD *Val2, 1991 DWORD Flags 1992 ); 1993 1994 PCSTR WINAPI SymSrvGetSupplement( 1995 HANDLE hProcess, 1996 PCSTR SymPath, 1997 PCSTR Node, 1998 PCSTR File 1999 ); 2000 2001 PCWSTR WINAPI SymSrvGetSupplementW( 2002 HANDLE hProcess, 2003 PCWSTR SymPath, 2004 PCWSTR Node, 2005 PCWSTR File 2006 ); 2007 2008 WINBOOL WINAPI SymSrvIsStore( 2009 HANDLE hProcess, 2010 PCSTR path 2011 ); 2012 2013 WINBOOL WINAPI SymSrvIsStoreW( 2014 HANDLE hProcess, 2015 PCWSTR path 2016 ); 2017 2018 PCSTR WINAPI SymSrvStoreFile( 2019 HANDLE hProcess, 2020 PCSTR SrvPath, 2021 PCSTR File, 2022 DWORD Flags 2023 ); 2024 2025 PCWSTR WINAPI SymSrvStoreFileW( 2026 HANDLE hProcess, 2027 PCWSTR SrvPath, 2028 PCWSTR File, 2029 DWORD Flags 2030 ); 2031 2032 #define SYMSTOREOPT_COMPRESS 0x01 2033 #define SYMSTOREOPT_OVERWRITE 0x02 2034 #define SYMSTOREOPT_RETURNINDEX 0x04 2035 #define SYMSTOREOPT_POINTER 0x08 2036 #define SYMSTOREOPT_PASS_IF_EXISTS 0x40 2037 2038 PCSTR WINAPI SymSrvStoreSupplement( 2039 HANDLE hProcess, 2040 const PCTSTR SymPath, 2041 PCSTR Node, 2042 PCSTR File, 2043 DWORD Flags 2044 ); 2045 2046 PCWSTR WINAPI SymSrvStoreSupplementW( 2047 HANDLE hProcess, 2048 const PCWSTR SymPath, 2049 PCWSTR Node, 2050 PCWSTR File, 2051 DWORD Flags 2052 ); 2053 2054 PCSTR WINAPI SymSrvDeltaName( 2055 HANDLE hProcess, 2056 PCSTR SymPath, 2057 PCSTR Type, 2058 PCSTR File1, 2059 PCSTR File2 2060 ); 2061 2062 PCWSTR WINAPI SymSrvDeltaNameW( 2063 HANDLE hProcess, 2064 PCWSTR SymPath, 2065 PCWSTR Type, 2066 PCWSTR File1, 2067 PCWSTR File2 2068 ); 2069 2070 #ifdef DBGHELP_TRANSLATE_TCHAR 2071 #define SymInitialize SymInitializeW 2072 #define SymAddSymbol SymAddSymbolW 2073 #define SymDeleteSymbol SymDeleteSymbolW 2074 #define SearchTreeForFile SearchTreeForFileW 2075 #define UnDecorateSymbolName UnDecorateSymbolNameW 2076 #define SymGetLineFromName64 SymGetLineFromNameW64 2077 #define SymGetLineFromAddr64 SymGetLineFromAddrW64 2078 #define SymGetLineFromInlineContext SymGetLineFromInlineContextW 2079 #define SymGetLineNext64 SymGetLineNextW64 2080 #define SymGetLinePrev64 SymGetLinePrevW64 2081 #define SymFromName SymFromNameW 2082 #define SymFindExecutableImage SymFindExecutableImageW 2083 #define FindExecutableImageEx FindExecutableImageExW 2084 #define SymSearch SymSearchW 2085 #define SymEnumLines SymEnumLinesW 2086 #define SymEnumSourceLines SymEnumSourceLinesW 2087 #define SymGetTypeFromName SymGetTypeFromNameW 2088 #define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW 2089 #define SymFromAddr SymFromAddrW 2090 #define SymFromInlineContext SymFromInlineContextW 2091 #define SymMatchString SymMatchStringW 2092 #define SymEnumSourceFiles SymEnumSourceFilesW 2093 #define SymEnumSymbols SymEnumSymbolsW 2094 #define SymEnumSymbolsEx SymEnumSymbolsExW 2095 #define SymLoadModuleEx SymLoadModuleExW 2096 #define SymSetSearchPath SymSetSearchPathW 2097 #define SymGetSearchPath SymGetSearchPathW 2098 #define EnumDirTree EnumDirTreeW 2099 #define SymFromToken SymFromTokenW 2100 #define SymFromIndex SymFromIndexW 2101 #define SymGetScope SymGetScopeW 2102 #define SymNext SymNextW 2103 #define SymPrev SymPrevW 2104 #define SymEnumTypes SymEnumTypesW 2105 #define SymEnumTypesByName SymEnumTypesByNameW 2106 #define SymRegisterCallback64 SymRegisterCallbackW64 2107 #define SymFindDebugInfoFile SymFindDebugInfoFileW 2108 #define FindDebugInfoFileEx FindDebugInfoFileExW 2109 #define SymFindFileInPath SymFindFileInPathW 2110 #define SymEnumerateModules64 SymEnumerateModulesW64 2111 #define SymSetHomeDirectory SymSetHomeDirectoryW 2112 #define SymGetHomeDirectory SymGetHomeDirectoryW 2113 #define SymGetSourceFile SymGetSourceFileW 2114 #define SymGetSourceFileToken SymGetSourceFileTokenW 2115 #define SymGetSourceFileFromToken SymGetSourceFileFromTokenW 2116 #define SymGetSourceVarFromToken SymGetSourceVarFromTokenW 2117 #define SymGetSourceFileTokenByTokenName SymGetSourceFileTokenByTokenNameW 2118 #define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64 2119 #define SymFindFileInPath SymFindFileInPathW 2120 #define SymMatchFileName SymMatchFileNameW 2121 #define SymGetSourceFileFromTokenByTokenName SymGetSourceFileFromTokenByTokenNameW 2122 #define SymGetModuleInfo64 SymGetModuleInfoW64 2123 #define SymAddSourceStream SymAddSourceStreamW 2124 #define SymSrvIsStore SymSrvIsStoreW 2125 #define SymSrvDeltaName SymSrvDeltaNameW 2126 #define SymSrvGetSupplement SymSrvGetSupplementW 2127 #define SymSrvStoreSupplement SymSrvStoreSupplementW 2128 #define SymSrvGetFileIndexes SymSrvGetFileIndexesW 2129 #define SymSrvGetFileIndexString SymSrvGetFileIndexStringW 2130 #define SymSrvStoreFile SymSrvStoreFileW 2131 #define SymGetSymbolFile SymGetSymbolFileW 2132 #define EnumerateLoadedModules64 EnumerateLoadedModulesW64 2133 #define EnumerateLoadedModulesEx EnumerateLoadedModulesExW 2134 #define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW 2135 2136 #define IMAGEHLP_LINE64 IMAGEHLP_LINEW64 2137 #define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64 2138 #define SYMBOL_INFO SYMBOL_INFOW 2139 #define PSYMBOL_INFO PSYMBOL_INFOW 2140 #define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW 2141 #define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW 2142 #define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW 2143 #define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW 2144 #define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW 2145 #define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW 2146 #define SRCCODEINFO SRCCODEINFOW 2147 #define PSRCCODEINFO PSRCCODEINFOW 2148 #define SOURCEFILE SOURCEFILEW 2149 #define PSOURCEFILE PSOURCEFILEW 2150 #define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW 2151 #define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW 2152 #define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW 2153 #define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW 2154 #define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW 2155 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64 2156 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64 2157 #define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW 2158 #define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW 2159 #define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64 2160 #define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64 2161 #define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOW 2162 #define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW 2163 2164 #define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW 2165 #define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW 2166 2167 #endif /* DBGHELP_TRANSLATE_TCHAR */ 2168 2169 #include <poppack.h> 2170 2171 #ifdef __cplusplus 2172 } 2173 #endif 2174