1 /** 2 * This file has no copyright assigned and is placed in the Public Domain. 3 * This file is part of the w64 mingw-runtime package. 4 * No warranty is given; refer to the file DISCLAIMER.PD within this package. 5 */ 6 #ifndef _DBGHELP_ 7 #define _DBGHELP_ 8 9 #ifdef _WIN64 10 #ifndef _IMAGEHLP64 11 #define _IMAGEHLP64 12 #endif 13 #endif 14 15 #ifdef __cplusplus 16 extern "C" { 17 #endif 18 19 #define IMAGEAPI DECLSPEC_IMPORT WINAPI 20 #define DBHLP_DEPRECIATED __declspec(deprecated) 21 22 #define DBHLPAPI IMAGEAPI 23 24 #define IMAGE_SEPARATION (64*1024) 25 26 typedef struct _LOADED_IMAGE { 27 PSTR ModuleName; 28 HANDLE hFile; 29 PUCHAR MappedAddress; 30 #ifdef _IMAGEHLP64 31 PIMAGE_NT_HEADERS64 FileHeader; 32 #else 33 PIMAGE_NT_HEADERS32 FileHeader; 34 #endif 35 PIMAGE_SECTION_HEADER LastRvaSection; 36 ULONG NumberOfSections; 37 PIMAGE_SECTION_HEADER Sections; 38 ULONG Characteristics; 39 BOOLEAN fSystemImage; 40 BOOLEAN fDOSImage; 41 LIST_ENTRY Links; 42 ULONG SizeOfImage; 43 } LOADED_IMAGE,*PLOADED_IMAGE; 44 45 #define MAX_SYM_NAME 2000 46 47 typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData); 48 typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR filename,PVOID context); 49 typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData); 50 51 typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR); 52 typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID); 53 typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID); 54 typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64); 55 typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context); 56 typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)(); 57 typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR); 58 59 HANDLE IMAGEAPI FindDebugInfoFile(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath); 60 HANDLE IMAGEAPI FindDebugInfoFileEx(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData); 61 BOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context); 62 HANDLE IMAGEAPI FindExecutableImage(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath); 63 HANDLE IMAGEAPI FindExecutableImageEx(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData); 64 PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base); 65 PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader); 66 PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size); 67 PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva); 68 PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection); 69 70 #define SSRVOPT_CALLBACK 0x0001 71 #define SSRVOPT_DWORD 0x0002 72 #define SSRVOPT_DWORDPTR 0x0004 73 #define SSRVOPT_GUIDPTR 0x0008 74 #define SSRVOPT_OLDGUIDPTR 0x0010 75 #define SSRVOPT_UNATTENDED 0x0020 76 #define SSRVOPT_NOCOPY 0x0040 77 #define SSRVOPT_PARENTWIN 0x0080 78 #define SSRVOPT_PARAMTYPE 0x0100 79 #define SSRVOPT_SECURE 0x0200 80 #define SSRVOPT_TRACE 0x0400 81 #define SSRVOPT_SETCONTEXT 0x0800 82 #define SSRVOPT_PROXY 0x1000 83 #define SSRVOPT_DOWNSTREAM_STORE 0x2000 84 #define SSRVOPT_RESET ((ULONG_PTR)-1) 85 86 #define SSRVACTION_TRACE 1 87 #define SSRVACTION_QUERYCANCEL 2 88 #define SSRVACTION_EVENT 3 89 90 #ifndef _WIN64 91 92 typedef struct _IMAGE_DEBUG_INFORMATION { 93 LIST_ENTRY List; 94 DWORD ReservedSize; 95 PVOID ReservedMappedBase; 96 USHORT ReservedMachine; 97 USHORT ReservedCharacteristics; 98 DWORD ReservedCheckSum; 99 DWORD ImageBase; 100 DWORD SizeOfImage; 101 DWORD ReservedNumberOfSections; 102 PIMAGE_SECTION_HEADER ReservedSections; 103 DWORD ReservedExportedNamesSize; 104 PSTR ReservedExportedNames; 105 DWORD ReservedNumberOfFunctionTableEntries; 106 PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries; 107 DWORD ReservedLowestFunctionStartingAddress; 108 DWORD ReservedHighestFunctionEndingAddress; 109 DWORD ReservedNumberOfFpoTableEntries; 110 PFPO_DATA ReservedFpoTableEntries; 111 DWORD SizeOfCoffSymbols; 112 PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols; 113 DWORD ReservedSizeOfCodeViewSymbols; 114 PVOID ReservedCodeViewSymbols; 115 PSTR ImageFilePath; 116 PSTR ImageFileName; 117 PSTR ReservedDebugFilePath; 118 DWORD ReservedTimeDateStamp; 119 BOOL ReservedRomImage; 120 PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory; 121 DWORD ReservedNumberOfDebugDirectories; 122 DWORD ReservedOriginalFunctionTableBaseAddress; 123 DWORD Reserved[2 ]; 124 } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION; 125 126 PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase); 127 BOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo); 128 #endif 129 130 typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData); 131 132 BOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer); 133 BOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData); 134 BOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath); 135 136 #define UNDNAME_COMPLETE (0x0000) 137 #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) 138 #define UNDNAME_NO_MS_KEYWORDS (0x0002) 139 #define UNDNAME_NO_FUNCTION_RETURNS (0x0004) 140 #define UNDNAME_NO_ALLOCATION_MODEL (0x0008) 141 #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010) 142 #define UNDNAME_NO_MS_THISTYPE (0x0020) 143 #define UNDNAME_NO_CV_THISTYPE (0x0040) 144 #define UNDNAME_NO_THISTYPE (0x0060) 145 #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) 146 #define UNDNAME_NO_THROW_SIGNATURES (0x0100) 147 #define UNDNAME_NO_MEMBER_TYPE (0x0200) 148 #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400) 149 #define UNDNAME_32_BIT_DECODE (0x0800) 150 #define UNDNAME_NAME_ONLY (0x1000) 151 #define UNDNAME_NO_ARGUMENTS (0x2000) 152 #define UNDNAME_NO_SPECIAL_SYMS (0x4000) 153 154 DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags); 155 156 #define DBHHEADER_DEBUGDIRS 0x1 157 158 typedef struct _MODLOAD_DATA { 159 DWORD ssize; 160 DWORD ssig; 161 PVOID data; 162 DWORD size; 163 DWORD flags; 164 } MODLOAD_DATA,*PMODLOAD_DATA; 165 166 typedef enum { 167 AddrMode1616,AddrMode1632,AddrModeReal,AddrModeFlat 168 } ADDRESS_MODE; 169 170 typedef struct _tagADDRESS64 { 171 DWORD64 Offset; 172 WORD Segment; 173 ADDRESS_MODE Mode; 174 } ADDRESS64,*LPADDRESS64; 175 176 #ifdef _IMAGEHLP64 177 #define ADDRESS ADDRESS64 178 #define LPADDRESS LPADDRESS64 179 #else 180 typedef struct _tagADDRESS { 181 DWORD Offset; 182 WORD Segment; 183 ADDRESS_MODE Mode; 184 } ADDRESS,*LPADDRESS; 185 Address32To64(LPADDRESS a32,LPADDRESS64 a64)186 static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) { 187 a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset; 188 a64->Segment = a32->Segment; 189 a64->Mode = a32->Mode; 190 } 191 Address64To32(LPADDRESS64 a64,LPADDRESS a32)192 static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) { 193 a32->Offset = (ULONG)a64->Offset; 194 a32->Segment = a64->Segment; 195 a32->Mode = a64->Mode; 196 } 197 #endif 198 199 typedef struct _KDHELP64 { 200 DWORD64 Thread; 201 DWORD ThCallbackStack; 202 DWORD ThCallbackBStore; 203 DWORD NextCallback; 204 DWORD FramePointer; 205 DWORD64 KiCallUserMode; 206 DWORD64 KeUserCallbackDispatcher; 207 DWORD64 SystemRangeStart; 208 DWORD64 Reserved[8]; 209 } KDHELP64,*PKDHELP64; 210 211 #ifdef _IMAGEHLP64 212 #define KDHELP KDHELP64 213 #define PKDHELP PKDHELP64 214 #else 215 typedef struct _KDHELP { 216 DWORD Thread; 217 DWORD ThCallbackStack; 218 DWORD NextCallback; 219 DWORD FramePointer; 220 DWORD KiCallUserMode; 221 DWORD KeUserCallbackDispatcher; 222 DWORD SystemRangeStart; 223 DWORD ThCallbackBStore; 224 DWORD Reserved[8]; 225 } KDHELP,*PKDHELP; 226 KdHelp32To64(PKDHELP p32,PKDHELP64 p64)227 static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) { 228 p64->Thread = p32->Thread; 229 p64->ThCallbackStack = p32->ThCallbackStack; 230 p64->NextCallback = p32->NextCallback; 231 p64->FramePointer = p32->FramePointer; 232 p64->KiCallUserMode = p32->KiCallUserMode; 233 p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher; 234 p64->SystemRangeStart = p32->SystemRangeStart; 235 } 236 #endif 237 238 typedef struct _tagSTACKFRAME64 { 239 ADDRESS64 AddrPC; 240 ADDRESS64 AddrReturn; 241 ADDRESS64 AddrFrame; 242 ADDRESS64 AddrStack; 243 ADDRESS64 AddrBStore; 244 PVOID FuncTableEntry; 245 DWORD64 Params[4]; 246 BOOL Far; 247 BOOL Virtual; 248 DWORD64 Reserved[3]; 249 KDHELP64 KdHelp; 250 } STACKFRAME64,*LPSTACKFRAME64; 251 252 #ifdef _IMAGEHLP64 253 #define STACKFRAME STACKFRAME64 254 #define LPSTACKFRAME LPSTACKFRAME64 255 #else 256 typedef struct _tagSTACKFRAME { 257 ADDRESS AddrPC; 258 ADDRESS AddrReturn; 259 ADDRESS AddrFrame; 260 ADDRESS AddrStack; 261 PVOID FuncTableEntry; 262 DWORD Params[4]; 263 BOOL Far; 264 BOOL Virtual; 265 DWORD Reserved[3]; 266 KDHELP KdHelp; 267 ADDRESS AddrBStore; 268 } STACKFRAME,*LPSTACKFRAME; 269 #endif 270 271 typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead); 272 typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase); 273 typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address); 274 typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr); 275 276 BOOL 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); 277 278 #ifdef _IMAGEHLP64 279 #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64 280 #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64 281 #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64 282 #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64 283 #define StackWalk StackWalk64 284 #else 285 typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead); 286 typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase); 287 typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address); 288 typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr); 289 290 BOOL 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); 291 #endif 292 293 #define API_VERSION_NUMBER 9 294 295 typedef struct API_VERSION { 296 USHORT MajorVersion; 297 USHORT MinorVersion; 298 USHORT Revision; 299 USHORT Reserved; 300 } API_VERSION,*LPAPI_VERSION; 301 302 LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID); 303 LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion); 304 DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module); 305 306 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext); 307 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext); 308 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext); 309 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext); 310 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext); 311 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext); 312 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext); 313 314 #ifdef _IMAGEHLP64 315 #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64 316 #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64 317 #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W 318 #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64 319 #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64 320 #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64 321 #else 322 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR ModuleName,ULONG BaseOfDll,PVOID UserContext); 323 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext); 324 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext); 325 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext); 326 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext); 327 #endif 328 329 #define SYMFLAG_VALUEPRESENT 0x00000001 330 #define SYMFLAG_REGISTER 0x00000008 331 #define SYMFLAG_REGREL 0x00000010 332 #define SYMFLAG_FRAMEREL 0x00000020 333 #define SYMFLAG_PARAMETER 0x00000040 334 #define SYMFLAG_LOCAL 0x00000080 335 #define SYMFLAG_CONSTANT 0x00000100 336 #define SYMFLAG_EXPORT 0x00000200 337 #define SYMFLAG_FORWARDER 0x00000400 338 #define SYMFLAG_FUNCTION 0x00000800 339 #define SYMFLAG_VIRTUAL 0x00001000 340 #define SYMFLAG_THUNK 0x00002000 341 #define SYMFLAG_TLSREL 0x00004000 342 343 typedef enum { 344 SymNone = 0,SymCoff,SymCv,SymPdb,SymExport,SymDeferred,SymSym,SymDia,SymVirtual,NumSymTypes 345 } SYM_TYPE; 346 347 typedef struct _IMAGEHLP_SYMBOL64 { 348 DWORD SizeOfStruct; 349 DWORD64 Address; 350 DWORD Size; 351 DWORD Flags; 352 DWORD MaxNameLength; 353 CHAR Name[1]; 354 } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64; 355 356 typedef struct _IMAGEHLP_SYMBOL64_PACKAGE { 357 IMAGEHLP_SYMBOL64 sym; 358 CHAR name[MAX_SYM_NAME + 1]; 359 } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE; 360 361 #ifdef _IMAGEHLP64 362 363 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64 364 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64 365 #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE 366 #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE 367 #else 368 369 typedef struct _IMAGEHLP_SYMBOL { 370 DWORD SizeOfStruct; 371 DWORD Address; 372 DWORD Size; 373 DWORD Flags; 374 DWORD MaxNameLength; 375 CHAR Name[1]; 376 } IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL; 377 378 typedef struct _IMAGEHLP_SYMBOL_PACKAGE { 379 IMAGEHLP_SYMBOL sym; 380 CHAR name[MAX_SYM_NAME + 1]; 381 } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE; 382 #endif 383 384 typedef struct _IMAGEHLP_MODULE64 { 385 DWORD SizeOfStruct; 386 DWORD64 BaseOfImage; 387 DWORD ImageSize; 388 DWORD TimeDateStamp; 389 DWORD CheckSum; 390 DWORD NumSyms; 391 SYM_TYPE SymType; 392 CHAR ModuleName[32]; 393 CHAR ImageName[256]; 394 CHAR LoadedImageName[256]; 395 CHAR LoadedPdbName[256]; 396 DWORD CVSig; 397 CHAR CVData[MAX_PATH*3]; 398 DWORD PdbSig; 399 GUID PdbSig70; 400 DWORD PdbAge; 401 BOOL PdbUnmatched; 402 BOOL DbgUnmatched; 403 BOOL LineNumbers; 404 BOOL GlobalSymbols; 405 BOOL TypeInfo; 406 } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64; 407 408 typedef struct _IMAGEHLP_MODULE64W { 409 DWORD SizeOfStruct; 410 DWORD64 BaseOfImage; 411 DWORD ImageSize; 412 DWORD TimeDateStamp; 413 DWORD CheckSum; 414 DWORD NumSyms; 415 SYM_TYPE SymType; 416 WCHAR ModuleName[32]; 417 WCHAR ImageName[256]; 418 WCHAR LoadedImageName[256]; 419 WCHAR LoadedPdbName[256]; 420 DWORD CVSig; 421 WCHAR CVData[MAX_PATH*3]; 422 DWORD PdbSig; 423 GUID PdbSig70; 424 DWORD PdbAge; 425 BOOL PdbUnmatched; 426 BOOL DbgUnmatched; 427 BOOL LineNumbers; 428 BOOL GlobalSymbols; 429 BOOL TypeInfo; 430 } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64; 431 432 #ifdef _IMAGEHLP64 433 #define IMAGEHLP_MODULE IMAGEHLP_MODULE64 434 #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64 435 #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64 436 #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64 437 #else 438 typedef struct _IMAGEHLP_MODULE { 439 DWORD SizeOfStruct; 440 DWORD BaseOfImage; 441 DWORD ImageSize; 442 DWORD TimeDateStamp; 443 DWORD CheckSum; 444 DWORD NumSyms; 445 SYM_TYPE SymType; 446 CHAR ModuleName[32]; 447 CHAR ImageName[256]; 448 CHAR LoadedImageName[256]; 449 } IMAGEHLP_MODULE,*PIMAGEHLP_MODULE; 450 451 typedef struct _IMAGEHLP_MODULEW { 452 DWORD SizeOfStruct; 453 DWORD BaseOfImage; 454 DWORD ImageSize; 455 DWORD TimeDateStamp; 456 DWORD CheckSum; 457 DWORD NumSyms; 458 SYM_TYPE SymType; 459 WCHAR ModuleName[32]; 460 WCHAR ImageName[256]; 461 WCHAR LoadedImageName[256]; 462 } IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW; 463 #endif 464 465 typedef struct _IMAGEHLP_LINE64 { 466 DWORD SizeOfStruct; 467 PVOID Key; 468 DWORD LineNumber; 469 PCHAR FileName; 470 DWORD64 Address; 471 } IMAGEHLP_LINE64,*PIMAGEHLP_LINE64; 472 473 #ifdef _IMAGEHLP64 474 #define IMAGEHLP_LINE IMAGEHLP_LINE64 475 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64 476 #else 477 typedef struct _IMAGEHLP_LINE { 478 DWORD SizeOfStruct; 479 PVOID Key; 480 DWORD LineNumber; 481 PCHAR FileName; 482 DWORD Address; 483 } IMAGEHLP_LINE,*PIMAGEHLP_LINE; 484 #endif 485 486 typedef struct _SOURCEFILE { 487 DWORD64 ModBase; 488 PCHAR FileName; 489 } SOURCEFILE,*PSOURCEFILE; 490 491 #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 492 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 493 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 494 #define CBA_SYMBOLS_UNLOADED 0x00000004 495 #define CBA_DUPLICATE_SYMBOL 0x00000005 496 #define CBA_READ_MEMORY 0x00000006 497 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 498 #define CBA_SET_OPTIONS 0x00000008 499 #define CBA_EVENT 0x00000010 500 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 501 #define CBA_DEBUG_INFO 0x10000000 502 503 typedef struct _IMAGEHLP_CBA_READ_MEMORY { 504 DWORD64 addr; 505 PVOID buf; 506 DWORD bytes; 507 DWORD *bytesread; 508 } IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY; 509 510 enum { 511 sevInfo = 0,sevProblem,sevAttn,sevFatal,sevMax 512 }; 513 514 typedef struct _IMAGEHLP_CBA_EVENT { 515 DWORD severity; 516 DWORD code; 517 PCHAR desc; 518 PVOID object; 519 } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT; 520 521 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 { 522 DWORD SizeOfStruct; 523 DWORD64 BaseOfImage; 524 DWORD CheckSum; 525 DWORD TimeDateStamp; 526 CHAR FileName[MAX_PATH]; 527 BOOLEAN Reparse; 528 HANDLE hFile; 529 DWORD Flags; 530 } IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; 531 532 #define DSLFLAG_MISMATCHED_PDB 0x1 533 #define DSLFLAG_MISMATCHED_DBG 0x2 534 535 #ifdef _IMAGEHLP64 536 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64 537 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 538 #else 539 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD { 540 DWORD SizeOfStruct; 541 DWORD BaseOfImage; 542 DWORD CheckSum; 543 DWORD TimeDateStamp; 544 CHAR FileName[MAX_PATH]; 545 BOOLEAN Reparse; 546 HANDLE hFile; 547 } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD; 548 #endif 549 550 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 { 551 DWORD SizeOfStruct; 552 DWORD NumberOfDups; 553 PIMAGEHLP_SYMBOL64 Symbol; 554 DWORD SelectedSymbol; 555 } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64; 556 557 #ifdef _IMAGEHLP64 558 #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64 559 #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64 560 #else 561 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL { 562 DWORD SizeOfStruct; 563 DWORD NumberOfDups; 564 PIMAGEHLP_SYMBOL Symbol; 565 DWORD SelectedSymbol; 566 } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL; 567 #endif 568 569 BOOL IMAGEAPI SymSetParentWindow(HWND hwnd); 570 PCHAR IMAGEAPI SymSetHomeDirectory(PCSTR dir); 571 PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size); 572 573 enum { 574 hdBase = 0,hdSym,hdSrc,hdMax 575 }; 576 577 #define SYMOPT_CASE_INSENSITIVE 0x00000001 578 #define SYMOPT_UNDNAME 0x00000002 579 #define SYMOPT_DEFERRED_LOADS 0x00000004 580 #define SYMOPT_NO_CPP 0x00000008 581 #define SYMOPT_LOAD_LINES 0x00000010 582 #define SYMOPT_OMAP_FIND_NEAREST 0x00000020 583 #define SYMOPT_LOAD_ANYTHING 0x00000040 584 #define SYMOPT_IGNORE_CVREC 0x00000080 585 #define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100 586 #define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200 587 #define SYMOPT_EXACT_SYMBOLS 0x00000400 588 #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 589 #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 590 #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 591 #define SYMOPT_PUBLICS_ONLY 0x00004000 592 #define SYMOPT_NO_PUBLICS 0x00008000 593 #define SYMOPT_AUTO_PUBLICS 0x00010000 594 #define SYMOPT_NO_IMAGE_SEARCH 0x00020000 595 #define SYMOPT_SECURE 0x00040000 596 #define SYMOPT_NO_PROMPTS 0x00080000 597 598 #define SYMOPT_DEBUG 0x80000000 599 600 DWORD IMAGEAPI SymSetOptions(DWORD SymOptions); 601 DWORD IMAGEAPI SymGetOptions(VOID); 602 BOOL IMAGEAPI SymCleanup(HANDLE hProcess); 603 BOOL IMAGEAPI SymMatchString(LPSTR string,LPSTR expression,BOOL fCase); 604 605 typedef BOOL (CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext); 606 607 BOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,LPSTR Mask,PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles,PVOID UserContext); 608 BOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext); 609 610 #ifdef _IMAGEHLP64 611 #define SymEnumerateModules SymEnumerateModules64 612 #else 613 BOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext); 614 #endif 615 616 BOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext); 617 BOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext); 618 619 #ifdef _IMAGEHLP64 620 #define SymEnumerateSymbols SymEnumerateSymbols64 621 #define SymEnumerateSymbolsW SymEnumerateSymbolsW64 622 #else 623 BOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 624 BOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext); 625 #endif 626 627 BOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext); 628 #ifdef _IMAGEHLP64 629 #define EnumerateLoadedModules EnumerateLoadedModules64 630 #else 631 BOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext); 632 #endif 633 634 PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase); 635 636 #ifdef _IMAGEHLP64 637 #define SymFunctionTableAccess SymFunctionTableAccess64 638 #else 639 PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase); 640 #endif 641 642 BOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo); 643 BOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo); 644 645 #ifdef _IMAGEHLP64 646 #define SymGetModuleInfo SymGetModuleInfo64 647 #define SymGetModuleInfoW SymGetModuleInfoW64 648 #else 649 BOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo); 650 BOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo); 651 #endif 652 653 DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr); 654 655 #ifdef _IMAGEHLP64 656 #define SymGetModuleBase SymGetModuleBase64 657 #else 658 DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr); 659 #endif 660 661 BOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol); 662 663 #ifdef _IMAGEHLP64 664 #define SymGetSymNext SymGetSymNext64 665 #else 666 BOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol); 667 #endif 668 669 BOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol); 670 671 #ifdef _IMAGEHLP64 672 #define SymGetSymPrev SymGetSymPrev64 673 #else 674 BOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol); 675 #endif 676 677 typedef struct _SRCCODEINFO { 678 DWORD SizeOfStruct; 679 PVOID Key; 680 DWORD64 ModBase; 681 CHAR Obj[MAX_PATH + 1]; 682 CHAR FileName[MAX_PATH + 1]; 683 DWORD LineNumber; 684 DWORD64 Address; 685 } SRCCODEINFO,*PSRCCODEINFO; 686 687 typedef BOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext); 688 689 BOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext); 690 BOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64); 691 692 #ifdef _IMAGEHLP64 693 #define SymGetLineFromAddr SymGetLineFromAddr64 694 #else 695 BOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line); 696 #endif 697 698 BOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line); 699 700 #ifdef _IMAGEHLP64 701 #define SymGetLineFromName SymGetLineFromName64 702 #else 703 BOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line); 704 #endif 705 706 BOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line); 707 708 #ifdef _IMAGEHLP64 709 #define SymGetLineNext SymGetLineNext64 710 #else 711 BOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line); 712 #endif 713 714 BOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line); 715 716 #ifdef _IMAGEHLP64 717 #define SymGetLinePrev SymGetLinePrev64 718 #else 719 BOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line); 720 #endif 721 722 BOOL IMAGEAPI SymMatchFileName(PSTR FileName,PSTR Match,PSTR *FileNameStop,PSTR *MatchStop); 723 BOOL IMAGEAPI SymInitialize(HANDLE hProcess,PSTR UserSearchPath,BOOL fInvadeProcess); 724 BOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength); 725 BOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PSTR SearchPath); 726 DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll); 727 728 #define SLMFLAG_VIRTUAL 0x1 729 730 DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags); 731 732 #ifdef _IMAGEHLP64 733 #define SymLoadModule SymLoadModule64 734 #else 735 DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll); 736 #endif 737 738 BOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll); 739 740 #ifdef _IMAGEHLP64 741 #define SymUnloadModule SymUnloadModule64 742 #else 743 BOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll); 744 #endif 745 746 BOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength); 747 748 #ifdef _IMAGEHLP64 749 #define SymUnDName SymUnDName64 750 #else 751 BOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength); 752 #endif 753 754 BOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext); 755 756 BOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext); 757 758 #ifdef _IMAGEHLP64 759 #define SymRegisterCallback SymRegisterCallback64 760 #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64 761 #else 762 BOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext); 763 BOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext); 764 #endif 765 766 typedef struct _IMAGEHLP_SYMBOL_SRC { 767 DWORD sizeofstruct; 768 DWORD type; 769 char file[MAX_PATH]; 770 } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC; 771 772 typedef struct _MODULE_TYPE_INFO { 773 USHORT dataLength; 774 USHORT leaf; 775 BYTE data[1]; 776 } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO; 777 778 typedef struct _SYMBOL_INFO { 779 ULONG SizeOfStruct; 780 ULONG TypeIndex; 781 ULONG64 Reserved[2]; 782 ULONG info; 783 ULONG Size; 784 ULONG64 ModBase; 785 ULONG Flags; 786 ULONG64 Value; 787 ULONG64 Address; 788 ULONG Register; 789 ULONG Scope; 790 ULONG Tag; 791 ULONG NameLen; 792 ULONG MaxNameLen; 793 CHAR Name[1]; 794 } SYMBOL_INFO,*PSYMBOL_INFO; 795 796 typedef struct _SYMBOL_INFO_PACKAGE { 797 SYMBOL_INFO si; 798 CHAR name[MAX_SYM_NAME + 1]; 799 } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE; 800 801 typedef struct _IMAGEHLP_STACK_FRAME 802 { 803 ULONG64 InstructionOffset; 804 ULONG64 ReturnOffset; 805 ULONG64 FrameOffset; 806 ULONG64 StackOffset; 807 ULONG64 BackingStoreOffset; 808 ULONG64 FuncTableEntry; 809 ULONG64 Params[4]; 810 ULONG64 Reserved[5]; 811 BOOL Virtual; 812 ULONG Reserved2; 813 } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME; 814 815 typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT; 816 817 BOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context); 818 BOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol); 819 BOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol); 820 BOOL IMAGEAPI SymFromName(HANDLE hProcess,LPSTR Name,PSYMBOL_INFO Symbol); 821 822 typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext); 823 824 BOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 825 BOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 826 827 #define SYMENUMFLAG_FULLSRCH 1 828 #define SYMENUMFLAG_SPEEDSRCH 2 829 830 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO { 831 TI_GET_SYMTAG,TI_GET_SYMNAME,TI_GET_LENGTH,TI_GET_TYPE,TI_GET_TYPEID,TI_GET_BASETYPE,TI_GET_ARRAYINDEXTYPEID,TI_FINDCHILDREN, 832 TI_GET_DATAKIND,TI_GET_ADDRESSOFFSET,TI_GET_OFFSET,TI_GET_VALUE,TI_GET_COUNT,TI_GET_CHILDRENCOUNT,TI_GET_BITPOSITION,TI_GET_VIRTUALBASECLASS, 833 TI_GET_VIRTUALTABLESHAPEID,TI_GET_VIRTUALBASEPOINTEROFFSET,TI_GET_CLASSPARENTID,TI_GET_NESTED,TI_GET_SYMINDEX,TI_GET_LEXICALPARENT, 834 TI_GET_ADDRESS,TI_GET_THISADJUST,TI_GET_UDTKIND,TI_IS_EQUIV_TO,TI_GET_CALLING_CONVENTION 835 } IMAGEHLP_SYMBOL_TYPE_INFO; 836 837 typedef struct _TI_FINDCHILDREN_PARAMS { 838 ULONG Count; 839 ULONG Start; 840 ULONG ChildId[1]; 841 } TI_FINDCHILDREN_PARAMS; 842 843 BOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo); 844 BOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 845 BOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,LPSTR Name,PSYMBOL_INFO Symbol); 846 BOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags); 847 BOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags); 848 849 typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData); 850 851 BOOL WINAPI DbgHelpCreateUserDump(LPSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData); 852 BOOL WINAPI DbgHelpCreateUserDumpW(LPWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData); 853 BOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol); 854 855 #ifdef _IMAGEHLP64 856 #define SymGetSymFromAddr SymGetSymFromAddr64 857 #else 858 BOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol); 859 #endif 860 861 BOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL64 Symbol); 862 863 #ifdef _IMAGEHLP64 864 #define SymGetSymFromName SymGetSymFromName64 865 #else 866 BOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL Symbol); 867 #endif 868 869 DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FilePath); 870 DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,DWORD one,DWORD two,DWORD three,LPSTR FilePath); 871 DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext); 872 873 #define SYMF_OMAP_GENERATED 0x00000001 874 #define SYMF_OMAP_MODIFIED 0x00000002 875 #define SYMF_REGISTER 0x00000008 876 #define SYMF_REGREL 0x00000010 877 #define SYMF_FRAMEREL 0x00000020 878 #define SYMF_PARAMETER 0x00000040 879 #define SYMF_LOCAL 0x00000080 880 #define SYMF_CONSTANT 0x00000100 881 #define SYMF_EXPORT 0x00000200 882 #define SYMF_FORWARDER 0x00000400 883 #define SYMF_FUNCTION 0x00000800 884 #define SYMF_VIRTUAL 0x00001000 885 #define SYMF_THUNK 0x00002000 886 #define SYMF_TLSREL 0x00004000 887 888 #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1 889 #define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER 890 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL 891 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL 892 #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER 893 #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL 894 #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT 895 #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION 896 #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL 897 #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK 898 #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL 899 900 #include <pshpack4.h> 901 902 #define MINIDUMP_SIGNATURE ('PMDM') 903 #define MINIDUMP_VERSION (42899) 904 typedef DWORD RVA; 905 typedef ULONG64 RVA64; 906 907 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR { 908 ULONG32 DataSize; 909 RVA Rva; 910 } MINIDUMP_LOCATION_DESCRIPTOR; 911 912 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 { 913 ULONG64 DataSize; 914 RVA64 Rva; 915 } MINIDUMP_LOCATION_DESCRIPTOR64; 916 917 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR { 918 ULONG64 StartOfMemoryRange; 919 MINIDUMP_LOCATION_DESCRIPTOR Memory; 920 } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR; 921 922 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 { 923 ULONG64 StartOfMemoryRange; 924 ULONG64 DataSize; 925 } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64; 926 927 typedef struct _MINIDUMP_HEADER { 928 ULONG32 Signature; 929 ULONG32 Version; 930 ULONG32 NumberOfStreams; 931 RVA StreamDirectoryRva; 932 ULONG32 CheckSum; 933 union { 934 ULONG32 Reserved; 935 ULONG32 TimeDateStamp; 936 } DUMMYUNIONNAME; 937 ULONG64 Flags; 938 } MINIDUMP_HEADER,*PMINIDUMP_HEADER; 939 940 typedef struct _MINIDUMP_DIRECTORY { 941 ULONG32 StreamType; 942 MINIDUMP_LOCATION_DESCRIPTOR Location; 943 } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY; 944 945 typedef struct _MINIDUMP_STRING { 946 ULONG32 Length; 947 WCHAR Buffer [0]; 948 } MINIDUMP_STRING,*PMINIDUMP_STRING; 949 950 typedef enum _MINIDUMP_STREAM_TYPE { 951 UnusedStream = 0,ReservedStream0 = 1,ReservedStream1 = 2,ThreadListStream = 3,ModuleListStream = 4,MemoryListStream = 5, 952 ExceptionStream = 6,SystemInfoStream = 7,ThreadExListStream = 8,Memory64ListStream = 9,CommentStreamA = 10,CommentStreamW = 11, 953 HandleDataStream = 12,FunctionTableStream = 13,UnloadedModuleListStream = 14,MiscInfoStream = 15,LastReservedStream = 0xffff 954 } MINIDUMP_STREAM_TYPE; 955 956 typedef union _CPU_INFORMATION { 957 struct { 958 ULONG32 VendorId [3 ]; 959 ULONG32 VersionInformation; 960 ULONG32 FeatureInformation; 961 ULONG32 AMDExtendedCpuFeatures; 962 } X86CpuInfo; 963 struct { 964 ULONG64 ProcessorFeatures [2 ]; 965 } OtherCpuInfo; 966 } CPU_INFORMATION,*PCPU_INFORMATION; 967 968 typedef struct _MINIDUMP_SYSTEM_INFO { 969 USHORT ProcessorArchitecture; 970 USHORT ProcessorLevel; 971 USHORT ProcessorRevision; 972 union { 973 USHORT Reserved0; 974 struct { 975 UCHAR NumberOfProcessors; 976 UCHAR ProductType; 977 } DUMMYSTRUCTNAME; 978 } DUMMYUNIONNAME; 979 ULONG32 MajorVersion; 980 ULONG32 MinorVersion; 981 ULONG32 BuildNumber; 982 ULONG32 PlatformId; 983 RVA CSDVersionRva; 984 union { 985 ULONG32 Reserved1; 986 struct { 987 USHORT SuiteMask; 988 USHORT Reserved2; 989 } DUMMYSTRUCTNAME; 990 } DUMMYUNIONNAME1; 991 CPU_INFORMATION Cpu; 992 } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO; 993 994 C_ASSERT (sizeof (((PPROCESS_INFORMATION)0)->dwThreadId)==4); 995 996 typedef struct _MINIDUMP_THREAD { 997 ULONG32 ThreadId; 998 ULONG32 SuspendCount; 999 ULONG32 PriorityClass; 1000 ULONG32 Priority; 1001 ULONG64 Teb; 1002 MINIDUMP_MEMORY_DESCRIPTOR Stack; 1003 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; 1004 } MINIDUMP_THREAD,*PMINIDUMP_THREAD; 1005 1006 typedef struct _MINIDUMP_THREAD_LIST { 1007 ULONG32 NumberOfThreads; 1008 MINIDUMP_THREAD Threads [0]; 1009 } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST; 1010 1011 typedef struct _MINIDUMP_THREAD_EX { 1012 ULONG32 ThreadId; 1013 ULONG32 SuspendCount; 1014 ULONG32 PriorityClass; 1015 ULONG32 Priority; 1016 ULONG64 Teb; 1017 MINIDUMP_MEMORY_DESCRIPTOR Stack; 1018 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; 1019 MINIDUMP_MEMORY_DESCRIPTOR BackingStore; 1020 } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX; 1021 1022 typedef struct _MINIDUMP_THREAD_EX_LIST { 1023 ULONG32 NumberOfThreads; 1024 MINIDUMP_THREAD_EX Threads [0]; 1025 } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST; 1026 1027 typedef struct _MINIDUMP_EXCEPTION { 1028 ULONG32 ExceptionCode; 1029 ULONG32 ExceptionFlags; 1030 ULONG64 ExceptionRecord; 1031 ULONG64 ExceptionAddress; 1032 ULONG32 NumberParameters; 1033 ULONG32 __unusedAlignment; 1034 ULONG64 ExceptionInformation [EXCEPTION_MAXIMUM_PARAMETERS ]; 1035 } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION; 1036 1037 typedef struct MINIDUMP_EXCEPTION_STREAM { 1038 ULONG32 ThreadId; 1039 ULONG32 __alignment; 1040 MINIDUMP_EXCEPTION ExceptionRecord; 1041 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; 1042 } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM; 1043 1044 typedef struct _MINIDUMP_MODULE { 1045 ULONG64 BaseOfImage; 1046 ULONG32 SizeOfImage; 1047 ULONG32 CheckSum; 1048 ULONG32 TimeDateStamp; 1049 RVA ModuleNameRva; 1050 VS_FIXEDFILEINFO VersionInfo; 1051 MINIDUMP_LOCATION_DESCRIPTOR CvRecord; 1052 MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; 1053 ULONG64 Reserved0; 1054 ULONG64 Reserved1; 1055 } MINIDUMP_MODULE,*PMINIDUMP_MODULE; 1056 1057 typedef struct _MINIDUMP_MODULE_LIST { 1058 ULONG32 NumberOfModules; 1059 MINIDUMP_MODULE Modules [0 ]; 1060 } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST; 1061 1062 typedef struct _MINIDUMP_MEMORY_LIST { 1063 ULONG32 NumberOfMemoryRanges; 1064 MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0]; 1065 } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST; 1066 1067 typedef struct _MINIDUMP_MEMORY64_LIST { 1068 ULONG64 NumberOfMemoryRanges; 1069 RVA64 BaseRva; 1070 MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0]; 1071 } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST; 1072 1073 typedef struct _MINIDUMP_EXCEPTION_INFORMATION { 1074 DWORD ThreadId; 1075 PEXCEPTION_POINTERS ExceptionPointers; 1076 BOOL ClientPointers; 1077 } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION; 1078 1079 typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 { 1080 DWORD ThreadId; 1081 ULONG64 ExceptionRecord; 1082 ULONG64 ContextRecord; 1083 BOOL ClientPointers; 1084 } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64; 1085 1086 typedef struct _MINIDUMP_HANDLE_DESCRIPTOR { 1087 ULONG64 Handle; 1088 RVA TypeNameRva; 1089 RVA ObjectNameRva; 1090 ULONG32 Attributes; 1091 ULONG32 GrantedAccess; 1092 ULONG32 HandleCount; 1093 ULONG32 PointerCount; 1094 } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR; 1095 1096 typedef struct _MINIDUMP_HANDLE_DATA_STREAM { 1097 ULONG32 SizeOfHeader; 1098 ULONG32 SizeOfDescriptor; 1099 ULONG32 NumberOfDescriptors; 1100 ULONG32 Reserved; 1101 } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM; 1102 1103 typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR { 1104 ULONG64 MinimumAddress; 1105 ULONG64 MaximumAddress; 1106 ULONG64 BaseAddress; 1107 ULONG32 EntryCount; 1108 ULONG32 SizeOfAlignPad; 1109 } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR; 1110 1111 typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM { 1112 ULONG32 SizeOfHeader; 1113 ULONG32 SizeOfDescriptor; 1114 ULONG32 SizeOfNativeDescriptor; 1115 ULONG32 SizeOfFunctionEntry; 1116 ULONG32 NumberOfDescriptors; 1117 ULONG32 SizeOfAlignPad; 1118 } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM; 1119 1120 typedef struct _MINIDUMP_UNLOADED_MODULE { 1121 ULONG64 BaseOfImage; 1122 ULONG32 SizeOfImage; 1123 ULONG32 CheckSum; 1124 ULONG32 TimeDateStamp; 1125 RVA ModuleNameRva; 1126 } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE; 1127 1128 typedef struct _MINIDUMP_UNLOADED_MODULE_LIST { 1129 ULONG32 SizeOfHeader; 1130 ULONG32 SizeOfEntry; 1131 ULONG32 NumberOfEntries; 1132 } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST; 1133 1134 #define MINIDUMP_MISC1_PROCESS_ID 0x00000001 1135 #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 1136 1137 typedef struct _MINIDUMP_MISC_INFO { 1138 ULONG32 SizeOfInfo; 1139 ULONG32 Flags1; 1140 ULONG32 ProcessId; 1141 ULONG32 ProcessCreateTime; 1142 ULONG32 ProcessUserTime; 1143 ULONG32 ProcessKernelTime; 1144 } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO; 1145 1146 typedef struct _MINIDUMP_USER_RECORD { 1147 ULONG32 Type; 1148 MINIDUMP_LOCATION_DESCRIPTOR Memory; 1149 } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD; 1150 1151 typedef struct _MINIDUMP_USER_STREAM { 1152 ULONG32 Type; 1153 ULONG BufferSize; 1154 PVOID Buffer; 1155 } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM; 1156 1157 typedef struct _MINIDUMP_USER_STREAM_INFORMATION { 1158 ULONG UserStreamCount; 1159 PMINIDUMP_USER_STREAM UserStreamArray; 1160 } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION; 1161 1162 typedef enum _MINIDUMP_CALLBACK_TYPE { 1163 ModuleCallback,ThreadCallback,ThreadExCallback,IncludeThreadCallback,IncludeModuleCallback,MemoryCallback 1164 } MINIDUMP_CALLBACK_TYPE; 1165 1166 typedef struct _MINIDUMP_THREAD_CALLBACK { 1167 ULONG ThreadId; 1168 HANDLE ThreadHandle; 1169 CONTEXT Context; 1170 ULONG SizeOfContext; 1171 ULONG64 StackBase; 1172 ULONG64 StackEnd; 1173 } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK; 1174 1175 typedef struct _MINIDUMP_THREAD_EX_CALLBACK { 1176 ULONG ThreadId; 1177 HANDLE ThreadHandle; 1178 CONTEXT Context; 1179 ULONG SizeOfContext; 1180 ULONG64 StackBase; 1181 ULONG64 StackEnd; 1182 ULONG64 BackingStoreBase; 1183 ULONG64 BackingStoreEnd; 1184 } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK; 1185 1186 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK { 1187 ULONG ThreadId; 1188 } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK; 1189 1190 typedef enum _THREAD_WRITE_FLAGS { 1191 ThreadWriteThread = 0x0001,ThreadWriteStack = 0x0002,ThreadWriteContext = 0x0004,ThreadWriteBackingStore = 0x0008, 1192 ThreadWriteInstructionWindow = 0x0010,ThreadWriteThreadData = 0x0020 1193 } THREAD_WRITE_FLAGS; 1194 1195 typedef struct _MINIDUMP_MODULE_CALLBACK { 1196 PWCHAR FullPath; 1197 ULONG64 BaseOfImage; 1198 ULONG SizeOfImage; 1199 ULONG CheckSum; 1200 ULONG TimeDateStamp; 1201 VS_FIXEDFILEINFO VersionInfo; 1202 PVOID CvRecord; 1203 ULONG SizeOfCvRecord; 1204 PVOID MiscRecord; 1205 ULONG SizeOfMiscRecord; 1206 } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK; 1207 1208 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK { 1209 ULONG64 BaseOfImage; 1210 } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK; 1211 1212 typedef enum _MODULE_WRITE_FLAGS { 1213 ModuleWriteModule = 0x0001,ModuleWriteDataSeg = 0x0002,ModuleWriteMiscRecord = 0x0004,ModuleWriteCvRecord = 0x0008, 1214 ModuleReferencedByMemory = 0x0010 1215 } MODULE_WRITE_FLAGS; 1216 1217 typedef struct _MINIDUMP_CALLBACK_INPUT { 1218 ULONG ProcessId; 1219 HANDLE ProcessHandle; 1220 ULONG CallbackType; 1221 union { 1222 MINIDUMP_THREAD_CALLBACK Thread; 1223 MINIDUMP_THREAD_EX_CALLBACK ThreadEx; 1224 MINIDUMP_MODULE_CALLBACK Module; 1225 MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; 1226 MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; 1227 } DUMMYUNIONNAME; 1228 } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT; 1229 1230 typedef struct _MINIDUMP_CALLBACK_OUTPUT { 1231 union { 1232 ULONG ModuleWriteFlags; 1233 ULONG ThreadWriteFlags; 1234 struct { 1235 ULONG64 MemoryBase; 1236 ULONG MemorySize; 1237 } DUMMYSTRUCTNAME; 1238 } DUMMYUNIONNAME; 1239 } MINIDUMP_CALLBACK_OUTPUT,*PMINIDUMP_CALLBACK_OUTPUT; 1240 1241 typedef enum _MINIDUMP_TYPE { 1242 MiniDumpNormal = 0x0000,MiniDumpWithDataSegs = 0x0001,MiniDumpWithFullMemory = 0x0002,MiniDumpWithHandleData = 0x0004, 1243 MiniDumpFilterMemory = 0x0008,MiniDumpScanMemory = 0x0010,MiniDumpWithUnloadedModules = 0x0020,MiniDumpWithIndirectlyReferencedMemory = 0x0040, 1244 MiniDumpFilterModulePaths = 0x0080,MiniDumpWithProcessThreadData = 0x0100,MiniDumpWithPrivateReadWriteMemory = 0x0200, 1245 MiniDumpWithoutOptionalData = 0x0400 1246 } MINIDUMP_TYPE; 1247 1248 typedef BOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput); 1249 1250 typedef struct _MINIDUMP_CALLBACK_INFORMATION { 1251 MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; 1252 PVOID CallbackParam; 1253 } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION; 1254 1255 #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva))) 1256 1257 BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess,DWORD ProcessId,HANDLE hFile,MINIDUMP_TYPE DumpType,CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam); 1258 BOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize); 1259 1260 #include <poppack.h> 1261 1262 #ifdef __cplusplus 1263 } 1264 #endif 1265 #endif 1266