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