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 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
616 DWORD SizeOfStruct;
617 DWORD64 BaseOfImage;
618 DWORD CheckSum;
619 DWORD TimeDateStamp;
620 WCHAR FileName[MAX_PATH + 1];
621 BOOLEAN Reparse;
622 HANDLE hFile;
623 DWORD Flags;
624 } IMAGEHLP_DEFERRED_SYMBOL_LOADW64,*PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
625
626#define DSLFLAG_MISMATCHED_PDB 0x1
627#define DSLFLAG_MISMATCHED_DBG 0x2
628
629#ifdef _IMAGEHLP64
630#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
631#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
632#else
633 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
634 DWORD SizeOfStruct;
635 DWORD BaseOfImage;
636 DWORD CheckSum;
637 DWORD TimeDateStamp;
638 CHAR FileName[MAX_PATH];
639 BOOLEAN Reparse;
640 HANDLE hFile;
641 } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
642#endif
643
644 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
645 DWORD SizeOfStruct;
646 DWORD NumberOfDups;
647 PIMAGEHLP_SYMBOL64 Symbol;
648 DWORD SelectedSymbol;
649 } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64;
650
651#ifdef _IMAGEHLP64
652#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
653#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
654#else
655 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
656 DWORD SizeOfStruct;
657 DWORD NumberOfDups;
658 PIMAGEHLP_SYMBOL Symbol;
659 DWORD SelectedSymbol;
660 } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL;
661#endif
662
663typedef struct _SYMSRV_INDEX_INFO {
664 DWORD sizeofstruct;
665 CHAR file[MAX_PATH +1];
666 WINBOOL stripped;
667 DWORD timestamp;
668 DWORD size;
669 CHAR dbgfile[MAX_PATH +1];
670 CHAR pdbfile[MAX_PATH + 1];
671 GUID guid;
672 DWORD sig;
673 DWORD age;
674} SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO;
675
676typedef struct _SYMSRV_INDEX_INFOW {
677 DWORD sizeofstruct;
678 WCHAR file[MAX_PATH +1];
679 WINBOOL stripped;
680 DWORD timestamp;
681 DWORD size;
682 WCHAR dbgfile[MAX_PATH +1];
683 WCHAR pdbfile[MAX_PATH + 1];
684 GUID guid;
685 DWORD sig;
686 DWORD age;
687} SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW;
688
689 WINBOOL IMAGEAPI SymSetParentWindow(HWND hwnd);
690 PCHAR IMAGEAPI SymSetHomeDirectory(HANDLE hProcess,PCSTR dir);
691 PCHAR IMAGEAPI SymSetHomeDirectoryW(HANDLE hProcess,PCWSTR dir);
692 PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size);
693 PWCHAR IMAGEAPI SymGetHomeDirectoryW(DWORD type,PWSTR dir,size_t size);
694
695#define hdBase 0
696#define hdSym 1
697#define hdSrc 2
698#define hdMax 3
699
700#define SYMOPT_CASE_INSENSITIVE 0x00000001
701#define SYMOPT_UNDNAME 0x00000002
702#define SYMOPT_DEFERRED_LOADS 0x00000004
703#define SYMOPT_NO_CPP 0x00000008
704#define SYMOPT_LOAD_LINES 0x00000010
705#define SYMOPT_OMAP_FIND_NEAREST 0x00000020
706#define SYMOPT_LOAD_ANYTHING 0x00000040
707#define SYMOPT_IGNORE_CVREC 0x00000080
708#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
709#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
710#define SYMOPT_EXACT_SYMBOLS 0x00000400
711#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
712#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
713#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
714#define SYMOPT_PUBLICS_ONLY 0x00004000
715#define SYMOPT_NO_PUBLICS 0x00008000
716#define SYMOPT_AUTO_PUBLICS 0x00010000
717#define SYMOPT_NO_IMAGE_SEARCH 0x00020000
718#define SYMOPT_SECURE 0x00040000
719#define SYMOPT_NO_PROMPTS 0x00080000
720#define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000
721#define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000
722#define SYMOPT_FAVOR_COMPRESSED 0x00800000
723#define SYMOPT_FLAT_DIRECTORY 0x00400000
724#define SYMOPT_IGNORE_IMAGEDIR 0x00200000
725#define SYMOPT_OVERWRITE 0x00100000
726
727#define SYMOPT_DEBUG 0x80000000
728
729 DWORD IMAGEAPI SymSetOptions(DWORD SymOptions);
730 DWORD IMAGEAPI SymGetOptions(VOID);
731 WINBOOL IMAGEAPI SymCleanup(HANDLE hProcess);
732 WINBOOL IMAGEAPI SymMatchString(PCSTR string,PCSTR expression,WINBOOL fCase);
733 WINBOOL IMAGEAPI SymMatchStringW(PCWSTR string,PCWSTR expression,WINBOOL fCase);
734
735 typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext);
736 typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW pSourceFile,PVOID UserContext);
737#define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK
738
739 WINBOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,PCSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,PVOID UserContext);
740 WINBOOL IMAGEAPI SymEnumSourceFilesW(HANDLE hProcess,ULONG64 ModBase,PCWSTR Mask,PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,PVOID UserContext);
741 WINBOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext);
742 WINBOOL IMAGEAPI SymEnumerateModulesW64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,PVOID UserContext);
743
744#ifdef _IMAGEHLP64
745#define SymEnumerateModules SymEnumerateModules64
746#else
747 WINBOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext);
748#endif
749
750 WINBOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext);
751 WINBOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext);
752
753#ifdef _IMAGEHLP64
754#define SymEnumerateSymbols SymEnumerateSymbols64
755#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
756#else
757 WINBOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
758 WINBOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
759#endif
760
761 WINBOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext);
762 WINBOOL IMAGEAPI EnumerateLoadedModulesW64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,PVOID UserContext);
763
764#ifdef _IMAGEHLP64
765#define EnumerateLoadedModules EnumerateLoadedModules64
766#else
767 WINBOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext);
768#endif
769
770 PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase);
771
772#ifdef _IMAGEHLP64
773#define SymFunctionTableAccess SymFunctionTableAccess64
774#else
775 PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase);
776#endif
777
778 WINBOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo);
779 WINBOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo);
780
781#ifdef _IMAGEHLP64
782#define SymGetModuleInfo SymGetModuleInfo64
783#define SymGetModuleInfoW SymGetModuleInfoW64
784#else
785 WINBOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo);
786 WINBOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo);
787#endif
788
789 DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr);
790
791#ifdef _IMAGEHLP64
792#define SymGetModuleBase SymGetModuleBase64
793#else
794 DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr);
795#endif
796
797 WINBOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
798
799#ifdef _IMAGEHLP64
800#define SymGetSymNext SymGetSymNext64
801#else
802 WINBOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
803#endif
804
805 WINBOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
806
807#ifdef _IMAGEHLP64
808#define SymGetSymPrev SymGetSymPrev64
809#else
810 WINBOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
811#endif
812
813 typedef struct _SRCCODEINFO {
814 DWORD SizeOfStruct;
815 PVOID Key;
816 DWORD64 ModBase;
817 CHAR Obj[MAX_PATH + 1];
818 CHAR FileName[MAX_PATH + 1];
819 DWORD LineNumber;
820 DWORD64 Address;
821 } SRCCODEINFO,*PSRCCODEINFO;
822
823 typedef struct _SRCCODEINFOW {
824 DWORD SizeOfStruct;
825 PVOID Key;
826 DWORD64 ModBase;
827 WCHAR Obj[MAX_PATH + 1];
828 WCHAR FileName[MAX_PATH + 1];
829 DWORD LineNumber;
830 DWORD64 Address;
831 } SRCCODEINFOW,*PSRCCODEINFOW;
832
833 typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext);
834 typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW LineInfo,PVOID UserContext);
835
836 WINBOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext);
837 WINBOOL IMAGEAPI SymEnumLinesW(HANDLE hProcess,ULONG64 Base,PCWSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,PVOID UserContext);
838 WINBOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64);
839 WINBOOL IMAGEAPI SymGetLineFromAddrW64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW64 Line64);
840
841#ifdef _IMAGEHLP64
842#define SymGetLineFromAddr SymGetLineFromAddr64
843#define SymGetLineFromAddrW SymGetLineFromAddrW64
844#else
845 WINBOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line);
846 WINBOOL IMAGEAPI SymGetLineFromAddrW(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINEW Line);
847#endif
848
849 WINBOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line);
850 WINBOOL IMAGEAPI SymGetLineFromNameW64(HANDLE hProcess,PCWSTR ModuleName,PCWSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINEW64 Line);
851
852#ifdef _IMAGEHLP64
853#define SymGetLineFromName SymGetLineFromName64
854#else
855 WINBOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PCSTR ModuleName,PCSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line);
856#endif
857
858 WINBOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
859 WINBOOL IMAGEAPI SymGetLineNextW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line);
860
861#ifdef _IMAGEHLP64
862#define SymGetLineNext SymGetLineNext64
863#else
864 WINBOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line);
865#endif
866
867 WINBOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
868 WINBOOL IMAGEAPI SymGetLinePrevW64(HANDLE hProcess,PIMAGEHLP_LINEW64 Line);
869
870#ifdef _IMAGEHLP64
871#define SymGetLinePrev SymGetLinePrev64
872#else
873 WINBOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line);
874#endif
875
876 WINBOOL IMAGEAPI SymMatchFileName(PCSTR FileName,PCSTR Match,PSTR *FileNameStop,PSTR *MatchStop);
877 WINBOOL IMAGEAPI SymMatchFileNameW(PCWSTR FileName,PCWSTR Match,PWSTR *FileNameStop,PWSTR *MatchStop);
878 WINBOOL IMAGEAPI SymInitialize(HANDLE hProcess,PCSTR UserSearchPath,WINBOOL fInvadeProcess);
879 WINBOOL IMAGEAPI SymInitializeW(HANDLE hProcess,PCWSTR UserSearchPath,WINBOOL fInvadeProcess);
880 WINBOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength);
881 WINBOOL IMAGEAPI SymGetSearchPathW(HANDLE hProcess,PWSTR SearchPath,DWORD SearchPathLength);
882 WINBOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PCSTR SearchPath);
883 WINBOOL IMAGEAPI SymSetSearchPathW(HANDLE hProcess,PCWSTR SearchPath);
884 DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll);
885
886#define SLMFLAG_VIRTUAL 0x1
887
888 DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
889 DWORD64 IMAGEAPI SymLoadModuleExW(HANDLE hProcess,HANDLE hFile,PCWSTR ImageName,PCWSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
890
891#ifdef _IMAGEHLP64
892#define SymLoadModule SymLoadModule64
893#else
894 DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PCSTR ImageName,PCSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll);
895#endif
896
897 WINBOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll);
898
899#ifdef _IMAGEHLP64
900#define SymUnloadModule SymUnloadModule64
901#else
902 WINBOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll);
903#endif
904
905 WINBOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength);
906
907#ifdef _IMAGEHLP64
908#define SymUnDName SymUnDName64
909#else
910 WINBOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength);
911#endif
912
913 WINBOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
914 WINBOOL IMAGEAPI SymRegisterCallbackW64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
915
916 WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext);
917
918#ifdef _IMAGEHLP64
919#define SymRegisterCallback SymRegisterCallback64
920#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
921#else
922 WINBOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext);
923 WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext);
924#endif
925
926 typedef struct _IMAGEHLP_SYMBOL_SRC {
927 DWORD sizeofstruct;
928 DWORD type;
929 char file[MAX_PATH];
930 } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC;
931
932 typedef struct _MODULE_TYPE_INFO {
933 USHORT dataLength;
934 USHORT leaf;
935 BYTE data[1];
936 } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO;
937
938 typedef struct _SYMBOL_INFO {
939 ULONG SizeOfStruct;
940 ULONG TypeIndex;
941 ULONG64 Reserved[2];
942 ULONG info;
943 ULONG Size;
944 ULONG64 ModBase;
945 ULONG Flags;
946 ULONG64 Value;
947 ULONG64 Address;
948 ULONG Register;
949 ULONG Scope;
950 ULONG Tag;
951 ULONG NameLen;
952 ULONG MaxNameLen;
953 CHAR Name[1];
954 } SYMBOL_INFO,*PSYMBOL_INFO;
955
956 typedef struct _SYMBOL_INFOW {
957 ULONG SizeOfStruct;
958 ULONG TypeIndex;
959 ULONG64 Reserved[2];
960 ULONG info;
961 ULONG Size;
962 ULONG64 ModBase;
963 ULONG Flags;
964 ULONG64 Value;
965 ULONG64 Address;
966 ULONG Register;
967 ULONG Scope;
968 ULONG Tag;
969 ULONG NameLen;
970 ULONG MaxNameLen;
971 WCHAR Name[1];
972 } SYMBOL_INFOW,*PSYMBOL_INFOW;
973
974#define SYMFLAG_CLR_TOKEN 0x00040000
975#define SYMFLAG_CONSTANT 0x00000100
976#define SYMFLAG_EXPORT 0x00000200
977#define SYMFLAG_FORWARDER 0x00000400
978#define SYMFLAG_FRAMEREL 0x00000020
979#define SYMFLAG_FUNCTION 0x00000800
980#define SYMFLAG_ILREL 0x00010000
981#define SYMFLAG_LOCAL 0x00000080
982#define SYMFLAG_METADATA 0x00020000
983#define SYMFLAG_PARAMETER 0x00000040
984#define SYMFLAG_REGISTER 0x00000008
985#define SYMFLAG_REGREL 0x00000010
986#define SYMFLAG_SLOT 0x00008000
987#define SYMFLAG_THUNK 0x00002000
988#define SYMFLAG_TLSREL 0x00004000
989#define SYMFLAG_VALUEPRESENT 0x00000001
990#define SYMFLAG_VIRTUAL 0x00001000
991
992 typedef struct _SYMBOL_INFO_PACKAGE {
993 SYMBOL_INFO si;
994 CHAR name[MAX_SYM_NAME + 1];
995 } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE;
996
997 typedef struct _IMAGEHLP_STACK_FRAME {
998 ULONG64 InstructionOffset;
999 ULONG64 ReturnOffset;
1000 ULONG64 FrameOffset;
1001 ULONG64 StackOffset;
1002 ULONG64 BackingStoreOffset;
1003 ULONG64 FuncTableEntry;
1004 ULONG64 Params[4];
1005 ULONG64 Reserved[5];
1006 WINBOOL Virtual;
1007 ULONG Reserved2;
1008 } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME;
1009
1010 typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT;
1011
1012 WINBOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context);
1013 WINBOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol);
1014 WINBOOL IMAGEAPI SymFromAddrW(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFOW Symbol);
1015 WINBOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol);
1016 WINBOOL IMAGEAPI SymFromTokenW(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFOW Symbol);
1017 WINBOOL IMAGEAPI SymFromName(HANDLE hProcess,PCSTR Name,PSYMBOL_INFO Symbol);
1018 WINBOOL IMAGEAPI SymFromNameW(HANDLE hProcess,PCWSTR Name,PSYMBOL_INFOW Symbol);
1019
1020 typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext);
1021 typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW pSymInfo,ULONG SymbolSize,PVOID UserContext);
1022
1023 WINBOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
1024 WINBOOL IMAGEAPI SymEnumSymbolsW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
1025 WINBOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
1026 WINBOOL IMAGEAPI SymEnumSymbolsForAddrW(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
1027
1028#define SYMENUMFLAG_FULLSRCH 1
1029#define SYMENUMFLAG_SPEEDSRCH 2
1030
1031 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
1032 TI_GET_SYMTAG,
1033 TI_GET_SYMNAME,
1034 TI_GET_LENGTH,
1035 TI_GET_TYPE,
1036 TI_GET_TYPEID,
1037 TI_GET_BASETYPE,
1038 TI_GET_ARRAYINDEXTYPEID,
1039 TI_FINDCHILDREN,
1040 TI_GET_DATAKIND,
1041 TI_GET_ADDRESSOFFSET,
1042 TI_GET_OFFSET,
1043 TI_GET_VALUE,
1044 TI_GET_COUNT,
1045 TI_GET_CHILDRENCOUNT,
1046 TI_GET_BITPOSITION,
1047 TI_GET_VIRTUALBASECLASS,
1048 TI_GET_VIRTUALTABLESHAPEID,
1049 TI_GET_VIRTUALBASEPOINTEROFFSET,
1050 TI_GET_CLASSPARENTID,
1051 TI_GET_NESTED,
1052 TI_GET_SYMINDEX,
1053 TI_GET_LEXICALPARENT,
1054 TI_GET_ADDRESS,
1055 TI_GET_THISADJUST,
1056 TI_GET_UDTKIND,
1057 TI_IS_EQUIV_TO,
1058 TI_GET_CALLING_CONVENTION
1059 } IMAGEHLP_SYMBOL_TYPE_INFO;
1060
1061 typedef struct _TI_FINDCHILDREN_PARAMS {
1062 ULONG Count;
1063 ULONG Start;
1064 ULONG ChildId[1];
1065 } TI_FINDCHILDREN_PARAMS;
1066
1067 WINBOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo);
1068 WINBOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
1069 WINBOOL IMAGEAPI SymEnumTypesW(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
1070 WINBOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,PSYMBOL_INFO Symbol);
1071 WINBOOL IMAGEAPI SymGetTypeFromNameW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,PSYMBOL_INFOW Symbol);
1072 WINBOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
1073 WINBOOL IMAGEAPI SymAddSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
1074 WINBOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags);
1075 WINBOOL IMAGEAPI SymDeleteSymbolW(HANDLE hProcess,ULONG64 BaseOfDll,PCWSTR Name,DWORD64 Address,DWORD Flags);
1076
1077 typedef WINBOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData);
1078
1079 WINBOOL WINAPI DbgHelpCreateUserDump(LPCSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
1080 WINBOOL WINAPI DbgHelpCreateUserDumpW(LPCWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
1081 WINBOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol);
1082
1083#ifdef _IMAGEHLP64
1084#define SymGetSymFromAddr SymGetSymFromAddr64
1085#else
1086 WINBOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol);
1087#endif
1088
1089 WINBOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL64 Symbol);
1090
1091#ifdef _IMAGEHLP64
1092#define SymGetSymFromName SymGetSymFromName64
1093#else
1094 WINBOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PCSTR Name,PIMAGEHLP_SYMBOL Symbol);
1095#endif
1096
1097 DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,PSTR FilePath);
1098 DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,PCSTR SearchPath,PCSTR FileName,DWORD one,DWORD two,DWORD three,PSTR FilePath);
1099 DBHLP_DEPRECIATED WINBOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
1100
1101#ifdef __cplusplus
1102}
1103#endif
1104
1105#define SYMF_OMAP_GENERATED 0x00000001
1106#define SYMF_OMAP_MODIFIED 0x00000002
1107#define SYMF_REGISTER 0x00000008
1108#define SYMF_REGREL 0x00000010
1109#define SYMF_FRAMEREL 0x00000020
1110#define SYMF_PARAMETER 0x00000040
1111#define SYMF_LOCAL 0x00000080
1112#define SYMF_CONSTANT 0x00000100
1113#define SYMF_EXPORT 0x00000200
1114#define SYMF_FORWARDER 0x00000400
1115#define SYMF_FUNCTION 0x00000800
1116#define SYMF_VIRTUAL 0x00001000
1117#define SYMF_THUNK 0x00002000
1118#define SYMF_TLSREL 0x00004000
1119
1120#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
1121#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER
1122#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL
1123#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL
1124#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER
1125#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL
1126#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT
1127#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION
1128#define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL
1129#define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK
1130#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL
1131
1132#include <pshpack4.h>
1133
1134#define MINIDUMP_SIGNATURE ('PMDM')
1135#define MINIDUMP_VERSION (42899)
1136 typedef DWORD RVA;
1137 typedef ULONG64 RVA64;
1138
1139 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
1140 ULONG32 DataSize;
1141 RVA Rva;
1142 } MINIDUMP_LOCATION_DESCRIPTOR;
1143
1144 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
1145 ULONG64 DataSize;
1146 RVA64 Rva;
1147 } MINIDUMP_LOCATION_DESCRIPTOR64;
1148
1149 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
1150 ULONG64 StartOfMemoryRange;
1151 MINIDUMP_LOCATION_DESCRIPTOR Memory;
1152 } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR;
1153
1154 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
1155 ULONG64 StartOfMemoryRange;
1156 ULONG64 DataSize;
1157 } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64;
1158
1159 typedef struct _MINIDUMP_HEADER {
1160 ULONG32 Signature;
1161 ULONG32 Version;
1162 ULONG32 NumberOfStreams;
1163 RVA StreamDirectoryRva;
1164 ULONG32 CheckSum;
1165 __C89_NAMELESS union {
1166 ULONG32 Reserved;
1167 ULONG32 TimeDateStamp;
1168 };
1169 ULONG64 Flags;
1170 } MINIDUMP_HEADER,*PMINIDUMP_HEADER;
1171
1172 typedef struct _MINIDUMP_DIRECTORY {
1173 ULONG32 StreamType;
1174 MINIDUMP_LOCATION_DESCRIPTOR Location;
1175 } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY;
1176
1177 typedef struct _MINIDUMP_STRING {
1178 ULONG32 Length;
1179 WCHAR Buffer[0];
1180 } MINIDUMP_STRING,*PMINIDUMP_STRING;
1181
1182 typedef enum _MINIDUMP_STREAM_TYPE {
1183 UnusedStream = 0,
1184 ReservedStream0 = 1,
1185 ReservedStream1 = 2,
1186 ThreadListStream = 3,
1187 ModuleListStream = 4,
1188 MemoryListStream = 5,
1189 ExceptionStream = 6,
1190 SystemInfoStream = 7,
1191 ThreadExListStream = 8,
1192 Memory64ListStream = 9,
1193 CommentStreamA = 10,
1194 CommentStreamW = 11,
1195 HandleDataStream = 12,
1196 FunctionTableStream = 13,
1197 UnloadedModuleListStream = 14,
1198 MiscInfoStream = 15,
1199 MemoryInfoListStream = 16,
1200 ThreadInfoListStream = 17,
1201 HandleOperationListStream = 18,
1202 TokenStream = 19,
1203 JavaScriptDataStream = 20,
1204 SystemMemoryInfoStream = 21,
1205 ProcessVmCountersStream = 22,
1206 IptTraceStream = 23,
1207 ThreadNamesStream = 24,
1208 ceStreamNull = 0x8000,
1209 ceStreamSystemInfo = 0x8001,
1210 ceStreamException = 0x8002,
1211 ceStreamModuleList = 0x8003,
1212 ceStreamProcessList = 0x8004,
1213 ceStreamThreadList = 0x8005,
1214 ceStreamThreadContextList = 0x8006,
1215 ceStreamThreadCallStackList = 0x8007,
1216 ceStreamMemoryVirtualList = 0x8008,
1217 ceStreamMemoryPhysicalList = 0x8009,
1218 ceStreamBucketParameters = 0x800a,
1219 ceStreamProcessModuleMap = 0x800b,
1220 ceStreamDiagnosisList = 0x800c,
1221 LastReservedStream = 0xffff
1222 } MINIDUMP_STREAM_TYPE;
1223
1224 typedef union _CPU_INFORMATION {
1225 struct {
1226 ULONG32 VendorId[3];
1227 ULONG32 VersionInformation;
1228 ULONG32 FeatureInformation;
1229 ULONG32 AMDExtendedCpuFeatures;
1230 } X86CpuInfo;
1231 struct {
1232 ULONG64 ProcessorFeatures[2];
1233 } OtherCpuInfo;
1234 } CPU_INFORMATION,*PCPU_INFORMATION;
1235
1236 typedef struct _MINIDUMP_SYSTEM_INFO {
1237 USHORT ProcessorArchitecture;
1238 USHORT ProcessorLevel;
1239 USHORT ProcessorRevision;
1240 __C89_NAMELESS union {
1241 USHORT Reserved0;
1242 __C89_NAMELESS struct {
1243 UCHAR NumberOfProcessors;
1244 UCHAR ProductType;
1245 };
1246 };
1247 ULONG32 MajorVersion;
1248 ULONG32 MinorVersion;
1249 ULONG32 BuildNumber;
1250 ULONG32 PlatformId;
1251 RVA CSDVersionRva;
1252 __C89_NAMELESS union {
1253 ULONG32 Reserved1;
1254 __C89_NAMELESS struct {
1255 USHORT SuiteMask;
1256 USHORT Reserved2;
1257 };
1258 };
1259 CPU_INFORMATION Cpu;
1260 } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO;
1261
1262 C_ASSERT(sizeof(((PPROCESS_INFORMATION)0)->dwThreadId)==4);
1263
1264 typedef struct _MINIDUMP_THREAD {
1265 ULONG32 ThreadId;
1266 ULONG32 SuspendCount;
1267 ULONG32 PriorityClass;
1268 ULONG32 Priority;
1269 ULONG64 Teb;
1270 MINIDUMP_MEMORY_DESCRIPTOR Stack;
1271 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1272 } MINIDUMP_THREAD,*PMINIDUMP_THREAD;
1273
1274 typedef struct _MINIDUMP_THREAD_LIST {
1275 ULONG32 NumberOfThreads;
1276 MINIDUMP_THREAD Threads[0];
1277 } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST;
1278
1279 typedef struct _MINIDUMP_THREAD_EX {
1280 ULONG32 ThreadId;
1281 ULONG32 SuspendCount;
1282 ULONG32 PriorityClass;
1283 ULONG32 Priority;
1284 ULONG64 Teb;
1285 MINIDUMP_MEMORY_DESCRIPTOR Stack;
1286 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1287 MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
1288 } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX;
1289
1290 typedef struct _MINIDUMP_THREAD_EX_LIST {
1291 ULONG32 NumberOfThreads;
1292 MINIDUMP_THREAD_EX Threads[0];
1293 } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST;
1294
1295 typedef struct _MINIDUMP_EXCEPTION {
1296 ULONG32 ExceptionCode;
1297 ULONG32 ExceptionFlags;
1298 ULONG64 ExceptionRecord;
1299 ULONG64 ExceptionAddress;
1300 ULONG32 NumberParameters;
1301 ULONG32 __unusedAlignment;
1302 ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
1303 } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION;
1304
1305 typedef struct MINIDUMP_EXCEPTION_STREAM {
1306 ULONG32 ThreadId;
1307 ULONG32 __alignment;
1308 MINIDUMP_EXCEPTION ExceptionRecord;
1309 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1310 } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM;
1311
1312 typedef struct _MINIDUMP_MODULE {
1313 ULONG64 BaseOfImage;
1314 ULONG32 SizeOfImage;
1315 ULONG32 CheckSum;
1316 ULONG32 TimeDateStamp;
1317 RVA ModuleNameRva;
1318 VS_FIXEDFILEINFO VersionInfo;
1319 MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
1320 MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
1321 ULONG64 Reserved0;
1322 ULONG64 Reserved1;
1323 } MINIDUMP_MODULE,*PMINIDUMP_MODULE;
1324
1325 typedef struct _MINIDUMP_MODULE_LIST {
1326 ULONG32 NumberOfModules;
1327 MINIDUMP_MODULE Modules[0];
1328 } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST;
1329
1330 typedef struct _MINIDUMP_MEMORY_LIST {
1331 ULONG32 NumberOfMemoryRanges;
1332 MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[0];
1333 } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST;
1334
1335 typedef struct _MINIDUMP_MEMORY64_LIST {
1336 ULONG64 NumberOfMemoryRanges;
1337 RVA64 BaseRva;
1338 MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[0];
1339 } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST;
1340
1341 typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
1342 DWORD ThreadId;
1343 PEXCEPTION_POINTERS ExceptionPointers;
1344 WINBOOL ClientPointers;
1345 } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION;
1346
1347 typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
1348 DWORD ThreadId;
1349 ULONG64 ExceptionRecord;
1350 ULONG64 ContextRecord;
1351 WINBOOL ClientPointers;
1352 } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64;
1353
1354 typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
1355 MiniHandleObjectInformationNone,
1356 MiniThreadInformation1,
1357 MiniMutantInformation1,
1358 MiniMutantInformation2,
1359 MiniProcessInformation1,
1360 MiniProcessInformation2,
1361 MiniEventInformation1,
1362 MiniSectionInformation1,
1363 MiniSemaphoreInformation1,
1364 MiniHandleObjectInformationTypeMax
1365 } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
1366
1367 typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION {
1368 RVA NextInfoRva;
1369 ULONG32 InfoType;
1370 ULONG32 SizeOfInfo;
1371 } MINIDUMP_HANDLE_OBJECT_INFORMATION;
1372
1373 typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
1374 ULONG64 Handle;
1375 RVA TypeNameRva;
1376 RVA ObjectNameRva;
1377 ULONG32 Attributes;
1378 ULONG32 GrantedAccess;
1379 ULONG32 HandleCount;
1380 ULONG32 PointerCount;
1381 } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR;
1382
1383 typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
1384 ULONG32 SizeOfHeader;
1385 ULONG32 SizeOfDescriptor;
1386 ULONG32 NumberOfDescriptors;
1387 ULONG32 Reserved;
1388 } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM;
1389
1390 typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
1391 ULONG64 MinimumAddress;
1392 ULONG64 MaximumAddress;
1393 ULONG64 BaseAddress;
1394 ULONG32 EntryCount;
1395 ULONG32 SizeOfAlignPad;
1396 } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
1397
1398 typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
1399 ULONG32 SizeOfHeader;
1400 ULONG32 SizeOfDescriptor;
1401 ULONG32 SizeOfNativeDescriptor;
1402 ULONG32 SizeOfFunctionEntry;
1403 ULONG32 NumberOfDescriptors;
1404 ULONG32 SizeOfAlignPad;
1405 } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM;
1406
1407 typedef struct _MINIDUMP_UNLOADED_MODULE {
1408 ULONG64 BaseOfImage;
1409 ULONG32 SizeOfImage;
1410 ULONG32 CheckSum;
1411 ULONG32 TimeDateStamp;
1412 RVA ModuleNameRva;
1413 } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE;
1414
1415 typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
1416 ULONG32 SizeOfHeader;
1417 ULONG32 SizeOfEntry;
1418 ULONG32 NumberOfEntries;
1419 } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST;
1420
1421#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
1422#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
1423#define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004
1424
1425 typedef struct _MINIDUMP_MISC_INFO {
1426 ULONG32 SizeOfInfo;
1427 ULONG32 Flags1;
1428 ULONG32 ProcessId;
1429 ULONG32 ProcessCreateTime;
1430 ULONG32 ProcessUserTime;
1431 ULONG32 ProcessKernelTime;
1432 } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO;
1433
1434 typedef struct _MINIDUMP_USER_RECORD {
1435 ULONG32 Type;
1436 MINIDUMP_LOCATION_DESCRIPTOR Memory;
1437 } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD;
1438
1439 typedef struct _MINIDUMP_USER_STREAM {
1440 ULONG32 Type;
1441 ULONG BufferSize;
1442 PVOID Buffer;
1443 } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM;
1444
1445 typedef struct _MINIDUMP_USER_STREAM_INFORMATION {
1446 ULONG UserStreamCount;
1447 PMINIDUMP_USER_STREAM UserStreamArray;
1448 } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION;
1449
1450 typedef enum _MINIDUMP_CALLBACK_TYPE {
1451 ModuleCallback,
1452 ThreadCallback,
1453 ThreadExCallback,
1454 IncludeThreadCallback,
1455 IncludeModuleCallback,
1456 MemoryCallback,
1457 CancelCallback,
1458 WriteKernelMinidumpCallback,
1459 KernelMinidumpStatusCallback,
1460 RemoveMemoryCallback,
1461 IncludeVmRegionCallback,
1462 IoStartCallback,
1463 IoWriteAllCallback,
1464 IoFinishCallback,
1465 ReadMemoryFailureCallback,
1466 SecondaryFlagsCallback,
1467 IsProcessSnapshotCallback,
1468 VmStartCallback,
1469 VmQueryCallback,
1470 VmPreReadCallback,
1471 VmPostReadCallback
1472 } MINIDUMP_CALLBACK_TYPE;
1473
1474 typedef struct _MINIDUMP_THREAD_CALLBACK {
1475 ULONG ThreadId;
1476 HANDLE ThreadHandle;
1477#if defined(__aarch64__)
1478 ULONG Pad;
1479#endif
1480 CONTEXT Context;
1481 ULONG SizeOfContext;
1482 ULONG64 StackBase;
1483 ULONG64 StackEnd;
1484 } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK;
1485
1486 typedef struct _MINIDUMP_THREAD_EX_CALLBACK {
1487 ULONG ThreadId;
1488 HANDLE ThreadHandle;
1489#if defined(__aarch64__)
1490 ULONG Pad;
1491#endif
1492 CONTEXT Context;
1493 ULONG SizeOfContext;
1494 ULONG64 StackBase;
1495 ULONG64 StackEnd;
1496 ULONG64 BackingStoreBase;
1497 ULONG64 BackingStoreEnd;
1498 } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK;
1499
1500 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK {
1501 ULONG ThreadId;
1502 } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK;
1503
1504 typedef enum _THREAD_WRITE_FLAGS {
1505 ThreadWriteThread = 0x0001,
1506 ThreadWriteStack = 0x0002,
1507 ThreadWriteContext = 0x0004,
1508 ThreadWriteBackingStore = 0x0008,
1509 ThreadWriteInstructionWindow = 0x0010,
1510 ThreadWriteThreadData = 0x0020,
1511 ThreadWriteThreadInfo = 0x0040
1512 } THREAD_WRITE_FLAGS;
1513
1514 typedef struct _MINIDUMP_MODULE_CALLBACK {
1515 PWCHAR FullPath;
1516 ULONG64 BaseOfImage;
1517 ULONG SizeOfImage;
1518 ULONG CheckSum;
1519 ULONG TimeDateStamp;
1520 VS_FIXEDFILEINFO VersionInfo;
1521 PVOID CvRecord;
1522 ULONG SizeOfCvRecord;
1523 PVOID MiscRecord;
1524 ULONG SizeOfMiscRecord;
1525 } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK;
1526
1527 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK {
1528 ULONG64 BaseOfImage;
1529 } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK;
1530
1531 typedef enum _MODULE_WRITE_FLAGS {
1532 ModuleWriteModule = 0x0001,
1533 ModuleWriteDataSeg = 0x0002,
1534 ModuleWriteMiscRecord = 0x0004,
1535 ModuleWriteCvRecord = 0x0008,
1536 ModuleReferencedByMemory = 0x0010,
1537 ModuleWriteTlsData = 0x0020,
1538 ModuleWriteCodeSegs = 0x0040
1539 } MODULE_WRITE_FLAGS;
1540
1541 typedef enum _MINIDUMP_SECONDARY_FLAGS {
1542 MiniSecondaryWithoutPowerInfo = 0x00000001
1543 } MINIDUMP_SECONDARY_FLAGS;
1544
1545 typedef struct _MINIDUMP_CALLBACK_INPUT {
1546 ULONG ProcessId;
1547 HANDLE ProcessHandle;
1548 ULONG CallbackType;
1549 __C89_NAMELESS union {
1550 MINIDUMP_THREAD_CALLBACK Thread;
1551 MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
1552 MINIDUMP_MODULE_CALLBACK Module;
1553 MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
1554 MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
1555 };
1556 } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT;
1557
1558typedef struct _MINIDUMP_MEMORY_INFO {
1559 ULONG64 BaseAddress;
1560 ULONG64 AllocationBase;
1561 ULONG32 AllocationProtect;
1562 ULONG32 __alignment1;
1563 ULONG64 RegionSize;
1564 ULONG32 State;
1565 ULONG32 Protect;
1566 ULONG32 Type;
1567 ULONG32 __alignment2;
1568} MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO;
1569
1570typedef struct _MINIDUMP_MISC_INFO_2 {
1571 ULONG32 SizeOfInfo;
1572 ULONG32 Flags1;
1573 ULONG32 ProcessId;
1574 ULONG32 ProcessCreateTime;
1575 ULONG32 ProcessUserTime;
1576 ULONG32 ProcessKernelTime;
1577 ULONG32 ProcessorMaxMhz;
1578 ULONG32 ProcessorCurrentMhz;
1579 ULONG32 ProcessorMhzLimit;
1580 ULONG32 ProcessorMaxIdleState;
1581 ULONG32 ProcessorCurrentIdleState;
1582} MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2;
1583
1584typedef struct _MINIDUMP_MEMORY_INFO_LIST {
1585 ULONG SizeOfHeader;
1586 ULONG SizeOfEntry;
1587 ULONG64 NumberOfEntries;
1588} MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST;
1589
1590 typedef struct _MINIDUMP_CALLBACK_OUTPUT {
1591 __C89_NAMELESS union {
1592 ULONG ModuleWriteFlags;
1593 ULONG ThreadWriteFlags;
1594 ULONG SecondaryFlags;
1595 __C89_NAMELESS struct {
1596 ULONG64 MemoryBase;
1597 ULONG MemorySize;
1598 };
1599 __C89_NAMELESS struct {
1600 WINBOOL CheckCancel;
1601 WINBOOL Cancel;
1602 };
1603 HANDLE Handle;
1604 };
1605 __C89_NAMELESS struct {
1606 MINIDUMP_MEMORY_INFO VmRegion;
1607 WINBOOL Continue;
1608 };
1609 HRESULT Status;
1610 } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
1611
1612 typedef enum _MINIDUMP_TYPE {
1613 MiniDumpNormal = 0x00000000,
1614 MiniDumpWithDataSegs = 0x00000001,
1615 MiniDumpWithFullMemory = 0x00000002,
1616 MiniDumpWithHandleData = 0x00000004,
1617 MiniDumpFilterMemory = 0x00000008,
1618 MiniDumpScanMemory = 0x00000010,
1619 MiniDumpWithUnloadedModules = 0x00000020,
1620 MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
1621 MiniDumpFilterModulePaths = 0x00000080,
1622 MiniDumpWithProcessThreadData = 0x00000100,
1623 MiniDumpWithPrivateReadWriteMemory = 0x00000200,
1624 MiniDumpWithoutOptionalData = 0x00000400,
1625 MiniDumpWithFullMemoryInfo = 0x00000800,
1626 MiniDumpWithThreadInfo = 0x00001000,
1627 MiniDumpWithCodeSegs = 0x00002000,
1628 MiniDumpWithoutAuxiliaryState = 0x00004000,
1629 MiniDumpWithFullAuxiliaryState = 0x00008000,
1630 MiniDumpWithPrivateWriteCopyMemory = 0x00010000,
1631 MiniDumpIgnoreInaccessibleMemory = 0x00020000,
1632 MiniDumpWithTokenInformation = 0x00040000,
1633 MiniDumpWithModuleHeaders = 0x00080000,
1634 MiniDumpFilterTriage = 0x00100000,
1635 MiniDumpWithAvxXStateContext = 0x00200000,
1636 MiniDumpWithIptTrace = 0x00400000,
1637 MiniDumpScanInaccessiblePartialPages = 0x00800000,
1638 MiniDumpValidTypeFlags = 0x00ffffff
1639 } MINIDUMP_TYPE;
1640
1641#define MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001
1642#define MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002
1643#define MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004
1644#define MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008
1645#define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010
1646#define MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020
1647
1648typedef struct _MINIDUMP_THREAD_INFO {
1649 ULONG32 ThreadId;
1650 ULONG32 DumpFlags;
1651 ULONG32 DumpError;
1652 ULONG32 ExitStatus;
1653 ULONG64 CreateTime;
1654 ULONG64 ExitTime;
1655 ULONG64 KernelTime;
1656 ULONG64 UserTime;
1657 ULONG64 StartAddress;
1658 ULONG64 Affinity;
1659} MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO;
1660
1661typedef struct _MINIDUMP_THREAD_INFO_LIST {
1662 ULONG SizeOfHeader;
1663 ULONG SizeOfEntry;
1664 ULONG NumberOfEntries;
1665} MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST;
1666
1667typedef struct _MINIDUMP_HANDLE_OPERATION_LIST {
1668 ULONG32 SizeOfHeader;
1669 ULONG32 SizeOfEntry;
1670 ULONG32 NumberOfEntries;
1671 ULONG32 Reserved;
1672} MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST;
1673
1674#ifdef __cplusplus
1675extern "C" {
1676#endif
1677
1678 typedef WINBOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
1679
1680 typedef struct _MINIDUMP_CALLBACK_INFORMATION {
1681 MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
1682 PVOID CallbackParam;
1683 } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION;
1684
1685#define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
1686
1687 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);
1688 WINBOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize);
1689
1690WINBOOL WINAPI EnumerateLoadedModulesEx(
1691 HANDLE hProcess,
1692 PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
1693 PVOID UserContext
1694);
1695
1696WINBOOL WINAPI EnumerateLoadedModulesExW(
1697 HANDLE hProcess,
1698 PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
1699 PVOID UserContext
1700);
1701
1702WINBOOL WINAPI SymAddSourceStream(
1703 HANDLE hProcess,
1704 ULONG64 Base,
1705 PCSTR StreamFile,
1706 PBYTE Buffer,
1707 size_t Size
1708);
1709
1710WINBOOL WINAPI SymAddSourceStreamW(
1711 HANDLE hProcess,
1712 ULONG64 Base,
1713 PCWSTR StreamFile,
1714 PBYTE Buffer,
1715 size_t Size
1716);
1717
1718WINBOOL WINAPI SymEnumSourceLines(
1719 HANDLE hProcess,
1720 ULONG64 Base,
1721 PCSTR Obj,
1722 PCSTR File,
1723 DWORD Line,
1724 DWORD Flags,
1725 PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
1726 PVOID UserContext
1727);
1728
1729WINBOOL WINAPI SymEnumSourceLinesW(
1730 HANDLE hProcess,
1731 ULONG64 Base,
1732 PCWSTR Obj,
1733 PCWSTR File,
1734 DWORD Line,
1735 DWORD Flags,
1736 PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
1737 PVOID UserContext
1738);
1739
1740WINBOOL WINAPI SymEnumTypesByName(
1741 HANDLE hProcess,
1742 ULONG64 BaseOfDll,
1743 PCSTR mask,
1744 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
1745 PVOID UserContext
1746);
1747
1748WINBOOL WINAPI SymEnumTypesByNameW(
1749 HANDLE hProcess,
1750 ULONG64 BaseOfDll,
1751 PCSTR mask,
1752 PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
1753 PVOID UserContext
1754);
1755
1756HANDLE WINAPI SymFindDebugInfoFile(
1757 HANDLE hProcess,
1758 PCSTR FileName,
1759 PSTR DebugFilePath,
1760 PFIND_DEBUG_FILE_CALLBACK Callback,
1761 PVOID CallerData
1762);
1763
1764HANDLE WINAPI SymFindDebugInfoFileW(
1765 HANDLE hProcess,
1766 PCWSTR FileName,
1767 PWSTR DebugFilePath,
1768 PFIND_DEBUG_FILE_CALLBACKW Callback,
1769 PVOID CallerData
1770);
1771
1772HANDLE WINAPI SymFindExecutableImage(
1773 HANDLE hProcess,
1774 PCSTR FileName,
1775 PSTR ImageFilePath,
1776 PFIND_EXE_FILE_CALLBACK Callback,
1777 PVOID CallerData
1778);
1779
1780HANDLE WINAPI SymFindExecutableImageW(
1781 HANDLE hProcess,
1782 PCWSTR FileName,
1783 PWSTR ImageFilePath,
1784 PFIND_EXE_FILE_CALLBACKW Callback,
1785 PVOID CallerData
1786);
1787
1788WINBOOL WINAPI SymFromIndex(
1789 HANDLE hProcess,
1790 ULONG64 BaseOfDll,
1791 DWORD Index,
1792 PSYMBOL_INFO Symbol
1793);
1794
1795WINBOOL WINAPI SymFromIndexW(
1796 HANDLE hProcess,
1797 ULONG64 BaseOfDll,
1798 DWORD Index,
1799 PSYMBOL_INFOW Symbol
1800);
1801
1802WINBOOL WINAPI SymGetScope(
1803 HANDLE hProcess,
1804 ULONG64 BaseOfDll,
1805 DWORD Index,
1806 PSYMBOL_INFO Symbol
1807);
1808
1809WINBOOL WINAPI SymGetScopeW(
1810 HANDLE hProcess,
1811 ULONG64 BaseOfDll,
1812 DWORD Index,
1813 PSYMBOL_INFOW Symbol
1814);
1815
1816WINBOOL WINAPI SymGetSourceFileFromToken(
1817 HANDLE hProcess,
1818 PVOID Token,
1819 PCSTR Params,
1820 PSTR FilePath,
1821 DWORD Size
1822);
1823
1824WINBOOL WINAPI SymGetSourceFileFromTokenW(
1825 HANDLE hProcess,
1826 PVOID Token,
1827 PCWSTR Params,
1828 PWSTR FilePath,
1829 DWORD Size
1830);
1831
1832WINBOOL WINAPI SymGetSourceFileToken(
1833 HANDLE hProcess,
1834 ULONG64 Base,
1835 PCSTR FileSpec,
1836 PVOID *Token,
1837 DWORD *Size
1838);
1839
1840WINBOOL WINAPI SymGetSourceFileTokenW(
1841 HANDLE hProcess,
1842 ULONG64 Base,
1843 PCWSTR FileSpec,
1844 PVOID *Token,
1845 DWORD *Size
1846);
1847
1848WINBOOL WINAPI SymGetSourceFile(
1849 HANDLE hProcess,
1850 ULONG64 Base,
1851 PCSTR Params,
1852 PCSTR FileSpec,
1853 PSTR FilePath,
1854 DWORD Size
1855);
1856
1857WINBOOL WINAPI SymGetSourceFileW(
1858 HANDLE hProcess,
1859 ULONG64 Base,
1860 PCWSTR Params,
1861 PCWSTR FileSpec,
1862 PWSTR FilePath,
1863 DWORD Size
1864);
1865
1866WINBOOL WINAPI SymGetSourceVarFromToken(
1867 HANDLE hProcess,
1868 PVOID Token,
1869 PCSTR Params,
1870 PCSTR VarName,
1871 PSTR Value,
1872 DWORD Size
1873);
1874
1875WINBOOL WINAPI SymGetSourceVarFromTokenW(
1876 HANDLE hProcess,
1877 PVOID Token,
1878 PCWSTR Params,
1879 PCWSTR VarName,
1880 PWSTR Value,
1881 DWORD Size
1882);
1883
1884WINBOOL WINAPI SymGetSymbolFile(
1885 HANDLE hProcess,
1886 PCSTR SymPath,
1887 PCSTR ImageFile,
1888 DWORD Type,
1889 PSTR SymbolFile,
1890 size_t cSymbolFile,
1891 PSTR DbgFile,
1892 size_t cDbgFile
1893);
1894
1895WINBOOL WINAPI SymGetSymbolFileW(
1896 HANDLE hProcess,
1897 PCWSTR SymPath,
1898 PCWSTR ImageFile,
1899 DWORD Type,
1900 PWSTR SymbolFile,
1901 size_t cSymbolFile,
1902 PWSTR DbgFile,
1903 size_t cDbgFile
1904);
1905
1906WINBOOL WINAPI SymNext(
1907 HANDLE hProcess,
1908 PSYMBOL_INFO Symbol
1909);
1910
1911WINBOOL WINAPI SymNextW(
1912 HANDLE hProcess,
1913 PSYMBOL_INFOW Symbol
1914);
1915
1916WINBOOL WINAPI SymPrev(
1917 HANDLE hProcess,
1918 PSYMBOL_INFO Symbol
1919);
1920
1921WINBOOL WINAPI SymPrevW(
1922 HANDLE hProcess,
1923 PSYMBOL_INFOW Symbol
1924);
1925
1926WINBOOL WINAPI SymRefreshModuleList(
1927 HANDLE hProcess
1928);
1929
1930#define SYMSEARCH_MASKOBJS 0x01
1931#define SYMSEARCH_RECURSE 0x02
1932#define SYMSEARCH_GLOBALSONLY 0x04
1933#define SYMSEARCH_ALLITEMS 0x08
1934
1935WINBOOL WINAPI SymSearch(
1936 HANDLE hProcess,
1937 ULONG64 BaseOfDll,
1938 DWORD Index,
1939 DWORD SymTag,
1940 PCSTR Mask,
1941 DWORD64 Address,
1942 PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
1943 PVOID UserContext,
1944 DWORD Options
1945);
1946
1947WINBOOL WINAPI SymSearchW(
1948 HANDLE hProcess,
1949 ULONG64 BaseOfDll,
1950 DWORD Index,
1951 DWORD SymTag,
1952 PCWSTR Mask,
1953 DWORD64 Address,
1954 PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
1955 PVOID UserContext,
1956 DWORD Options
1957);
1958
1959WINBOOL WINAPI SymSrvGetFileIndexString(
1960 HANDLE hProcess,
1961 PCSTR SrvPath,
1962 PCSTR File,
1963 PSTR Index,
1964 size_t Size,
1965 DWORD Flags
1966);
1967
1968WINBOOL WINAPI SymSrvGetFileIndexStringW(
1969 HANDLE hProcess,
1970 PCWSTR SrvPath,
1971 PCWSTR File,
1972 PWSTR Index,
1973 size_t Size,
1974 DWORD Flags
1975);
1976
1977WINBOOL WINAPI SymSrvGetFileIndexInfo(
1978 PCSTR File,
1979 PSYMSRV_INDEX_INFO Info,
1980 DWORD Flags
1981);
1982
1983WINBOOL WINAPI SymSrvGetFileIndexInfoW(
1984 PCWSTR File,
1985 PSYMSRV_INDEX_INFOW Info,
1986 DWORD Flags
1987);
1988
1989WINBOOL WINAPI SymSrvGetFileIndexes(
1990 PCTSTR File,
1991 GUID *Id,
1992 DWORD *Val1,
1993 DWORD *Val2,
1994 DWORD Flags
1995);
1996
1997WINBOOL WINAPI SymSrvGetFileIndexesW(
1998 PCWSTR File,
1999 GUID *Id,
2000 DWORD *Val1,
2001 DWORD *Val2,
2002 DWORD Flags
2003);
2004
2005PCSTR WINAPI SymSrvGetSupplement(
2006 HANDLE hProcess,
2007 PCSTR SymPath,
2008 PCSTR Node,
2009 PCSTR File
2010);
2011
2012PCWSTR WINAPI SymSrvGetSupplementW(
2013 HANDLE hProcess,
2014 PCWSTR SymPath,
2015 PCWSTR Node,
2016 PCWSTR File
2017);
2018
2019WINBOOL WINAPI SymSrvIsStore(
2020 HANDLE hProcess,
2021 PCSTR path
2022);
2023
2024WINBOOL WINAPI SymSrvIsStoreW(
2025 HANDLE hProcess,
2026 PCWSTR path
2027);
2028
2029PCSTR WINAPI SymSrvStoreFile(
2030 HANDLE hProcess,
2031 PCSTR SrvPath,
2032 PCSTR File,
2033 DWORD Flags
2034);
2035
2036PCWSTR WINAPI SymSrvStoreFileW(
2037 HANDLE hProcess,
2038 PCWSTR SrvPath,
2039 PCWSTR File,
2040 DWORD Flags
2041);
2042
2043#define SYMSTOREOPT_COMPRESS 0x01
2044#define SYMSTOREOPT_OVERWRITE 0x02
2045#define SYMSTOREOPT_RETURNINDEX 0x04
2046#define SYMSTOREOPT_POINTER 0x08
2047#define SYMSTOREOPT_PASS_IF_EXISTS 0x40
2048
2049PCSTR WINAPI SymSrvStoreSupplement(
2050 HANDLE hProcess,
2051 const PCTSTR SymPath,
2052 PCSTR Node,
2053 PCSTR File,
2054 DWORD Flags
2055);
2056
2057PCWSTR WINAPI SymSrvStoreSupplementW(
2058 HANDLE hProcess,
2059 const PCWSTR SymPath,
2060 PCWSTR Node,
2061 PCWSTR File,
2062 DWORD Flags
2063);
2064
2065PCSTR WINAPI SymSrvDeltaName(
2066 HANDLE hProcess,
2067 PCSTR SymPath,
2068 PCSTR Type,
2069 PCSTR File1,
2070 PCSTR File2
2071);
2072
2073PCWSTR WINAPI SymSrvDeltaNameW(
2074 HANDLE hProcess,
2075 PCWSTR SymPath,
2076 PCWSTR Type,
2077 PCWSTR File1,
2078 PCWSTR File2
2079);
2080
2081#ifdef DBGHELP_TRANSLATE_TCHAR
2082#define SymInitialize SymInitializeW
2083#define SymAddSymbol SymAddSymbolW
2084#define SymDeleteSymbol SymDeleteSymbolW
2085#define SearchTreeForFile SearchTreeForFileW
2086#define UnDecorateSymbolName UnDecorateSymbolNameW
2087#define SymGetLineFromName64 SymGetLineFromNameW64
2088#define SymGetLineFromAddr64 SymGetLineFromAddrW64
2089#define SymGetLineFromInlineContext SymGetLineFromInlineContextW
2090#define SymGetLineNext64 SymGetLineNextW64
2091#define SymGetLinePrev64 SymGetLinePrevW64
2092#define SymFromName SymFromNameW
2093#define SymFindExecutableImage SymFindExecutableImageW
2094#define FindExecutableImageEx FindExecutableImageExW
2095#define SymSearch SymSearchW
2096#define SymEnumLines SymEnumLinesW
2097#define SymEnumSourceLines SymEnumSourceLinesW
2098#define SymGetTypeFromName SymGetTypeFromNameW
2099#define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW
2100#define SymFromAddr SymFromAddrW
2101#define SymFromInlineContext SymFromInlineContextW
2102#define SymMatchString SymMatchStringW
2103#define SymEnumSourceFiles SymEnumSourceFilesW
2104#define SymEnumSymbols SymEnumSymbolsW
2105#define SymEnumSymbolsEx SymEnumSymbolsExW
2106#define SymLoadModuleEx SymLoadModuleExW
2107#define SymSetSearchPath SymSetSearchPathW
2108#define SymGetSearchPath SymGetSearchPathW
2109#define EnumDirTree EnumDirTreeW
2110#define SymFromToken SymFromTokenW
2111#define SymFromIndex SymFromIndexW
2112#define SymGetScope SymGetScopeW
2113#define SymNext SymNextW
2114#define SymPrev SymPrevW
2115#define SymEnumTypes SymEnumTypesW
2116#define SymEnumTypesByName SymEnumTypesByNameW
2117#define SymRegisterCallback64 SymRegisterCallbackW64
2118#define SymFindDebugInfoFile SymFindDebugInfoFileW
2119#define FindDebugInfoFileEx FindDebugInfoFileExW
2120#define SymFindFileInPath SymFindFileInPathW
2121#define SymEnumerateModules64 SymEnumerateModulesW64
2122#define SymSetHomeDirectory SymSetHomeDirectoryW
2123#define SymGetHomeDirectory SymGetHomeDirectoryW
2124#define SymGetSourceFile SymGetSourceFileW
2125#define SymGetSourceFileToken SymGetSourceFileTokenW
2126#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
2127#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
2128#define SymGetSourceFileTokenByTokenName SymGetSourceFileTokenByTokenNameW
2129#define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64
2130#define SymFindFileInPath SymFindFileInPathW
2131#define SymMatchFileName SymMatchFileNameW
2132#define SymGetSourceFileFromTokenByTokenName SymGetSourceFileFromTokenByTokenNameW
2133#define SymGetModuleInfo64 SymGetModuleInfoW64
2134#define SymAddSourceStream SymAddSourceStreamW
2135#define SymSrvIsStore SymSrvIsStoreW
2136#define SymSrvDeltaName SymSrvDeltaNameW
2137#define SymSrvGetSupplement SymSrvGetSupplementW
2138#define SymSrvStoreSupplement SymSrvStoreSupplementW
2139#define SymSrvGetFileIndexes SymSrvGetFileIndexesW
2140#define SymSrvGetFileIndexString SymSrvGetFileIndexStringW
2141#define SymSrvStoreFile SymSrvStoreFileW
2142#define SymGetSymbolFile SymGetSymbolFileW
2143#define EnumerateLoadedModules64 EnumerateLoadedModulesW64
2144#define EnumerateLoadedModulesEx EnumerateLoadedModulesExW
2145#define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW
2146
2147#define IMAGEHLP_LINE64 IMAGEHLP_LINEW64
2148#define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64
2149#define SYMBOL_INFO SYMBOL_INFOW
2150#define PSYMBOL_INFO PSYMBOL_INFOW
2151#define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW
2152#define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW
2153#define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW
2154#define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW
2155#define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW
2156#define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW
2157#define SRCCODEINFO SRCCODEINFOW
2158#define PSRCCODEINFO PSRCCODEINFOW
2159#define SOURCEFILE SOURCEFILEW
2160#define PSOURCEFILE PSOURCEFILEW
2161#define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW
2162#define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW
2163#define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW
2164#define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW
2165#define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW
2166#define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64
2167#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64
2168#define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW
2169#define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW
2170#define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64
2171#define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64
2172#define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOW
2173#define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW
2174
2175#define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW
2176#define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW
2177
2178#endif /* DBGHELP_TRANSLATE_TCHAR */
2179
2180#include <poppack.h>
2181
2182#ifdef __cplusplus
2183}
2184#endif
2185