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