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
16extern "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
1266