Mercurial > games > semicongine

comparison fuhtark_test/include/winapi/dbghelp.h @ 1500:91c8c3b7cbf0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add: futhark tests for generating vulkan api
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 21:36:48 +0700
parents
children
comparison
equal deleted inserted replaced
1499:1f58458b7ef7 1500:91c8c3b7cbf0
1 /**
2 * This file has no copyright assigned and is placed in the Public Domain.
3 * This file is part of the w64 mingw-runtime package.
4 * No warranty is given; refer to the file DISCLAIMER within this package.
5 */
6 #ifndef _DBGHELP_
7 #define _DBGHELP_
8
9 #ifdef _WIN64
10 #ifndef _IMAGEHLP64
11 #define _IMAGEHLP64
12 #endif
13 #endif
14
15 #ifdef __cplusplus
16 extern "C" {
17 #endif
18
19 #define IMAGEAPI DECLSPEC_IMPORT WINAPI
20 #define DBHLP_DEPRECIATED __declspec(deprecated)
21
22 #define DBHLPAPI IMAGEAPI
23
24 #define IMAGE_SEPARATION (64*1024)
25
26 typedef struct _LOADED_IMAGE {
27 PSTR ModuleName;
28 HANDLE hFile;
29 PUCHAR MappedAddress;
30 #ifdef _IMAGEHLP64
31 PIMAGE_NT_HEADERS64 FileHeader;
32 #else
33 PIMAGE_NT_HEADERS32 FileHeader;
34 #endif
35 PIMAGE_SECTION_HEADER LastRvaSection;
36 ULONG NumberOfSections;
37 PIMAGE_SECTION_HEADER Sections;
38 ULONG Characteristics;
39 BOOLEAN fSystemImage;
40 BOOLEAN fDOSImage;
41 LIST_ENTRY Links;
42 ULONG SizeOfImage;
43 } LOADED_IMAGE,*PLOADED_IMAGE;
44
45 #define MAX_SYM_NAME 2000
46
47 typedef WINBOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
48 typedef WINBOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR filename,PVOID context);
49 typedef WINBOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
50
51 typedef WINBOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR);
52 typedef WINBOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
53 typedef WINBOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
54 typedef WINBOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64);
55 typedef WINBOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context);
56 typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
57 typedef WINBOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR);
58
59 HANDLE IMAGEAPI FindDebugInfoFile(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath);
60 HANDLE IMAGEAPI FindDebugInfoFileEx(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData);
61 WINBOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context);
62 HANDLE IMAGEAPI FindExecutableImage(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath);
63 HANDLE IMAGEAPI FindExecutableImageEx(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData);
64 PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base);
65 PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader);
66 PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size);
67 PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva);
68 PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection);
69
70 #define SSRVOPT_CALLBACK 0x0001
71 #define SSRVOPT_DWORD 0x0002
72 #define SSRVOPT_DWORDPTR 0x0004
73 #define SSRVOPT_GUIDPTR 0x0008
74 #define SSRVOPT_OLDGUIDPTR 0x0010
75 #define SSRVOPT_UNATTENDED 0x0020
76 #define SSRVOPT_NOCOPY 0x0040
77 #define SSRVOPT_PARENTWIN 0x0080
78 #define SSRVOPT_PARAMTYPE 0x0100
79 #define SSRVOPT_SECURE 0x0200
80 #define SSRVOPT_TRACE 0x0400
81 #define SSRVOPT_SETCONTEXT 0x0800
82 #define SSRVOPT_PROXY 0x1000
83 #define SSRVOPT_DOWNSTREAM_STORE 0x2000
84 #define SSRVOPT_RESET ((ULONG_PTR)-1)
85
86 #define SSRVACTION_TRACE 1
87 #define SSRVACTION_QUERYCANCEL 2
88 #define SSRVACTION_EVENT 3
89
90 #ifndef _WIN64
91
92 typedef struct _IMAGE_DEBUG_INFORMATION {
93 LIST_ENTRY List;
94 DWORD ReservedSize;
95 PVOID ReservedMappedBase;
96 USHORT ReservedMachine;
97 USHORT ReservedCharacteristics;
98 DWORD ReservedCheckSum;
99 DWORD ImageBase;
100 DWORD SizeOfImage;
101 DWORD ReservedNumberOfSections;
102 PIMAGE_SECTION_HEADER ReservedSections;
103 DWORD ReservedExportedNamesSize;
104 PSTR ReservedExportedNames;
105 DWORD ReservedNumberOfFunctionTableEntries;
106 PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
107 DWORD ReservedLowestFunctionStartingAddress;
108 DWORD ReservedHighestFunctionEndingAddress;
109 DWORD ReservedNumberOfFpoTableEntries;
110 PFPO_DATA ReservedFpoTableEntries;
111 DWORD SizeOfCoffSymbols;
112 PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
113 DWORD ReservedSizeOfCodeViewSymbols;
114 PVOID ReservedCodeViewSymbols;
115 PSTR ImageFilePath;
116 PSTR ImageFileName;
117 PSTR ReservedDebugFilePath;
118 DWORD ReservedTimeDateStamp;
119 WINBOOL ReservedRomImage;
120 PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
121 DWORD ReservedNumberOfDebugDirectories;
122 DWORD ReservedOriginalFunctionTableBaseAddress;
123 DWORD Reserved[2 ];
124 } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION;
125
126 PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase);
127 WINBOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo);
128 #endif
129
130 typedef WINBOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData);
131
132 WINBOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer);
133 WINBOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData);
134 WINBOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath);
135
136 #define UNDNAME_COMPLETE (0x0000)
137 #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001)
138 #define UNDNAME_NO_MS_KEYWORDS (0x0002)
139 #define UNDNAME_NO_FUNCTION_RETURNS (0x0004)
140 #define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
141 #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
142 #define UNDNAME_NO_MS_THISTYPE (0x0020)
143 #define UNDNAME_NO_CV_THISTYPE (0x0040)
144 #define UNDNAME_NO_THISTYPE (0x0060)
145 #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080)
146 #define UNDNAME_NO_THROW_SIGNATURES (0x0100)
147 #define UNDNAME_NO_MEMBER_TYPE (0x0200)
148 #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
149 #define UNDNAME_32_BIT_DECODE (0x0800)
150 #define UNDNAME_NAME_ONLY (0x1000)
151 #define UNDNAME_NO_ARGUMENTS (0x2000)
152 #define UNDNAME_NO_SPECIAL_SYMS (0x4000)
153
154 DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags);
155
156 #define DBHHEADER_DEBUGDIRS 0x1
157
158 typedef struct _MODLOAD_DATA {
159 DWORD ssize;
160 DWORD ssig;
161 PVOID data;
162 DWORD size;
163 DWORD flags;
164 } MODLOAD_DATA,*PMODLOAD_DATA;
165
166 typedef enum {
167 AddrMode1616,AddrMode1632,AddrModeReal,AddrModeFlat
168 } ADDRESS_MODE;
169
170 typedef struct _tagADDRESS64 {
171 DWORD64 Offset;
172 WORD Segment;
173 ADDRESS_MODE Mode;
174 } ADDRESS64,*LPADDRESS64;
175
176 #ifdef _IMAGEHLP64
177 #define ADDRESS ADDRESS64
178 #define LPADDRESS LPADDRESS64
179 #else
180 typedef struct _tagADDRESS {
181 DWORD Offset;
182 WORD Segment;
183 ADDRESS_MODE Mode;
184 } ADDRESS,*LPADDRESS;
185
186 static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) {
187 a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
188 a64->Segment = a32->Segment;
189 a64->Mode = a32->Mode;
190 }
191
192 static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) {
193 a32->Offset = (ULONG)a64->Offset;
194 a32->Segment = a64->Segment;
195 a32->Mode = a64->Mode;
196 }
197 #endif
198
199 typedef struct _KDHELP64 {
200 DWORD64 Thread;
201 DWORD ThCallbackStack;
202 DWORD ThCallbackBStore;
203 DWORD NextCallback;
204 DWORD FramePointer;
205 DWORD64 KiCallUserMode;
206 DWORD64 KeUserCallbackDispatcher;
207 DWORD64 SystemRangeStart;
208 DWORD64 Reserved[8];
209 } KDHELP64,*PKDHELP64;
210
211 #ifdef _IMAGEHLP64
212 #define KDHELP KDHELP64
213 #define PKDHELP PKDHELP64
214 #else
215 typedef struct _KDHELP {
216 DWORD Thread;
217 DWORD ThCallbackStack;
218 DWORD NextCallback;
219 DWORD FramePointer;
220 DWORD KiCallUserMode;
221 DWORD KeUserCallbackDispatcher;
222 DWORD SystemRangeStart;
223 DWORD ThCallbackBStore;
224 DWORD Reserved[8];
225 } KDHELP,*PKDHELP;
226
227 static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) {
228 p64->Thread = p32->Thread;
229 p64->ThCallbackStack = p32->ThCallbackStack;
230 p64->NextCallback = p32->NextCallback;
231 p64->FramePointer = p32->FramePointer;
232 p64->KiCallUserMode = p32->KiCallUserMode;
233 p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
234 p64->SystemRangeStart = p32->SystemRangeStart;
235 }
236 #endif
237
238 typedef struct _tagSTACKFRAME64 {
239 ADDRESS64 AddrPC;
240 ADDRESS64 AddrReturn;
241 ADDRESS64 AddrFrame;
242 ADDRESS64 AddrStack;
243 ADDRESS64 AddrBStore;
244 PVOID FuncTableEntry;
245 DWORD64 Params[4];
246 WINBOOL Far;
247 WINBOOL Virtual;
248 DWORD64 Reserved[3];
249 KDHELP64 KdHelp;
250 } STACKFRAME64,*LPSTACKFRAME64;
251
252 #ifdef _IMAGEHLP64
253 #define STACKFRAME STACKFRAME64
254 #define LPSTACKFRAME LPSTACKFRAME64
255 #else
256 typedef struct _tagSTACKFRAME {
257 ADDRESS AddrPC;
258 ADDRESS AddrReturn;
259 ADDRESS AddrFrame;
260 ADDRESS AddrStack;
261 PVOID FuncTableEntry;
262 DWORD Params[4];
263 WINBOOL Far;
264 WINBOOL Virtual;
265 DWORD Reserved[3];
266 KDHELP KdHelp;
267 ADDRESS AddrBStore;
268 } STACKFRAME,*LPSTACKFRAME;
269 #endif
270
271 typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead);
272 typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase);
273 typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address);
274 typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr);
275
276 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 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
277
278 #ifdef _IMAGEHLP64
279 #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
280 #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
281 #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
282 #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
283 #define StackWalk StackWalk64
284 #else
285 typedef WINBOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead);
286 typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase);
287 typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address);
288 typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr);
289
290 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 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
291 #endif
292
293 #define API_VERSION_NUMBER 9
294
295 typedef struct API_VERSION {
296 USHORT MajorVersion;
297 USHORT MinorVersion;
298 USHORT Revision;
299 USHORT Reserved;
300 } API_VERSION,*LPAPI_VERSION;
301
302 LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
303 LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion);
304 DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module);
305
306 typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext);
307 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
308 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
309 typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext);
310 typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext);
311 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext);
312 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext);
313
314 #ifdef _IMAGEHLP64
315 #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
316 #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
317 #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
318 #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
319 #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
320 #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
321 #else
322 typedef WINBOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR ModuleName,ULONG BaseOfDll,PVOID UserContext);
323 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
324 typedef WINBOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
325 typedef WINBOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext);
326 typedef WINBOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext);
327 #endif
328
329 #define SYMFLAG_VALUEPRESENT 0x00000001
330 #define SYMFLAG_REGISTER 0x00000008
331 #define SYMFLAG_REGREL 0x00000010
332 #define SYMFLAG_FRAMEREL 0x00000020
333 #define SYMFLAG_PARAMETER 0x00000040
334 #define SYMFLAG_LOCAL 0x00000080
335 #define SYMFLAG_CONSTANT 0x00000100
336 #define SYMFLAG_EXPORT 0x00000200
337 #define SYMFLAG_FORWARDER 0x00000400
338 #define SYMFLAG_FUNCTION 0x00000800
339 #define SYMFLAG_VIRTUAL 0x00001000
340 #define SYMFLAG_THUNK 0x00002000
341 #define SYMFLAG_TLSREL 0x00004000
342
343 typedef enum {
344 SymNone = 0,SymCoff,SymCv,SymPdb,SymExport,SymDeferred,SymSym,SymDia,SymVirtual,NumSymTypes
345 } SYM_TYPE;
346
347 typedef struct _IMAGEHLP_SYMBOL64 {
348 DWORD SizeOfStruct;
349 DWORD64 Address;
350 DWORD Size;
351 DWORD Flags;
352 DWORD MaxNameLength;
353 CHAR Name[1];
354 } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64;
355
356 typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
357 IMAGEHLP_SYMBOL64 sym;
358 CHAR name[MAX_SYM_NAME + 1];
359 } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE;
360
361 #ifdef _IMAGEHLP64
362
363 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
364 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
365 #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
366 #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
367 #else
368
369 typedef struct _IMAGEHLP_SYMBOL {
370 DWORD SizeOfStruct;
371 DWORD Address;
372 DWORD Size;
373 DWORD Flags;
374 DWORD MaxNameLength;
375 CHAR Name[1];
376 } IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL;
377
378 typedef struct _IMAGEHLP_SYMBOL_PACKAGE {
379 IMAGEHLP_SYMBOL sym;
380 CHAR name[MAX_SYM_NAME + 1];
381 } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE;
382 #endif
383
384 typedef struct _IMAGEHLP_MODULE64 {
385 DWORD SizeOfStruct;
386 DWORD64 BaseOfImage;
387 DWORD ImageSize;
388 DWORD TimeDateStamp;
389 DWORD CheckSum;
390 DWORD NumSyms;
391 SYM_TYPE SymType;
392 CHAR ModuleName[32];
393 CHAR ImageName[256];
394 CHAR LoadedImageName[256];
395 CHAR LoadedPdbName[256];
396 DWORD CVSig;
397 CHAR CVData[MAX_PATH*3];
398 DWORD PdbSig;
399 GUID PdbSig70;
400 DWORD PdbAge;
401 WINBOOL PdbUnmatched;
402 WINBOOL DbgUnmatched;
403 WINBOOL LineNumbers;
404 WINBOOL GlobalSymbols;
405 WINBOOL TypeInfo;
406 } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64;
407
408 typedef struct _IMAGEHLP_MODULE64W {
409 DWORD SizeOfStruct;
410 DWORD64 BaseOfImage;
411 DWORD ImageSize;
412 DWORD TimeDateStamp;
413 DWORD CheckSum;
414 DWORD NumSyms;
415 SYM_TYPE SymType;
416 WCHAR ModuleName[32];
417 WCHAR ImageName[256];
418 WCHAR LoadedImageName[256];
419 WCHAR LoadedPdbName[256];
420 DWORD CVSig;
421 WCHAR CVData[MAX_PATH*3];
422 DWORD PdbSig;
423 GUID PdbSig70;
424 DWORD PdbAge;
425 WINBOOL PdbUnmatched;
426 WINBOOL DbgUnmatched;
427 WINBOOL LineNumbers;
428 WINBOOL GlobalSymbols;
429 WINBOOL TypeInfo;
430 } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64;
431
432 #ifdef _IMAGEHLP64
433 #define IMAGEHLP_MODULE IMAGEHLP_MODULE64
434 #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
435 #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
436 #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
437 #else
438 typedef struct _IMAGEHLP_MODULE {
439 DWORD SizeOfStruct;
440 DWORD BaseOfImage;
441 DWORD ImageSize;
442 DWORD TimeDateStamp;
443 DWORD CheckSum;
444 DWORD NumSyms;
445 SYM_TYPE SymType;
446 CHAR ModuleName[32];
447 CHAR ImageName[256];
448 CHAR LoadedImageName[256];
449 } IMAGEHLP_MODULE,*PIMAGEHLP_MODULE;
450
451 typedef struct _IMAGEHLP_MODULEW {
452 DWORD SizeOfStruct;
453 DWORD BaseOfImage;
454 DWORD ImageSize;
455 DWORD TimeDateStamp;
456 DWORD CheckSum;
457 DWORD NumSyms;
458 SYM_TYPE SymType;
459 WCHAR ModuleName[32];
460 WCHAR ImageName[256];
461 WCHAR LoadedImageName[256];
462 } IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW;
463 #endif
464
465 typedef struct _IMAGEHLP_LINE64 {
466 DWORD SizeOfStruct;
467 PVOID Key;
468 DWORD LineNumber;
469 PCHAR FileName;
470 DWORD64 Address;
471 } IMAGEHLP_LINE64,*PIMAGEHLP_LINE64;
472
473 #ifdef _IMAGEHLP64
474 #define IMAGEHLP_LINE IMAGEHLP_LINE64
475 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64
476 #else
477 typedef struct _IMAGEHLP_LINE {
478 DWORD SizeOfStruct;
479 PVOID Key;
480 DWORD LineNumber;
481 PCHAR FileName;
482 DWORD Address;
483 } IMAGEHLP_LINE,*PIMAGEHLP_LINE;
484 #endif
485
486 typedef struct _SOURCEFILE {
487 DWORD64 ModBase;
488 PCHAR FileName;
489 } SOURCEFILE,*PSOURCEFILE;
490
491 #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
492 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
493 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
494 #define CBA_SYMBOLS_UNLOADED 0x00000004
495 #define CBA_DUPLICATE_SYMBOL 0x00000005
496 #define CBA_READ_MEMORY 0x00000006
497 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
498 #define CBA_SET_OPTIONS 0x00000008
499 #define CBA_EVENT 0x00000010
500 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
501 #define CBA_DEBUG_INFO 0x10000000
502
503 typedef struct _IMAGEHLP_CBA_READ_MEMORY {
504 DWORD64 addr;
505 PVOID buf;
506 DWORD bytes;
507 DWORD *bytesread;
508 } IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY;
509
510 enum {
511 sevInfo = 0,sevProblem,sevAttn,sevFatal,sevMax
512 };
513
514 typedef struct _IMAGEHLP_CBA_EVENT {
515 DWORD severity;
516 DWORD code;
517 PCHAR desc;
518 PVOID object;
519 } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT;
520
521 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
522 DWORD SizeOfStruct;
523 DWORD64 BaseOfImage;
524 DWORD CheckSum;
525 DWORD TimeDateStamp;
526 CHAR FileName[MAX_PATH];
527 BOOLEAN Reparse;
528 HANDLE hFile;
529 DWORD Flags;
530 } IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
531
532 #define DSLFLAG_MISMATCHED_PDB 0x1
533 #define DSLFLAG_MISMATCHED_DBG 0x2
534
535 #ifdef _IMAGEHLP64
536 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
537 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
538 #else
539 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
540 DWORD SizeOfStruct;
541 DWORD BaseOfImage;
542 DWORD CheckSum;
543 DWORD TimeDateStamp;
544 CHAR FileName[MAX_PATH];
545 BOOLEAN Reparse;
546 HANDLE hFile;
547 } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
548 #endif
549
550 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
551 DWORD SizeOfStruct;
552 DWORD NumberOfDups;
553 PIMAGEHLP_SYMBOL64 Symbol;
554 DWORD SelectedSymbol;
555 } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64;
556
557 #ifdef _IMAGEHLP64
558 #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
559 #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
560 #else
561 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
562 DWORD SizeOfStruct;
563 DWORD NumberOfDups;
564 PIMAGEHLP_SYMBOL Symbol;
565 DWORD SelectedSymbol;
566 } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL;
567 #endif
568
569 WINBOOL IMAGEAPI SymSetParentWindow(HWND hwnd);
570 PCHAR IMAGEAPI SymSetHomeDirectory(PCSTR dir);
571 PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size);
572
573 typedef enum {
574 hdBase = 0,hdSym,hdSrc,hdMax
575 };
576
577 #define SYMOPT_CASE_INSENSITIVE 0x00000001
578 #define SYMOPT_UNDNAME 0x00000002
579 #define SYMOPT_DEFERRED_LOADS 0x00000004
580 #define SYMOPT_NO_CPP 0x00000008
581 #define SYMOPT_LOAD_LINES 0x00000010
582 #define SYMOPT_OMAP_FIND_NEAREST 0x00000020
583 #define SYMOPT_LOAD_ANYTHING 0x00000040
584 #define SYMOPT_IGNORE_CVREC 0x00000080
585 #define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
586 #define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
587 #define SYMOPT_EXACT_SYMBOLS 0x00000400
588 #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
589 #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
590 #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
591 #define SYMOPT_PUBLICS_ONLY 0x00004000
592 #define SYMOPT_NO_PUBLICS 0x00008000
593 #define SYMOPT_AUTO_PUBLICS 0x00010000
594 #define SYMOPT_NO_IMAGE_SEARCH 0x00020000
595 #define SYMOPT_SECURE 0x00040000
596 #define SYMOPT_NO_PROMPTS 0x00080000
597
598 #define SYMOPT_DEBUG 0x80000000
599
600 DWORD IMAGEAPI SymSetOptions(DWORD SymOptions);
601 DWORD IMAGEAPI SymGetOptions(VOID);
602 WINBOOL IMAGEAPI SymCleanup(HANDLE hProcess);
603 WINBOOL IMAGEAPI SymMatchString(LPSTR string,LPSTR expression,WINBOOL fCase);
604
605 typedef WINBOOL (CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext);
606
607 WINBOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,LPSTR Mask,PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles,PVOID UserContext);
608 WINBOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext);
609
610 #ifdef _IMAGEHLP64
611 #define SymEnumerateModules SymEnumerateModules64
612 #else
613 WINBOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext);
614 #endif
615
616 WINBOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext);
617 WINBOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext);
618
619 #ifdef _IMAGEHLP64
620 #define SymEnumerateSymbols SymEnumerateSymbols64
621 #define SymEnumerateSymbolsW SymEnumerateSymbolsW64
622 #else
623 WINBOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
624 WINBOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
625 #endif
626
627 WINBOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext);
628 #ifdef _IMAGEHLP64
629 #define EnumerateLoadedModules EnumerateLoadedModules64
630 #else
631 WINBOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext);
632 #endif
633
634 PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase);
635
636 #ifdef _IMAGEHLP64
637 #define SymFunctionTableAccess SymFunctionTableAccess64
638 #else
639 PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase);
640 #endif
641
642 WINBOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo);
643 WINBOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo);
644
645 #ifdef _IMAGEHLP64
646 #define SymGetModuleInfo SymGetModuleInfo64
647 #define SymGetModuleInfoW SymGetModuleInfoW64
648 #else
649 WINBOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo);
650 WINBOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo);
651 #endif
652
653 DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr);
654
655 #ifdef _IMAGEHLP64
656 #define SymGetModuleBase SymGetModuleBase64
657 #else
658 DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr);
659 #endif
660
661 WINBOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
662
663 #ifdef _IMAGEHLP64
664 #define SymGetSymNext SymGetSymNext64
665 #else
666 WINBOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
667 #endif
668
669 WINBOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
670
671 #ifdef _IMAGEHLP64
672 #define SymGetSymPrev SymGetSymPrev64
673 #else
674 WINBOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
675 #endif
676
677 typedef struct _SRCCODEINFO {
678 DWORD SizeOfStruct;
679 PVOID Key;
680 DWORD64 ModBase;
681 CHAR Obj[MAX_PATH + 1];
682 CHAR FileName[MAX_PATH + 1];
683 DWORD LineNumber;
684 DWORD64 Address;
685 } SRCCODEINFO,*PSRCCODEINFO;
686
687 typedef WINBOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext);
688
689 WINBOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext);
690 WINBOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64);
691
692 #ifdef _IMAGEHLP64
693 #define SymGetLineFromAddr SymGetLineFromAddr64
694 #else
695 WINBOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line);
696 #endif
697
698 WINBOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line);
699
700 #ifdef _IMAGEHLP64
701 #define SymGetLineFromName SymGetLineFromName64
702 #else
703 WINBOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line);
704 #endif
705
706 WINBOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
707
708 #ifdef _IMAGEHLP64
709 #define SymGetLineNext SymGetLineNext64
710 #else
711 WINBOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line);
712 #endif
713
714 WINBOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
715
716 #ifdef _IMAGEHLP64
717 #define SymGetLinePrev SymGetLinePrev64
718 #else
719 WINBOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line);
720 #endif
721
722 WINBOOL IMAGEAPI SymMatchFileName(PSTR FileName,PSTR Match,PSTR *FileNameStop,PSTR *MatchStop);
723 WINBOOL IMAGEAPI SymInitialize(HANDLE hProcess,PSTR UserSearchPath,WINBOOL fInvadeProcess);
724 WINBOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength);
725 WINBOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PSTR SearchPath);
726 DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll);
727
728 #define SLMFLAG_VIRTUAL 0x1
729
730 DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
731
732 #ifdef _IMAGEHLP64
733 #define SymLoadModule SymLoadModule64
734 #else
735 DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll);
736 #endif
737
738 WINBOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll);
739
740 #ifdef _IMAGEHLP64
741 #define SymUnloadModule SymUnloadModule64
742 #else
743 WINBOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll);
744 #endif
745
746 WINBOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength);
747
748 #ifdef _IMAGEHLP64
749 #define SymUnDName SymUnDName64
750 #else
751 WINBOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength);
752 #endif
753
754 WINBOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
755
756 WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext);
757
758 #ifdef _IMAGEHLP64
759 #define SymRegisterCallback SymRegisterCallback64
760 #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
761 #else
762 WINBOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext);
763 WINBOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext);
764 #endif
765
766 typedef struct _IMAGEHLP_SYMBOL_SRC {
767 DWORD sizeofstruct;
768 DWORD type;
769 char file[MAX_PATH];
770 } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC;
771
772 typedef struct _MODULE_TYPE_INFO {
773 USHORT dataLength;
774 USHORT leaf;
775 BYTE data[1];
776 } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO;
777
778 typedef struct _SYMBOL_INFO {
779 ULONG SizeOfStruct;
780 ULONG TypeIndex;
781 ULONG64 Reserved[2];
782 ULONG info;
783 ULONG Size;
784 ULONG64 ModBase;
785 ULONG Flags;
786 ULONG64 Value;
787 ULONG64 Address;
788 ULONG Register;
789 ULONG Scope;
790 ULONG Tag;
791 ULONG NameLen;
792 ULONG MaxNameLen;
793 CHAR Name[1];
794 } SYMBOL_INFO,*PSYMBOL_INFO;
795
796 typedef struct _SYMBOL_INFO_PACKAGE {
797 SYMBOL_INFO si;
798 CHAR name[MAX_SYM_NAME + 1];
799 } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE;
800
801 typedef struct _IMAGEHLP_STACK_FRAME
802 {
803 ULONG64 InstructionOffset;
804 ULONG64 ReturnOffset;
805 ULONG64 FrameOffset;
806 ULONG64 StackOffset;
807 ULONG64 BackingStoreOffset;
808 ULONG64 FuncTableEntry;
809 ULONG64 Params[4];
810 ULONG64 Reserved[5];
811 WINBOOL Virtual;
812 ULONG Reserved2;
813 } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME;
814
815 typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT;
816
817 WINBOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context);
818 WINBOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol);
819 WINBOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol);
820 WINBOOL IMAGEAPI SymFromName(HANDLE hProcess,LPSTR Name,PSYMBOL_INFO Symbol);
821
822 typedef WINBOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext);
823
824 WINBOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
825 WINBOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
826
827 #define SYMENUMFLAG_FULLSRCH 1
828 #define SYMENUMFLAG_SPEEDSRCH 2
829
830 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
831 TI_GET_SYMTAG,TI_GET_SYMNAME,TI_GET_LENGTH,TI_GET_TYPE,TI_GET_TYPEID,TI_GET_BASETYPE,TI_GET_ARRAYINDEXTYPEID,TI_FINDCHILDREN,
832 TI_GET_DATAKIND,TI_GET_ADDRESSOFFSET,TI_GET_OFFSET,TI_GET_VALUE,TI_GET_COUNT,TI_GET_CHILDRENCOUNT,TI_GET_BITPOSITION,TI_GET_VIRTUALBASECLASS,
833 TI_GET_VIRTUALTABLESHAPEID,TI_GET_VIRTUALBASEPOINTEROFFSET,TI_GET_CLASSPARENTID,TI_GET_NESTED,TI_GET_SYMINDEX,TI_GET_LEXICALPARENT,
834 TI_GET_ADDRESS,TI_GET_THISADJUST,TI_GET_UDTKIND,TI_IS_EQUIV_TO,TI_GET_CALLING_CONVENTION
835 } IMAGEHLP_SYMBOL_TYPE_INFO;
836
837 typedef struct _TI_FINDCHILDREN_PARAMS {
838 ULONG Count;
839 ULONG Start;
840 ULONG ChildId[1];
841 } TI_FINDCHILDREN_PARAMS;
842
843 WINBOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo);
844 WINBOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
845 WINBOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,LPSTR Name,PSYMBOL_INFO Symbol);
846 WINBOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
847 WINBOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags);
848
849 typedef WINBOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData);
850
851 WINBOOL WINAPI DbgHelpCreateUserDump(LPSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
852 WINBOOL WINAPI DbgHelpCreateUserDumpW(LPWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
853 WINBOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol);
854
855 #ifdef _IMAGEHLP64
856 #define SymGetSymFromAddr SymGetSymFromAddr64
857 #else
858 WINBOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol);
859 #endif
860
861 WINBOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL64 Symbol);
862
863 #ifdef _IMAGEHLP64
864 #define SymGetSymFromName SymGetSymFromName64
865 #else
866 WINBOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL Symbol);
867 #endif
868
869 DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FilePath);
870 DBHLP_DEPRECIATED WINBOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,DWORD one,DWORD two,DWORD three,LPSTR FilePath);
871 DBHLP_DEPRECIATED WINBOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
872
873 #define SYMF_OMAP_GENERATED 0x00000001
874 #define SYMF_OMAP_MODIFIED 0x00000002
875 #define SYMF_REGISTER 0x00000008
876 #define SYMF_REGREL 0x00000010
877 #define SYMF_FRAMEREL 0x00000020
878 #define SYMF_PARAMETER 0x00000040
879 #define SYMF_LOCAL 0x00000080
880 #define SYMF_CONSTANT 0x00000100
881 #define SYMF_EXPORT 0x00000200
882 #define SYMF_FORWARDER 0x00000400
883 #define SYMF_FUNCTION 0x00000800
884 #define SYMF_VIRTUAL 0x00001000
885 #define SYMF_THUNK 0x00002000
886 #define SYMF_TLSREL 0x00004000
887
888 #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
889 #define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER
890 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL
891 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL
892 #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER
893 #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL
894 #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT
895 #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION
896 #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL
897 #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK
898 #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL
899
900 #include <pshpack4.h>
901
902 #define MINIDUMP_SIGNATURE ('PMDM')
903 #define MINIDUMP_VERSION (42899)
904 typedef DWORD RVA;
905 typedef ULONG64 RVA64;
906
907 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
908 ULONG32 DataSize;
909 RVA Rva;
910 } MINIDUMP_LOCATION_DESCRIPTOR;
911
912 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
913 ULONG64 DataSize;
914 RVA64 Rva;
915 } MINIDUMP_LOCATION_DESCRIPTOR64;
916
917 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
918 ULONG64 StartOfMemoryRange;
919 MINIDUMP_LOCATION_DESCRIPTOR Memory;
920 } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR;
921
922 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
923 ULONG64 StartOfMemoryRange;
924 ULONG64 DataSize;
925 } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64;
926
927 typedef struct _MINIDUMP_HEADER {
928 ULONG32 Signature;
929 ULONG32 Version;
930 ULONG32 NumberOfStreams;
931 RVA StreamDirectoryRva;
932 ULONG32 CheckSum;
933 __MINGW_EXTENSION union {
934 ULONG32 Reserved;
935 ULONG32 TimeDateStamp;
936 };
937 ULONG64 Flags;
938 } MINIDUMP_HEADER,*PMINIDUMP_HEADER;
939
940 typedef struct _MINIDUMP_DIRECTORY {
941 ULONG32 StreamType;
942 MINIDUMP_LOCATION_DESCRIPTOR Location;
943 } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY;
944
945 typedef struct _MINIDUMP_STRING {
946 ULONG32 Length;
947 WCHAR Buffer [0];
948 } MINIDUMP_STRING,*PMINIDUMP_STRING;
949
950 typedef enum _MINIDUMP_STREAM_TYPE {
951 UnusedStream = 0,ReservedStream0 = 1,ReservedStream1 = 2,ThreadListStream = 3,ModuleListStream = 4,MemoryListStream = 5,
952 ExceptionStream = 6,SystemInfoStream = 7,ThreadExListStream = 8,Memory64ListStream = 9,CommentStreamA = 10,CommentStreamW = 11,
953 HandleDataStream = 12,FunctionTableStream = 13,UnloadedModuleListStream = 14,MiscInfoStream = 15,LastReservedStream = 0xffff
954 } MINIDUMP_STREAM_TYPE;
955
956 typedef union _CPU_INFORMATION {
957 struct {
958 ULONG32 VendorId [3 ];
959 ULONG32 VersionInformation;
960 ULONG32 FeatureInformation;
961 ULONG32 AMDExtendedCpuFeatures;
962 } X86CpuInfo;
963 struct {
964 ULONG64 ProcessorFeatures [2 ];
965 } OtherCpuInfo;
966 } CPU_INFORMATION,*PCPU_INFORMATION;
967
968 typedef struct _MINIDUMP_SYSTEM_INFO {
969 USHORT ProcessorArchitecture;
970 USHORT ProcessorLevel;
971 USHORT ProcessorRevision;
972 __MINGW_EXTENSION union {
973 USHORT Reserved0;
974 __MINGW_EXTENSION struct {
975 UCHAR NumberOfProcessors;
976 UCHAR ProductType;
977 };
978 };
979 ULONG32 MajorVersion;
980 ULONG32 MinorVersion;
981 ULONG32 BuildNumber;
982 ULONG32 PlatformId;
983 RVA CSDVersionRva;
984 __MINGW_EXTENSION union {
985 ULONG32 Reserved1;
986 __MINGW_EXTENSION struct {
987 USHORT SuiteMask;
988 USHORT Reserved2;
989 };
990 };
991 CPU_INFORMATION Cpu;
992 } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO;
993
994 C_ASSERT (sizeof (((PPROCESS_INFORMATION)0)->dwThreadId)==4);
995
996 typedef struct _MINIDUMP_THREAD {
997 ULONG32 ThreadId;
998 ULONG32 SuspendCount;
999 ULONG32 PriorityClass;
1000 ULONG32 Priority;
1001 ULONG64 Teb;
1002 MINIDUMP_MEMORY_DESCRIPTOR Stack;
1003 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1004 } MINIDUMP_THREAD,*PMINIDUMP_THREAD;
1005
1006 typedef struct _MINIDUMP_THREAD_LIST {
1007 ULONG32 NumberOfThreads;
1008 MINIDUMP_THREAD Threads [0];
1009 } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST;
1010
1011 typedef struct _MINIDUMP_THREAD_EX {
1012 ULONG32 ThreadId;
1013 ULONG32 SuspendCount;
1014 ULONG32 PriorityClass;
1015 ULONG32 Priority;
1016 ULONG64 Teb;
1017 MINIDUMP_MEMORY_DESCRIPTOR Stack;
1018 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1019 MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
1020 } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX;
1021
1022 typedef struct _MINIDUMP_THREAD_EX_LIST {
1023 ULONG32 NumberOfThreads;
1024 MINIDUMP_THREAD_EX Threads [0];
1025 } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST;
1026
1027 typedef struct _MINIDUMP_EXCEPTION {
1028 ULONG32 ExceptionCode;
1029 ULONG32 ExceptionFlags;
1030 ULONG64 ExceptionRecord;
1031 ULONG64 ExceptionAddress;
1032 ULONG32 NumberParameters;
1033 ULONG32 __unusedAlignment;
1034 ULONG64 ExceptionInformation [EXCEPTION_MAXIMUM_PARAMETERS ];
1035 } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION;
1036
1037 typedef struct MINIDUMP_EXCEPTION_STREAM {
1038 ULONG32 ThreadId;
1039 ULONG32 __alignment;
1040 MINIDUMP_EXCEPTION ExceptionRecord;
1041 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1042 } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM;
1043
1044 typedef struct _MINIDUMP_MODULE {
1045 ULONG64 BaseOfImage;
1046 ULONG32 SizeOfImage;
1047 ULONG32 CheckSum;
1048 ULONG32 TimeDateStamp;
1049 RVA ModuleNameRva;
1050 VS_FIXEDFILEINFO VersionInfo;
1051 MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
1052 MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
1053 ULONG64 Reserved0;
1054 ULONG64 Reserved1;
1055 } MINIDUMP_MODULE,*PMINIDUMP_MODULE;
1056
1057 typedef struct _MINIDUMP_MODULE_LIST {
1058 ULONG32 NumberOfModules;
1059 MINIDUMP_MODULE Modules [0 ];
1060 } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST;
1061
1062 typedef struct _MINIDUMP_MEMORY_LIST {
1063 ULONG32 NumberOfMemoryRanges;
1064 MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0];
1065 } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST;
1066
1067 typedef struct _MINIDUMP_MEMORY64_LIST {
1068 ULONG64 NumberOfMemoryRanges;
1069 RVA64 BaseRva;
1070 MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0];
1071 } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST;
1072
1073 typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
1074 DWORD ThreadId;
1075 PEXCEPTION_POINTERS ExceptionPointers;
1076 WINBOOL ClientPointers;
1077 } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION;
1078
1079 typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
1080 DWORD ThreadId;
1081 ULONG64 ExceptionRecord;
1082 ULONG64 ContextRecord;
1083 WINBOOL ClientPointers;
1084 } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64;
1085
1086 typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
1087 ULONG64 Handle;
1088 RVA TypeNameRva;
1089 RVA ObjectNameRva;
1090 ULONG32 Attributes;
1091 ULONG32 GrantedAccess;
1092 ULONG32 HandleCount;
1093 ULONG32 PointerCount;
1094 } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR;
1095
1096 typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
1097 ULONG32 SizeOfHeader;
1098 ULONG32 SizeOfDescriptor;
1099 ULONG32 NumberOfDescriptors;
1100 ULONG32 Reserved;
1101 } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM;
1102
1103 typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
1104 ULONG64 MinimumAddress;
1105 ULONG64 MaximumAddress;
1106 ULONG64 BaseAddress;
1107 ULONG32 EntryCount;
1108 ULONG32 SizeOfAlignPad;
1109 } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
1110
1111 typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
1112 ULONG32 SizeOfHeader;
1113 ULONG32 SizeOfDescriptor;
1114 ULONG32 SizeOfNativeDescriptor;
1115 ULONG32 SizeOfFunctionEntry;
1116 ULONG32 NumberOfDescriptors;
1117 ULONG32 SizeOfAlignPad;
1118 } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM;
1119
1120 typedef struct _MINIDUMP_UNLOADED_MODULE {
1121 ULONG64 BaseOfImage;
1122 ULONG32 SizeOfImage;
1123 ULONG32 CheckSum;
1124 ULONG32 TimeDateStamp;
1125 RVA ModuleNameRva;
1126 } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE;
1127
1128 typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
1129 ULONG32 SizeOfHeader;
1130 ULONG32 SizeOfEntry;
1131 ULONG32 NumberOfEntries;
1132 } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST;
1133
1134 #define MINIDUMP_MISC1_PROCESS_ID 0x00000001
1135 #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
1136
1137 typedef struct _MINIDUMP_MISC_INFO {
1138 ULONG32 SizeOfInfo;
1139 ULONG32 Flags1;
1140 ULONG32 ProcessId;
1141 ULONG32 ProcessCreateTime;
1142 ULONG32 ProcessUserTime;
1143 ULONG32 ProcessKernelTime;
1144 } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO;
1145
1146 typedef struct _MINIDUMP_USER_RECORD {
1147 ULONG32 Type;
1148 MINIDUMP_LOCATION_DESCRIPTOR Memory;
1149 } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD;
1150
1151 typedef struct _MINIDUMP_USER_STREAM {
1152 ULONG32 Type;
1153 ULONG BufferSize;
1154 PVOID Buffer;
1155 } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM;
1156
1157 typedef struct _MINIDUMP_USER_STREAM_INFORMATION {
1158 ULONG UserStreamCount;
1159 PMINIDUMP_USER_STREAM UserStreamArray;
1160 } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION;
1161
1162 typedef enum _MINIDUMP_CALLBACK_TYPE {
1163 ModuleCallback,ThreadCallback,ThreadExCallback,IncludeThreadCallback,IncludeModuleCallback,MemoryCallback
1164 } MINIDUMP_CALLBACK_TYPE;
1165
1166 typedef struct _MINIDUMP_THREAD_CALLBACK {
1167 ULONG ThreadId;
1168 HANDLE ThreadHandle;
1169 CONTEXT Context;
1170 ULONG SizeOfContext;
1171 ULONG64 StackBase;
1172 ULONG64 StackEnd;
1173 } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK;
1174
1175 typedef struct _MINIDUMP_THREAD_EX_CALLBACK {
1176 ULONG ThreadId;
1177 HANDLE ThreadHandle;
1178 CONTEXT Context;
1179 ULONG SizeOfContext;
1180 ULONG64 StackBase;
1181 ULONG64 StackEnd;
1182 ULONG64 BackingStoreBase;
1183 ULONG64 BackingStoreEnd;
1184 } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK;
1185
1186 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK {
1187 ULONG ThreadId;
1188 } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK;
1189
1190 typedef enum _THREAD_WRITE_FLAGS {
1191 ThreadWriteThread = 0x0001,ThreadWriteStack = 0x0002,ThreadWriteContext = 0x0004,ThreadWriteBackingStore = 0x0008,
1192 ThreadWriteInstructionWindow = 0x0010,ThreadWriteThreadData = 0x0020
1193 } THREAD_WRITE_FLAGS;
1194
1195 typedef struct _MINIDUMP_MODULE_CALLBACK {
1196 PWCHAR FullPath;
1197 ULONG64 BaseOfImage;
1198 ULONG SizeOfImage;
1199 ULONG CheckSum;
1200 ULONG TimeDateStamp;
1201 VS_FIXEDFILEINFO VersionInfo;
1202 PVOID CvRecord;
1203 ULONG SizeOfCvRecord;
1204 PVOID MiscRecord;
1205 ULONG SizeOfMiscRecord;
1206 } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK;
1207
1208 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK {
1209 ULONG64 BaseOfImage;
1210 } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK;
1211
1212 typedef enum _MODULE_WRITE_FLAGS {
1213 ModuleWriteModule = 0x0001,ModuleWriteDataSeg = 0x0002,ModuleWriteMiscRecord = 0x0004,ModuleWriteCvRecord = 0x0008,
1214 ModuleReferencedByMemory = 0x0010
1215 } MODULE_WRITE_FLAGS;
1216
1217 typedef struct _MINIDUMP_CALLBACK_INPUT {
1218 ULONG ProcessId;
1219 HANDLE ProcessHandle;
1220 ULONG CallbackType;
1221 __MINGW_EXTENSION union {
1222 MINIDUMP_THREAD_CALLBACK Thread;
1223 MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
1224 MINIDUMP_MODULE_CALLBACK Module;
1225 MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
1226 MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
1227 };
1228 } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT;
1229
1230 typedef struct _MINIDUMP_CALLBACK_OUTPUT {
1231 __MINGW_EXTENSION union {
1232 ULONG ModuleWriteFlags;
1233 ULONG ThreadWriteFlags;
1234 __MINGW_EXTENSION struct {
1235 ULONG64 MemoryBase;
1236 ULONG MemorySize;
1237 };
1238 };
1239 } MINIDUMP_CALLBACK_OUTPUT,*PMINIDUMP_CALLBACK_OUTPUT;
1240
1241 typedef enum _MINIDUMP_TYPE {
1242 MiniDumpNormal = 0x0000,MiniDumpWithDataSegs = 0x0001,MiniDumpWithFullMemory = 0x0002,MiniDumpWithHandleData = 0x0004,
1243 MiniDumpFilterMemory = 0x0008,MiniDumpScanMemory = 0x0010,MiniDumpWithUnloadedModules = 0x0020,MiniDumpWithIndirectlyReferencedMemory = 0x0040,
1244 MiniDumpFilterModulePaths = 0x0080,MiniDumpWithProcessThreadData = 0x0100,MiniDumpWithPrivateReadWriteMemory = 0x0200,
1245 MiniDumpWithoutOptionalData = 0x0400
1246 } MINIDUMP_TYPE;
1247
1248 typedef WINBOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
1249
1250 typedef struct _MINIDUMP_CALLBACK_INFORMATION {
1251 MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
1252 PVOID CallbackParam;
1253 } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION;
1254
1255 #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
1256
1257 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);
1258 WINBOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize);
1259
1260 #include <poppack.h>
1261
1262 #ifdef __cplusplus
1263 }
1264 #endif
1265 #endif