src/gallium/auxiliary/util/dbghelp.h

   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
 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
 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
 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