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