CoCalc -- dbghelp.h

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/src/gallium/auxiliary/util/dbghelp.h
⁴⁵⁶¹ views
1
/**
2
 * This file has no copyright assigned and is placed in the Public Domain.
3
 * This file is part of the w64 mingw-runtime package.
4
 * No warranty is given; refer to the file DISCLAIMER.PD within this package.
5
 */
6
#ifndef _DBGHELP_
7
#define _DBGHELP_
8

9
#ifdef _WIN64
10
#ifndef _IMAGEHLP64
11
#define _IMAGEHLP64
12
#endif
13
#endif
14

15
#ifdef __cplusplus
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 BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
48
  typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR filename,PVOID context);
49
  typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
50

51
  typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR);
52
  typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
53
  typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
54
  typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64);
55
  typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context);
56
  typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
57
  typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR);
58

59
  HANDLE IMAGEAPI FindDebugInfoFile(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath);
60
  HANDLE IMAGEAPI FindDebugInfoFileEx(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData);
61
  BOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context);
62
  HANDLE IMAGEAPI FindExecutableImage(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath);
63
  HANDLE IMAGEAPI FindExecutableImageEx(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData);
64
  PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base);
65
  PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader);
66
  PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size);
67
  PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva);
68
  PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection);
69

70
#define SSRVOPT_CALLBACK 0x0001
71
#define SSRVOPT_DWORD 0x0002
72
#define SSRVOPT_DWORDPTR 0x0004
73
#define SSRVOPT_GUIDPTR 0x0008
74
#define SSRVOPT_OLDGUIDPTR 0x0010
75
#define SSRVOPT_UNATTENDED 0x0020
76
#define SSRVOPT_NOCOPY 0x0040
77
#define SSRVOPT_PARENTWIN 0x0080
78
#define SSRVOPT_PARAMTYPE 0x0100
79
#define SSRVOPT_SECURE 0x0200
80
#define SSRVOPT_TRACE 0x0400
81
#define SSRVOPT_SETCONTEXT 0x0800
82
#define SSRVOPT_PROXY 0x1000
83
#define SSRVOPT_DOWNSTREAM_STORE 0x2000
84
#define SSRVOPT_RESET ((ULONG_PTR)-1)
85

86
#define SSRVACTION_TRACE 1
87
#define SSRVACTION_QUERYCANCEL 2
88
#define SSRVACTION_EVENT 3
89

90
#ifndef _WIN64
91

92
  typedef struct _IMAGE_DEBUG_INFORMATION {
93
    LIST_ENTRY List;
94
    DWORD ReservedSize;
95
    PVOID ReservedMappedBase;
96
    USHORT ReservedMachine;
97
    USHORT ReservedCharacteristics;
98
    DWORD ReservedCheckSum;
99
    DWORD ImageBase;
100
    DWORD SizeOfImage;
101
    DWORD ReservedNumberOfSections;
102
    PIMAGE_SECTION_HEADER ReservedSections;
103
    DWORD ReservedExportedNamesSize;
104
    PSTR ReservedExportedNames;
105
    DWORD ReservedNumberOfFunctionTableEntries;
106
    PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
107
    DWORD ReservedLowestFunctionStartingAddress;
108
    DWORD ReservedHighestFunctionEndingAddress;
109
    DWORD ReservedNumberOfFpoTableEntries;
110
    PFPO_DATA ReservedFpoTableEntries;
111
    DWORD SizeOfCoffSymbols;
112
    PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
113
    DWORD ReservedSizeOfCodeViewSymbols;
114
    PVOID ReservedCodeViewSymbols;
115
    PSTR ImageFilePath;
116
    PSTR ImageFileName;
117
    PSTR ReservedDebugFilePath;
118
    DWORD ReservedTimeDateStamp;
119
    BOOL ReservedRomImage;
120
    PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
121
    DWORD ReservedNumberOfDebugDirectories;
122
    DWORD ReservedOriginalFunctionTableBaseAddress;
123
    DWORD Reserved[2 ];
124
  } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION;
125

126
  PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase);
127
  BOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo);
128
#endif
129

130
  typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData);
131

132
  BOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer);
133
  BOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData);
134
  BOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath);
135

136
#define UNDNAME_COMPLETE (0x0000)
137
#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001)
138
#define UNDNAME_NO_MS_KEYWORDS (0x0002)
139
#define UNDNAME_NO_FUNCTION_RETURNS (0x0004)
140
#define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
141
#define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
142
#define UNDNAME_NO_MS_THISTYPE (0x0020)
143
#define UNDNAME_NO_CV_THISTYPE (0x0040)
144
#define UNDNAME_NO_THISTYPE (0x0060)
145
#define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080)
146
#define UNDNAME_NO_THROW_SIGNATURES (0x0100)
147
#define UNDNAME_NO_MEMBER_TYPE (0x0200)
148
#define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
149
#define UNDNAME_32_BIT_DECODE (0x0800)
150
#define UNDNAME_NAME_ONLY (0x1000)
151
#define UNDNAME_NO_ARGUMENTS (0x2000)
152
#define UNDNAME_NO_SPECIAL_SYMS (0x4000)
153

154
  DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags);
155

156
#define DBHHEADER_DEBUGDIRS 0x1
157

158
  typedef struct _MODLOAD_DATA {
159
    DWORD ssize;
160
    DWORD ssig;
161
    PVOID data;
162
    DWORD size;
163
    DWORD flags;
164
  } MODLOAD_DATA,*PMODLOAD_DATA;
165

166
  typedef enum {
167
    AddrMode1616,AddrMode1632,AddrModeReal,AddrModeFlat
168
  } ADDRESS_MODE;
169

170
  typedef struct _tagADDRESS64 {
171
    DWORD64 Offset;
172
    WORD Segment;
173
    ADDRESS_MODE Mode;
174
  } ADDRESS64,*LPADDRESS64;
175

176
#ifdef _IMAGEHLP64
177
#define ADDRESS ADDRESS64
178
#define LPADDRESS LPADDRESS64
179
#else
180
  typedef struct _tagADDRESS {
181
    DWORD Offset;
182
    WORD Segment;
183
    ADDRESS_MODE Mode;
184
  } ADDRESS,*LPADDRESS;
185

186
  static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) {
187
    a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
188
    a64->Segment = a32->Segment;
189
    a64->Mode = a32->Mode;
190
  }
191

192
  static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) {
193
    a32->Offset = (ULONG)a64->Offset;
194
    a32->Segment = a64->Segment;
195
    a32->Mode = a64->Mode;
196
  }
197
#endif
198

199
  typedef struct _KDHELP64 {
200
    DWORD64 Thread;
201
    DWORD ThCallbackStack;
202
    DWORD ThCallbackBStore;
203
    DWORD NextCallback;
204
    DWORD FramePointer;
205
    DWORD64 KiCallUserMode;
206
    DWORD64 KeUserCallbackDispatcher;
207
    DWORD64 SystemRangeStart;
208
    DWORD64 Reserved[8];
209
  } KDHELP64,*PKDHELP64;
210

211
#ifdef _IMAGEHLP64
212
#define KDHELP KDHELP64
213
#define PKDHELP PKDHELP64
214
#else
215
  typedef struct _KDHELP {
216
    DWORD Thread;
217
    DWORD ThCallbackStack;
218
    DWORD NextCallback;
219
    DWORD FramePointer;
220
    DWORD KiCallUserMode;
221
    DWORD KeUserCallbackDispatcher;
222
    DWORD SystemRangeStart;
223
    DWORD ThCallbackBStore;
224
    DWORD Reserved[8];
225
  } KDHELP,*PKDHELP;
226

227
  static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) {
228
    p64->Thread = p32->Thread;
229
    p64->ThCallbackStack = p32->ThCallbackStack;
230
    p64->NextCallback = p32->NextCallback;
231
    p64->FramePointer = p32->FramePointer;
232
    p64->KiCallUserMode = p32->KiCallUserMode;
233
    p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
234
    p64->SystemRangeStart = p32->SystemRangeStart;
235
  }
236
#endif
237

238
  typedef struct _tagSTACKFRAME64 {
239
    ADDRESS64 AddrPC;
240
    ADDRESS64 AddrReturn;
241
    ADDRESS64 AddrFrame;
242
    ADDRESS64 AddrStack;
243
    ADDRESS64 AddrBStore;
244
    PVOID FuncTableEntry;
245
    DWORD64 Params[4];
246
    BOOL Far;
247
    BOOL Virtual;
248
    DWORD64 Reserved[3];
249
    KDHELP64 KdHelp;
250
  } STACKFRAME64,*LPSTACKFRAME64;
251

252
#ifdef _IMAGEHLP64
253
#define STACKFRAME STACKFRAME64
254
#define LPSTACKFRAME LPSTACKFRAME64
255
#else
256
  typedef struct _tagSTACKFRAME {
257
    ADDRESS AddrPC;
258
    ADDRESS AddrReturn;
259
    ADDRESS AddrFrame;
260
    ADDRESS AddrStack;
261
    PVOID FuncTableEntry;
262
    DWORD Params[4];
263
    BOOL Far;
264
    BOOL Virtual;
265
    DWORD Reserved[3];
266
    KDHELP KdHelp;
267
    ADDRESS AddrBStore;
268
  } STACKFRAME,*LPSTACKFRAME;
269
#endif
270

271
  typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead);
272
  typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase);
273
  typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address);
274
  typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr);
275

276
  BOOL IMAGEAPI StackWalk64(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME64 StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
277

278
#ifdef _IMAGEHLP64
279
#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
280
#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
281
#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
282
#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
283
#define StackWalk StackWalk64
284
#else
285
  typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead);
286
  typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase);
287
  typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address);
288
  typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr);
289

290
  BOOL IMAGEAPI StackWalk(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
291
#endif
292

293
#define API_VERSION_NUMBER 9
294

295
  typedef struct API_VERSION {
296
    USHORT MajorVersion;
297
    USHORT MinorVersion;
298
    USHORT Revision;
299
    USHORT Reserved;
300
  } API_VERSION,*LPAPI_VERSION;
301

302
  LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
303
  LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion);
304
  DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module);
305

306
  typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext);
307
  typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
308
  typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
309
  typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext);
310
  typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext);
311
  typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext);
312
  typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext);
313

314
#ifdef _IMAGEHLP64
315
#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
316
#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
317
#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
318
#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
319
#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
320
#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
321
#else
322
  typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR ModuleName,ULONG BaseOfDll,PVOID UserContext);
323
  typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
324
  typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
325
  typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext);
326
  typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext);
327
#endif
328

329
#define SYMFLAG_VALUEPRESENT 0x00000001
330
#define SYMFLAG_REGISTER 0x00000008
331
#define SYMFLAG_REGREL 0x00000010
332
#define SYMFLAG_FRAMEREL 0x00000020
333
#define SYMFLAG_PARAMETER 0x00000040
334
#define SYMFLAG_LOCAL 0x00000080
335
#define SYMFLAG_CONSTANT 0x00000100
336
#define SYMFLAG_EXPORT 0x00000200
337
#define SYMFLAG_FORWARDER 0x00000400
338
#define SYMFLAG_FUNCTION 0x00000800
339
#define SYMFLAG_VIRTUAL 0x00001000
340
#define SYMFLAG_THUNK 0x00002000
341
#define SYMFLAG_TLSREL 0x00004000
342

343
  typedef enum {
344
    SymNone = 0,SymCoff,SymCv,SymPdb,SymExport,SymDeferred,SymSym,SymDia,SymVirtual,NumSymTypes
345
  } SYM_TYPE;
346

347
  typedef struct _IMAGEHLP_SYMBOL64 {
348
    DWORD SizeOfStruct;
349
    DWORD64 Address;
350
    DWORD Size;
351
    DWORD Flags;
352
    DWORD MaxNameLength;
353
    CHAR Name[1];
354
  } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64;
355

356
  typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
357
    IMAGEHLP_SYMBOL64 sym;
358
    CHAR name[MAX_SYM_NAME + 1];
359
  } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE;
360

361
#ifdef _IMAGEHLP64
362

363
#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
364
#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
365
#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
366
#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
367
#else
368

369
  typedef struct _IMAGEHLP_SYMBOL {
370
    DWORD SizeOfStruct;
371
    DWORD Address;
372
    DWORD Size;
373
    DWORD Flags;
374
    DWORD MaxNameLength;
375
    CHAR Name[1];
376
  } IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL;
377

378
  typedef struct _IMAGEHLP_SYMBOL_PACKAGE {
379
    IMAGEHLP_SYMBOL sym;
380
    CHAR name[MAX_SYM_NAME + 1];
381
  } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE;
382
#endif
383

384
  typedef struct _IMAGEHLP_MODULE64 {
385
    DWORD SizeOfStruct;
386
    DWORD64 BaseOfImage;
387
    DWORD ImageSize;
388
    DWORD TimeDateStamp;
389
    DWORD CheckSum;
390
    DWORD NumSyms;
391
    SYM_TYPE SymType;
392
    CHAR ModuleName[32];
393
    CHAR ImageName[256];
394
    CHAR LoadedImageName[256];
395
    CHAR LoadedPdbName[256];
396
    DWORD CVSig;
397
    CHAR CVData[MAX_PATH*3];
398
    DWORD PdbSig;
399
    GUID PdbSig70;
400
    DWORD PdbAge;
401
    BOOL PdbUnmatched;
402
    BOOL DbgUnmatched;
403
    BOOL LineNumbers;
404
    BOOL GlobalSymbols;
405
    BOOL TypeInfo;
406
  } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64;
407

408
  typedef struct _IMAGEHLP_MODULE64W {
409
    DWORD SizeOfStruct;
410
    DWORD64 BaseOfImage;
411
    DWORD ImageSize;
412
    DWORD TimeDateStamp;
413
    DWORD CheckSum;
414
    DWORD NumSyms;
415
    SYM_TYPE SymType;
416
    WCHAR ModuleName[32];
417
    WCHAR ImageName[256];
418
    WCHAR LoadedImageName[256];
419
    WCHAR LoadedPdbName[256];
420
    DWORD CVSig;
421
    WCHAR CVData[MAX_PATH*3];
422
    DWORD PdbSig;
423
    GUID PdbSig70;
424
    DWORD PdbAge;
425
    BOOL PdbUnmatched;
426
    BOOL DbgUnmatched;
427
    BOOL LineNumbers;
428
    BOOL GlobalSymbols;
429
    BOOL TypeInfo;
430
  } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64;
431

432
#ifdef _IMAGEHLP64
433
#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
434
#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
435
#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
436
#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
437
#else
438
  typedef struct _IMAGEHLP_MODULE {
439
    DWORD SizeOfStruct;
440
    DWORD BaseOfImage;
441
    DWORD ImageSize;
442
    DWORD TimeDateStamp;
443
    DWORD CheckSum;
444
    DWORD NumSyms;
445
    SYM_TYPE SymType;
446
    CHAR ModuleName[32];
447
    CHAR ImageName[256];
448
    CHAR LoadedImageName[256];
449
  } IMAGEHLP_MODULE,*PIMAGEHLP_MODULE;
450

451
  typedef struct _IMAGEHLP_MODULEW {
452
    DWORD SizeOfStruct;
453
    DWORD BaseOfImage;
454
    DWORD ImageSize;
455
    DWORD TimeDateStamp;
456
    DWORD CheckSum;
457
    DWORD NumSyms;
458
    SYM_TYPE SymType;
459
    WCHAR ModuleName[32];
460
    WCHAR ImageName[256];
461
    WCHAR LoadedImageName[256];
462
  } IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW;
463
#endif
464

465
  typedef struct _IMAGEHLP_LINE64 {
466
    DWORD SizeOfStruct;
467
    PVOID Key;
468
    DWORD LineNumber;
469
    PCHAR FileName;
470
    DWORD64 Address;
471
  } IMAGEHLP_LINE64,*PIMAGEHLP_LINE64;
472

473
#ifdef _IMAGEHLP64
474
#define IMAGEHLP_LINE IMAGEHLP_LINE64
475
#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
476
#else
477
  typedef struct _IMAGEHLP_LINE {
478
    DWORD SizeOfStruct;
479
    PVOID Key;
480
    DWORD LineNumber;
481
    PCHAR FileName;
482
    DWORD Address;
483
  } IMAGEHLP_LINE,*PIMAGEHLP_LINE;
484
#endif
485

486
  typedef struct _SOURCEFILE {
487
    DWORD64 ModBase;
488
    PCHAR FileName;
489
  } SOURCEFILE,*PSOURCEFILE;
490

491
#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
492
#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
493
#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
494
#define CBA_SYMBOLS_UNLOADED 0x00000004
495
#define CBA_DUPLICATE_SYMBOL 0x00000005
496
#define CBA_READ_MEMORY 0x00000006
497
#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
498
#define CBA_SET_OPTIONS 0x00000008
499
#define CBA_EVENT 0x00000010
500
#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
501
#define CBA_DEBUG_INFO 0x10000000
502

503
  typedef struct _IMAGEHLP_CBA_READ_MEMORY {
504
    DWORD64 addr;
505
    PVOID buf;
506
    DWORD bytes;
507
    DWORD *bytesread;
508
  } IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY;
509

510
  enum {
511
    sevInfo = 0,sevProblem,sevAttn,sevFatal,sevMax
512
  };
513

514
  typedef struct _IMAGEHLP_CBA_EVENT {
515
    DWORD severity;
516
    DWORD code;
517
    PCHAR desc;
518
    PVOID object;
519
  } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT;
520

521
  typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
522
    DWORD SizeOfStruct;
523
    DWORD64 BaseOfImage;
524
    DWORD CheckSum;
525
    DWORD TimeDateStamp;
526
    CHAR FileName[MAX_PATH];
527
    BOOLEAN Reparse;
528
    HANDLE hFile;
529
    DWORD Flags;
530
  } IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
531

532
#define DSLFLAG_MISMATCHED_PDB 0x1
533
#define DSLFLAG_MISMATCHED_DBG 0x2
534

535
#ifdef _IMAGEHLP64
536
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
537
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
538
#else
539
  typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
540
    DWORD SizeOfStruct;
541
    DWORD BaseOfImage;
542
    DWORD CheckSum;
543
    DWORD TimeDateStamp;
544
    CHAR FileName[MAX_PATH];
545
    BOOLEAN Reparse;
546
    HANDLE hFile;
547
  } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
548
#endif
549

550
  typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
551
    DWORD SizeOfStruct;
552
    DWORD NumberOfDups;
553
    PIMAGEHLP_SYMBOL64 Symbol;
554
    DWORD SelectedSymbol;
555
  } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64;
556

557
#ifdef _IMAGEHLP64
558
#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
559
#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
560
#else
561
  typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
562
    DWORD SizeOfStruct;
563
    DWORD NumberOfDups;
564
    PIMAGEHLP_SYMBOL Symbol;
565
    DWORD SelectedSymbol;
566
  } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL;
567
#endif
568

569
  BOOL IMAGEAPI SymSetParentWindow(HWND hwnd);
570
  PCHAR IMAGEAPI SymSetHomeDirectory(PCSTR dir);
571
  PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size);
572

573
  enum {
574
    hdBase = 0,hdSym,hdSrc,hdMax
575
  };
576

577
#define SYMOPT_CASE_INSENSITIVE 0x00000001
578
#define SYMOPT_UNDNAME 0x00000002
579
#define SYMOPT_DEFERRED_LOADS 0x00000004
580
#define SYMOPT_NO_CPP 0x00000008
581
#define SYMOPT_LOAD_LINES 0x00000010
582
#define SYMOPT_OMAP_FIND_NEAREST 0x00000020
583
#define SYMOPT_LOAD_ANYTHING 0x00000040
584
#define SYMOPT_IGNORE_CVREC 0x00000080
585
#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
586
#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
587
#define SYMOPT_EXACT_SYMBOLS 0x00000400
588
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
589
#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
590
#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
591
#define SYMOPT_PUBLICS_ONLY 0x00004000
592
#define SYMOPT_NO_PUBLICS 0x00008000
593
#define SYMOPT_AUTO_PUBLICS 0x00010000
594
#define SYMOPT_NO_IMAGE_SEARCH 0x00020000
595
#define SYMOPT_SECURE 0x00040000
596
#define SYMOPT_NO_PROMPTS 0x00080000
597

598
#define SYMOPT_DEBUG 0x80000000
599

600
  DWORD IMAGEAPI SymSetOptions(DWORD SymOptions);
601
  DWORD IMAGEAPI SymGetOptions(VOID);
602
  BOOL IMAGEAPI SymCleanup(HANDLE hProcess);
603
  BOOL IMAGEAPI SymMatchString(LPSTR string,LPSTR expression,BOOL fCase);
604

605
  typedef BOOL (CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext);
606

607
  BOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,LPSTR Mask,PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles,PVOID UserContext);
608
  BOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext);
609

610
#ifdef _IMAGEHLP64
611
#define SymEnumerateModules SymEnumerateModules64
612
#else
613
  BOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext);
614
#endif
615

616
  BOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext);
617
  BOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext);
618

619
#ifdef _IMAGEHLP64
620
#define SymEnumerateSymbols SymEnumerateSymbols64
621
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
622
#else
623
  BOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
624
  BOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
625
#endif
626

627
  BOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext);
628
#ifdef _IMAGEHLP64
629
#define EnumerateLoadedModules EnumerateLoadedModules64
630
#else
631
  BOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext);
632
#endif
633

634
  PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase);
635

636
#ifdef _IMAGEHLP64
637
#define SymFunctionTableAccess SymFunctionTableAccess64
638
#else
639
  PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase);
640
#endif
641

642
  BOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo);
643
  BOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo);
644

645
#ifdef _IMAGEHLP64
646
#define SymGetModuleInfo SymGetModuleInfo64
647
#define SymGetModuleInfoW SymGetModuleInfoW64
648
#else
649
  BOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo);
650
  BOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo);
651
#endif
652

653
  DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr);
654

655
#ifdef _IMAGEHLP64
656
#define SymGetModuleBase SymGetModuleBase64
657
#else
658
  DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr);
659
#endif
660

661
  BOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
662

663
#ifdef _IMAGEHLP64
664
#define SymGetSymNext SymGetSymNext64
665
#else
666
  BOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
667
#endif
668

669
  BOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
670

671
#ifdef _IMAGEHLP64
672
#define SymGetSymPrev SymGetSymPrev64
673
#else
674
  BOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
675
#endif
676

677
  typedef struct _SRCCODEINFO {
678
    DWORD SizeOfStruct;
679
    PVOID Key;
680
    DWORD64 ModBase;
681
    CHAR Obj[MAX_PATH + 1];
682
    CHAR FileName[MAX_PATH + 1];
683
    DWORD LineNumber;
684
    DWORD64 Address;
685
  } SRCCODEINFO,*PSRCCODEINFO;
686

687
  typedef BOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext);
688

689
  BOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext);
690
  BOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64);
691

692
#ifdef _IMAGEHLP64
693
#define SymGetLineFromAddr SymGetLineFromAddr64
694
#else
695
  BOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line);
696
#endif
697

698
  BOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line);
699

700
#ifdef _IMAGEHLP64
701
#define SymGetLineFromName SymGetLineFromName64
702
#else
703
  BOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line);
704
#endif
705

706
  BOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
707

708
#ifdef _IMAGEHLP64
709
#define SymGetLineNext SymGetLineNext64
710
#else
711
  BOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line);
712
#endif
713

714
  BOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
715

716
#ifdef _IMAGEHLP64
717
#define SymGetLinePrev SymGetLinePrev64
718
#else
719
  BOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line);
720
#endif
721

722
  BOOL IMAGEAPI SymMatchFileName(PSTR FileName,PSTR Match,PSTR *FileNameStop,PSTR *MatchStop);
723
  BOOL IMAGEAPI SymInitialize(HANDLE hProcess,PSTR UserSearchPath,BOOL fInvadeProcess);
724
  BOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength);
725
  BOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PSTR SearchPath);
726
  DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll);
727

728
#define SLMFLAG_VIRTUAL 0x1
729

730
  DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
731

732
#ifdef _IMAGEHLP64
733
#define SymLoadModule SymLoadModule64
734
#else
735
  DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll);
736
#endif
737

738
  BOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll);
739

740
#ifdef _IMAGEHLP64
741
#define SymUnloadModule SymUnloadModule64
742
#else
743
  BOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll);
744
#endif
745

746
  BOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength);
747

748
#ifdef _IMAGEHLP64
749
#define SymUnDName SymUnDName64
750
#else
751
  BOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength);
752
#endif
753

754
  BOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
755

756
  BOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext);
757

758
#ifdef _IMAGEHLP64
759
#define SymRegisterCallback SymRegisterCallback64
760
#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
761
#else
762
  BOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext);
763
  BOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext);
764
#endif
765

766
  typedef struct _IMAGEHLP_SYMBOL_SRC {
767
    DWORD sizeofstruct;
768
    DWORD type;
769
    char file[MAX_PATH];
770
  } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC;
771

772
  typedef struct _MODULE_TYPE_INFO {
773
    USHORT dataLength;
774
    USHORT leaf;
775
    BYTE data[1];
776
  } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO;
777

778
  typedef struct _SYMBOL_INFO {
779
    ULONG SizeOfStruct;
780
    ULONG TypeIndex;
781
    ULONG64 Reserved[2];
782
    ULONG info;
783
    ULONG Size;
784
    ULONG64 ModBase;
785
    ULONG Flags;
786
    ULONG64 Value;
787
    ULONG64 Address;
788
    ULONG Register;
789
    ULONG Scope;
790
    ULONG Tag;
791
    ULONG NameLen;
792
    ULONG MaxNameLen;
793
    CHAR Name[1];
794
  } SYMBOL_INFO,*PSYMBOL_INFO;
795

796
  typedef struct _SYMBOL_INFO_PACKAGE {
797
    SYMBOL_INFO si;
798
    CHAR name[MAX_SYM_NAME + 1];
799
  } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE;
800

801
  typedef struct _IMAGEHLP_STACK_FRAME
802
  {
803
    ULONG64 InstructionOffset;
804
    ULONG64 ReturnOffset;
805
    ULONG64 FrameOffset;
806
    ULONG64 StackOffset;
807
    ULONG64 BackingStoreOffset;
808
    ULONG64 FuncTableEntry;
809
    ULONG64 Params[4];
810
    ULONG64 Reserved[5];
811
    BOOL Virtual;
812
    ULONG Reserved2;
813
  } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME;
814

815
  typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT;
816

817
  BOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context);
818
  BOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol);
819
  BOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol);
820
  BOOL IMAGEAPI SymFromName(HANDLE hProcess,LPSTR Name,PSYMBOL_INFO Symbol);
821

822
  typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext);
823

824
  BOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
825
  BOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
826

827
#define SYMENUMFLAG_FULLSRCH 1
828
#define SYMENUMFLAG_SPEEDSRCH 2
829

830
  typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
831
    TI_GET_SYMTAG,TI_GET_SYMNAME,TI_GET_LENGTH,TI_GET_TYPE,TI_GET_TYPEID,TI_GET_BASETYPE,TI_GET_ARRAYINDEXTYPEID,TI_FINDCHILDREN,
832
    TI_GET_DATAKIND,TI_GET_ADDRESSOFFSET,TI_GET_OFFSET,TI_GET_VALUE,TI_GET_COUNT,TI_GET_CHILDRENCOUNT,TI_GET_BITPOSITION,TI_GET_VIRTUALBASECLASS,
833
    TI_GET_VIRTUALTABLESHAPEID,TI_GET_VIRTUALBASEPOINTEROFFSET,TI_GET_CLASSPARENTID,TI_GET_NESTED,TI_GET_SYMINDEX,TI_GET_LEXICALPARENT,
834
    TI_GET_ADDRESS,TI_GET_THISADJUST,TI_GET_UDTKIND,TI_IS_EQUIV_TO,TI_GET_CALLING_CONVENTION
835
  } IMAGEHLP_SYMBOL_TYPE_INFO;
836

837
  typedef struct _TI_FINDCHILDREN_PARAMS {
838
    ULONG Count;
839
    ULONG Start;
840
    ULONG ChildId[1];
841
  } TI_FINDCHILDREN_PARAMS;
842

843
  BOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo);
844
  BOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
845
  BOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,LPSTR Name,PSYMBOL_INFO Symbol);
846
  BOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
847
  BOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags);
848

849
  typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData);
850

851
  BOOL WINAPI DbgHelpCreateUserDump(LPSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
852
  BOOL WINAPI DbgHelpCreateUserDumpW(LPWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
853
  BOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol);
854

855
#ifdef _IMAGEHLP64
856
#define SymGetSymFromAddr SymGetSymFromAddr64
857
#else
858
  BOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol);
859
#endif
860

861
  BOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL64 Symbol);
862

863
#ifdef _IMAGEHLP64
864
#define SymGetSymFromName SymGetSymFromName64
865
#else
866
  BOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL Symbol);
867
#endif
868

869
  DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FilePath);
870
  DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,DWORD one,DWORD two,DWORD three,LPSTR FilePath);
871
  DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
872

873
#define SYMF_OMAP_GENERATED 0x00000001
874
#define SYMF_OMAP_MODIFIED 0x00000002
875
#define SYMF_REGISTER 0x00000008
876
#define SYMF_REGREL 0x00000010
877
#define SYMF_FRAMEREL 0x00000020
878
#define SYMF_PARAMETER 0x00000040
879
#define SYMF_LOCAL 0x00000080
880
#define SYMF_CONSTANT 0x00000100
881
#define SYMF_EXPORT 0x00000200
882
#define SYMF_FORWARDER 0x00000400
883
#define SYMF_FUNCTION 0x00000800
884
#define SYMF_VIRTUAL 0x00001000
885
#define SYMF_THUNK 0x00002000
886
#define SYMF_TLSREL 0x00004000
887

888
#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
889
#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER
890
#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL
891
#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL
892
#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER
893
#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL
894
#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT
895
#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION
896
#define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL
897
#define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK
898
#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL
899

900
#include <pshpack4.h>
901

902
#define MINIDUMP_SIGNATURE ('PMDM')
903
#define MINIDUMP_VERSION (42899)
904
  typedef DWORD RVA;
905
  typedef ULONG64 RVA64;
906

907
  typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
908
    ULONG32 DataSize;
909
    RVA Rva;
910
  } MINIDUMP_LOCATION_DESCRIPTOR;
911

912
  typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
913
    ULONG64 DataSize;
914
    RVA64 Rva;
915
  } MINIDUMP_LOCATION_DESCRIPTOR64;
916

917
  typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
918
    ULONG64 StartOfMemoryRange;
919
    MINIDUMP_LOCATION_DESCRIPTOR Memory;
920
  } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR;
921

922
  typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
923
    ULONG64 StartOfMemoryRange;
924
    ULONG64 DataSize;
925
  } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64;
926

927
  typedef struct _MINIDUMP_HEADER {
928
    ULONG32 Signature;
929
    ULONG32 Version;
930
    ULONG32 NumberOfStreams;
931
    RVA StreamDirectoryRva;
932
    ULONG32 CheckSum;
933
    union {
934
      ULONG32 Reserved;
935
      ULONG32 TimeDateStamp;
936
    } DUMMYUNIONNAME;
937
    ULONG64 Flags;
938
  } MINIDUMP_HEADER,*PMINIDUMP_HEADER;
939

940
  typedef struct _MINIDUMP_DIRECTORY {
941
    ULONG32 StreamType;
942
    MINIDUMP_LOCATION_DESCRIPTOR Location;
943
  } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY;
944

945
  typedef struct _MINIDUMP_STRING {
946
    ULONG32 Length;
947
    WCHAR Buffer [0];
948
  } MINIDUMP_STRING,*PMINIDUMP_STRING;
949

950
  typedef enum _MINIDUMP_STREAM_TYPE {
951
    UnusedStream = 0,ReservedStream0 = 1,ReservedStream1 = 2,ThreadListStream = 3,ModuleListStream = 4,MemoryListStream = 5,
952
    ExceptionStream = 6,SystemInfoStream = 7,ThreadExListStream = 8,Memory64ListStream = 9,CommentStreamA = 10,CommentStreamW = 11,
953
    HandleDataStream = 12,FunctionTableStream = 13,UnloadedModuleListStream = 14,MiscInfoStream = 15,LastReservedStream = 0xffff
954
  } MINIDUMP_STREAM_TYPE;
955

956
  typedef union _CPU_INFORMATION {
957
    struct {
958
      ULONG32 VendorId [3 ];
959
      ULONG32 VersionInformation;
960
      ULONG32 FeatureInformation;
961
      ULONG32 AMDExtendedCpuFeatures;
962
    } X86CpuInfo;
963
    struct {
964
      ULONG64 ProcessorFeatures [2 ];
965
    } OtherCpuInfo;
966
  } CPU_INFORMATION,*PCPU_INFORMATION;
967

968
  typedef struct _MINIDUMP_SYSTEM_INFO {
969
    USHORT ProcessorArchitecture;
970
    USHORT ProcessorLevel;
971
    USHORT ProcessorRevision;
972
    union {
973
      USHORT Reserved0;
974
      struct {
975
	UCHAR NumberOfProcessors;
976
	UCHAR ProductType;
977
      } DUMMYSTRUCTNAME;
978
    } DUMMYUNIONNAME;
979
    ULONG32 MajorVersion;
980
    ULONG32 MinorVersion;
981
    ULONG32 BuildNumber;
982
    ULONG32 PlatformId;
983
    RVA CSDVersionRva;
984
    union {
985
      ULONG32 Reserved1;
986
      struct {
987
	USHORT SuiteMask;
988
	USHORT Reserved2;
989
      } DUMMYSTRUCTNAME;
990
    } DUMMYUNIONNAME1;
991
    CPU_INFORMATION Cpu;
992
  } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO;
993

994
  C_ASSERT (sizeof (((PPROCESS_INFORMATION)0)->dwThreadId)==4);
995

996
  typedef struct _MINIDUMP_THREAD {
997
    ULONG32 ThreadId;
998
    ULONG32 SuspendCount;
999
    ULONG32 PriorityClass;
1000
    ULONG32 Priority;
1001
    ULONG64 Teb;
1002
    MINIDUMP_MEMORY_DESCRIPTOR Stack;
1003
    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1004
  } MINIDUMP_THREAD,*PMINIDUMP_THREAD;
1005

1006
  typedef struct _MINIDUMP_THREAD_LIST {
1007
    ULONG32 NumberOfThreads;
1008
    MINIDUMP_THREAD Threads [0];
1009
  } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST;
1010

1011
  typedef struct _MINIDUMP_THREAD_EX {
1012
    ULONG32 ThreadId;
1013
    ULONG32 SuspendCount;
1014
    ULONG32 PriorityClass;
1015
    ULONG32 Priority;
1016
    ULONG64 Teb;
1017
    MINIDUMP_MEMORY_DESCRIPTOR Stack;
1018
    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1019
    MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
1020
  } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX;
1021

1022
  typedef struct _MINIDUMP_THREAD_EX_LIST {
1023
    ULONG32 NumberOfThreads;
1024
    MINIDUMP_THREAD_EX Threads [0];
1025
  } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST;
1026

1027
  typedef struct _MINIDUMP_EXCEPTION {
1028
    ULONG32 ExceptionCode;
1029
    ULONG32 ExceptionFlags;
1030
    ULONG64 ExceptionRecord;
1031
    ULONG64 ExceptionAddress;
1032
    ULONG32 NumberParameters;
1033
    ULONG32 __unusedAlignment;
1034
    ULONG64 ExceptionInformation [EXCEPTION_MAXIMUM_PARAMETERS ];
1035
  } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION;
1036

1037
  typedef struct MINIDUMP_EXCEPTION_STREAM {
1038
    ULONG32 ThreadId;
1039
    ULONG32 __alignment;
1040
    MINIDUMP_EXCEPTION ExceptionRecord;
1041
    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
1042
  } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM;
1043

1044
  typedef struct _MINIDUMP_MODULE {
1045
    ULONG64 BaseOfImage;
1046
    ULONG32 SizeOfImage;
1047
    ULONG32 CheckSum;
1048
    ULONG32 TimeDateStamp;
1049
    RVA ModuleNameRva;
1050
    VS_FIXEDFILEINFO VersionInfo;
1051
    MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
1052
    MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
1053
    ULONG64 Reserved0;
1054
    ULONG64 Reserved1;
1055
  } MINIDUMP_MODULE,*PMINIDUMP_MODULE;
1056

1057
  typedef struct _MINIDUMP_MODULE_LIST {
1058
    ULONG32 NumberOfModules;
1059
    MINIDUMP_MODULE Modules [0 ];
1060
  } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST;
1061

1062
  typedef struct _MINIDUMP_MEMORY_LIST {
1063
    ULONG32 NumberOfMemoryRanges;
1064
    MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0];
1065
  } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST;
1066

1067
  typedef struct _MINIDUMP_MEMORY64_LIST {
1068
    ULONG64 NumberOfMemoryRanges;
1069
    RVA64 BaseRva;
1070
    MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0];
1071
  } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST;
1072

1073
  typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
1074
    DWORD ThreadId;
1075
    PEXCEPTION_POINTERS ExceptionPointers;
1076
    BOOL ClientPointers;
1077
  } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION;
1078

1079
  typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
1080
    DWORD ThreadId;
1081
    ULONG64 ExceptionRecord;
1082
    ULONG64 ContextRecord;
1083
    BOOL ClientPointers;
1084
  } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64;
1085

1086
  typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
1087
    ULONG64 Handle;
1088
    RVA TypeNameRva;
1089
    RVA ObjectNameRva;
1090
    ULONG32 Attributes;
1091
    ULONG32 GrantedAccess;
1092
    ULONG32 HandleCount;
1093
    ULONG32 PointerCount;
1094
  } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR;
1095

1096
  typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
1097
    ULONG32 SizeOfHeader;
1098
    ULONG32 SizeOfDescriptor;
1099
    ULONG32 NumberOfDescriptors;
1100
    ULONG32 Reserved;
1101
  } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM;
1102

1103
  typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
1104
    ULONG64 MinimumAddress;
1105
    ULONG64 MaximumAddress;
1106
    ULONG64 BaseAddress;
1107
    ULONG32 EntryCount;
1108
    ULONG32 SizeOfAlignPad;
1109
  } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
1110

1111
  typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
1112
    ULONG32 SizeOfHeader;
1113
    ULONG32 SizeOfDescriptor;
1114
    ULONG32 SizeOfNativeDescriptor;
1115
    ULONG32 SizeOfFunctionEntry;
1116
    ULONG32 NumberOfDescriptors;
1117
    ULONG32 SizeOfAlignPad;
1118
  } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM;
1119

1120
  typedef struct _MINIDUMP_UNLOADED_MODULE {
1121
    ULONG64 BaseOfImage;
1122
    ULONG32 SizeOfImage;
1123
    ULONG32 CheckSum;
1124
    ULONG32 TimeDateStamp;
1125
    RVA ModuleNameRva;
1126
  } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE;
1127

1128
  typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
1129
    ULONG32 SizeOfHeader;
1130
    ULONG32 SizeOfEntry;
1131
    ULONG32 NumberOfEntries;
1132
  } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST;
1133

1134
#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
1135
#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
1136

1137
  typedef struct _MINIDUMP_MISC_INFO {
1138
    ULONG32 SizeOfInfo;
1139
    ULONG32 Flags1;
1140
    ULONG32 ProcessId;
1141
    ULONG32 ProcessCreateTime;
1142
    ULONG32 ProcessUserTime;
1143
    ULONG32 ProcessKernelTime;
1144
  } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO;
1145

1146
  typedef struct _MINIDUMP_USER_RECORD {
1147
    ULONG32 Type;
1148
    MINIDUMP_LOCATION_DESCRIPTOR Memory;
1149
  } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD;
1150

1151
  typedef struct _MINIDUMP_USER_STREAM {
1152
    ULONG32 Type;
1153
    ULONG BufferSize;
1154
    PVOID Buffer;
1155
  } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM;
1156

1157
  typedef struct _MINIDUMP_USER_STREAM_INFORMATION {
1158
    ULONG UserStreamCount;
1159
    PMINIDUMP_USER_STREAM UserStreamArray;
1160
  } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION;
1161

1162
  typedef enum _MINIDUMP_CALLBACK_TYPE {
1163
    ModuleCallback,ThreadCallback,ThreadExCallback,IncludeThreadCallback,IncludeModuleCallback,MemoryCallback
1164
  } MINIDUMP_CALLBACK_TYPE;
1165

1166
  typedef struct _MINIDUMP_THREAD_CALLBACK {
1167
    ULONG ThreadId;
1168
    HANDLE ThreadHandle;
1169
    CONTEXT Context;
1170
    ULONG SizeOfContext;
1171
    ULONG64 StackBase;
1172
    ULONG64 StackEnd;
1173
  } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK;
1174

1175
  typedef struct _MINIDUMP_THREAD_EX_CALLBACK {
1176
    ULONG ThreadId;
1177
    HANDLE ThreadHandle;
1178
    CONTEXT Context;
1179
    ULONG SizeOfContext;
1180
    ULONG64 StackBase;
1181
    ULONG64 StackEnd;
1182
    ULONG64 BackingStoreBase;
1183
    ULONG64 BackingStoreEnd;
1184
  } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK;
1185

1186
  typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK {
1187
    ULONG ThreadId;
1188
  } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK;
1189

1190
  typedef enum _THREAD_WRITE_FLAGS {
1191
    ThreadWriteThread = 0x0001,ThreadWriteStack = 0x0002,ThreadWriteContext = 0x0004,ThreadWriteBackingStore = 0x0008,
1192
    ThreadWriteInstructionWindow = 0x0010,ThreadWriteThreadData = 0x0020
1193
  } THREAD_WRITE_FLAGS;
1194

1195
  typedef struct _MINIDUMP_MODULE_CALLBACK {
1196
    PWCHAR FullPath;
1197
    ULONG64 BaseOfImage;
1198
    ULONG SizeOfImage;
1199
    ULONG CheckSum;
1200
    ULONG TimeDateStamp;
1201
    VS_FIXEDFILEINFO VersionInfo;
1202
    PVOID CvRecord;
1203
    ULONG SizeOfCvRecord;
1204
    PVOID MiscRecord;
1205
    ULONG SizeOfMiscRecord;
1206
  } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK;
1207

1208
  typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK {
1209
    ULONG64 BaseOfImage;
1210
  } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK;
1211

1212
  typedef enum _MODULE_WRITE_FLAGS {
1213
    ModuleWriteModule = 0x0001,ModuleWriteDataSeg = 0x0002,ModuleWriteMiscRecord = 0x0004,ModuleWriteCvRecord = 0x0008,
1214
    ModuleReferencedByMemory = 0x0010
1215
  } MODULE_WRITE_FLAGS;
1216

1217
  typedef struct _MINIDUMP_CALLBACK_INPUT {
1218
    ULONG ProcessId;
1219
    HANDLE ProcessHandle;
1220
    ULONG CallbackType;
1221
    union {
1222
      MINIDUMP_THREAD_CALLBACK Thread;
1223
      MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
1224
      MINIDUMP_MODULE_CALLBACK Module;
1225
      MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
1226
      MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
1227
    } DUMMYUNIONNAME;
1228
  } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT;
1229

1230
  typedef struct _MINIDUMP_CALLBACK_OUTPUT {
1231
    union {
1232
      ULONG ModuleWriteFlags;
1233
      ULONG ThreadWriteFlags;
1234
      struct {
1235
	ULONG64 MemoryBase;
1236
	ULONG MemorySize;
1237
      } DUMMYSTRUCTNAME;
1238
    } DUMMYUNIONNAME;
1239
  } MINIDUMP_CALLBACK_OUTPUT,*PMINIDUMP_CALLBACK_OUTPUT;
1240

1241
  typedef enum _MINIDUMP_TYPE {
1242
    MiniDumpNormal = 0x0000,MiniDumpWithDataSegs = 0x0001,MiniDumpWithFullMemory = 0x0002,MiniDumpWithHandleData = 0x0004,
1243
    MiniDumpFilterMemory = 0x0008,MiniDumpScanMemory = 0x0010,MiniDumpWithUnloadedModules = 0x0020,MiniDumpWithIndirectlyReferencedMemory = 0x0040,
1244
    MiniDumpFilterModulePaths = 0x0080,MiniDumpWithProcessThreadData = 0x0100,MiniDumpWithPrivateReadWriteMemory = 0x0200,
1245
    MiniDumpWithoutOptionalData = 0x0400
1246
  } MINIDUMP_TYPE;
1247

1248
  typedef BOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
1249

1250
  typedef struct _MINIDUMP_CALLBACK_INFORMATION {
1251
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
1252
    PVOID CallbackParam;
1253
  } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION;
1254

1255
#define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
1256

1257
  BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess,DWORD ProcessId,HANDLE hFile,MINIDUMP_TYPE DumpType,CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
1258
  BOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize);
1259

1260
#include <poppack.h>
1261

1262
#ifdef __cplusplus
1263
}
1264
#endif
1265
#endif
1266

1267
Product

Resources

Company
