~armagetronad-dev/armagetronad/trunk-winlibs-breakpad

« back to all changes in this revision

Viewing changes to MicrosoftSDK/DbgHelp.h

  • Committer: Manuel Moos
  • Date: 2011-08-13 16:14:12 UTC
  • Revision ID: manuel@moosnet.de-20110813161412-53unupj8ytelu27r
Adding DbgHelp.h from microsoft SDK, it's needed for breakpad and is mingw compatible enough.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*++ BUILD Version: 0000     Increment this if a change has global effects
 
2
 
 
3
Copyright (c) Microsoft Corporation. All rights reserved.
 
4
 
 
5
Module Name:
 
6
 
 
7
    dbghelp.h
 
8
 
 
9
Abstract:
 
10
 
 
11
    This module defines the prototypes and constants required for the image
 
12
    help routines.
 
13
 
 
14
    Contains debugging support routines that are redistributable.
 
15
 
 
16
Revision History:
 
17
 
 
18
--*/
 
19
 
 
20
#ifndef _DBGHELP_
 
21
#define _DBGHELP_
 
22
 
 
23
#if _MSC_VER > 1020
 
24
#pragma once
 
25
#endif
 
26
 
 
27
 
 
28
// As a general principal always call the 64 bit version
 
29
// of every API, if a choice exists.  The 64 bit version
 
30
// works great on 32 bit platforms, and is forward
 
31
// compatible to 64 bit platforms.
 
32
 
 
33
#ifdef _WIN64
 
34
#ifndef _IMAGEHLP64
 
35
#define _IMAGEHLP64
 
36
#endif
 
37
#endif
 
38
 
 
39
#include <pshpack8.h>
 
40
 
 
41
// For those without specstrings.h
 
42
// Since there are different versions of this header, I need to
 
43
// individually test each item and define it if it is not around.
 
44
 
 
45
#ifndef __in
 
46
 #define __in
 
47
#endif
 
48
#ifndef __out
 
49
 #define __out
 
50
#endif
 
51
#ifndef __inout
 
52
 #define __inout
 
53
#endif
 
54
#ifndef __in_opt
 
55
 #define __in_opt
 
56
#endif
 
57
#ifndef __out_opt
 
58
 #define __out_opt
 
59
#endif
 
60
#ifndef __inout_opt
 
61
 #define __inout_opt
 
62
#endif
 
63
#ifndef __in_ecount
 
64
 #define __in_ecount(x)
 
65
#endif
 
66
#ifndef __out_ecount
 
67
 #define __out_ecount(x)
 
68
#endif
 
69
#ifndef __inout_ecount
 
70
 #define __inout_ecount(x)
 
71
#endif
 
72
#ifndef __in_bcount
 
73
 #define __in_bcount(x)
 
74
#endif
 
75
#ifndef __out_bcount
 
76
 #define __out_bcount(x)
 
77
#endif
 
78
#ifndef __inout_bcount
 
79
 #define __inout_bcount(x)
 
80
#endif
 
81
#ifndef __out_xcount
 
82
 #define __out_xcount(x)
 
83
#endif
 
84
#ifndef __deref_opt_out
 
85
 #define __deref_opt_out
 
86
#endif
 
87
#ifndef __deref_out
 
88
 #define __deref_out
 
89
#endif
 
90
#ifndef __out_ecount_opt
 
91
 #define __out_ecount_opt(x)
 
92
#endif
 
93
#ifndef __in_bcount_opt
 
94
 #define __in_bcount_opt(x)
 
95
#endif
 
96
#ifndef __out_bcount_opt
 
97
 #define __out_bcount_opt(x)
 
98
#endif
 
99
#ifndef __deref_out_opt
 
100
 #define __deref_out_opt
 
101
#endif
 
102
 
 
103
 
 
104
#ifdef __cplusplus
 
105
extern "C" {
 
106
#endif
 
107
 
 
108
#ifdef _IMAGEHLP_SOURCE_
 
109
 #define IMAGEAPI __stdcall
 
110
 #define DBHLP_DEPRECIATED
 
111
#else
 
112
 #define IMAGEAPI DECLSPEC_IMPORT __stdcall
 
113
 #if (_MSC_VER >= 1300) && !defined(MIDL_PASS)
 
114
  #define DBHLP_DEPRECIATED   __declspec(deprecated)
 
115
 #else
 
116
  #define DBHLP_DEPRECIATED
 
117
 #endif
 
118
#endif
 
119
 
 
120
#define DBHLPAPI IMAGEAPI
 
121
 
 
122
#define IMAGE_SEPARATION (64*1024)
 
123
 
 
124
// Observant readers may notice that 2 new fields,
 
125
// 'fReadOnly' and 'Version' have been added to
 
126
// the LOADED_IMAGE structure after 'fDOSImage'.
 
127
// This does not change the size of the structure 
 
128
// from previous headers.  That is because while 
 
129
// 'fDOSImage' is a byte, it is padded by the 
 
130
// compiler to 4 bytes.  So the 2 new fields are 
 
131
// slipped into the extra space.
 
132
 
 
133
typedef struct _LOADED_IMAGE {
 
134
    PSTR                  ModuleName;
 
135
    HANDLE                hFile;
 
136
    PUCHAR                MappedAddress;
 
137
#ifdef _IMAGEHLP64
 
138
    PIMAGE_NT_HEADERS64   FileHeader;
 
139
#else
 
140
    PIMAGE_NT_HEADERS32   FileHeader;
 
141
#endif
 
142
    PIMAGE_SECTION_HEADER LastRvaSection;
 
143
    ULONG                 NumberOfSections;
 
144
    PIMAGE_SECTION_HEADER Sections;
 
145
    ULONG                 Characteristics;
 
146
    BOOLEAN               fSystemImage;
 
147
    BOOLEAN               fDOSImage;
 
148
    BOOLEAN               fReadOnly;
 
149
    UCHAR                 Version;
 
150
    LIST_ENTRY            Links;
 
151
    ULONG                 SizeOfImage;
 
152
} LOADED_IMAGE, *PLOADED_IMAGE;
 
153
 
 
154
#define MAX_SYM_NAME            2000
 
155
 
 
156
 
 
157
// Error codes set by dbghelp functions.  Call GetLastError
 
158
// to see them.
 
159
// Dbghelp also sets error codes found in winerror.h
 
160
 
 
161
#define ERROR_IMAGE_NOT_STRIPPED    0x8800  // the image is not stripped.  No dbg file available.
 
162
#define ERROR_NO_DBG_POINTER        0x8801  // image is stripped but there is no pointer to a dbg file
 
163
#define ERROR_NO_PDB_POINTER        0x8802  // image does not point to a pdb file
 
164
 
 
165
typedef BOOL
 
166
(CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(
 
167
    __in HANDLE FileHandle,
 
168
    __in PCSTR FileName,
 
169
    __in PVOID CallerData
 
170
    );
 
171
 
 
172
HANDLE
 
173
IMAGEAPI
 
174
SymFindDebugInfoFile(
 
175
    __in HANDLE hProcess,
 
176
    __in PCSTR FileName,
 
177
    __out_ecount(MAX_PATH + 1) PSTR DebugFilePath,
 
178
    __in_opt PFIND_DEBUG_FILE_CALLBACK Callback,
 
179
    __in_opt PVOID CallerData
 
180
    );
 
181
 
 
182
typedef BOOL
 
183
(CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(
 
184
    __in HANDLE FileHandle,
 
185
    __in PCWSTR FileName,
 
186
    __in PVOID  CallerData
 
187
    );
 
188
 
 
189
HANDLE
 
190
IMAGEAPI
 
191
SymFindDebugInfoFileW(
 
192
    __in HANDLE hProcess,
 
193
    __in PCWSTR FileName,
 
194
    __out_ecount(MAX_PATH + 1) PWSTR DebugFilePath,
 
195
    __in_opt PFIND_DEBUG_FILE_CALLBACKW Callback,
 
196
    __in_opt PVOID CallerData
 
197
    );
 
198
 
 
199
HANDLE
 
200
IMAGEAPI
 
201
FindDebugInfoFile (
 
202
    __in PCSTR FileName,
 
203
    __in PCSTR SymbolPath,
 
204
    __out_ecount(MAX_PATH + 1) PSTR DebugFilePath
 
205
    );
 
206
 
 
207
HANDLE
 
208
IMAGEAPI
 
209
FindDebugInfoFileEx (
 
210
    __in PCSTR FileName,
 
211
    __in PCSTR SymbolPath,
 
212
    __out_ecount(MAX_PATH + 1) PSTR  DebugFilePath,
 
213
    __in_opt PFIND_DEBUG_FILE_CALLBACK Callback,
 
214
    __in_opt PVOID CallerData
 
215
    );
 
216
 
 
217
HANDLE
 
218
IMAGEAPI
 
219
FindDebugInfoFileExW (
 
220
    __in PCWSTR FileName,
 
221
    __in PCWSTR SymbolPath,
 
222
    __out_ecount(MAX_PATH + 1) PWSTR DebugFilePath,
 
223
    __in_opt PFIND_DEBUG_FILE_CALLBACKW Callback,
 
224
    __in_opt PVOID CallerData
 
225
    );
 
226
 
 
227
typedef BOOL
 
228
(CALLBACK *PFINDFILEINPATHCALLBACK)(
 
229
    __in PCSTR filename,
 
230
    __in PVOID context
 
231
    );
 
232
 
 
233
BOOL
 
234
IMAGEAPI
 
235
SymFindFileInPath(
 
236
    __in HANDLE hprocess,
 
237
    __in_opt PCSTR SearchPath,
 
238
    __in PCSTR FileName,
 
239
    __in_opt PVOID id,
 
240
    __in DWORD two,
 
241
    __in DWORD three,
 
242
    __in DWORD flags,
 
243
    __out_ecount(MAX_PATH + 1) PSTR FoundFile,
 
244
    __in_opt PFINDFILEINPATHCALLBACK callback,
 
245
    __in_opt PVOID context
 
246
    );
 
247
 
 
248
typedef BOOL
 
249
(CALLBACK *PFINDFILEINPATHCALLBACKW)(
 
250
    __in PCWSTR filename,
 
251
    __in PVOID context
 
252
    );
 
253
 
 
254
BOOL
 
255
IMAGEAPI
 
256
SymFindFileInPathW(
 
257
    __in HANDLE hprocess,
 
258
    __in_opt PCWSTR SearchPath,
 
259
    __in PCWSTR FileName,
 
260
    __in_opt PVOID id,
 
261
    __in DWORD two,
 
262
    __in DWORD three,
 
263
    __in DWORD flags,
 
264
    __out_ecount(MAX_PATH + 1) PWSTR FoundFile,
 
265
    __in_opt PFINDFILEINPATHCALLBACKW callback,
 
266
    __in_opt PVOID context
 
267
    );
 
268
 
 
269
typedef BOOL
 
270
(CALLBACK *PFIND_EXE_FILE_CALLBACK)(
 
271
    __in HANDLE FileHandle,
 
272
    __in PCSTR FileName,
 
273
    __in_opt PVOID CallerData
 
274
    );
 
275
 
 
276
HANDLE
 
277
IMAGEAPI
 
278
SymFindExecutableImage(
 
279
    __in HANDLE hProcess,
 
280
    __in PCSTR FileName,
 
281
    __out_ecount(MAX_PATH + 1) PSTR ImageFilePath,
 
282
    __in PFIND_EXE_FILE_CALLBACK Callback,
 
283
    __in PVOID CallerData
 
284
    );
 
285
 
 
286
typedef BOOL
 
287
(CALLBACK *PFIND_EXE_FILE_CALLBACKW)(
 
288
    __in HANDLE FileHandle,
 
289
    __in PCWSTR FileName,
 
290
    __in_opt PVOID CallerData
 
291
    );
 
292
 
 
293
HANDLE
 
294
IMAGEAPI
 
295
SymFindExecutableImageW(
 
296
    __in HANDLE hProcess,
 
297
    __in PCWSTR FileName,
 
298
    __out_ecount(MAX_PATH + 1) PWSTR ImageFilePath,
 
299
    __in PFIND_EXE_FILE_CALLBACKW Callback,
 
300
    __in PVOID CallerData
 
301
    );
 
302
 
 
303
HANDLE
 
304
IMAGEAPI
 
305
FindExecutableImage(
 
306
    __in PCSTR FileName,
 
307
    __in PCSTR SymbolPath,
 
308
    __out_ecount(MAX_PATH + 1) PSTR ImageFilePath
 
309
    );
 
310
 
 
311
HANDLE
 
312
IMAGEAPI
 
313
FindExecutableImageEx(
 
314
    __in PCSTR FileName,
 
315
    __in PCSTR SymbolPath,
 
316
    __out_ecount(MAX_PATH + 1) PSTR ImageFilePath,
 
317
    __in_opt PFIND_EXE_FILE_CALLBACK Callback,
 
318
    __in_opt PVOID CallerData
 
319
    );
 
320
 
 
321
HANDLE
 
322
IMAGEAPI
 
323
FindExecutableImageExW(
 
324
    __in PCWSTR FileName,
 
325
    __in PCWSTR SymbolPath,
 
326
    __out_ecount(MAX_PATH + 1) PWSTR ImageFilePath,
 
327
    __in_opt PFIND_EXE_FILE_CALLBACKW Callback,
 
328
    __in PVOID CallerData
 
329
    );
 
330
 
 
331
PIMAGE_NT_HEADERS
 
332
IMAGEAPI
 
333
ImageNtHeader (
 
334
    __in PVOID Base
 
335
    );
 
336
 
 
337
PVOID
 
338
IMAGEAPI
 
339
ImageDirectoryEntryToDataEx (
 
340
    __in PVOID Base,
 
341
    __in BOOLEAN MappedAsImage,
 
342
    __in USHORT DirectoryEntry,
 
343
    __out PULONG Size,
 
344
    __out_opt PIMAGE_SECTION_HEADER *FoundHeader
 
345
    );
 
346
 
 
347
PVOID
 
348
IMAGEAPI
 
349
ImageDirectoryEntryToData (
 
350
    __in PVOID Base,
 
351
    __in BOOLEAN MappedAsImage,
 
352
    __in USHORT DirectoryEntry,
 
353
    __out PULONG Size
 
354
    );
 
355
 
 
356
PIMAGE_SECTION_HEADER
 
357
IMAGEAPI
 
358
ImageRvaToSection(
 
359
    __in PIMAGE_NT_HEADERS NtHeaders,
 
360
    __in PVOID Base,
 
361
    __in ULONG Rva
 
362
    );
 
363
 
 
364
PVOID
 
365
IMAGEAPI
 
366
ImageRvaToVa(
 
367
    __in PIMAGE_NT_HEADERS NtHeaders,
 
368
    __in PVOID Base,
 
369
    __in ULONG Rva,
 
370
    __in_opt OUT PIMAGE_SECTION_HEADER *LastRvaSection
 
371
    );
 
372
 
 
373
#ifndef _WIN64
 
374
// This api won't be ported to Win64 - Fix your code.
 
375
 
 
376
typedef struct _IMAGE_DEBUG_INFORMATION {
 
377
    LIST_ENTRY List;
 
378
    DWORD ReservedSize;
 
379
    PVOID ReservedMappedBase;
 
380
    USHORT ReservedMachine;
 
381
    USHORT ReservedCharacteristics;
 
382
    DWORD ReservedCheckSum;
 
383
    DWORD ImageBase;
 
384
    DWORD SizeOfImage;
 
385
 
 
386
    DWORD ReservedNumberOfSections;
 
387
    PIMAGE_SECTION_HEADER ReservedSections;
 
388
 
 
389
    DWORD ReservedExportedNamesSize;
 
390
    PSTR ReservedExportedNames;
 
391
 
 
392
    DWORD ReservedNumberOfFunctionTableEntries;
 
393
    PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
 
394
    DWORD ReservedLowestFunctionStartingAddress;
 
395
    DWORD ReservedHighestFunctionEndingAddress;
 
396
 
 
397
    DWORD ReservedNumberOfFpoTableEntries;
 
398
    PFPO_DATA ReservedFpoTableEntries;
 
399
 
 
400
    DWORD SizeOfCoffSymbols;
 
401
    PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
 
402
 
 
403
    DWORD ReservedSizeOfCodeViewSymbols;
 
404
    PVOID ReservedCodeViewSymbols;
 
405
 
 
406
    PSTR ImageFilePath;
 
407
    PSTR ImageFileName;
 
408
    PSTR ReservedDebugFilePath;
 
409
 
 
410
    DWORD ReservedTimeDateStamp;
 
411
 
 
412
    BOOL  ReservedRomImage;
 
413
    PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
 
414
    DWORD ReservedNumberOfDebugDirectories;
 
415
 
 
416
    DWORD ReservedOriginalFunctionTableBaseAddress;
 
417
 
 
418
    DWORD Reserved[ 2 ];
 
419
 
 
420
} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
 
421
 
 
422
 
 
423
PIMAGE_DEBUG_INFORMATION
 
424
IMAGEAPI
 
425
MapDebugInformation(
 
426
    __in_opt HANDLE FileHandle,
 
427
    __in PCSTR FileName,
 
428
    __in_opt PCSTR SymbolPath,
 
429
    __in ULONG ImageBase
 
430
    );
 
431
 
 
432
BOOL
 
433
IMAGEAPI
 
434
UnmapDebugInformation(
 
435
    __out_xcount(unknown) PIMAGE_DEBUG_INFORMATION DebugInfo
 
436
    );
 
437
 
 
438
#endif
 
439
 
 
440
BOOL
 
441
IMAGEAPI
 
442
SearchTreeForFile(
 
443
    __in PCSTR RootPath,
 
444
    __in PCSTR InputPathName,
 
445
    __out_ecount(MAX_PATH + 1) PSTR OutputPathBuffer
 
446
    );
 
447
 
 
448
BOOL
 
449
IMAGEAPI
 
450
SearchTreeForFileW(
 
451
    __in PCWSTR RootPath,
 
452
    __in PCWSTR InputPathName,
 
453
    __out_ecount(MAX_PATH + 1) PWSTR OutputPathBuffer
 
454
    );
 
455
 
 
456
typedef BOOL
 
457
(CALLBACK *PENUMDIRTREE_CALLBACK)(
 
458
    __in PCSTR FilePath,
 
459
    __in_opt PVOID CallerData
 
460
    );
 
461
 
 
462
BOOL
 
463
IMAGEAPI
 
464
EnumDirTree(
 
465
    __in_opt HANDLE hProcess,
 
466
    __in PCSTR RootPath,
 
467
    __in PCSTR InputPathName,
 
468
    __out_ecount_opt(MAX_PATH + 1) PSTR OutputPathBuffer,
 
469
    __in_opt PENUMDIRTREE_CALLBACK cb,
 
470
    __in_opt PVOID data
 
471
    );
 
472
 
 
473
typedef BOOL
 
474
(CALLBACK *PENUMDIRTREE_CALLBACKW)(
 
475
    __in PCWSTR FilePath,
 
476
    __in_opt PVOID CallerData
 
477
    );
 
478
 
 
479
BOOL
 
480
IMAGEAPI
 
481
EnumDirTreeW(
 
482
    __in_opt HANDLE hProcess,
 
483
    __in PCWSTR RootPath,
 
484
    __in PCWSTR InputPathName,
 
485
    __out_ecount_opt(MAX_PATH + 1) PWSTR OutputPathBuffer,
 
486
    __in_opt PENUMDIRTREE_CALLBACKW cb,
 
487
    __in_opt PVOID data
 
488
    );
 
489
 
 
490
BOOL
 
491
IMAGEAPI
 
492
MakeSureDirectoryPathExists(
 
493
    __in PCSTR DirPath
 
494
    );
 
495
 
 
496
//
 
497
// UnDecorateSymbolName Flags
 
498
//
 
499
 
 
500
#define UNDNAME_COMPLETE                 (0x0000)  // Enable full undecoration
 
501
#define UNDNAME_NO_LEADING_UNDERSCORES   (0x0001)  // Remove leading underscores from MS extended keywords
 
502
#define UNDNAME_NO_MS_KEYWORDS           (0x0002)  // Disable expansion of MS extended keywords
 
503
#define UNDNAME_NO_FUNCTION_RETURNS      (0x0004)  // Disable expansion of return type for primary declaration
 
504
#define UNDNAME_NO_ALLOCATION_MODEL      (0x0008)  // Disable expansion of the declaration model
 
505
#define UNDNAME_NO_ALLOCATION_LANGUAGE   (0x0010)  // Disable expansion of the declaration language specifier
 
506
#define UNDNAME_NO_MS_THISTYPE           (0x0020)  // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
 
507
#define UNDNAME_NO_CV_THISTYPE           (0x0040)  // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
 
508
#define UNDNAME_NO_THISTYPE              (0x0060)  // Disable all modifiers on the 'this' type
 
509
#define UNDNAME_NO_ACCESS_SPECIFIERS     (0x0080)  // Disable expansion of access specifiers for members
 
510
#define UNDNAME_NO_THROW_SIGNATURES      (0x0100)  // Disable expansion of 'throw-signatures' for functions and pointers to functions
 
511
#define UNDNAME_NO_MEMBER_TYPE           (0x0200)  // Disable expansion of 'static' or 'virtual'ness of members
 
512
#define UNDNAME_NO_RETURN_UDT_MODEL      (0x0400)  // Disable expansion of MS model for UDT returns
 
513
#define UNDNAME_32_BIT_DECODE            (0x0800)  // Undecorate 32-bit decorated names
 
514
#define UNDNAME_NAME_ONLY                (0x1000)  // Crack only the name for primary declaration;
 
515
                                                                                                   //  return just [scope::]name.  Does expand template params
 
516
#define UNDNAME_NO_ARGUMENTS             (0x2000)  // Don't undecorate arguments to function
 
517
#define UNDNAME_NO_SPECIAL_SYMS          (0x4000)  // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
 
518
 
 
519
DWORD
 
520
IMAGEAPI
 
521
WINAPI
 
522
UnDecorateSymbolName(
 
523
    __in PCSTR name,
 
524
    __out_ecount(maxStringLength) PSTR outputString,
 
525
    __in DWORD maxStringLength,
 
526
    __in DWORD flags
 
527
    );
 
528
 
 
529
DWORD
 
530
IMAGEAPI
 
531
WINAPI
 
532
UnDecorateSymbolNameW(
 
533
    __in PCWSTR name,
 
534
    __out_ecount(maxStringLength) PWSTR outputString,
 
535
    __in DWORD maxStringLength,
 
536
    __in DWORD flags
 
537
    );
 
538
 
 
539
//
 
540
// these values are used for synthesized file types
 
541
// that can be passed in as image headers instead of
 
542
// the standard ones from ntimage.h
 
543
//
 
544
 
 
545
#define DBHHEADER_DEBUGDIRS     0x1
 
546
#define DBHHEADER_CVMISC        0x2
 
547
#define DBHHEADER_PDBGUID       0x3
 
548
typedef struct _MODLOAD_DATA {
 
549
    DWORD   ssize;                  // size of this struct
 
550
    DWORD   ssig;                   // signature identifying the passed data
 
551
    PVOID   data;                   // pointer to passed data
 
552
    DWORD   size;                   // size of passed data
 
553
    DWORD   flags;                  // options
 
554
} MODLOAD_DATA, *PMODLOAD_DATA;
 
555
 
 
556
typedef struct _MODLOAD_CVMISC {
 
557
    DWORD   oCV;                    // ofset to the codeview record
 
558
    size_t  cCV;                    // size of the codeview record
 
559
    DWORD   oMisc;                  // offset to the misc record
 
560
    size_t  cMisc;                  // size of the misc record
 
561
    DWORD   dtImage;                // datetime stamp of the image
 
562
    DWORD   cImage;                 // size of the image
 
563
} MODLOAD_CVMISC, *PMODLOAD_CVMISC;
 
564
 
 
565
typedef struct _MODLOAD_PDBGUID_PDBAGE {
 
566
    GUID    PdbGuid;                // Pdb Guid 
 
567
    DWORD   PdbAge;                 // Pdb Age 
 
568
} MODLOAD_PDBGUID_PDBAGE, *PMODLOAD_PDBGUID_PDBAGE;
 
569
 
 
570
//
 
571
// StackWalking API
 
572
//
 
573
 
 
574
typedef enum {
 
575
    AddrMode1616,
 
576
    AddrMode1632,
 
577
    AddrModeReal,
 
578
    AddrModeFlat
 
579
} ADDRESS_MODE;
 
580
 
 
581
typedef struct _tagADDRESS64 {
 
582
    DWORD64       Offset;
 
583
    WORD          Segment;
 
584
    ADDRESS_MODE  Mode;
 
585
} ADDRESS64, *LPADDRESS64;
 
586
 
 
587
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
588
#define ADDRESS ADDRESS64
 
589
#define LPADDRESS LPADDRESS64
 
590
#else
 
591
typedef struct _tagADDRESS {
 
592
    DWORD         Offset;
 
593
    WORD          Segment;
 
594
    ADDRESS_MODE  Mode;
 
595
} ADDRESS, *LPADDRESS;
 
596
 
 
597
__inline
 
598
void
 
599
Address32To64(
 
600
    __in LPADDRESS a32,
 
601
    __out LPADDRESS64 a64
 
602
    )
 
603
{
 
604
    a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
 
605
    a64->Segment = a32->Segment;
 
606
    a64->Mode = a32->Mode;
 
607
}
 
608
 
 
609
__inline
 
610
void
 
611
Address64To32(
 
612
    __in LPADDRESS64 a64,
 
613
    __out LPADDRESS a32
 
614
    )
 
615
{
 
616
    a32->Offset = (ULONG)a64->Offset;
 
617
    a32->Segment = a64->Segment;
 
618
    a32->Mode = a64->Mode;
 
619
}
 
620
#endif
 
621
 
 
622
//
 
623
// This structure is included in the STACKFRAME structure,
 
624
// and is used to trace through usermode callbacks in a thread's
 
625
// kernel stack.  The values must be copied by the kernel debugger
 
626
// from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
 
627
//
 
628
 
 
629
//
 
630
// New KDHELP structure for 64 bit system support.
 
631
// This structure is preferred in new code.
 
632
//
 
633
typedef struct _KDHELP64 {
 
634
 
 
635
    //
 
636
    // address of kernel thread object, as provided in the
 
637
    // WAIT_STATE_CHANGE packet.
 
638
    //
 
639
    DWORD64   Thread;
 
640
 
 
641
    //
 
642
    // offset in thread object to pointer to the current callback frame
 
643
    // in kernel stack.
 
644
    //
 
645
    DWORD   ThCallbackStack;
 
646
 
 
647
    //
 
648
    // offset in thread object to pointer to the current callback backing
 
649
    // store frame in kernel stack.
 
650
    //
 
651
    DWORD   ThCallbackBStore;
 
652
 
 
653
    //
 
654
    // offsets to values in frame:
 
655
    //
 
656
    // address of next callback frame
 
657
    DWORD   NextCallback;
 
658
 
 
659
    // address of saved frame pointer (if applicable)
 
660
    DWORD   FramePointer;
 
661
 
 
662
 
 
663
    //
 
664
    // Address of the kernel function that calls out to user mode
 
665
    //
 
666
    DWORD64   KiCallUserMode;
 
667
 
 
668
    //
 
669
    // Address of the user mode dispatcher function
 
670
    //
 
671
    DWORD64   KeUserCallbackDispatcher;
 
672
 
 
673
    //
 
674
    // Lowest kernel mode address
 
675
    //
 
676
    DWORD64   SystemRangeStart;
 
677
 
 
678
    //
 
679
    // Address of the user mode exception dispatcher function.
 
680
    // Added in API version 10.
 
681
    //
 
682
    DWORD64   KiUserExceptionDispatcher;
 
683
 
 
684
    //
 
685
    // Stack bounds, added in API version 11.
 
686
    //
 
687
    DWORD64   StackBase;
 
688
    DWORD64   StackLimit;
 
689
 
 
690
    DWORD64   Reserved[5];
 
691
 
 
692
} KDHELP64, *PKDHELP64;
 
693
 
 
694
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
695
#define KDHELP KDHELP64
 
696
#define PKDHELP PKDHELP64
 
697
#else
 
698
typedef struct _KDHELP {
 
699
 
 
700
    //
 
701
    // address of kernel thread object, as provided in the
 
702
    // WAIT_STATE_CHANGE packet.
 
703
    //
 
704
    DWORD   Thread;
 
705
 
 
706
    //
 
707
    // offset in thread object to pointer to the current callback frame
 
708
    // in kernel stack.
 
709
    //
 
710
    DWORD   ThCallbackStack;
 
711
 
 
712
    //
 
713
    // offsets to values in frame:
 
714
    //
 
715
    // address of next callback frame
 
716
    DWORD   NextCallback;
 
717
 
 
718
    // address of saved frame pointer (if applicable)
 
719
    DWORD   FramePointer;
 
720
 
 
721
    //
 
722
    // Address of the kernel function that calls out to user mode
 
723
    //
 
724
    DWORD   KiCallUserMode;
 
725
 
 
726
    //
 
727
    // Address of the user mode dispatcher function
 
728
    //
 
729
    DWORD   KeUserCallbackDispatcher;
 
730
 
 
731
    //
 
732
    // Lowest kernel mode address
 
733
    //
 
734
    DWORD   SystemRangeStart;
 
735
 
 
736
    //
 
737
    // offset in thread object to pointer to the current callback backing
 
738
    // store frame in kernel stack.
 
739
    //
 
740
    DWORD   ThCallbackBStore;
 
741
 
 
742
    //
 
743
    // Address of the user mode exception dispatcher function.
 
744
    // Added in API version 10.
 
745
    //
 
746
    DWORD   KiUserExceptionDispatcher;
 
747
 
 
748
    //
 
749
    // Stack bounds, added in API version 11.
 
750
    //
 
751
    DWORD   StackBase;
 
752
    DWORD   StackLimit;
 
753
 
 
754
    DWORD   Reserved[5];
 
755
 
 
756
} KDHELP, *PKDHELP;
 
757
 
 
758
__inline
 
759
void
 
760
KdHelp32To64(
 
761
    __in PKDHELP p32,
 
762
    __out PKDHELP64 p64
 
763
    )
 
764
{
 
765
    p64->Thread = p32->Thread;
 
766
    p64->ThCallbackStack = p32->ThCallbackStack;
 
767
    p64->NextCallback = p32->NextCallback;
 
768
    p64->FramePointer = p32->FramePointer;
 
769
    p64->KiCallUserMode = p32->KiCallUserMode;
 
770
    p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
 
771
    p64->SystemRangeStart = p32->SystemRangeStart;
 
772
    p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher;
 
773
    p64->StackBase = p32->StackBase;
 
774
    p64->StackLimit = p32->StackLimit;
 
775
}
 
776
#endif
 
777
 
 
778
typedef struct _tagSTACKFRAME64 {
 
779
    ADDRESS64   AddrPC;               // program counter
 
780
    ADDRESS64   AddrReturn;           // return address
 
781
    ADDRESS64   AddrFrame;            // frame pointer
 
782
    ADDRESS64   AddrStack;            // stack pointer
 
783
    ADDRESS64   AddrBStore;           // backing store pointer
 
784
    PVOID       FuncTableEntry;       // pointer to pdata/fpo or NULL
 
785
    DWORD64     Params[4];            // possible arguments to the function
 
786
    BOOL        Far;                  // WOW far call
 
787
    BOOL        Virtual;              // is this a virtual frame?
 
788
    DWORD64     Reserved[3];
 
789
    KDHELP64    KdHelp;
 
790
} STACKFRAME64, *LPSTACKFRAME64;
 
791
 
 
792
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
793
#define STACKFRAME STACKFRAME64
 
794
#define LPSTACKFRAME LPSTACKFRAME64
 
795
#else
 
796
typedef struct _tagSTACKFRAME {
 
797
    ADDRESS     AddrPC;               // program counter
 
798
    ADDRESS     AddrReturn;           // return address
 
799
    ADDRESS     AddrFrame;            // frame pointer
 
800
    ADDRESS     AddrStack;            // stack pointer
 
801
    PVOID       FuncTableEntry;       // pointer to pdata/fpo or NULL
 
802
    DWORD       Params[4];            // possible arguments to the function
 
803
    BOOL        Far;                  // WOW far call
 
804
    BOOL        Virtual;              // is this a virtual frame?
 
805
    DWORD       Reserved[3];
 
806
    KDHELP      KdHelp;
 
807
    ADDRESS     AddrBStore;           // backing store pointer
 
808
} STACKFRAME, *LPSTACKFRAME;
 
809
#endif
 
810
 
 
811
 
 
812
typedef
 
813
BOOL
 
814
(__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(
 
815
    __in HANDLE hProcess,
 
816
    __in DWORD64 qwBaseAddress,
 
817
    __out_bcount(nSize) PVOID lpBuffer,
 
818
    __in DWORD nSize,
 
819
    __out LPDWORD lpNumberOfBytesRead
 
820
    );
 
821
 
 
822
typedef
 
823
PVOID
 
824
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)(
 
825
    __in HANDLE ahProcess,
 
826
    __in DWORD64 AddrBase
 
827
    );
 
828
 
 
829
typedef
 
830
DWORD64
 
831
(__stdcall *PGET_MODULE_BASE_ROUTINE64)(
 
832
    __in HANDLE hProcess,
 
833
    __in DWORD64 Address
 
834
    );
 
835
 
 
836
typedef
 
837
DWORD64
 
838
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(
 
839
    __in HANDLE hProcess,
 
840
    __in HANDLE hThread,
 
841
    __in LPADDRESS64 lpaddr
 
842
    );
 
843
 
 
844
BOOL
 
845
IMAGEAPI
 
846
StackWalk64(
 
847
    __in DWORD MachineType,
 
848
    __in HANDLE hProcess,
 
849
    __in HANDLE hThread,
 
850
    __inout LPSTACKFRAME64 StackFrame,
 
851
    __inout PVOID ContextRecord,
 
852
    __in_opt PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
 
853
    __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
 
854
    __in_opt PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
 
855
    __in_opt PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
 
856
    );
 
857
 
 
858
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
859
 
 
860
#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
 
861
#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
 
862
#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
 
863
#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
 
864
 
 
865
#define StackWalk StackWalk64
 
866
 
 
867
#else
 
868
 
 
869
typedef
 
870
BOOL
 
871
(__stdcall *PREAD_PROCESS_MEMORY_ROUTINE)(
 
872
    __in HANDLE hProcess,
 
873
    __in DWORD lpBaseAddress,
 
874
    __out_bcount(nSize) PVOID lpBuffer,
 
875
    __in DWORD nSize,
 
876
    __out PDWORD lpNumberOfBytesRead
 
877
    );
 
878
 
 
879
typedef
 
880
PVOID
 
881
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)(
 
882
    __in HANDLE hProcess,
 
883
    __in DWORD AddrBase
 
884
    );
 
885
 
 
886
typedef
 
887
DWORD
 
888
(__stdcall *PGET_MODULE_BASE_ROUTINE)(
 
889
    __in HANDLE hProcess,
 
890
    __in DWORD Address
 
891
    );
 
892
 
 
893
typedef
 
894
DWORD
 
895
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE)(
 
896
    __in HANDLE hProcess,
 
897
    __in HANDLE hThread,
 
898
    __out LPADDRESS lpaddr
 
899
    );
 
900
 
 
901
BOOL
 
902
IMAGEAPI
 
903
StackWalk(
 
904
    DWORD MachineType,
 
905
    __in HANDLE hProcess,
 
906
    __in HANDLE hThread,
 
907
    __inout LPSTACKFRAME StackFrame,
 
908
    __inout PVOID ContextRecord,
 
909
    __in_opt PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
 
910
    __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
 
911
    __in_opt PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
 
912
    __in_opt PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
 
913
    );
 
914
 
 
915
#endif
 
916
 
 
917
 
 
918
#define API_VERSION_NUMBER 11
 
919
 
 
920
typedef struct API_VERSION {
 
921
    USHORT  MajorVersion;
 
922
    USHORT  MinorVersion;
 
923
    USHORT  Revision;
 
924
    USHORT  Reserved;
 
925
} API_VERSION, *LPAPI_VERSION;
 
926
 
 
927
LPAPI_VERSION
 
928
IMAGEAPI
 
929
ImagehlpApiVersion(
 
930
    VOID
 
931
    );
 
932
 
 
933
LPAPI_VERSION
 
934
IMAGEAPI
 
935
ImagehlpApiVersionEx(
 
936
    __in LPAPI_VERSION AppVersion
 
937
    );
 
938
 
 
939
DWORD
 
940
IMAGEAPI
 
941
GetTimestampForLoadedLibrary(
 
942
    __in HMODULE Module
 
943
    );
 
944
 
 
945
//
 
946
// typedefs for function pointers
 
947
//
 
948
typedef BOOL
 
949
(CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(
 
950
    __in PCSTR ModuleName,
 
951
    __in DWORD64 BaseOfDll,
 
952
    __in_opt PVOID UserContext
 
953
    );
 
954
 
 
955
typedef BOOL
 
956
(CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(
 
957
    __in PCWSTR ModuleName,
 
958
    __in DWORD64 BaseOfDll,
 
959
    __in_opt PVOID UserContext
 
960
    );
 
961
 
 
962
typedef BOOL
 
963
(CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(
 
964
    __in PCSTR ModuleName,
 
965
    __in DWORD64 ModuleBase,
 
966
    __in ULONG ModuleSize,
 
967
    __in_opt PVOID UserContext
 
968
    );
 
969
 
 
970
typedef BOOL
 
971
(CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(
 
972
    __in PCWSTR ModuleName,
 
973
    __in DWORD64 ModuleBase,
 
974
    __in ULONG ModuleSize,
 
975
    __in_opt PVOID UserContext
 
976
    );
 
977
 
 
978
typedef BOOL
 
979
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(
 
980
    __in PCSTR SymbolName,
 
981
    __in DWORD64 SymbolAddress,
 
982
    __in ULONG SymbolSize,
 
983
    __in_opt PVOID UserContext
 
984
    );
 
985
 
 
986
typedef BOOL
 
987
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(
 
988
    __in PCWSTR SymbolName,
 
989
    __in DWORD64 SymbolAddress,
 
990
    __in ULONG SymbolSize,
 
991
    __in_opt PVOID UserContext
 
992
    );
 
993
 
 
994
typedef BOOL
 
995
(CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(
 
996
    __in HANDLE hProcess,
 
997
    __in ULONG ActionCode,
 
998
    __in_opt ULONG64 CallbackData,
 
999
    __in_opt ULONG64 UserContext
 
1000
    );
 
1001
 
 
1002
typedef
 
1003
PVOID
 
1004
(CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(
 
1005
    __in HANDLE hProcess,
 
1006
    __in DWORD AddrBase,
 
1007
    __in_opt PVOID UserContext
 
1008
    );
 
1009
 
 
1010
typedef
 
1011
PVOID
 
1012
(CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(
 
1013
    __in HANDLE hProcess,
 
1014
    __in ULONG64 AddrBase,
 
1015
    __in ULONG64 UserContext
 
1016
    );
 
1017
 
 
1018
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1019
 
 
1020
#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
 
1021
#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
 
1022
#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
 
1023
#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
 
1024
#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
 
1025
#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
 
1026
 
 
1027
#else
 
1028
 
 
1029
typedef BOOL
 
1030
(CALLBACK *PSYM_ENUMMODULES_CALLBACK)(
 
1031
    __in PCSTR ModuleName,
 
1032
    __in ULONG BaseOfDll,
 
1033
    __in_opt PVOID UserContext
 
1034
    );
 
1035
 
 
1036
typedef BOOL
 
1037
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(
 
1038
    __in PCSTR SymbolName,
 
1039
    __in ULONG SymbolAddress,
 
1040
    __in ULONG SymbolSize,
 
1041
    __in_opt PVOID UserContext
 
1042
    );
 
1043
 
 
1044
typedef BOOL
 
1045
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(
 
1046
    __in PCWSTR SymbolName,
 
1047
    __in ULONG SymbolAddress,
 
1048
    __in ULONG SymbolSize,
 
1049
    __in_opt PVOID UserContext
 
1050
    );
 
1051
 
 
1052
typedef BOOL
 
1053
(CALLBACK *PENUMLOADED_MODULES_CALLBACK)(
 
1054
    __in PCSTR ModuleName,
 
1055
    __in ULONG ModuleBase,
 
1056
    __in ULONG ModuleSize,
 
1057
    __in_opt PVOID UserContext
 
1058
    );
 
1059
 
 
1060
typedef BOOL
 
1061
(CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(
 
1062
    __in HANDLE hProcess,
 
1063
    __in ULONG ActionCode,
 
1064
    __in_opt PVOID CallbackData,
 
1065
    __in_opt PVOID UserContext
 
1066
    );
 
1067
 
 
1068
#endif
 
1069
 
 
1070
 
 
1071
// values found in SYMBOL_INFO.Tag
 
1072
//
 
1073
// This was taken from cvconst.h and should
 
1074
// not override any values found there.
 
1075
//
 
1076
// #define _NO_CVCONST_H_ if you don't
 
1077
// have access to that file...
 
1078
 
 
1079
#ifdef _NO_CVCONST_H
 
1080
 
 
1081
// DIA enums
 
1082
 
 
1083
enum SymTagEnum
 
1084
{
 
1085
    SymTagNull,
 
1086
    SymTagExe,
 
1087
    SymTagCompiland,
 
1088
    SymTagCompilandDetails,
 
1089
    SymTagCompilandEnv,
 
1090
    SymTagFunction,
 
1091
    SymTagBlock,
 
1092
    SymTagData,
 
1093
    SymTagAnnotation,
 
1094
    SymTagLabel,
 
1095
    SymTagPublicSymbol,
 
1096
    SymTagUDT,
 
1097
    SymTagEnum,
 
1098
    SymTagFunctionType,
 
1099
    SymTagPointerType,
 
1100
    SymTagArrayType,
 
1101
    SymTagBaseType,
 
1102
    SymTagTypedef,
 
1103
    SymTagBaseClass,
 
1104
    SymTagFriend,
 
1105
    SymTagFunctionArgType,
 
1106
    SymTagFuncDebugStart,
 
1107
    SymTagFuncDebugEnd,
 
1108
    SymTagUsingNamespace,
 
1109
    SymTagVTableShape,
 
1110
    SymTagVTable,
 
1111
    SymTagCustom,
 
1112
    SymTagThunk,
 
1113
    SymTagCustomType,
 
1114
    SymTagManagedType,
 
1115
    SymTagDimension,
 
1116
    SymTagMax
 
1117
};
 
1118
 
 
1119
#endif
 
1120
 
 
1121
//
 
1122
// flags found in SYMBOL_INFO.Flags
 
1123
//
 
1124
 
 
1125
#define SYMFLAG_VALUEPRESENT     0x00000001
 
1126
#define SYMFLAG_REGISTER         0x00000008
 
1127
#define SYMFLAG_REGREL           0x00000010
 
1128
#define SYMFLAG_FRAMEREL         0x00000020
 
1129
#define SYMFLAG_PARAMETER        0x00000040
 
1130
#define SYMFLAG_LOCAL            0x00000080
 
1131
#define SYMFLAG_CONSTANT         0x00000100
 
1132
#define SYMFLAG_EXPORT           0x00000200
 
1133
#define SYMFLAG_FORWARDER        0x00000400
 
1134
#define SYMFLAG_FUNCTION         0x00000800
 
1135
#define SYMFLAG_VIRTUAL          0x00001000
 
1136
#define SYMFLAG_THUNK            0x00002000
 
1137
#define SYMFLAG_TLSREL           0x00004000
 
1138
#define SYMFLAG_SLOT             0x00008000
 
1139
#define SYMFLAG_ILREL            0x00010000
 
1140
#define SYMFLAG_METADATA         0x00020000
 
1141
#define SYMFLAG_CLR_TOKEN        0x00040000
 
1142
 
 
1143
// this resets SymNext/Prev to the beginning
 
1144
// of the module passed in the address field
 
1145
 
 
1146
#define SYMFLAG_RESET            0x80000000
 
1147
 
 
1148
//
 
1149
// symbol type enumeration
 
1150
//
 
1151
typedef enum {
 
1152
    SymNone = 0,
 
1153
    SymCoff,
 
1154
    SymCv,
 
1155
    SymPdb,
 
1156
    SymExport,
 
1157
    SymDeferred,
 
1158
    SymSym,       // .sym file
 
1159
    SymDia,
 
1160
    SymVirtual,
 
1161
    NumSymTypes
 
1162
} SYM_TYPE;
 
1163
 
 
1164
//
 
1165
// symbol data structure
 
1166
//
 
1167
 
 
1168
typedef struct _IMAGEHLP_SYMBOL64 {
 
1169
    DWORD   SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOL64)
 
1170
    DWORD64 Address;                // virtual address including dll base address
 
1171
    DWORD   Size;                   // estimated size of symbol, can be zero
 
1172
    DWORD   Flags;                  // info about the symbols, see the SYMF defines
 
1173
    DWORD   MaxNameLength;          // maximum size of symbol name in 'Name'
 
1174
    CHAR    Name[1];                // symbol name (null terminated string)
 
1175
} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
 
1176
 
 
1177
typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
 
1178
    IMAGEHLP_SYMBOL64 sym;
 
1179
    CHAR              name[MAX_SYM_NAME + 1];
 
1180
} IMAGEHLP_SYMBOL64_PACKAGE, *PIMAGEHLP_SYMBOL64_PACKAGE;
 
1181
 
 
1182
typedef struct _IMAGEHLP_SYMBOLW64 {
 
1183
    DWORD   SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOLW64)
 
1184
    DWORD64 Address;                // virtual address including dll base address
 
1185
    DWORD   Size;                   // estimated size of symbol, can be zero
 
1186
    DWORD   Flags;                  // info about the symbols, see the SYMF defines
 
1187
    DWORD   MaxNameLength;          // maximum size of symbol name in 'Name'
 
1188
    WCHAR   Name[1];                // symbol name (null terminated string)
 
1189
} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
 
1190
 
 
1191
typedef struct _IMAGEHLP_SYMBOLW64_PACKAGE {
 
1192
    IMAGEHLP_SYMBOLW64 sym;
 
1193
    WCHAR              name[MAX_SYM_NAME + 1];
 
1194
} IMAGEHLP_SYMBOLW64_PACKAGE, *PIMAGEHLP_SYMBOLW64_PACKAGE;
 
1195
 
 
1196
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1197
 
 
1198
 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
 
1199
 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
 
1200
 #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
 
1201
 #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
 
1202
 #define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64
 
1203
 #define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64
 
1204
 #define IMAGEHLP_SYMBOLW_PACKAGE IMAGEHLP_SYMBOLW64_PACKAGE
 
1205
 #define PIMAGEHLP_SYMBOLW_PACKAGE PIMAGEHLP_SYMBOLW64_PACKAGE
 
1206
 
 
1207
#else
 
1208
 
 
1209
 typedef struct _IMAGEHLP_SYMBOL {
 
1210
     DWORD SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOL)
 
1211
     DWORD Address;                // virtual address including dll base address
 
1212
     DWORD Size;                   // estimated size of symbol, can be zero
 
1213
     DWORD Flags;                  // info about the symbols, see the SYMF defines
 
1214
     DWORD                       MaxNameLength;          // maximum size of symbol name in 'Name'
 
1215
     CHAR                        Name[1];                // symbol name (null terminated string)
 
1216
 } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
 
1217
 
 
1218
 typedef struct _IMAGEHLP_SYMBOL_PACKAGE {
 
1219
     IMAGEHLP_SYMBOL sym;
 
1220
     CHAR            name[MAX_SYM_NAME + 1];
 
1221
 } IMAGEHLP_SYMBOL_PACKAGE, *PIMAGEHLP_SYMBOL_PACKAGE;
 
1222
 
 
1223
 typedef struct _IMAGEHLP_SYMBOLW {
 
1224
     DWORD SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOLW)
 
1225
     DWORD Address;                // virtual address including dll base address
 
1226
     DWORD Size;                   // estimated size of symbol, can be zero
 
1227
     DWORD Flags;                  // info about the symbols, see the SYMF defines
 
1228
     DWORD                       MaxNameLength;          // maximum size of symbol name in 'Name'
 
1229
     WCHAR                       Name[1];                // symbol name (null terminated string)
 
1230
 } IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW;
 
1231
 
 
1232
 typedef struct _IMAGEHLP_SYMBOLW_PACKAGE {
 
1233
     IMAGEHLP_SYMBOLW sym;
 
1234
     WCHAR            name[MAX_SYM_NAME + 1];
 
1235
 } IMAGEHLP_SYMBOLW_PACKAGE, *PIMAGEHLP_SYMBOLW_PACKAGE;
 
1236
 
 
1237
#endif
 
1238
 
 
1239
//
 
1240
// module data structure
 
1241
//
 
1242
 
 
1243
typedef struct _IMAGEHLP_MODULE64 {
 
1244
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
 
1245
    DWORD64  BaseOfImage;            // base load address of module
 
1246
    DWORD    ImageSize;              // virtual size of the loaded module
 
1247
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1248
    DWORD    CheckSum;               // checksum from the pe header
 
1249
    DWORD    NumSyms;                // number of symbols in the symbol table
 
1250
    SYM_TYPE SymType;                // type of symbols loaded
 
1251
    CHAR     ModuleName[32];         // module name
 
1252
    CHAR     ImageName[256];         // image name
 
1253
    CHAR     LoadedImageName[256];   // symbol file name
 
1254
    // new elements: 07-Jun-2002
 
1255
    CHAR     LoadedPdbName[256];     // pdb file name
 
1256
    DWORD    CVSig;                  // Signature of the CV record in the debug directories
 
1257
    CHAR     CVData[MAX_PATH * 3];   // Contents of the CV record
 
1258
    DWORD    PdbSig;                 // Signature of PDB
 
1259
    GUID     PdbSig70;               // Signature of PDB (VC 7 and up)
 
1260
    DWORD    PdbAge;                 // DBI age of pdb
 
1261
    BOOL     PdbUnmatched;           // loaded an unmatched pdb
 
1262
    BOOL     DbgUnmatched;           // loaded an unmatched dbg
 
1263
    BOOL     LineNumbers;            // we have line number information
 
1264
    BOOL     GlobalSymbols;          // we have internal symbol information
 
1265
    BOOL     TypeInfo;               // we have type information
 
1266
    // new elements: 17-Dec-2003
 
1267
    BOOL     SourceIndexed;          // pdb supports source server
 
1268
    BOOL     Publics;                // contains public symbols
 
1269
} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
 
1270
 
 
1271
typedef struct _IMAGEHLP_MODULEW64 {
 
1272
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
 
1273
    DWORD64  BaseOfImage;            // base load address of module
 
1274
    DWORD    ImageSize;              // virtual size of the loaded module
 
1275
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1276
    DWORD    CheckSum;               // checksum from the pe header
 
1277
    DWORD    NumSyms;                // number of symbols in the symbol table
 
1278
    SYM_TYPE SymType;                // type of symbols loaded
 
1279
    WCHAR    ModuleName[32];         // module name
 
1280
    WCHAR    ImageName[256];         // image name
 
1281
    // new elements: 07-Jun-2002
 
1282
    WCHAR    LoadedImageName[256];   // symbol file name
 
1283
    WCHAR    LoadedPdbName[256];     // pdb file name
 
1284
    DWORD    CVSig;                  // Signature of the CV record in the debug directories
 
1285
    WCHAR        CVData[MAX_PATH * 3];   // Contents of the CV record
 
1286
    DWORD    PdbSig;                 // Signature of PDB
 
1287
    GUID     PdbSig70;               // Signature of PDB (VC 7 and up)
 
1288
    DWORD    PdbAge;                 // DBI age of pdb
 
1289
    BOOL     PdbUnmatched;           // loaded an unmatched pdb
 
1290
    BOOL     DbgUnmatched;           // loaded an unmatched dbg
 
1291
    BOOL     LineNumbers;            // we have line number information
 
1292
    BOOL     GlobalSymbols;          // we have internal symbol information
 
1293
    BOOL     TypeInfo;               // we have type information
 
1294
    // new elements: 17-Dec-2003
 
1295
    BOOL     SourceIndexed;          // pdb supports source server
 
1296
    BOOL     Publics;                // contains public symbols
 
1297
} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
 
1298
 
 
1299
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1300
#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
 
1301
#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
 
1302
#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
 
1303
#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
 
1304
#else
 
1305
typedef struct _IMAGEHLP_MODULE {
 
1306
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE)
 
1307
    DWORD    BaseOfImage;            // base load address of module
 
1308
    DWORD    ImageSize;              // virtual size of the loaded module
 
1309
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1310
    DWORD    CheckSum;               // checksum from the pe header
 
1311
    DWORD    NumSyms;                // number of symbols in the symbol table
 
1312
    SYM_TYPE SymType;                // type of symbols loaded
 
1313
    CHAR     ModuleName[32];         // module name
 
1314
    CHAR     ImageName[256];         // image name
 
1315
    CHAR     LoadedImageName[256];   // symbol file name
 
1316
} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
 
1317
 
 
1318
typedef struct _IMAGEHLP_MODULEW {
 
1319
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE)
 
1320
    DWORD    BaseOfImage;            // base load address of module
 
1321
    DWORD    ImageSize;              // virtual size of the loaded module
 
1322
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1323
    DWORD    CheckSum;               // checksum from the pe header
 
1324
    DWORD    NumSyms;                // number of symbols in the symbol table
 
1325
    SYM_TYPE SymType;                // type of symbols loaded
 
1326
    WCHAR    ModuleName[32];         // module name
 
1327
    WCHAR    ImageName[256];         // image name
 
1328
    WCHAR    LoadedImageName[256];   // symbol file name
 
1329
} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
 
1330
#endif
 
1331
 
 
1332
//
 
1333
// source file line data structure
 
1334
//
 
1335
 
 
1336
typedef struct _IMAGEHLP_LINE64 {
 
1337
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE64)
 
1338
    PVOID    Key;                    // internal
 
1339
    DWORD    LineNumber;             // line number in file
 
1340
    PCHAR    FileName;               // full filename
 
1341
    DWORD64  Address;                // first instruction of line
 
1342
} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
 
1343
 
 
1344
typedef struct _IMAGEHLP_LINEW64 {
 
1345
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE64)
 
1346
    PVOID    Key;                    // internal
 
1347
    DWORD    LineNumber;             // line number in file
 
1348
    PWSTR    FileName;               // full filename
 
1349
    DWORD64  Address;                // first instruction of line
 
1350
} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
 
1351
 
 
1352
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1353
#define IMAGEHLP_LINE IMAGEHLP_LINE64
 
1354
#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
 
1355
#else
 
1356
typedef struct _IMAGEHLP_LINE {
 
1357
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE)
 
1358
    PVOID    Key;                    // internal
 
1359
    DWORD    LineNumber;             // line number in file
 
1360
    PCHAR    FileName;               // full filename
 
1361
    DWORD    Address;                // first instruction of line
 
1362
} IMAGEHLP_LINE, *PIMAGEHLP_LINE;
 
1363
 
 
1364
typedef struct _IMAGEHLP_LINEW {
 
1365
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE64)
 
1366
    PVOID    Key;                    // internal
 
1367
    DWORD    LineNumber;             // line number in file
 
1368
    PCHAR    FileName;               // full filename
 
1369
    DWORD64  Address;                // first instruction of line
 
1370
} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
 
1371
#endif
 
1372
 
 
1373
//
 
1374
// source file structure
 
1375
//
 
1376
 
 
1377
typedef struct _SOURCEFILE {
 
1378
    DWORD64  ModBase;                // base address of loaded module
 
1379
    PCHAR    FileName;               // full filename of source
 
1380
} SOURCEFILE, *PSOURCEFILE;
 
1381
 
 
1382
typedef struct _SOURCEFILEW {
 
1383
    DWORD64  ModBase;                // base address of loaded module
 
1384
    PWSTR    FileName;               // full filename of source
 
1385
} SOURCEFILEW, *PSOURCEFILEW;
 
1386
 
 
1387
//
 
1388
// data structures used for registered symbol callbacks
 
1389
//
 
1390
 
 
1391
#define CBA_DEFERRED_SYMBOL_LOAD_START          0x00000001
 
1392
#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE       0x00000002
 
1393
#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE        0x00000003
 
1394
#define CBA_SYMBOLS_UNLOADED                    0x00000004
 
1395
#define CBA_DUPLICATE_SYMBOL                    0x00000005
 
1396
#define CBA_READ_MEMORY                         0x00000006
 
1397
#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL         0x00000007
 
1398
#define CBA_SET_OPTIONS                         0x00000008
 
1399
#define CBA_EVENT                               0x00000010
 
1400
#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL        0x00000020
 
1401
#define CBA_DEBUG_INFO                          0x10000000
 
1402
#define CBA_SRCSRV_INFO                         0x20000000
 
1403
#define CBA_SRCSRV_EVENT                        0x40000000
 
1404
 
 
1405
typedef struct _IMAGEHLP_CBA_READ_MEMORY {
 
1406
    DWORD64   addr;                                     // address to read from
 
1407
    PVOID     buf;                                      // buffer to read to
 
1408
    DWORD     bytes;                                    // amount of bytes to read
 
1409
    DWORD    *bytesread;                                // pointer to store amount of bytes read
 
1410
} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
 
1411
 
 
1412
enum {
 
1413
    sevInfo = 0,
 
1414
    sevProblem,
 
1415
    sevAttn,
 
1416
    sevFatal,
 
1417
    sevMax  // unused
 
1418
};
 
1419
 
 
1420
#define EVENT_SRCSPEW_START 100
 
1421
#define EVENT_SRCSPEW       100
 
1422
#define EVENT_SRCSPEW_END   199
 
1423
 
 
1424
typedef struct _IMAGEHLP_CBA_EVENT {
 
1425
    DWORD severity;                                     // values from sevInfo to sevFatal
 
1426
    DWORD code;                                         // numerical code IDs the error
 
1427
    PCHAR desc;                                         // may contain a text description of the error
 
1428
    PVOID object;                                       // value dependant upon the error code
 
1429
} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
 
1430
 
 
1431
typedef struct _IMAGEHLP_CBA_EVENTW {
 
1432
    DWORD  severity;                                     // values from sevInfo to sevFatal
 
1433
    DWORD  code;                                         // numerical code IDs the error
 
1434
    PCWSTR desc;                                         // may contain a text description of the error
 
1435
    PVOID  object;                                       // value dependant upon the error code
 
1436
} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
 
1437
 
 
1438
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
 
1439
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
 
1440
    DWORD64  BaseOfImage;            // base load address of module
 
1441
    DWORD    CheckSum;               // checksum from the pe header
 
1442
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1443
    CHAR     FileName[MAX_PATH];     // symbols file or image name
 
1444
    BOOLEAN  Reparse;                // load failure reparse
 
1445
    HANDLE   hFile;                  // file handle, if passed
 
1446
    DWORD    Flags;                     //
 
1447
} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
 
1448
 
 
1449
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
 
1450
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOADW64)
 
1451
    DWORD64  BaseOfImage;            // base load address of module
 
1452
    DWORD    CheckSum;               // checksum from the pe header
 
1453
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1454
    WCHAR    FileName[MAX_PATH + 1]; // symbols file or image name
 
1455
    BOOLEAN  Reparse;                // load failure reparse
 
1456
    HANDLE   hFile;                  // file handle, if passed
 
1457
    DWORD    Flags;         //
 
1458
} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
 
1459
 
 
1460
#define DSLFLAG_MISMATCHED_PDB  0x1
 
1461
#define DSLFLAG_MISMATCHED_DBG  0x2
 
1462
 
 
1463
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1464
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
 
1465
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
 
1466
#else
 
1467
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
 
1468
    DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
 
1469
    DWORD    BaseOfImage;            // base load address of module
 
1470
    DWORD    CheckSum;               // checksum from the pe header
 
1471
    DWORD    TimeDateStamp;          // date/time stamp from pe header
 
1472
    CHAR     FileName[MAX_PATH];     // symbols file or image name
 
1473
    BOOLEAN  Reparse;                // load failure reparse
 
1474
    HANDLE   hFile;                  // file handle, if passed
 
1475
} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
 
1476
#endif
 
1477
 
 
1478
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
 
1479
    DWORD              SizeOfStruct;           // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
 
1480
    DWORD              NumberOfDups;           // number of duplicates in the Symbol array
 
1481
    PIMAGEHLP_SYMBOL64 Symbol;                 // array of duplicate symbols
 
1482
    DWORD              SelectedSymbol;         // symbol selected (-1 to start)
 
1483
} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
 
1484
 
 
1485
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1486
#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
 
1487
#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
 
1488
#else
 
1489
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
 
1490
    DWORD            SizeOfStruct;           // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
 
1491
    DWORD            NumberOfDups;           // number of duplicates in the Symbol array
 
1492
    PIMAGEHLP_SYMBOL Symbol;                 // array of duplicate symbols
 
1493
    DWORD            SelectedSymbol;         // symbol selected (-1 to start)
 
1494
} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
 
1495
#endif
 
1496
 
 
1497
// If dbghelp ever needs to display graphical UI, it will use this as the parent window.
 
1498
 
 
1499
BOOL
 
1500
IMAGEAPI
 
1501
SymSetParentWindow(
 
1502
    __in HWND hwnd
 
1503
    );
 
1504
 
 
1505
PCHAR
 
1506
IMAGEAPI
 
1507
SymSetHomeDirectory(
 
1508
    __in_opt HANDLE hProcess,
 
1509
    __in_opt PCSTR dir
 
1510
    );
 
1511
 
 
1512
PWSTR
 
1513
IMAGEAPI
 
1514
SymSetHomeDirectoryW(
 
1515
    __in_opt HANDLE hProcess,
 
1516
    __in_opt PCWSTR dir
 
1517
    );
 
1518
 
 
1519
PCHAR
 
1520
IMAGEAPI
 
1521
SymGetHomeDirectory(
 
1522
    __in DWORD type,
 
1523
    __out_ecount(size) PSTR dir,
 
1524
    __in size_t size
 
1525
    );
 
1526
 
 
1527
PWSTR
 
1528
IMAGEAPI
 
1529
SymGetHomeDirectoryW(
 
1530
    __in DWORD type,
 
1531
    __out_ecount(size) PWSTR dir,
 
1532
    __in size_t size
 
1533
    );
 
1534
 
 
1535
typedef enum {
 
1536
    hdBase = 0, // root directory for dbghelp
 
1537
    hdSym,      // where symbols are stored
 
1538
    hdSrc,      // where source is stored
 
1539
    hdMax       // end marker
 
1540
};
 
1541
 
 
1542
typedef struct _OMAP {
 
1543
    ULONG  rva;
 
1544
    ULONG  rvaTo;
 
1545
} OMAP, *POMAP;
 
1546
 
 
1547
BOOL
 
1548
IMAGEAPI
 
1549
SymGetOmaps(
 
1550
    __in HANDLE hProcess,
 
1551
    __in DWORD64 BaseOfDll,
 
1552
    __out POMAP *OmapTo,
 
1553
    __out PDWORD64 cOmapTo,
 
1554
    __out POMAP *OmapFrom,
 
1555
    __out PDWORD64 cOmapFrom
 
1556
    );
 
1557
 
 
1558
//
 
1559
// options that are set/returned by SymSetOptions() & SymGetOptions()
 
1560
// these are used as a mask
 
1561
//
 
1562
#define SYMOPT_CASE_INSENSITIVE          0x00000001
 
1563
#define SYMOPT_UNDNAME                   0x00000002
 
1564
#define SYMOPT_DEFERRED_LOADS            0x00000004
 
1565
#define SYMOPT_NO_CPP                    0x00000008
 
1566
#define SYMOPT_LOAD_LINES                0x00000010
 
1567
#define SYMOPT_OMAP_FIND_NEAREST         0x00000020
 
1568
#define SYMOPT_LOAD_ANYTHING             0x00000040
 
1569
#define SYMOPT_IGNORE_CVREC              0x00000080
 
1570
#define SYMOPT_NO_UNQUALIFIED_LOADS      0x00000100
 
1571
#define SYMOPT_FAIL_CRITICAL_ERRORS      0x00000200
 
1572
#define SYMOPT_EXACT_SYMBOLS             0x00000400
 
1573
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS    0x00000800
 
1574
#define SYMOPT_IGNORE_NT_SYMPATH         0x00001000
 
1575
#define SYMOPT_INCLUDE_32BIT_MODULES     0x00002000
 
1576
#define SYMOPT_PUBLICS_ONLY              0x00004000
 
1577
#define SYMOPT_NO_PUBLICS                0x00008000
 
1578
#define SYMOPT_AUTO_PUBLICS              0x00010000
 
1579
#define SYMOPT_NO_IMAGE_SEARCH           0x00020000
 
1580
#define SYMOPT_SECURE                    0x00040000
 
1581
#define SYMOPT_NO_PROMPTS                0x00080000
 
1582
#define SYMOPT_OVERWRITE                 0x00100000
 
1583
#define SYMOPT_IGNORE_IMAGEDIR           0x00200000
 
1584
#define SYMOPT_FLAT_DIRECTORY            0x00400000
 
1585
#define SYMOPT_FAVOR_COMPRESSED          0x00800000
 
1586
#define SYMOPT_ALLOW_ZERO_ADDRESS        0x01000000
 
1587
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000
 
1588
 
 
1589
#define SYMOPT_DEBUG                     0x80000000
 
1590
 
 
1591
DWORD
 
1592
IMAGEAPI
 
1593
SymSetOptions(
 
1594
    __in DWORD   SymOptions
 
1595
    );
 
1596
 
 
1597
DWORD
 
1598
IMAGEAPI
 
1599
SymGetOptions(
 
1600
    VOID
 
1601
    );
 
1602
 
 
1603
BOOL
 
1604
IMAGEAPI
 
1605
SymCleanup(
 
1606
    __in HANDLE hProcess
 
1607
    );
 
1608
 
 
1609
BOOL
 
1610
IMAGEAPI
 
1611
SymMatchString(
 
1612
    __in PCSTR string,
 
1613
    __in PCSTR expression,
 
1614
    __in BOOL fCase
 
1615
    );
 
1616
 
 
1617
BOOL
 
1618
IMAGEAPI
 
1619
SymMatchStringA(
 
1620
    __in PCSTR string,
 
1621
    __in PCSTR expression,
 
1622
    __in BOOL fCase
 
1623
    );
 
1624
 
 
1625
BOOL
 
1626
IMAGEAPI
 
1627
SymMatchStringW(
 
1628
    __in PCWSTR string,
 
1629
    __in PCWSTR expression,
 
1630
    __in BOOL fCase
 
1631
    );
 
1632
 
 
1633
typedef BOOL
 
1634
(CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(
 
1635
    __in PSOURCEFILE pSourceFile,
 
1636
    __in_opt PVOID UserContext
 
1637
    );
 
1638
 
 
1639
// for backwards compatibility - don't use this
 
1640
#define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK
 
1641
 
 
1642
BOOL
 
1643
IMAGEAPI
 
1644
SymEnumSourceFiles(
 
1645
    __in HANDLE hProcess,
 
1646
    __in ULONG64 ModBase,
 
1647
    __in_opt PCSTR Mask,
 
1648
    __in PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,
 
1649
    __in_opt PVOID UserContext
 
1650
    );
 
1651
 
 
1652
typedef BOOL
 
1653
(CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(
 
1654
    __in PSOURCEFILEW pSourceFile,
 
1655
    __in_opt PVOID UserContext
 
1656
    );
 
1657
 
 
1658
BOOL
 
1659
IMAGEAPI
 
1660
SymEnumSourceFilesW(
 
1661
    __in HANDLE hProcess,
 
1662
    __in ULONG64 ModBase,
 
1663
    __in_opt PCWSTR Mask,
 
1664
    __in PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,
 
1665
    __in_opt PVOID UserContext
 
1666
    );
 
1667
 
 
1668
BOOL
 
1669
IMAGEAPI
 
1670
SymEnumerateModules64(
 
1671
    __in HANDLE hProcess,
 
1672
    __in PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,
 
1673
    __in_opt PVOID UserContext
 
1674
    );
 
1675
 
 
1676
BOOL
 
1677
IMAGEAPI
 
1678
SymEnumerateModulesW64(
 
1679
    __in HANDLE hProcess,
 
1680
    __in PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,
 
1681
    __in_opt PVOID UserContext
 
1682
    );
 
1683
 
 
1684
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1685
#define SymEnumerateModules SymEnumerateModules64
 
1686
#else
 
1687
BOOL
 
1688
IMAGEAPI
 
1689
SymEnumerateModules(
 
1690
    __in HANDLE hProcess,
 
1691
    __in PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
 
1692
    __in_opt PVOID UserContext
 
1693
    );
 
1694
#endif
 
1695
 
 
1696
BOOL
 
1697
IMAGEAPI
 
1698
EnumerateLoadedModulesEx(
 
1699
    __in HANDLE hProcess,
 
1700
    __in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
 
1701
    __in_opt PVOID UserContext
 
1702
    );
 
1703
    
 
1704
BOOL
 
1705
IMAGEAPI
 
1706
EnumerateLoadedModulesExW(
 
1707
    __in HANDLE hProcess,
 
1708
    __in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
 
1709
    __in_opt PVOID UserContext
 
1710
    );
 
1711
 
 
1712
BOOL
 
1713
IMAGEAPI
 
1714
EnumerateLoadedModules64(
 
1715
    __in HANDLE hProcess,
 
1716
    __in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
 
1717
    __in_opt PVOID UserContext
 
1718
    );
 
1719
 
 
1720
BOOL
 
1721
IMAGEAPI
 
1722
EnumerateLoadedModulesW64(
 
1723
    __in HANDLE hProcess,
 
1724
    __in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
 
1725
    __in_opt PVOID UserContext
 
1726
    );
 
1727
 
 
1728
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1729
#define EnumerateLoadedModules EnumerateLoadedModules64
 
1730
#else
 
1731
BOOL
 
1732
IMAGEAPI
 
1733
EnumerateLoadedModules(
 
1734
    __in HANDLE hProcess,
 
1735
    __in PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
 
1736
    __in_opt PVOID UserContext
 
1737
    );
 
1738
#endif
 
1739
 
 
1740
PVOID
 
1741
IMAGEAPI
 
1742
SymFunctionTableAccess64(
 
1743
    __in HANDLE hProcess,
 
1744
    __in DWORD64 AddrBase
 
1745
    );
 
1746
 
 
1747
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1748
#define SymFunctionTableAccess SymFunctionTableAccess64
 
1749
#else
 
1750
PVOID
 
1751
IMAGEAPI
 
1752
SymFunctionTableAccess(
 
1753
    __in HANDLE hProcess,
 
1754
    __in DWORD AddrBase
 
1755
    );
 
1756
#endif
 
1757
 
 
1758
BOOL
 
1759
IMAGEAPI
 
1760
SymGetUnwindInfo(
 
1761
    __in HANDLE hProcess,
 
1762
    __in DWORD64 Address,
 
1763
    __out_bcount_opt(*Size) PVOID Buffer,
 
1764
    __inout PULONG Size
 
1765
    );
 
1766
 
 
1767
BOOL
 
1768
IMAGEAPI
 
1769
SymGetModuleInfo64(
 
1770
    __in HANDLE hProcess,
 
1771
    __in DWORD64 qwAddr,
 
1772
    __out PIMAGEHLP_MODULE64 ModuleInfo
 
1773
    );
 
1774
 
 
1775
BOOL
 
1776
IMAGEAPI
 
1777
SymGetModuleInfoW64(
 
1778
    __in HANDLE hProcess,
 
1779
    __in DWORD64 qwAddr,
 
1780
    __out PIMAGEHLP_MODULEW64 ModuleInfo
 
1781
    );
 
1782
 
 
1783
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1784
#define SymGetModuleInfo   SymGetModuleInfo64
 
1785
#define SymGetModuleInfoW  SymGetModuleInfoW64
 
1786
#else
 
1787
BOOL
 
1788
IMAGEAPI
 
1789
SymGetModuleInfo(
 
1790
    __in HANDLE hProcess,
 
1791
    __in DWORD dwAddr,
 
1792
    __out PIMAGEHLP_MODULE ModuleInfo
 
1793
    );
 
1794
 
 
1795
BOOL
 
1796
IMAGEAPI
 
1797
SymGetModuleInfoW(
 
1798
    __in HANDLE hProcess,
 
1799
    __in DWORD dwAddr,
 
1800
    __out PIMAGEHLP_MODULEW ModuleInfo
 
1801
    );
 
1802
#endif
 
1803
 
 
1804
DWORD64
 
1805
IMAGEAPI
 
1806
SymGetModuleBase64(
 
1807
    __in HANDLE hProcess,
 
1808
    __in DWORD64 qwAddr
 
1809
    );
 
1810
 
 
1811
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1812
#define SymGetModuleBase SymGetModuleBase64
 
1813
#else
 
1814
DWORD
 
1815
IMAGEAPI
 
1816
SymGetModuleBase(
 
1817
    __in HANDLE hProcess,
 
1818
    __in DWORD dwAddr
 
1819
    );
 
1820
#endif
 
1821
 
 
1822
typedef struct _SRCCODEINFO {
 
1823
    DWORD   SizeOfStruct;           // set to sizeof(SRCCODEINFO)
 
1824
    PVOID   Key;                    // not used
 
1825
    DWORD64 ModBase;                // base address of module this applies to
 
1826
    CHAR    Obj[MAX_PATH + 1];      // the object file within the module
 
1827
    CHAR    FileName[MAX_PATH + 1]; // full filename
 
1828
    DWORD   LineNumber;             // line number in file
 
1829
    DWORD64 Address;                // first instruction of line
 
1830
} SRCCODEINFO, *PSRCCODEINFO;
 
1831
 
 
1832
typedef struct _SRCCODEINFOW {
 
1833
    DWORD   SizeOfStruct;           // set to sizeof(SRCCODEINFO)
 
1834
    PVOID   Key;                    // not used
 
1835
    DWORD64 ModBase;                // base address of module this applies to
 
1836
    WCHAR   Obj[MAX_PATH + 1];      // the object file within the module
 
1837
    WCHAR   FileName[MAX_PATH + 1]; // full filename
 
1838
    DWORD   LineNumber;             // line number in file
 
1839
    DWORD64 Address;                // first instruction of line
 
1840
} SRCCODEINFOW, *PSRCCODEINFOW;
 
1841
 
 
1842
typedef BOOL
 
1843
(CALLBACK *PSYM_ENUMLINES_CALLBACK)(
 
1844
    __in PSRCCODEINFO LineInfo,
 
1845
    __in_opt PVOID UserContext
 
1846
    );
 
1847
 
 
1848
BOOL
 
1849
IMAGEAPI
 
1850
SymEnumLines(
 
1851
    __in HANDLE hProcess,
 
1852
    __in ULONG64 Base,
 
1853
    __in_opt PCSTR Obj,
 
1854
    __in_opt PCSTR File,
 
1855
    __in PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
 
1856
    __in_opt PVOID UserContext
 
1857
    );
 
1858
 
 
1859
typedef BOOL
 
1860
(CALLBACK *PSYM_ENUMLINES_CALLBACKW)(
 
1861
    __in PSRCCODEINFOW LineInfo,
 
1862
    __in_opt PVOID UserContext
 
1863
    );
 
1864
 
 
1865
BOOL
 
1866
IMAGEAPI
 
1867
SymEnumLinesW(
 
1868
    __in HANDLE hProcess,
 
1869
    __in ULONG64 Base,
 
1870
    __in_opt PCWSTR Obj,
 
1871
    __in_opt PCWSTR File,
 
1872
    __in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
 
1873
    __in_opt PVOID UserContext
 
1874
    );
 
1875
 
 
1876
BOOL
 
1877
IMAGEAPI
 
1878
SymGetLineFromAddr64(
 
1879
    __in HANDLE hProcess,
 
1880
    __in DWORD64 qwAddr,
 
1881
    __out PDWORD pdwDisplacement,
 
1882
    __out PIMAGEHLP_LINE64 Line64
 
1883
    );
 
1884
 
 
1885
BOOL
 
1886
IMAGEAPI
 
1887
SymGetLineFromAddrW64(
 
1888
    __in HANDLE hProcess,
 
1889
    __in DWORD64 dwAddr,
 
1890
    __out PDWORD pdwDisplacement,
 
1891
    __out PIMAGEHLP_LINEW64 Line
 
1892
    );
 
1893
 
 
1894
BOOL
 
1895
IMAGEAPI
 
1896
SymEnumSourceLines(
 
1897
    __in HANDLE hProcess,
 
1898
    __in ULONG64 Base,
 
1899
    __in_opt PCSTR Obj,
 
1900
    __in_opt PCSTR File,
 
1901
    __in_opt DWORD Line,
 
1902
    __in DWORD Flags,
 
1903
    __in PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
 
1904
    __in_opt PVOID UserContext
 
1905
    );
 
1906
 
 
1907
BOOL
 
1908
IMAGEAPI
 
1909
SymEnumSourceLinesW(
 
1910
    __in HANDLE hProcess,
 
1911
    __in ULONG64 Base,
 
1912
    __in_opt PCWSTR Obj,
 
1913
    __in_opt PCWSTR File,
 
1914
    __in_opt DWORD Line,
 
1915
    __in DWORD Flags,
 
1916
    __in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
 
1917
    __in_opt PVOID UserContext
 
1918
    );
 
1919
 
 
1920
// flags for SymEnumSourceLines
 
1921
 
 
1922
#define ESLFLAG_FULLPATH        0x1
 
1923
#define ESLFLAG_NEAREST         0x2
 
1924
#define ESLFLAG_PREV            0x4
 
1925
#define ESLFLAG_NEXT            0x8
 
1926
 
 
1927
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1928
#define SymGetLineFromAddr SymGetLineFromAddr64
 
1929
#define SymGetLineFromAddrW SymGetLineFromAddrW64
 
1930
#else
 
1931
BOOL
 
1932
IMAGEAPI
 
1933
SymGetLineFromAddr(
 
1934
    __in HANDLE hProcess,
 
1935
    __in DWORD dwAddr,
 
1936
    __out PDWORD pdwDisplacement,
 
1937
    __out PIMAGEHLP_LINE Line
 
1938
    );
 
1939
 
 
1940
BOOL
 
1941
IMAGEAPI
 
1942
SymGetLineFromAddrW(
 
1943
    __in HANDLE hProcess,
 
1944
    __in DWORD dwAddr,
 
1945
    __out PDWORD pdwDisplacement,
 
1946
    __out PIMAGEHLP_LINEW Line
 
1947
    );
 
1948
#endif
 
1949
 
 
1950
BOOL
 
1951
IMAGEAPI
 
1952
SymGetLineFromName64(
 
1953
    __in HANDLE hProcess,
 
1954
    __in_opt PCSTR ModuleName,
 
1955
    __in_opt PCSTR FileName,
 
1956
    __in DWORD dwLineNumber,
 
1957
    __out PLONG plDisplacement,
 
1958
    __inout PIMAGEHLP_LINE64 Line
 
1959
    );
 
1960
 
 
1961
BOOL
 
1962
IMAGEAPI
 
1963
SymGetLineFromNameW64(
 
1964
    __in HANDLE hProcess,
 
1965
    __in_opt PCWSTR ModuleName,
 
1966
    __in_opt PCWSTR FileName,
 
1967
    __in DWORD dwLineNumber,
 
1968
    __out PLONG plDisplacement,
 
1969
    __inout PIMAGEHLP_LINEW64 Line
 
1970
    );
 
1971
 
 
1972
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
1973
#define SymGetLineFromName SymGetLineFromName64
 
1974
#else
 
1975
BOOL
 
1976
IMAGEAPI
 
1977
SymGetLineFromName(
 
1978
    __in HANDLE hProcess,
 
1979
    __in_opt PCSTR ModuleName,
 
1980
    __in_opt PCSTR FileName,
 
1981
    __in DWORD dwLineNumber,
 
1982
    __out PLONG plDisplacement,
 
1983
    __inout PIMAGEHLP_LINE Line
 
1984
    );
 
1985
#endif
 
1986
 
 
1987
BOOL
 
1988
IMAGEAPI
 
1989
SymGetLineNext64(
 
1990
    __in HANDLE hProcess,
 
1991
    __inout PIMAGEHLP_LINE64 Line
 
1992
    );
 
1993
 
 
1994
BOOL
 
1995
IMAGEAPI
 
1996
SymGetLineNextW64(
 
1997
    __in HANDLE hProcess,
 
1998
    __inout PIMAGEHLP_LINEW64 Line
 
1999
    );
 
2000
 
 
2001
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
2002
#define SymGetLineNext SymGetLineNext64
 
2003
#else
 
2004
BOOL
 
2005
IMAGEAPI
 
2006
SymGetLineNext(
 
2007
    __in HANDLE hProcess,
 
2008
    __inout PIMAGEHLP_LINE Line
 
2009
    );
 
2010
 
 
2011
BOOL
 
2012
IMAGEAPI
 
2013
SymGetLineNextW(
 
2014
    __in HANDLE hProcess,
 
2015
    __inout PIMAGEHLP_LINEW Line
 
2016
    );
 
2017
#endif
 
2018
 
 
2019
BOOL
 
2020
IMAGEAPI
 
2021
SymGetLinePrev64(
 
2022
    __in HANDLE hProcess,
 
2023
    __inout PIMAGEHLP_LINE64 Line
 
2024
    );
 
2025
 
 
2026
BOOL
 
2027
IMAGEAPI
 
2028
SymGetLinePrevW64(
 
2029
    __in HANDLE hProcess,
 
2030
    __inout PIMAGEHLP_LINEW64 Line
 
2031
    );
 
2032
 
 
2033
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
2034
#define SymGetLinePrev SymGetLinePrev64
 
2035
#else
 
2036
BOOL
 
2037
IMAGEAPI
 
2038
SymGetLinePrev(
 
2039
    __in HANDLE hProcess,
 
2040
    __inout PIMAGEHLP_LINE Line
 
2041
    );
 
2042
 
 
2043
BOOL
 
2044
IMAGEAPI
 
2045
SymGetLinePrevW(
 
2046
    __in HANDLE hProcess,
 
2047
    __inout PIMAGEHLP_LINEW Line
 
2048
    );
 
2049
#endif
 
2050
 
 
2051
ULONG
 
2052
IMAGEAPI
 
2053
SymGetFileLineOffsets64(
 
2054
    __in HANDLE hProcess,
 
2055
    __in_opt PCSTR ModuleName,
 
2056
    __in PCSTR FileName,
 
2057
    __out_ecount(BufferLines) PDWORD64 Buffer,
 
2058
    __in ULONG BufferLines
 
2059
    );
 
2060
 
 
2061
BOOL
 
2062
IMAGEAPI
 
2063
SymMatchFileName(
 
2064
    __in PCSTR FileName,
 
2065
    __in PCSTR Match,
 
2066
    __deref_opt_out PSTR *FileNameStop,
 
2067
    __deref_opt_out PSTR *MatchStop
 
2068
    );
 
2069
 
 
2070
BOOL
 
2071
IMAGEAPI
 
2072
SymMatchFileNameW(
 
2073
    __in PCWSTR FileName,
 
2074
    __in PCWSTR Match,
 
2075
    __deref_opt_out PWSTR *FileNameStop,
 
2076
    __deref_opt_out PWSTR *MatchStop
 
2077
    );
 
2078
 
 
2079
BOOL
 
2080
IMAGEAPI
 
2081
SymGetSourceFile(
 
2082
    __in HANDLE hProcess,
 
2083
    __in ULONG64 Base,
 
2084
    __in_opt PCSTR Params,
 
2085
    __in PCSTR FileSpec,
 
2086
    __out_ecount(Size) PSTR FilePath,
 
2087
    __in DWORD Size
 
2088
    );
 
2089
 
 
2090
BOOL
 
2091
IMAGEAPI
 
2092
SymGetSourceFileW(
 
2093
    __in HANDLE hProcess,
 
2094
    __in ULONG64 Base,
 
2095
    __in_opt PCWSTR Params,
 
2096
    __in PCWSTR FileSpec,
 
2097
    __out_ecount(Size) PWSTR FilePath,
 
2098
    __in DWORD Size
 
2099
    );
 
2100
 
 
2101
BOOL
 
2102
IMAGEAPI
 
2103
SymGetSourceFileToken(
 
2104
    __in HANDLE hProcess,
 
2105
    __in ULONG64 Base,
 
2106
    __in PCSTR FileSpec,
 
2107
    __deref_out PVOID *Token,
 
2108
    __out DWORD *Size
 
2109
    );
 
2110
 
 
2111
BOOL
 
2112
IMAGEAPI
 
2113
SymGetSourceFileTokenW(
 
2114
    __in HANDLE hProcess,
 
2115
    __in ULONG64 Base,
 
2116
    __in PCWSTR FileSpec,
 
2117
    __deref_out PVOID *Token,
 
2118
    __out DWORD *Size
 
2119
    );
 
2120
 
 
2121
BOOL
 
2122
IMAGEAPI
 
2123
SymGetSourceFileFromToken(
 
2124
    __in HANDLE hProcess,
 
2125
    __in PVOID Token,
 
2126
    __in_opt PCSTR Params,
 
2127
    __out_ecount(Size) PSTR FilePath,
 
2128
    __in DWORD Size
 
2129
    );
 
2130
 
 
2131
BOOL
 
2132
IMAGEAPI
 
2133
SymGetSourceFileFromTokenW(
 
2134
    __in HANDLE hProcess,
 
2135
    __in PVOID Token,
 
2136
    __in_opt PCWSTR Params,
 
2137
    __out_ecount(Size) PWSTR FilePath,
 
2138
    __in DWORD Size
 
2139
    );
 
2140
 
 
2141
BOOL
 
2142
IMAGEAPI
 
2143
SymGetSourceVarFromToken(
 
2144
    __in HANDLE hProcess,
 
2145
    __in PVOID Token,
 
2146
    __in_opt PCSTR Params,
 
2147
    __in PCSTR VarName,
 
2148
    __out_ecount(Size) PSTR Value,
 
2149
    __in DWORD Size
 
2150
    );
 
2151
 
 
2152
BOOL
 
2153
IMAGEAPI
 
2154
SymGetSourceVarFromTokenW(
 
2155
    __in HANDLE hProcess,
 
2156
    __in PVOID Token,
 
2157
    __in_opt PCWSTR Params,
 
2158
    __in PCWSTR VarName,
 
2159
    __out_ecount(Size) PWSTR Value,
 
2160
    __in DWORD Size
 
2161
    );
 
2162
 
 
2163
typedef BOOL (CALLBACK *PENUMSOURCEFILETOKENSCALLBACK)(__in PVOID token,  __in size_t size);
 
2164
 
 
2165
BOOL
 
2166
IMAGEAPI
 
2167
SymEnumSourceFileTokens(
 
2168
    __in HANDLE hProcess,
 
2169
    __in ULONG64 Base,
 
2170
    __in PENUMSOURCEFILETOKENSCALLBACK Callback
 
2171
    );
 
2172
 
 
2173
BOOL
 
2174
IMAGEAPI
 
2175
SymInitialize(
 
2176
    __in HANDLE hProcess,
 
2177
    __in_opt PCSTR UserSearchPath,
 
2178
    __in BOOL fInvadeProcess
 
2179
    );
 
2180
 
 
2181
BOOL
 
2182
IMAGEAPI
 
2183
SymInitializeW(
 
2184
    __in HANDLE hProcess,
 
2185
    __in_opt PCWSTR UserSearchPath,
 
2186
    __in BOOL fInvadeProcess
 
2187
    );
 
2188
 
 
2189
BOOL
 
2190
IMAGEAPI
 
2191
SymGetSearchPath(
 
2192
    __in HANDLE hProcess,
 
2193
    __out_ecount(SearchPathLength) PSTR SearchPath,
 
2194
    __in DWORD SearchPathLength
 
2195
    );
 
2196
 
 
2197
BOOL
 
2198
IMAGEAPI
 
2199
SymGetSearchPathW(
 
2200
    __in HANDLE hProcess,
 
2201
    __out_ecount(SearchPathLength) PWSTR SearchPath,
 
2202
    __in DWORD SearchPathLength
 
2203
    );
 
2204
 
 
2205
BOOL
 
2206
IMAGEAPI
 
2207
SymSetSearchPath(
 
2208
    __in HANDLE hProcess,
 
2209
    __in_opt PCSTR SearchPath
 
2210
    );
 
2211
 
 
2212
BOOL
 
2213
IMAGEAPI
 
2214
SymSetSearchPathW(
 
2215
    __in HANDLE hProcess,
 
2216
    __in_opt PCWSTR SearchPath
 
2217
    );
 
2218
 
 
2219
#define SLMFLAG_VIRTUAL     0x1
 
2220
#define SLMFLAG_ALT_INDEX   0x2
 
2221
#define SLMFLAG_NO_SYMBOLS  0x4
 
2222
 
 
2223
DWORD64
 
2224
IMAGEAPI
 
2225
SymLoadModuleEx(
 
2226
    __in HANDLE hProcess,
 
2227
    __in_opt HANDLE hFile,
 
2228
    __in_opt PCSTR ImageName,
 
2229
    __in_opt PCSTR ModuleName,
 
2230
    __in DWORD64 BaseOfDll,
 
2231
    __in DWORD DllSize,
 
2232
    __in_opt PMODLOAD_DATA Data,
 
2233
    __in_opt DWORD Flags
 
2234
    );
 
2235
 
 
2236
DWORD64
 
2237
IMAGEAPI
 
2238
SymLoadModuleExW(
 
2239
    __in HANDLE hProcess,
 
2240
    __in_opt HANDLE hFile,
 
2241
    __in_opt PCWSTR ImageName,
 
2242
    __in_opt PCWSTR ModuleName,
 
2243
    __in DWORD64 BaseOfDll,
 
2244
    __in DWORD DllSize,
 
2245
    __in_opt PMODLOAD_DATA Data,
 
2246
    __in_opt DWORD Flags
 
2247
    );
 
2248
 
 
2249
BOOL
 
2250
IMAGEAPI
 
2251
SymUnloadModule64(
 
2252
    __in HANDLE hProcess,
 
2253
    __in DWORD64 BaseOfDll
 
2254
    );
 
2255
 
 
2256
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
2257
#define SymUnloadModule SymUnloadModule64
 
2258
#else
 
2259
BOOL
 
2260
IMAGEAPI
 
2261
SymUnloadModule(
 
2262
    __in HANDLE hProcess,
 
2263
    __in DWORD BaseOfDll
 
2264
    );
 
2265
#endif
 
2266
 
 
2267
BOOL
 
2268
IMAGEAPI
 
2269
SymUnDName64(
 
2270
    __in PIMAGEHLP_SYMBOL64 sym,            // Symbol to undecorate
 
2271
    __out_ecount(UnDecNameLength) PSTR UnDecName,   // Buffer to store undecorated name in
 
2272
    __in DWORD UnDecNameLength              // Size of the buffer
 
2273
    );
 
2274
 
 
2275
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
2276
#define SymUnDName SymUnDName64
 
2277
#else
 
2278
BOOL
 
2279
IMAGEAPI
 
2280
SymUnDName(
 
2281
    __in PIMAGEHLP_SYMBOL sym,              // Symbol to undecorate
 
2282
    __out_ecount(UnDecNameLength) PSTR UnDecName,   // Buffer to store undecorated name in
 
2283
    __in DWORD UnDecNameLength              // Size of the buffer
 
2284
    );
 
2285
#endif
 
2286
 
 
2287
BOOL
 
2288
IMAGEAPI
 
2289
SymRegisterCallback64(
 
2290
    __in HANDLE hProcess,
 
2291
    __in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
 
2292
    __in ULONG64 UserContext
 
2293
    );
 
2294
 
 
2295
BOOL
 
2296
IMAGEAPI
 
2297
SymRegisterCallbackW64(
 
2298
    __in HANDLE hProcess,
 
2299
    __in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
 
2300
    __in ULONG64 UserContext
 
2301
    );
 
2302
 
 
2303
BOOL
 
2304
IMAGEAPI
 
2305
SymRegisterFunctionEntryCallback64(
 
2306
    __in HANDLE hProcess,
 
2307
    __in PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,
 
2308
    __in ULONG64 UserContext
 
2309
    );
 
2310
 
 
2311
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
2312
#define SymRegisterCallback SymRegisterCallback64
 
2313
#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
 
2314
#else
 
2315
BOOL
 
2316
IMAGEAPI
 
2317
SymRegisterCallback(
 
2318
    __in HANDLE hProcess,
 
2319
    __in PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
 
2320
    __in_opt PVOID UserContext
 
2321
    );
 
2322
 
 
2323
BOOL
 
2324
IMAGEAPI
 
2325
SymRegisterFunctionEntryCallback(
 
2326
    __in HANDLE hProcess,
 
2327
    __in PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,
 
2328
    __in_opt PVOID UserContext
 
2329
    );
 
2330
#endif
 
2331
 
 
2332
 
 
2333
typedef struct _IMAGEHLP_SYMBOL_SRC {
 
2334
    DWORD sizeofstruct;
 
2335
    DWORD type;
 
2336
    char  file[MAX_PATH];
 
2337
} IMAGEHLP_SYMBOL_SRC, *PIMAGEHLP_SYMBOL_SRC;
 
2338
 
 
2339
typedef struct _MODULE_TYPE_INFO { // AKA TYPTYP
 
2340
    USHORT      dataLength;
 
2341
    USHORT      leaf;
 
2342
    BYTE        data[1];
 
2343
} MODULE_TYPE_INFO, *PMODULE_TYPE_INFO;
 
2344
 
 
2345
typedef struct _SYMBOL_INFO {
 
2346
    ULONG       SizeOfStruct;
 
2347
    ULONG       TypeIndex;        // Type Index of symbol
 
2348
    ULONG64     Reserved[2];
 
2349
    ULONG       Index;
 
2350
    ULONG       Size;
 
2351
    ULONG64     ModBase;          // Base Address of module comtaining this symbol
 
2352
    ULONG       Flags;
 
2353
    ULONG64     Value;            // Value of symbol, ValuePresent should be 1
 
2354
    ULONG64     Address;          // Address of symbol including base address of module
 
2355
    ULONG       Register;         // register holding value or pointer to value
 
2356
    ULONG       Scope;            // scope of the symbol
 
2357
    ULONG       Tag;              // pdb classification
 
2358
    ULONG       NameLen;          // Actual length of name
 
2359
    ULONG       MaxNameLen;
 
2360
    CHAR        Name[1];          // Name of symbol
 
2361
} SYMBOL_INFO, *PSYMBOL_INFO;
 
2362
 
 
2363
typedef struct _SYMBOL_INFO_PACKAGE {
 
2364
    SYMBOL_INFO si;
 
2365
    CHAR        name[MAX_SYM_NAME + 1];
 
2366
} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
 
2367
 
 
2368
typedef struct _SYMBOL_INFOW {
 
2369
    ULONG       SizeOfStruct;
 
2370
    ULONG       TypeIndex;        // Type Index of symbol
 
2371
    ULONG64     Reserved[2];
 
2372
    ULONG       Index;
 
2373
    ULONG       Size;
 
2374
    ULONG64     ModBase;          // Base Address of module comtaining this symbol
 
2375
    ULONG       Flags;
 
2376
    ULONG64     Value;            // Value of symbol, ValuePresent should be 1
 
2377
    ULONG64     Address;          // Address of symbol including base address of module
 
2378
    ULONG       Register;         // register holding value or pointer to value
 
2379
    ULONG       Scope;            // scope of the symbol
 
2380
    ULONG       Tag;              // pdb classification
 
2381
    ULONG       NameLen;          // Actual length of name
 
2382
    ULONG       MaxNameLen;
 
2383
    WCHAR       Name[1];          // Name of symbol
 
2384
} SYMBOL_INFOW, *PSYMBOL_INFOW;
 
2385
 
 
2386
typedef struct _SYMBOL_INFO_PACKAGEW {
 
2387
    SYMBOL_INFOW si;
 
2388
    WCHAR        name[MAX_SYM_NAME + 1];
 
2389
} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
 
2390
 
 
2391
typedef struct _IMAGEHLP_STACK_FRAME
 
2392
{
 
2393
    ULONG64 InstructionOffset;
 
2394
    ULONG64 ReturnOffset;
 
2395
    ULONG64 FrameOffset;
 
2396
    ULONG64 StackOffset;
 
2397
    ULONG64 BackingStoreOffset;
 
2398
    ULONG64 FuncTableEntry;
 
2399
    ULONG64 Params[4];
 
2400
    ULONG64 Reserved[5];
 
2401
    BOOL    Virtual;
 
2402
    ULONG   Reserved2;
 
2403
} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
 
2404
 
 
2405
typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
 
2406
 
 
2407
 
 
2408
BOOL
 
2409
IMAGEAPI
 
2410
SymSetContext(
 
2411
    __in HANDLE hProcess,
 
2412
    __in PIMAGEHLP_STACK_FRAME StackFrame,
 
2413
    __in_opt PIMAGEHLP_CONTEXT Context
 
2414
    );
 
2415
 
 
2416
BOOL
 
2417
IMAGEAPI
 
2418
SymSetScopeFromAddr(
 
2419
    __in HANDLE hProcess,
 
2420
    __in ULONG64 Address
 
2421
    );
 
2422
 
 
2423
BOOL
 
2424
IMAGEAPI
 
2425
SymSetScopeFromIndex(
 
2426
    __in HANDLE hProcess,
 
2427
    __in ULONG64 BaseOfDll,
 
2428
    __in DWORD Index
 
2429
    );
 
2430
 
 
2431
typedef BOOL
 
2432
(CALLBACK *PSYM_ENUMPROCESSES_CALLBACK)(
 
2433
    __in HANDLE hProcess,
 
2434
    __in PVOID UserContext
 
2435
    );
 
2436
 
 
2437
BOOL
 
2438
IMAGEAPI
 
2439
SymEnumProcesses(
 
2440
    __in PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback,
 
2441
    __in PVOID UserContext
 
2442
    );
 
2443
 
 
2444
BOOL
 
2445
IMAGEAPI
 
2446
SymFromAddr(
 
2447
    __in HANDLE hProcess,
 
2448
    __in DWORD64 Address,
 
2449
    __out_opt PDWORD64 Displacement,
 
2450
    __inout PSYMBOL_INFO Symbol
 
2451
    );
 
2452
 
 
2453
BOOL
 
2454
IMAGEAPI
 
2455
SymFromAddrW(
 
2456
    __in HANDLE hProcess,
 
2457
    __in DWORD64 Address,
 
2458
    __out_opt PDWORD64 Displacement,
 
2459
    __inout PSYMBOL_INFOW Symbol
 
2460
    );
 
2461
 
 
2462
BOOL
 
2463
IMAGEAPI
 
2464
SymFromToken(
 
2465
    __in HANDLE hProcess,
 
2466
    __in DWORD64 Base,
 
2467
    __in DWORD Token,
 
2468
    __inout PSYMBOL_INFO Symbol
 
2469
    );
 
2470
 
 
2471
BOOL
 
2472
IMAGEAPI
 
2473
SymFromTokenW(
 
2474
    __in HANDLE hProcess,
 
2475
    __in DWORD64 Base,
 
2476
    __in DWORD Token,
 
2477
    __inout PSYMBOL_INFOW Symbol
 
2478
    );
 
2479
 
 
2480
BOOL
 
2481
IMAGEAPI
 
2482
SymNext(
 
2483
    __in HANDLE hProcess,
 
2484
    __inout PSYMBOL_INFO si
 
2485
    );
 
2486
 
 
2487
BOOL
 
2488
IMAGEAPI
 
2489
SymNextW(
 
2490
    __in HANDLE hProcess,
 
2491
    __inout PSYMBOL_INFOW siw
 
2492
    );
 
2493
 
 
2494
BOOL
 
2495
IMAGEAPI
 
2496
SymPrev(
 
2497
    __in HANDLE hProcess,
 
2498
    __inout PSYMBOL_INFO si
 
2499
    );
 
2500
 
 
2501
BOOL
 
2502
IMAGEAPI
 
2503
SymPrevW(
 
2504
    __in HANDLE hProcess,
 
2505
    __inout PSYMBOL_INFOW siw
 
2506
    );
 
2507
 
 
2508
// While SymFromName will provide a symbol from a name,
 
2509
// SymEnumSymbols can provide the same matching information
 
2510
// for ALL symbols with a matching name, even regular
 
2511
// expressions.  That way you can search across modules
 
2512
// and differentiate between identically named symbols.
 
2513
 
 
2514
BOOL
 
2515
IMAGEAPI
 
2516
SymFromName(
 
2517
    __in HANDLE hProcess,
 
2518
    __in PCSTR Name,
 
2519
    __inout PSYMBOL_INFO Symbol
 
2520
    );
 
2521
 
 
2522
BOOL
 
2523
IMAGEAPI
 
2524
SymFromNameW(
 
2525
    __in HANDLE hProcess,
 
2526
    __in PCWSTR Name,
 
2527
    __inout PSYMBOL_INFOW Symbol
 
2528
    );
 
2529
 
 
2530
typedef BOOL
 
2531
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(
 
2532
    __in PSYMBOL_INFO pSymInfo,
 
2533
    __in ULONG SymbolSize,
 
2534
    __in_opt PVOID UserContext
 
2535
    );
 
2536
 
 
2537
BOOL
 
2538
IMAGEAPI
 
2539
SymEnumSymbols(
 
2540
    __in HANDLE hProcess,
 
2541
    __in ULONG64 BaseOfDll,
 
2542
    __in_opt PCSTR Mask,
 
2543
    __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 
2544
    __in_opt PVOID UserContext
 
2545
    );
 
2546
 
 
2547
typedef BOOL
 
2548
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(
 
2549
    __in PSYMBOL_INFOW pSymInfo,
 
2550
    __in ULONG SymbolSize,
 
2551
    __in_opt PVOID UserContext
 
2552
    );
 
2553
 
 
2554
BOOL
 
2555
IMAGEAPI
 
2556
SymEnumSymbolsW(
 
2557
    __in HANDLE hProcess,
 
2558
    __in ULONG64 BaseOfDll,
 
2559
    __in_opt PCWSTR Mask,
 
2560
    __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 
2561
    __in_opt PVOID UserContext
 
2562
    );
 
2563
 
 
2564
BOOL
 
2565
IMAGEAPI
 
2566
SymEnumSymbolsForAddr(
 
2567
    __in HANDLE hProcess,
 
2568
    __in DWORD64 Address,
 
2569
    __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 
2570
    __in_opt PVOID UserContext
 
2571
    );
 
2572
 
 
2573
BOOL
 
2574
IMAGEAPI
 
2575
SymEnumSymbolsForAddrW(
 
2576
    __in HANDLE hProcess,
 
2577
    __in DWORD64 Address,
 
2578
    __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 
2579
    __in_opt PVOID UserContext
 
2580
    );
 
2581
 
 
2582
#define SYMSEARCH_MASKOBJS      0x01    // used internally to implement other APIs
 
2583
#define SYMSEARCH_RECURSE       0X02    // recurse scopes
 
2584
#define SYMSEARCH_GLOBALSONLY   0X04    // search only for global symbols
 
2585
#define SYMSEARCH_ALLITEMS      0X08    // search for everything in the pdb, not just normal scoped symbols
 
2586
 
 
2587
BOOL
 
2588
IMAGEAPI
 
2589
SymSearch(
 
2590
    __in HANDLE hProcess,
 
2591
    __in ULONG64 BaseOfDll,
 
2592
    __in_opt DWORD Index,
 
2593
    __in_opt DWORD SymTag,
 
2594
    __in_opt PCSTR Mask,
 
2595
    __in_opt DWORD64 Address,
 
2596
    __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 
2597
    __in_opt PVOID UserContext,
 
2598
    __in DWORD Options
 
2599
    );
 
2600
 
 
2601
BOOL
 
2602
IMAGEAPI
 
2603
SymSearchW(
 
2604
    __in HANDLE hProcess,
 
2605
    __in ULONG64 BaseOfDll,
 
2606
    __in_opt DWORD Index,
 
2607
    __in_opt DWORD SymTag,
 
2608
    __in_opt PCWSTR Mask,
 
2609
    __in_opt DWORD64 Address,
 
2610
    __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 
2611
    __in_opt PVOID UserContext,
 
2612
    __in DWORD Options
 
2613
    );
 
2614
 
 
2615
BOOL
 
2616
IMAGEAPI
 
2617
SymGetScope(
 
2618
    __in HANDLE hProcess,
 
2619
    __in ULONG64 BaseOfDll,
 
2620
    __in DWORD Index,
 
2621
    __inout PSYMBOL_INFO Symbol
 
2622
    );
 
2623
 
 
2624
BOOL
 
2625
IMAGEAPI
 
2626
SymGetScopeW(
 
2627
    __in HANDLE hProcess,
 
2628
    __in ULONG64 BaseOfDll,
 
2629
    __in DWORD Index,
 
2630
    __inout PSYMBOL_INFOW Symbol
 
2631
    );
 
2632
 
 
2633
BOOL
 
2634
IMAGEAPI
 
2635
SymFromIndex(
 
2636
    __in HANDLE hProcess,
 
2637
    __in ULONG64 BaseOfDll,
 
2638
    __in DWORD Index,
 
2639
    __inout PSYMBOL_INFO Symbol
 
2640
    );
 
2641
 
 
2642
BOOL
 
2643
IMAGEAPI
 
2644
SymFromIndexW(
 
2645
    __in HANDLE hProcess,
 
2646
    __in ULONG64 BaseOfDll,
 
2647
    __in DWORD Index,
 
2648
    __inout PSYMBOL_INFOW Symbol
 
2649
    );
 
2650
 
 
2651
typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
 
2652
    TI_GET_SYMTAG,
 
2653
    TI_GET_SYMNAME,
 
2654
    TI_GET_LENGTH,
 
2655
    TI_GET_TYPE,
 
2656
    TI_GET_TYPEID,
 
2657
    TI_GET_BASETYPE,
 
2658
    TI_GET_ARRAYINDEXTYPEID,
 
2659
    TI_FINDCHILDREN,
 
2660
    TI_GET_DATAKIND,
 
2661
    TI_GET_ADDRESSOFFSET,
 
2662
    TI_GET_OFFSET,
 
2663
    TI_GET_VALUE,
 
2664
    TI_GET_COUNT,
 
2665
    TI_GET_CHILDRENCOUNT,
 
2666
    TI_GET_BITPOSITION,
 
2667
    TI_GET_VIRTUALBASECLASS,
 
2668
    TI_GET_VIRTUALTABLESHAPEID,
 
2669
    TI_GET_VIRTUALBASEPOINTEROFFSET,
 
2670
    TI_GET_CLASSPARENTID,
 
2671
    TI_GET_NESTED,
 
2672
    TI_GET_SYMINDEX,
 
2673
    TI_GET_LEXICALPARENT,
 
2674
    TI_GET_ADDRESS,
 
2675
    TI_GET_THISADJUST,
 
2676
    TI_GET_UDTKIND,
 
2677
    TI_IS_EQUIV_TO,
 
2678
    TI_GET_CALLING_CONVENTION,
 
2679
    TI_IS_CLOSE_EQUIV_TO,
 
2680
    TI_GTIEX_REQS_VALID,
 
2681
    TI_GET_VIRTUALBASEOFFSET,
 
2682
    TI_GET_VIRTUALBASEDISPINDEX,
 
2683
    TI_GET_IS_REFERENCE,
 
2684
    TI_GET_INDIRECTVIRTUALBASECLASS,
 
2685
    IMAGEHLP_SYMBOL_TYPE_INFO_MAX,
 
2686
} IMAGEHLP_SYMBOL_TYPE_INFO;
 
2687
 
 
2688
typedef struct _TI_FINDCHILDREN_PARAMS {
 
2689
    ULONG Count;
 
2690
    ULONG Start;
 
2691
    ULONG ChildId[1];
 
2692
} TI_FINDCHILDREN_PARAMS;
 
2693
 
 
2694
BOOL
 
2695
IMAGEAPI
 
2696
SymGetTypeInfo(
 
2697
    __in HANDLE hProcess,
 
2698
    __in DWORD64 ModBase,
 
2699
    __in ULONG TypeId,
 
2700
    __in IMAGEHLP_SYMBOL_TYPE_INFO GetType,
 
2701
    __out PVOID pInfo
 
2702
    );
 
2703
 
 
2704
#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001
 
2705
#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002
 
2706
 
 
2707
typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS {
 
2708
    IN  ULONG    SizeOfStruct;
 
2709
    IN  ULONG    Flags;
 
2710
    IN  ULONG    NumIds;
 
2711
    IN  PULONG   TypeIds;
 
2712
    IN  ULONG64  TagFilter;
 
2713
    IN  ULONG    NumReqs;
 
2714
    IN  IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
 
2715
    IN  PULONG_PTR ReqOffsets;
 
2716
    IN  PULONG   ReqSizes;
 
2717
    IN  ULONG_PTR ReqStride;
 
2718
    IN  ULONG_PTR BufferSize;
 
2719
    OUT PVOID    Buffer;
 
2720
    OUT ULONG    EntriesMatched;
 
2721
    OUT ULONG    EntriesFilled;
 
2722
    OUT ULONG64  TagsFound;
 
2723
    OUT ULONG64  AllReqsValid;
 
2724
    IN  ULONG    NumReqsValid;
 
2725
    OUT PULONG64 ReqsValid OPTIONAL;
 
2726
} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
 
2727
 
 
2728
BOOL
 
2729
IMAGEAPI
 
2730
SymGetTypeInfoEx(
 
2731
    __in HANDLE hProcess,
 
2732
    __in DWORD64 ModBase,
 
2733
    __inout PIMAGEHLP_GET_TYPE_INFO_PARAMS Params
 
2734
    );
 
2735
 
 
2736
BOOL
 
2737
IMAGEAPI
 
2738
SymEnumTypes(
 
2739
    __in HANDLE hProcess,
 
2740
    __in ULONG64 BaseOfDll,
 
2741
    __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 
2742
    __in_opt PVOID UserContext
 
2743
    );
 
2744
 
 
2745
BOOL
 
2746
IMAGEAPI
 
2747
SymEnumTypesW(
 
2748
    __in HANDLE hProcess,
 
2749
    __in ULONG64 BaseOfDll,
 
2750
    __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 
2751
    __in_opt PVOID UserContext
 
2752
    );
 
2753
 
 
2754
BOOL
 
2755
IMAGEAPI
 
2756
SymEnumTypesByName(
 
2757
    __in HANDLE hProcess,
 
2758
    __in ULONG64 BaseOfDll,
 
2759
    __in_opt PCSTR mask,
 
2760
    __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 
2761
    __in_opt PVOID UserContext
 
2762
    );
 
2763
 
 
2764
BOOL
 
2765
IMAGEAPI
 
2766
SymEnumTypesByNameW(
 
2767
    __in HANDLE hProcess,
 
2768
    __in ULONG64 BaseOfDll,
 
2769
    __in_opt PCWSTR mask,
 
2770
    __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 
2771
    __in_opt PVOID UserContext
 
2772
    );
 
2773
 
 
2774
BOOL
 
2775
IMAGEAPI
 
2776
SymGetTypeFromName(
 
2777
    __in HANDLE hProcess,
 
2778
    __in ULONG64 BaseOfDll,
 
2779
    __in PCSTR Name,
 
2780
    __inout PSYMBOL_INFO Symbol
 
2781
    );
 
2782
 
 
2783
BOOL
 
2784
IMAGEAPI
 
2785
SymGetTypeFromNameW(
 
2786
    __in HANDLE hProcess,
 
2787
    __in ULONG64 BaseOfDll,
 
2788
    __in PCWSTR Name,
 
2789
    __inout PSYMBOL_INFOW Symbol
 
2790
    );
 
2791
 
 
2792
BOOL
 
2793
IMAGEAPI
 
2794
SymAddSymbol(
 
2795
    __in HANDLE hProcess,
 
2796
    __in ULONG64 BaseOfDll,
 
2797
    __in PCSTR Name,
 
2798
    __in DWORD64 Address,
 
2799
    __in DWORD Size,
 
2800
    __in DWORD Flags
 
2801
    );
 
2802
 
 
2803
BOOL
 
2804
IMAGEAPI
 
2805
SymAddSymbolW(
 
2806
    __in HANDLE hProcess,
 
2807
    __in ULONG64 BaseOfDll,
 
2808
    __in PCWSTR Name,
 
2809
    __in DWORD64 Address,
 
2810
    __in DWORD Size,
 
2811
    __in DWORD Flags
 
2812
    );
 
2813
 
 
2814
BOOL
 
2815
IMAGEAPI
 
2816
SymDeleteSymbol(
 
2817
    __in HANDLE hProcess,
 
2818
    __in ULONG64 BaseOfDll,
 
2819
    __in_opt PCSTR Name,
 
2820
    __in DWORD64 Address,
 
2821
    __in DWORD Flags
 
2822
    );
 
2823
 
 
2824
BOOL
 
2825
IMAGEAPI
 
2826
SymDeleteSymbolW(
 
2827
    __in HANDLE hProcess,
 
2828
    __in ULONG64 BaseOfDll,
 
2829
    __in_opt PCWSTR Name,
 
2830
    __in DWORD64 Address,
 
2831
    __in DWORD Flags
 
2832
    );
 
2833
 
 
2834
BOOL
 
2835
IMAGEAPI
 
2836
SymRefreshModuleList(
 
2837
    __in HANDLE hProcess
 
2838
    );
 
2839
 
 
2840
BOOL
 
2841
IMAGEAPI
 
2842
SymAddSourceStream(
 
2843
    __in HANDLE hProcess,
 
2844
    __in ULONG64 Base,
 
2845
    __in_opt PCSTR StreamFile,
 
2846
    __in_bcount_opt(Size) PBYTE Buffer,
 
2847
    __in size_t Size
 
2848
    );
 
2849
 
 
2850
typedef BOOL (WINAPI *SYMADDSOURCESTREAM)(HANDLE, ULONG64, PCSTR, PBYTE, size_t);
 
2851
 
 
2852
BOOL
 
2853
IMAGEAPI
 
2854
SymAddSourceStreamA(
 
2855
    __in HANDLE hProcess,
 
2856
    __in ULONG64 Base,
 
2857
    __in_opt PCSTR StreamFile,
 
2858
    __in_bcount_opt(Size) PBYTE Buffer,
 
2859
    __in size_t Size
 
2860
    );
 
2861
 
 
2862
typedef BOOL (WINAPI *SYMADDSOURCESTREAMA)(HANDLE, ULONG64, PCSTR, PBYTE, size_t);
 
2863
 
 
2864
BOOL
 
2865
IMAGEAPI
 
2866
SymAddSourceStreamW(
 
2867
    __in HANDLE hProcess,
 
2868
    __in ULONG64 Base,
 
2869
    __in_opt PCWSTR FileSpec,
 
2870
    __in_bcount_opt(Size) PBYTE Buffer,
 
2871
    __in size_t Size
 
2872
    );
 
2873
 
 
2874
BOOL
 
2875
IMAGEAPI
 
2876
SymSrvIsStoreW(
 
2877
    __in_opt HANDLE hProcess,
 
2878
    __in PCWSTR path
 
2879
    );
 
2880
 
 
2881
BOOL
 
2882
IMAGEAPI
 
2883
SymSrvIsStore(
 
2884
    __in_opt HANDLE hProcess,
 
2885
    __in PCSTR path
 
2886
    );
 
2887
 
 
2888
PCSTR
 
2889
IMAGEAPI
 
2890
SymSrvDeltaName(
 
2891
    __in HANDLE hProcess,
 
2892
    __in_opt PCSTR SymPath,
 
2893
    __in PCSTR Type,
 
2894
    __in PCSTR File1,
 
2895
    __in PCSTR File2
 
2896
    );
 
2897
 
 
2898
PCWSTR
 
2899
IMAGEAPI
 
2900
SymSrvDeltaNameW(
 
2901
    __in HANDLE hProcess,
 
2902
    __in_opt PCWSTR SymPath,
 
2903
    __in PCWSTR Type,
 
2904
    __in PCWSTR File1,
 
2905
    __in PCWSTR File2
 
2906
    );
 
2907
 
 
2908
PCSTR
 
2909
IMAGEAPI
 
2910
SymSrvGetSupplement(
 
2911
    __in HANDLE hProcess,
 
2912
    __in_opt PCSTR SymPath,
 
2913
    __in PCSTR Node,
 
2914
    __in PCSTR File
 
2915
    );
 
2916
 
 
2917
PCWSTR
 
2918
IMAGEAPI
 
2919
SymSrvGetSupplementW(
 
2920
    __in HANDLE hProcess,
 
2921
    __in_opt PCWSTR SymPath,
 
2922
    __in PCWSTR Node,
 
2923
    __in PCWSTR File
 
2924
    );
 
2925
 
 
2926
BOOL
 
2927
IMAGEAPI
 
2928
SymSrvGetFileIndexes(
 
2929
    __in PCSTR File,
 
2930
    __out GUID *Id,
 
2931
    __out PDWORD Val1,
 
2932
    __out_opt PDWORD Val2,
 
2933
    __in DWORD Flags
 
2934
    );
 
2935
 
 
2936
BOOL
 
2937
IMAGEAPI
 
2938
SymSrvGetFileIndexesW(
 
2939
    __in PCWSTR File,
 
2940
    __out GUID *Id,
 
2941
    __out PDWORD Val1,
 
2942
    __out_opt PDWORD Val2,
 
2943
    __in DWORD Flags
 
2944
    );
 
2945
 
 
2946
BOOL
 
2947
IMAGEAPI
 
2948
SymSrvGetFileIndexStringW(
 
2949
    __in HANDLE hProcess,
 
2950
    __in_opt PCWSTR SrvPath,
 
2951
    __in PCWSTR File,
 
2952
    __out_ecount(Size) PWSTR Index,
 
2953
    __in size_t Size,
 
2954
    __in DWORD Flags
 
2955
    );
 
2956
 
 
2957
BOOL
 
2958
IMAGEAPI
 
2959
SymSrvGetFileIndexString(
 
2960
    __in HANDLE hProcess,
 
2961
    __in_opt PCSTR SrvPath,
 
2962
    __in PCSTR File,
 
2963
    __out_ecount(Size) PSTR Index,
 
2964
    __in size_t Size,
 
2965
    __in DWORD Flags
 
2966
    );
 
2967
 
 
2968
typedef struct {
 
2969
    DWORD sizeofstruct;
 
2970
    char file[MAX_PATH +1];
 
2971
    BOOL  stripped;
 
2972
    DWORD timestamp;
 
2973
    DWORD size;
 
2974
    char dbgfile[MAX_PATH +1];
 
2975
    char pdbfile[MAX_PATH + 1];
 
2976
    GUID  guid;
 
2977
    DWORD sig;
 
2978
    DWORD age;
 
2979
} SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO;
 
2980
 
 
2981
typedef struct {
 
2982
    DWORD sizeofstruct;
 
2983
    WCHAR file[MAX_PATH +1];
 
2984
    BOOL  stripped;
 
2985
    DWORD timestamp;
 
2986
    DWORD size;
 
2987
    WCHAR dbgfile[MAX_PATH +1];
 
2988
    WCHAR pdbfile[MAX_PATH + 1];
 
2989
    GUID  guid;
 
2990
    DWORD sig;
 
2991
    DWORD age;
 
2992
} SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW;
 
2993
 
 
2994
BOOL
 
2995
IMAGEAPI
 
2996
SymSrvGetFileIndexInfo(
 
2997
    __in PCSTR File,
 
2998
    __out PSYMSRV_INDEX_INFO Info,
 
2999
    __in DWORD Flags
 
3000
    );
 
3001
 
 
3002
BOOL
 
3003
IMAGEAPI
 
3004
SymSrvGetFileIndexInfoW(
 
3005
    __in PCWSTR File,
 
3006
    __out PSYMSRV_INDEX_INFOW Info,
 
3007
    __in DWORD Flags
 
3008
    );
 
3009
 
 
3010
PCSTR
 
3011
IMAGEAPI
 
3012
SymSrvStoreSupplement(
 
3013
    __in HANDLE hProcess,
 
3014
    __in_opt PCSTR SrvPath,
 
3015
    __in PCSTR Node,
 
3016
    __in PCSTR File,
 
3017
    __in DWORD Flags
 
3018
    );
 
3019
 
 
3020
PCWSTR
 
3021
IMAGEAPI
 
3022
SymSrvStoreSupplementW(
 
3023
    __in HANDLE hProcess,
 
3024
    __in_opt PCWSTR SymPath,
 
3025
    __in PCWSTR Node,
 
3026
    __in PCWSTR File,
 
3027
    __in DWORD Flags
 
3028
    );
 
3029
 
 
3030
PCSTR
 
3031
IMAGEAPI
 
3032
SymSrvStoreFile(
 
3033
    __in HANDLE hProcess,
 
3034
    __in_opt PCSTR SrvPath,
 
3035
    __in PCSTR File,
 
3036
    __in DWORD Flags
 
3037
    );
 
3038
 
 
3039
PCWSTR
 
3040
IMAGEAPI
 
3041
SymSrvStoreFileW(
 
3042
    __in HANDLE hProcess,
 
3043
    __in_opt PCWSTR SrvPath,
 
3044
    __in PCWSTR File,
 
3045
    __in DWORD Flags
 
3046
    );
 
3047
 
 
3048
// used by SymGetSymbolFile's "Type" parameter
 
3049
 
 
3050
typedef enum {
 
3051
    sfImage = 0,
 
3052
    sfDbg,
 
3053
    sfPdb,
 
3054
    sfMpd,
 
3055
    sfMax
 
3056
};
 
3057
 
 
3058
BOOL
 
3059
IMAGEAPI
 
3060
SymGetSymbolFile(
 
3061
    __in_opt HANDLE hProcess,
 
3062
    __in_opt PCSTR SymPath,
 
3063
    __in PCSTR ImageFile,
 
3064
    __in DWORD Type,
 
3065
    __out_ecount(cSymbolFile) PSTR SymbolFile,
 
3066
    __in size_t cSymbolFile,
 
3067
    __out_ecount(cDbgFile) PSTR DbgFile,
 
3068
    __in size_t cDbgFile
 
3069
    );
 
3070
 
 
3071
BOOL
 
3072
IMAGEAPI
 
3073
SymGetSymbolFileW(
 
3074
    __in_opt HANDLE hProcess,
 
3075
    __in_opt PCWSTR SymPath,
 
3076
    __in PCWSTR ImageFile,
 
3077
    __in DWORD Type,
 
3078
    __out_ecount(cSymbolFile) PWSTR SymbolFile,
 
3079
    __in size_t cSymbolFile,
 
3080
    __out_ecount(cDbgFile) PWSTR DbgFile,
 
3081
    __in size_t cDbgFile
 
3082
    );
 
3083
 
 
3084
//
 
3085
// Full user-mode dump creation.
 
3086
//
 
3087
 
 
3088
typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(
 
3089
    __in DWORD DataType,
 
3090
    __in PVOID* Data,
 
3091
    __out LPDWORD DataLength,
 
3092
    __in_opt PVOID UserData
 
3093
    );
 
3094
 
 
3095
BOOL
 
3096
WINAPI
 
3097
DbgHelpCreateUserDump(
 
3098
    __in_opt LPCSTR FileName,
 
3099
    __in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
 
3100
    __in_opt PVOID UserData
 
3101
    );
 
3102
 
 
3103
BOOL
 
3104
WINAPI
 
3105
DbgHelpCreateUserDumpW(
 
3106
    __in_opt LPCWSTR FileName,
 
3107
    __in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
 
3108
    __in_opt PVOID UserData
 
3109
    );
 
3110
 
 
3111
// -----------------------------------------------------------------
 
3112
// The following 4 legacy APIs are fully supported, but newer
 
3113
// ones are recommended.  SymFromName and SymFromAddr provide
 
3114
// much more detailed info on the returned symbol.
 
3115
 
 
3116
BOOL
 
3117
IMAGEAPI
 
3118
SymGetSymFromAddr64(
 
3119
    __in HANDLE hProcess,
 
3120
    __in DWORD64 qwAddr,
 
3121
    __out_opt PDWORD64 pdwDisplacement,
 
3122
    __inout PIMAGEHLP_SYMBOL64  Symbol
 
3123
    );
 
3124
 
 
3125
 
 
3126
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
3127
#define SymGetSymFromAddr SymGetSymFromAddr64
 
3128
#else
 
3129
BOOL
 
3130
IMAGEAPI
 
3131
SymGetSymFromAddr(
 
3132
    __in HANDLE hProcess,
 
3133
    __in DWORD dwAddr,
 
3134
    __out_opt PDWORD pdwDisplacement,
 
3135
    __inout PIMAGEHLP_SYMBOL Symbol
 
3136
    );
 
3137
#endif
 
3138
 
 
3139
// While following two APIs will provide a symbol from a name,
 
3140
// SymEnumSymbols can provide the same matching information
 
3141
// for ALL symbols with a matching name, even regular
 
3142
// expressions.  That way you can search across modules
 
3143
// and differentiate between identically named symbols.
 
3144
 
 
3145
BOOL
 
3146
IMAGEAPI
 
3147
SymGetSymFromName64(
 
3148
    __in HANDLE hProcess,
 
3149
    __in PCSTR Name,
 
3150
    __inout PIMAGEHLP_SYMBOL64 Symbol
 
3151
    );
 
3152
 
 
3153
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
3154
#define SymGetSymFromName SymGetSymFromName64
 
3155
#else
 
3156
BOOL
 
3157
IMAGEAPI
 
3158
SymGetSymFromName(
 
3159
    __in HANDLE hProcess,
 
3160
    __in PCSTR Name,
 
3161
    __inout PIMAGEHLP_SYMBOL Symbol
 
3162
    );
 
3163
#endif
 
3164
 
 
3165
 
 
3166
// Symbol server exports
 
3167
 
 
3168
typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
 
3169
typedef BOOL (WINAPI *PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
 
3170
typedef BOOL (WINAPI *PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR);
 
3171
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROC)(PCSTR, PCSTR, PCSTR, PSTR);
 
3172
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCA)(PCSTR, PCSTR, PCSTR, PSTR);
 
3173
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCW)(PCWSTR, PCWSTR, PCWSTR, PWSTR);
 
3174
typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
 
3175
typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
 
3176
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
 
3177
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSWPROC)(UINT_PTR, ULONG64);
 
3178
typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action, ULONG64 data, ULONG64 context);
 
3179
typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
 
3180
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(PCSTR);
 
3181
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROCA)(PCSTR);
 
3182
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROCW)(PCWSTR);
 
3183
typedef BOOL (WINAPI *PSYMBOLSERVERGETVERSION)(LPAPI_VERSION);
 
3184
typedef BOOL (WINAPI *PSYMBOLSERVERDELTANAME)(PCSTR, PVOID, DWORD, DWORD, PVOID, DWORD, DWORD, PSTR, size_t);
 
3185
typedef BOOL (WINAPI *PSYMBOLSERVERDELTANAMEW)(PCWSTR, PVOID, DWORD, DWORD, PVOID, DWORD, DWORD, PWSTR, size_t);
 
3186
typedef BOOL (WINAPI *PSYMBOLSERVERGETSUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, size_t);
 
3187
typedef BOOL (WINAPI *PSYMBOLSERVERGETSUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR, size_t);
 
3188
typedef BOOL (WINAPI *PSYMBOLSERVERSTORESUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, size_t, DWORD);
 
3189
typedef BOOL (WINAPI *PSYMBOLSERVERSTORESUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR, size_t, DWORD);
 
3190
typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRING)(PVOID, DWORD, DWORD, PSTR, size_t);
 
3191
typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRINGW)(PVOID, DWORD, DWORD, PWSTR, size_t);
 
3192
typedef BOOL (WINAPI *PSYMBOLSERVERSTOREFILE)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR, size_t, DWORD);
 
3193
typedef BOOL (WINAPI *PSYMBOLSERVERSTOREFILEW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR, size_t, DWORD);
 
3194
typedef BOOL (WINAPI *PSYMBOLSERVERISSTORE)(PCSTR);
 
3195
typedef BOOL (WINAPI *PSYMBOLSERVERISSTOREW)(PCWSTR);
 
3196
typedef DWORD (WINAPI *PSYMBOLSERVERVERSION)();
 
3197
typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERMESSAGEPROC)(UINT_PTR action, ULONG64 data, ULONG64 context);
 
3198
 
 
3199
#define SYMSRV_VERSION              2
 
3200
 
 
3201
#define SSRVOPT_CALLBACK            0x00000001
 
3202
#define SSRVOPT_DWORD               0x00000002
 
3203
#define SSRVOPT_DWORDPTR            0x00000004
 
3204
#define SSRVOPT_GUIDPTR             0x00000008
 
3205
#define SSRVOPT_OLDGUIDPTR          0x00000010
 
3206
#define SSRVOPT_UNATTENDED          0x00000020
 
3207
#define SSRVOPT_NOCOPY              0x00000040
 
3208
#define SSRVOPT_GETPATH             0x00000040
 
3209
#define SSRVOPT_PARENTWIN           0x00000080
 
3210
#define SSRVOPT_PARAMTYPE           0x00000100
 
3211
#define SSRVOPT_SECURE              0x00000200
 
3212
#define SSRVOPT_TRACE               0x00000400
 
3213
#define SSRVOPT_SETCONTEXT          0x00000800
 
3214
#define SSRVOPT_PROXY               0x00001000
 
3215
#define SSRVOPT_DOWNSTREAM_STORE    0x00002000
 
3216
#define SSRVOPT_OVERWRITE           0x00004000
 
3217
#define SSRVOPT_RESETTOU            0x00008000
 
3218
#define SSRVOPT_CALLBACKW           0x00010000
 
3219
#define SSRVOPT_FLAT_DEFAULT_STORE  0x00020000
 
3220
#define SSRVOPT_PROXYW              0x00040000
 
3221
#define SSRVOPT_MESSAGE             0x00080000
 
3222
#define SSRVOPT_SERVICE             0x00100000   // deprecated
 
3223
#define SSRVOPT_FAVOR_COMPRESSED    0x00200000
 
3224
#define SSRVOPT_STRING              0x00400000
 
3225
#define SSRVOPT_WINHTTP             0x00800000
 
3226
#define SSRVOPT_WININET             0x01000000
 
3227
 
 
3228
#define SSRVOPT_MAX                 0x0100000
 
3229
 
 
3230
#define SSRVOPT_RESET               ((ULONG_PTR)-1)
 
3231
 
 
3232
 
 
3233
#define NUM_SSRVOPTS                30
 
3234
 
 
3235
#define SSRVACTION_TRACE        1
 
3236
#define SSRVACTION_QUERYCANCEL  2
 
3237
#define SSRVACTION_EVENT        3
 
3238
#define SSRVACTION_EVENTW       4
 
3239
#define SSRVACTION_SIZE         5
 
3240
 
 
3241
#define SYMSTOREOPT_COMPRESS        0x01
 
3242
#define SYMSTOREOPT_OVERWRITE       0x02
 
3243
#define SYMSTOREOPT_RETURNINDEX     0x04
 
3244
#define SYMSTOREOPT_POINTER         0x08
 
3245
#define SYMSTOREOPT_ALT_INDEX       0x10
 
3246
#define SYMSTOREOPT_UNICODE         0x20
 
3247
#define SYMSTOREOPT_PASS_IF_EXISTS  0x40
 
3248
 
 
3249
#ifdef DBGHELP_TRANSLATE_TCHAR
 
3250
 #define SymInitialize                     SymInitializeW
 
3251
 #define SymAddSymbol                      SymAddSymbolW
 
3252
 #define SymDeleteSymbol                   SymDeleteSymbolW
 
3253
 #define SearchTreeForFile                 SearchTreeForFileW
 
3254
 #define UnDecorateSymbolName              UnDecorateSymbolNameW
 
3255
 #define SymGetLineFromName64              SymGetLineFromNameW64
 
3256
 #define SymGetLineFromAddr64              SymGetLineFromAddrW64
 
3257
 #define SymGetLineNext64                  SymGetLineNextW64
 
3258
 #define SymGetLinePrev64                  SymGetLinePrevW64
 
3259
 #define SymFromName                       SymFromNameW
 
3260
 #define SymFindExecutableImage            SymFindExecutableImageW
 
3261
 #define FindExecutableImageEx             FindExecutableImageExW
 
3262
 #define SymSearch                         SymSearchW
 
3263
 #define SymEnumLines                      SymEnumLinesW
 
3264
 #define SymEnumSourceLines                SymEnumSourceLinesW
 
3265
 #define SymGetTypeFromName                SymGetTypeFromNameW
 
3266
 #define SymEnumSymbolsForAddr             SymEnumSymbolsForAddrW
 
3267
 #define SymFromAddr                       SymFromAddrW
 
3268
 #define SymMatchString                    SymMatchStringW
 
3269
 #define SymEnumSourceFiles                SymEnumSourceFilesW
 
3270
 #define SymEnumSymbols                    SymEnumSymbolsW
 
3271
 #define SymLoadModuleEx                   SymLoadModuleExW
 
3272
 #define SymSetSearchPath                  SymSetSearchPathW
 
3273
 #define SymGetSearchPath                  SymGetSearchPathW
 
3274
 #define EnumDirTree                       EnumDirTreeW
 
3275
 #define SymFromToken                      SymFromTokenW
 
3276
 #define SymFromIndex                      SymFromIndexW
 
3277
 #define SymGetScope                       SymGetScopeW
 
3278
 #define SymNext                           SymNextW
 
3279
 #define SymPrev                           SymPrevW
 
3280
 #define SymEnumTypes                      SymEnumTypesW
 
3281
 #define SymEnumTypesByName                SymEnumTypesByNameW
 
3282
 #define SymRegisterCallback64             SymRegisterCallbackW64
 
3283
 #define SymFindDebugInfoFile              SymFindDebugInfoFileW
 
3284
 #define FindDebugInfoFileEx               FindDebugInfoFileExW
 
3285
 #define SymFindFileInPath                 SymFindFileInPathW
 
3286
 #define SymEnumerateModules64             SymEnumerateModulesW64
 
3287
 #define SymSetHomeDirectory               SymSetHomeDirectoryW
 
3288
 #define SymGetHomeDirectory               SymGetHomeDirectoryW
 
3289
 #define SymGetSourceFile                  SymGetSourceFileW
 
3290
 #define SymGetSourceFileToken             SymGetSourceFileTokenW
 
3291
 #define SymGetSourceFileFromToken         SymGetSourceFileFromTokenW
 
3292
 #define SymGetSourceVarFromToken          SymGetSourceVarFromTokenW
 
3293
 #define SymGetSourceFileToken             SymGetSourceFileTokenW
 
3294
 #define SymGetFileLineOffsets64           SymGetFileLineOffsetsW64
 
3295
 #define SymFindFileInPath                 SymFindFileInPathW
 
3296
 #define SymMatchFileName                  SymMatchFileNameW
 
3297
 #define SymGetSourceFileFromToken         SymGetSourceFileFromTokenW
 
3298
 #define SymGetSourceVarFromToken          SymGetSourceVarFromTokenW
 
3299
 #define SymGetModuleInfo64                SymGetModuleInfoW64
 
3300
 #define SymSrvIsStore                     SymSrvIsStoreW
 
3301
 #define SymSrvDeltaName                   SymSrvDeltaNameW
 
3302
 #define SymSrvGetSupplement               SymSrvGetSupplementW
 
3303
 #define SymSrvStoreSupplement             SymSrvStoreSupplementW
 
3304
 #define SymSrvGetFileIndexes              SymSrvGetFileIndexes
 
3305
 #define SymSrvGetFileIndexString          SymSrvGetFileIndexStringW
 
3306
 #define SymSrvStoreFile                   SymSrvStoreFileW
 
3307
 #define SymGetSymbolFile                  SymGetSymbolFileW
 
3308
 #define EnumerateLoadedModules64          EnumerateLoadedModulesW64
 
3309
 #define EnumerateLoadedModulesEx          EnumerateLoadedModulesExW
 
3310
 #define SymSrvGetFileIndexInfo            SymSrvGetFileIndexInfoW
 
3311
 
 
3312
 #define IMAGEHLP_LINE64                   IMAGEHLP_LINEW64
 
3313
 #define PIMAGEHLP_LINE64                  PIMAGEHLP_LINEW64
 
3314
 #define SYMBOL_INFO                       SYMBOL_INFOW
 
3315
 #define PSYMBOL_INFO                      PSYMBOL_INFOW
 
3316
 #define SYMBOL_INFO_PACKAGE               SYMBOL_INFO_PACKAGEW
 
3317
 #define PSYMBOL_INFO_PACKAGE              PSYMBOL_INFO_PACKAGEW
 
3318
 #define FIND_EXE_FILE_CALLBACK            FIND_EXE_FILE_CALLBACKW
 
3319
 #define PFIND_EXE_FILE_CALLBACK           PFIND_EXE_FILE_CALLBACKW
 
3320
 #define SYM_ENUMERATESYMBOLS_CALLBACK     SYM_ENUMERATESYMBOLS_CALLBACKW
 
3321
 #define PSYM_ENUMERATESYMBOLS_CALLBACK    PSYM_ENUMERATESYMBOLS_CALLBACKW
 
3322
 #define SRCCODEINFO                       SRCCODEINFOW
 
3323
 #define PSRCCODEINFO                      PSRCCODEINFOW
 
3324
 #define SOURCEFILE                        SOURCEFILEW
 
3325
 #define PSOURCEFILE                       PSOURCEFILEW
 
3326
 #define SYM_ENUMSOURECFILES_CALLBACK      SYM_ENUMSOURCEFILES_CALLBACKW
 
3327
 #define PSYM_ENUMSOURCEFILES_CALLBACK     PSYM_ENUMSOURECFILES_CALLBACKW
 
3328
 #define IMAGEHLP_CBA_EVENT                IMAGEHLP_CBA_EVENTW
 
3329
 #define PIMAGEHLP_CBA_EVENT               PIMAGEHLP_CBA_EVENTW
 
3330
 #define PENUMDIRTREE_CALLBACK             PENUMDIRTREE_CALLBACKW
 
3331
 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD64   IMAGEHLP_DEFERRED_SYMBOL_LOADW64
 
3332
 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64  PIMAGEHLP_DEFERRED_SYMBOL_LOADW64
 
3333
 #define PFIND_DEBUG_FILE_CALLBACK         PFIND_DEBUG_FILE_CALLBACKW
 
3334
 #define PFINDFILEINPATHCALLBACK           PFINDFILEINPATHCALLBACKW
 
3335
 #define IMAGEHLP_MODULE64                 IMAGEHLP_MODULEW64
 
3336
 #define PIMAGEHLP_MODULE64                PIMAGEHLP_MODULEW64
 
3337
 #define SYMSRV_INDEX_INFO                 SYMSRV_INDEX_INFOW
 
3338
 #define PSYMSRV_INDEX_INFO                PSYMSRV_INDEX_INFOW
 
3339
 
 
3340
 #define PSYMBOLSERVERPROC                 PSYMBOLSERVERPROCW
 
3341
 #define PSYMBOLSERVERPINGPROC             PSYMBOLSERVERPINGPROCW
 
3342
#endif
 
3343
 
 
3344
// -----------------------------------------------------------------
 
3345
// The following APIs exist only for backwards compatibility
 
3346
// with a pre-release version documented in an MSDN release.
 
3347
 
 
3348
// You should use SymFindFileInPath if you want to maintain
 
3349
// future compatibility.
 
3350
 
 
3351
DBHLP_DEPRECIATED
 
3352
BOOL
 
3353
IMAGEAPI
 
3354
FindFileInPath(
 
3355
    __in HANDLE hprocess,
 
3356
    __in PCSTR SearchPath,
 
3357
    __in PCSTR FileName,
 
3358
    __in PVOID id,
 
3359
    __in DWORD two,
 
3360
    __in DWORD three,
 
3361
    __in DWORD flags,
 
3362
    __out_ecount(MAX_PATH + 1) PSTR FilePath
 
3363
    );
 
3364
 
 
3365
// You should use SymFindFileInPath if you want to maintain
 
3366
// future compatibility.
 
3367
 
 
3368
DBHLP_DEPRECIATED
 
3369
BOOL
 
3370
IMAGEAPI
 
3371
FindFileInSearchPath(
 
3372
    __in HANDLE hprocess,
 
3373
    __in PCSTR SearchPath,
 
3374
    __in PCSTR FileName,
 
3375
    __in DWORD one,
 
3376
    __in DWORD two,
 
3377
    __in DWORD three,
 
3378
    __out_ecount(MAX_PATH + 1) PSTR FilePath
 
3379
    );
 
3380
 
 
3381
DBHLP_DEPRECIATED
 
3382
BOOL
 
3383
IMAGEAPI
 
3384
SymEnumSym(
 
3385
    __in HANDLE hProcess,
 
3386
    __in ULONG64 BaseOfDll,
 
3387
    __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 
3388
    __in_opt PVOID UserContext
 
3389
    );
 
3390
 
 
3391
DBHLP_DEPRECIATED
 
3392
BOOL
 
3393
IMAGEAPI
 
3394
SymEnumerateSymbols64(
 
3395
    __in HANDLE hProcess,
 
3396
    __in ULONG64 BaseOfDll,
 
3397
    __in PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,
 
3398
    __in_opt PVOID UserContext
 
3399
    );
 
3400
 
 
3401
DBHLP_DEPRECIATED
 
3402
BOOL
 
3403
IMAGEAPI
 
3404
SymEnumerateSymbolsW64(
 
3405
    __in HANDLE hProcess,
 
3406
    __in ULONG64 BaseOfDll,
 
3407
    __in PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,
 
3408
    __in_opt PVOID UserContext
 
3409
    );
 
3410
 
 
3411
 
 
3412
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
3413
#define SymEnumerateSymbols SymEnumerateSymbols64
 
3414
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
 
3415
#else
 
3416
DBHLP_DEPRECIATED
 
3417
BOOL
 
3418
IMAGEAPI
 
3419
SymEnumerateSymbols(
 
3420
    __in HANDLE hProcess,
 
3421
    __in ULONG BaseOfDll,
 
3422
    __in PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
 
3423
    __in_opt PVOID UserContext
 
3424
    );
 
3425
 
 
3426
DBHLP_DEPRECIATED
 
3427
BOOL
 
3428
IMAGEAPI
 
3429
SymEnumerateSymbolsW(
 
3430
    __in HANDLE hProcess,
 
3431
    __in ULONG BaseOfDll,
 
3432
    __in PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,
 
3433
    __in_opt PVOID UserContext
 
3434
    );
 
3435
#endif
 
3436
 
 
3437
// use SymLoadModuleEx
 
3438
 
 
3439
DWORD64
 
3440
IMAGEAPI
 
3441
SymLoadModule64(
 
3442
    __in HANDLE hProcess,
 
3443
    __in_opt HANDLE hFile,
 
3444
    __in_opt PCSTR ImageName,
 
3445
    __in_opt PCSTR ModuleName,
 
3446
    __in DWORD64 BaseOfDll,
 
3447
    __in DWORD SizeOfDll
 
3448
    );
 
3449
 
 
3450
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
3451
#define SymLoadModule SymLoadModule64
 
3452
#else
 
3453
DWORD
 
3454
IMAGEAPI
 
3455
SymLoadModule(
 
3456
    __in HANDLE hProcess,
 
3457
    __in_opt HANDLE hFile,
 
3458
    __in_opt PCSTR ImageName,
 
3459
    __in_opt PCSTR ModuleName,
 
3460
    __in DWORD BaseOfDll,
 
3461
    __in DWORD SizeOfDll
 
3462
    );
 
3463
#endif
 
3464
 
 
3465
BOOL
 
3466
IMAGEAPI
 
3467
SymGetSymNext64(
 
3468
    __in HANDLE hProcess,
 
3469
    __inout PIMAGEHLP_SYMBOL64 Symbol
 
3470
    );
 
3471
 
 
3472
BOOL
 
3473
IMAGEAPI
 
3474
SymGetSymNextW64(
 
3475
    __in HANDLE hProcess,
 
3476
    __inout PIMAGEHLP_SYMBOLW64 Symbol
 
3477
    );
 
3478
 
 
3479
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
3480
#define SymGetSymNext SymGetSymNext64
 
3481
#define SymGetSymNextW SymGetSymNextW64
 
3482
#else
 
3483
BOOL
 
3484
IMAGEAPI
 
3485
SymGetSymNext(
 
3486
    __in HANDLE hProcess,
 
3487
    __inout PIMAGEHLP_SYMBOL Symbol
 
3488
    );
 
3489
 
 
3490
BOOL
 
3491
IMAGEAPI
 
3492
SymGetSymNextW(
 
3493
    __in HANDLE hProcess,
 
3494
    __inout PIMAGEHLP_SYMBOLW Symbol
 
3495
    );
 
3496
#endif
 
3497
 
 
3498
BOOL
 
3499
IMAGEAPI
 
3500
SymGetSymPrev64(
 
3501
    __in HANDLE hProcess,
 
3502
    __inout PIMAGEHLP_SYMBOL64 Symbol
 
3503
    );
 
3504
 
 
3505
BOOL
 
3506
IMAGEAPI
 
3507
SymGetSymPrevW64(
 
3508
    __in HANDLE hProcess,
 
3509
    __inout PIMAGEHLP_SYMBOLW64 Symbol
 
3510
    );
 
3511
 
 
3512
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 
3513
#define SymGetSymPrev SymGetSymPrev64
 
3514
#define SymGetSymPrevW SymGetSymPrevW64
 
3515
#else
 
3516
BOOL
 
3517
IMAGEAPI
 
3518
SymGetSymPrev(
 
3519
    __in HANDLE hProcess,
 
3520
    __inout PIMAGEHLP_SYMBOL Symbol
 
3521
    );
 
3522
 
 
3523
BOOL
 
3524
IMAGEAPI
 
3525
SymGetSymPrevW(
 
3526
    __in HANDLE hProcess,
 
3527
    __inout PIMAGEHLP_SYMBOLW Symbol
 
3528
    );
 
3529
#endif
 
3530
 
 
3531
 
 
3532
// These values should not be used.
 
3533
// They have been replaced by SYMFLAG_ values.
 
3534
 
 
3535
#define SYMF_OMAP_GENERATED   0x00000001
 
3536
#define SYMF_OMAP_MODIFIED    0x00000002
 
3537
#define SYMF_REGISTER         0x00000008
 
3538
#define SYMF_REGREL           0x00000010
 
3539
#define SYMF_FRAMEREL         0x00000020
 
3540
#define SYMF_PARAMETER        0x00000040
 
3541
#define SYMF_LOCAL            0x00000080
 
3542
#define SYMF_CONSTANT         0x00000100
 
3543
#define SYMF_EXPORT           0x00000200
 
3544
#define SYMF_FORWARDER        0x00000400
 
3545
#define SYMF_FUNCTION         0x00000800
 
3546
#define SYMF_VIRTUAL          0x00001000
 
3547
#define SYMF_THUNK            0x00002000
 
3548
#define SYMF_TLSREL           0x00004000
 
3549
 
 
3550
// These values should also not be used.
 
3551
// They have been replaced by SYMFLAG_ values.
 
3552
 
 
3553
#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT          1
 
3554
#define IMAGEHLP_SYMBOL_INFO_REGISTER              SYMF_REGISTER        // 0x0008
 
3555
#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE           SYMF_REGREL          // 0x0010
 
3556
#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE         SYMF_FRAMEREL        // 0x0020
 
3557
#define IMAGEHLP_SYMBOL_INFO_PARAMETER             SYMF_PARAMETER       // 0x0040
 
3558
#define IMAGEHLP_SYMBOL_INFO_LOCAL                 SYMF_LOCAL           // 0x0080
 
3559
#define IMAGEHLP_SYMBOL_INFO_CONSTANT              SYMF_CONSTANT        // 0x0100
 
3560
#define IMAGEHLP_SYMBOL_FUNCTION                   SYMF_FUNCTION        // 0x0800
 
3561
#define IMAGEHLP_SYMBOL_VIRTUAL                    SYMF_VIRTUAL         // 0x1000
 
3562
#define IMAGEHLP_SYMBOL_THUNK                      SYMF_THUNK           // 0x2000
 
3563
#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE           SYMF_TLSREL          // 0x4000
 
3564
 
 
3565
#include <poppack.h>
 
3566
 
 
3567
 
 
3568
#include <pshpack4.h>
 
3569
 
 
3570
#if defined(_MSC_VER)
 
3571
#if _MSC_VER >= 800
 
3572
#if _MSC_VER >= 1200
 
3573
#pragma warning(push)
 
3574
#endif
 
3575
#pragma warning(disable:4200)    /* Zero length array */
 
3576
#pragma warning(disable:4201)    /* Nameless struct/union */
 
3577
#endif
 
3578
#endif
 
3579
 
 
3580
#define MINIDUMP_SIGNATURE ('PMDM')
 
3581
#define MINIDUMP_VERSION   (42899)
 
3582
typedef DWORD RVA;
 
3583
typedef ULONG64 RVA64;
 
3584
 
 
3585
typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
 
3586
    ULONG32 DataSize;
 
3587
    RVA Rva;
 
3588
} MINIDUMP_LOCATION_DESCRIPTOR;
 
3589
 
 
3590
typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
 
3591
    ULONG64 DataSize;
 
3592
    RVA64 Rva;
 
3593
} MINIDUMP_LOCATION_DESCRIPTOR64;
 
3594
 
 
3595
 
 
3596
typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
 
3597
    ULONG64 StartOfMemoryRange;
 
3598
    MINIDUMP_LOCATION_DESCRIPTOR Memory;
 
3599
} MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
 
3600
 
 
3601
// DESCRIPTOR64 is used for full-memory minidumps where
 
3602
// all of the raw memory is laid out sequentially at the
 
3603
// end of the dump.  There is no need for individual RVAs
 
3604
// as the RVA is the base RVA plus the sum of the preceeding
 
3605
// data blocks.
 
3606
typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
 
3607
    ULONG64 StartOfMemoryRange;
 
3608
    ULONG64 DataSize;
 
3609
} MINIDUMP_MEMORY_DESCRIPTOR64, *PMINIDUMP_MEMORY_DESCRIPTOR64;
 
3610
 
 
3611
 
 
3612
typedef struct _MINIDUMP_HEADER {
 
3613
    ULONG32 Signature;
 
3614
    ULONG32 Version;
 
3615
    ULONG32 NumberOfStreams;
 
3616
    RVA StreamDirectoryRva;
 
3617
    ULONG32 CheckSum;
 
3618
    union {
 
3619
        ULONG32 Reserved;
 
3620
        ULONG32 TimeDateStamp;
 
3621
    };
 
3622
    ULONG64 Flags;
 
3623
} MINIDUMP_HEADER, *PMINIDUMP_HEADER;
 
3624
 
 
3625
//
 
3626
// The MINIDUMP_HEADER field StreamDirectoryRva points to 
 
3627
// an array of MINIDUMP_DIRECTORY structures.
 
3628
//
 
3629
 
 
3630
typedef struct _MINIDUMP_DIRECTORY {
 
3631
    ULONG32 StreamType;
 
3632
    MINIDUMP_LOCATION_DESCRIPTOR Location;
 
3633
} MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
 
3634
 
 
3635
 
 
3636
typedef struct _MINIDUMP_STRING {
 
3637
    ULONG32 Length;         // Length in bytes of the string
 
3638
    WCHAR   Buffer [0];     // Variable size buffer
 
3639
} MINIDUMP_STRING, *PMINIDUMP_STRING;
 
3640
 
 
3641
 
 
3642
 
 
3643
//
 
3644
// The MINIDUMP_DIRECTORY field StreamType may be one of the following types.
 
3645
// Types will be added in the future, so if a program reading the minidump
 
3646
// header encounters a stream type it does not understand it should ignore
 
3647
// the data altogether. Any tag above LastReservedStream will not be used by
 
3648
// the system and is reserved for program-specific information.
 
3649
//
 
3650
 
 
3651
typedef enum _MINIDUMP_STREAM_TYPE {
 
3652
 
 
3653
    UnusedStream                = 0,
 
3654
    ReservedStream0             = 1,
 
3655
    ReservedStream1             = 2,
 
3656
    ThreadListStream            = 3,
 
3657
    ModuleListStream            = 4,
 
3658
    MemoryListStream            = 5,
 
3659
    ExceptionStream             = 6,
 
3660
    SystemInfoStream            = 7,
 
3661
    ThreadExListStream          = 8,
 
3662
    Memory64ListStream          = 9,
 
3663
    CommentStreamA              = 10,
 
3664
    CommentStreamW              = 11,
 
3665
    HandleDataStream            = 12,
 
3666
    FunctionTableStream         = 13,
 
3667
    UnloadedModuleListStream    = 14,
 
3668
    MiscInfoStream              = 15,
 
3669
    MemoryInfoListStream        = 16,
 
3670
    ThreadInfoListStream        = 17,
 
3671
    HandleOperationListStream   = 18,
 
3672
    TokenStream                 = 19,
 
3673
 
 
3674
    ceStreamNull                = 0x8000,
 
3675
    ceStreamSystemInfo          = 0x8001,
 
3676
    ceStreamException           = 0x8002,
 
3677
    ceStreamModuleList          = 0x8003,
 
3678
    ceStreamProcessList         = 0x8004,
 
3679
    ceStreamThreadList          = 0x8005, 
 
3680
    ceStreamThreadContextList   = 0x8006,
 
3681
    ceStreamThreadCallStackList = 0x8007,
 
3682
    ceStreamMemoryVirtualList   = 0x8008,
 
3683
    ceStreamMemoryPhysicalList  = 0x8009,
 
3684
    ceStreamBucketParameters    = 0x800A,     
 
3685
    ceStreamProcessModuleMap    = 0x800B,
 
3686
    ceStreamDiagnosisList       = 0x800C,
 
3687
 
 
3688
    LastReservedStream          = 0xffff
 
3689
 
 
3690
} MINIDUMP_STREAM_TYPE;
 
3691
 
 
3692
 
 
3693
//
 
3694
// The minidump system information contains processor and
 
3695
// Operating System specific information.
 
3696
// 
 
3697
 
 
3698
//
 
3699
// CPU information is obtained from one of two places.
 
3700
//
 
3701
//  1) On x86 computers, CPU_INFORMATION is obtained from the CPUID
 
3702
//     instruction. You must use the X86 portion of the union for X86
 
3703
//     computers.
 
3704
//
 
3705
//  2) On non-x86 architectures, CPU_INFORMATION is obtained by calling
 
3706
//     IsProcessorFeatureSupported().
 
3707
//
 
3708
 
 
3709
typedef union _CPU_INFORMATION {
 
3710
 
 
3711
    //
 
3712
    // X86 platforms use CPUID function to obtain processor information.
 
3713
    //
 
3714
    
 
3715
    struct {
 
3716
 
 
3717
        //
 
3718
        // CPUID Subfunction 0, register EAX (VendorId [0]),
 
3719
        // EBX (VendorId [1]) and ECX (VendorId [2]).
 
3720
        //
 
3721
        
 
3722
        ULONG32 VendorId [ 3 ];
 
3723
        
 
3724
        //
 
3725
        // CPUID Subfunction 1, register EAX
 
3726
        //
 
3727
        
 
3728
        ULONG32 VersionInformation;
 
3729
 
 
3730
        //
 
3731
        // CPUID Subfunction 1, register EDX
 
3732
        //
 
3733
        
 
3734
        ULONG32 FeatureInformation;
 
3735
        
 
3736
 
 
3737
        //
 
3738
        // CPUID, Subfunction 80000001, register EBX. This will only
 
3739
        // be obtained if the vendor id is "AuthenticAMD".
 
3740
        //
 
3741
        
 
3742
        ULONG32 AMDExtendedCpuFeatures;
 
3743
 
 
3744
    } X86CpuInfo;
 
3745
 
 
3746
    //
 
3747
    // Non-x86 platforms use processor feature flags.
 
3748
    //
 
3749
    
 
3750
    struct {
 
3751
 
 
3752
        ULONG64 ProcessorFeatures [ 2 ];
 
3753
        
 
3754
    } OtherCpuInfo;
 
3755
 
 
3756
} CPU_INFORMATION, *PCPU_INFORMATION;
 
3757
        
 
3758
typedef struct _MINIDUMP_SYSTEM_INFO {
 
3759
 
 
3760
    //
 
3761
    // ProcessorArchitecture, ProcessorLevel and ProcessorRevision are all
 
3762
    // taken from the SYSTEM_INFO structure obtained by GetSystemInfo( ).
 
3763
    //
 
3764
    
 
3765
    USHORT ProcessorArchitecture;
 
3766
    USHORT ProcessorLevel;
 
3767
    USHORT ProcessorRevision;
 
3768
 
 
3769
    union {
 
3770
        USHORT Reserved0;
 
3771
        struct {
 
3772
            UCHAR NumberOfProcessors;
 
3773
            UCHAR ProductType;
 
3774
        };
 
3775
    };
 
3776
 
 
3777
    //
 
3778
    // MajorVersion, MinorVersion, BuildNumber, PlatformId and
 
3779
    // CSDVersion are all taken from the OSVERSIONINFO structure
 
3780
    // returned by GetVersionEx( ).
 
3781
    //
 
3782
    
 
3783
    ULONG32 MajorVersion;
 
3784
    ULONG32 MinorVersion;
 
3785
    ULONG32 BuildNumber;
 
3786
    ULONG32 PlatformId;
 
3787
 
 
3788
    //
 
3789
    // RVA to a CSDVersion string in the string table.
 
3790
    //
 
3791
    
 
3792
    RVA CSDVersionRva;
 
3793
 
 
3794
    union {
 
3795
        ULONG32 Reserved1;
 
3796
        struct {
 
3797
            USHORT SuiteMask;
 
3798
            USHORT Reserved2;
 
3799
        };
 
3800
    };
 
3801
 
 
3802
    CPU_INFORMATION Cpu;
 
3803
 
 
3804
} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
 
3805
 
 
3806
 
 
3807
//
 
3808
// The minidump thread contains standard thread
 
3809
// information plus an RVA to the memory for this 
 
3810
// thread and an RVA to the CONTEXT structure for
 
3811
// this thread.
 
3812
//
 
3813
 
 
3814
 
 
3815
//
 
3816
// ThreadId must be 4 bytes on all architectures.
 
3817
//
 
3818
 
 
3819
C_ASSERT (sizeof ( ((PPROCESS_INFORMATION)0)->dwThreadId ) == 4);
 
3820
 
 
3821
typedef struct _MINIDUMP_THREAD {
 
3822
    ULONG32 ThreadId;
 
3823
    ULONG32 SuspendCount;
 
3824
    ULONG32 PriorityClass;
 
3825
    ULONG32 Priority;
 
3826
    ULONG64 Teb;
 
3827
    MINIDUMP_MEMORY_DESCRIPTOR Stack;
 
3828
    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 
3829
} MINIDUMP_THREAD, *PMINIDUMP_THREAD;
 
3830
 
 
3831
//
 
3832
// The thread list is a container of threads.
 
3833
//
 
3834
 
 
3835
typedef struct _MINIDUMP_THREAD_LIST {
 
3836
    ULONG32 NumberOfThreads;
 
3837
    MINIDUMP_THREAD Threads [0];
 
3838
} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
 
3839
 
 
3840
 
 
3841
typedef struct _MINIDUMP_THREAD_EX {
 
3842
    ULONG32 ThreadId;
 
3843
    ULONG32 SuspendCount;
 
3844
    ULONG32 PriorityClass;
 
3845
    ULONG32 Priority;
 
3846
    ULONG64 Teb;
 
3847
    MINIDUMP_MEMORY_DESCRIPTOR Stack;
 
3848
    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 
3849
    MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
 
3850
} MINIDUMP_THREAD_EX, *PMINIDUMP_THREAD_EX;
 
3851
 
 
3852
//
 
3853
// The thread list is a container of threads.
 
3854
//
 
3855
 
 
3856
typedef struct _MINIDUMP_THREAD_EX_LIST {
 
3857
    ULONG32 NumberOfThreads;
 
3858
    MINIDUMP_THREAD_EX Threads [0];
 
3859
} MINIDUMP_THREAD_EX_LIST, *PMINIDUMP_THREAD_EX_LIST;
 
3860
 
 
3861
 
 
3862
//
 
3863
// The MINIDUMP_EXCEPTION is the same as EXCEPTION on Win64.
 
3864
//
 
3865
 
 
3866
typedef struct _MINIDUMP_EXCEPTION  {
 
3867
    ULONG32 ExceptionCode;
 
3868
    ULONG32 ExceptionFlags;
 
3869
    ULONG64 ExceptionRecord;
 
3870
    ULONG64 ExceptionAddress;
 
3871
    ULONG32 NumberParameters;
 
3872
    ULONG32 __unusedAlignment;
 
3873
    ULONG64 ExceptionInformation [ EXCEPTION_MAXIMUM_PARAMETERS ];
 
3874
} MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
 
3875
 
 
3876
 
 
3877
//
 
3878
// The exception information stream contains the id of the thread that caused
 
3879
// the exception (ThreadId), the exception record for the exception
 
3880
// (ExceptionRecord) and an RVA to the thread context where the exception
 
3881
// occured.
 
3882
//
 
3883
 
 
3884
typedef struct MINIDUMP_EXCEPTION_STREAM {
 
3885
    ULONG32 ThreadId;
 
3886
    ULONG32  __alignment;
 
3887
    MINIDUMP_EXCEPTION ExceptionRecord;
 
3888
    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 
3889
} MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
 
3890
 
 
3891
 
 
3892
//
 
3893
// The MINIDUMP_MODULE contains information about a
 
3894
// a specific module. It includes the CheckSum and
 
3895
// the TimeDateStamp for the module so the module
 
3896
// can be reloaded during the analysis phase.
 
3897
//
 
3898
 
 
3899
typedef struct _MINIDUMP_MODULE {
 
3900
    ULONG64 BaseOfImage;
 
3901
    ULONG32 SizeOfImage;
 
3902
    ULONG32 CheckSum;
 
3903
    ULONG32 TimeDateStamp;
 
3904
    RVA ModuleNameRva;
 
3905
    VS_FIXEDFILEINFO VersionInfo;
 
3906
    MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
 
3907
    MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
 
3908
    ULONG64 Reserved0;                          // Reserved for future use.
 
3909
    ULONG64 Reserved1;                          // Reserved for future use.
 
3910
} MINIDUMP_MODULE, *PMINIDUMP_MODULE;   
 
3911
 
 
3912
 
 
3913
//
 
3914
// The minidump module list is a container for modules.
 
3915
//
 
3916
 
 
3917
typedef struct _MINIDUMP_MODULE_LIST {
 
3918
    ULONG32 NumberOfModules;
 
3919
    MINIDUMP_MODULE Modules [ 0 ];
 
3920
} MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
 
3921
 
 
3922
 
 
3923
//
 
3924
// Memory Ranges
 
3925
//
 
3926
 
 
3927
typedef struct _MINIDUMP_MEMORY_LIST {
 
3928
    ULONG32 NumberOfMemoryRanges;
 
3929
    MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0];
 
3930
} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
 
3931
 
 
3932
typedef struct _MINIDUMP_MEMORY64_LIST {
 
3933
    ULONG64 NumberOfMemoryRanges;
 
3934
    RVA64 BaseRva;
 
3935
    MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0];
 
3936
} MINIDUMP_MEMORY64_LIST, *PMINIDUMP_MEMORY64_LIST;
 
3937
 
 
3938
 
 
3939
//
 
3940
// Support for user supplied exception information.
 
3941
//
 
3942
 
 
3943
typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
 
3944
    DWORD ThreadId;
 
3945
    PEXCEPTION_POINTERS ExceptionPointers;
 
3946
    BOOL ClientPointers;
 
3947
} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
 
3948
 
 
3949
typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
 
3950
    DWORD ThreadId;
 
3951
    ULONG64 ExceptionRecord;
 
3952
    ULONG64 ContextRecord;
 
3953
    BOOL ClientPointers;
 
3954
} MINIDUMP_EXCEPTION_INFORMATION64, *PMINIDUMP_EXCEPTION_INFORMATION64;
 
3955
 
 
3956
 
 
3957
//
 
3958
// Support for capturing system handle state at the time of the dump.
 
3959
//
 
3960
 
 
3961
// Per-handle object information varies according to
 
3962
// the OS, the OS version, the processor type and
 
3963
// so on.  The minidump gives a minidump identifier
 
3964
// to each possible data format for identification
 
3965
// purposes but does not control nor describe the actual data.
 
3966
typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
 
3967
    MiniHandleObjectInformationNone,
 
3968
    MiniThreadInformation1,
 
3969
    MiniMutantInformation1,
 
3970
    MiniMutantInformation2,
 
3971
    MiniProcessInformation1,
 
3972
    MiniProcessInformation2,
 
3973
    MiniHandleObjectInformationTypeMax
 
3974
} MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
 
3975
 
 
3976
typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION {
 
3977
    RVA NextInfoRva;
 
3978
    ULONG32 InfoType;
 
3979
    ULONG32 SizeOfInfo;
 
3980
    // Raw information follows.
 
3981
} MINIDUMP_HANDLE_OBJECT_INFORMATION;
 
3982
 
 
3983
typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
 
3984
    ULONG64 Handle;
 
3985
    RVA TypeNameRva;
 
3986
    RVA ObjectNameRva;
 
3987
    ULONG32 Attributes;
 
3988
    ULONG32 GrantedAccess;
 
3989
    ULONG32 HandleCount;
 
3990
    ULONG32 PointerCount;
 
3991
} MINIDUMP_HANDLE_DESCRIPTOR, *PMINIDUMP_HANDLE_DESCRIPTOR;
 
3992
 
 
3993
typedef struct _MINIDUMP_HANDLE_DESCRIPTOR_2 {
 
3994
    ULONG64 Handle;
 
3995
    RVA TypeNameRva;
 
3996
    RVA ObjectNameRva;
 
3997
    ULONG32 Attributes;
 
3998
    ULONG32 GrantedAccess;
 
3999
    ULONG32 HandleCount;
 
4000
    ULONG32 PointerCount;
 
4001
    RVA ObjectInfoRva;
 
4002
    ULONG32 Reserved0;
 
4003
} MINIDUMP_HANDLE_DESCRIPTOR_2, *PMINIDUMP_HANDLE_DESCRIPTOR_2;
 
4004
 
 
4005
// The latest MINIDUMP_HANDLE_DESCRIPTOR definition.
 
4006
typedef MINIDUMP_HANDLE_DESCRIPTOR_2 MINIDUMP_HANDLE_DESCRIPTOR_N;
 
4007
typedef MINIDUMP_HANDLE_DESCRIPTOR_N *PMINIDUMP_HANDLE_DESCRIPTOR_N;
 
4008
 
 
4009
typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
 
4010
    ULONG32 SizeOfHeader;
 
4011
    ULONG32 SizeOfDescriptor;
 
4012
    ULONG32 NumberOfDescriptors;
 
4013
    ULONG32 Reserved;
 
4014
} MINIDUMP_HANDLE_DATA_STREAM, *PMINIDUMP_HANDLE_DATA_STREAM;
 
4015
 
 
4016
// Some operating systems can track the last operations
 
4017
// performed on a handle.  For example, Application Verifier
 
4018
// can enable this for some versions of Windows.  The
 
4019
// handle operation list collects handle operations
 
4020
// known for the dump target.
 
4021
// Each entry is an AVRF_HANDLE_OPERATION.
 
4022
typedef struct _MINIDUMP_HANDLE_OPERATION_LIST {
 
4023
    ULONG32 SizeOfHeader;
 
4024
    ULONG32 SizeOfEntry;
 
4025
    ULONG32 NumberOfEntries;
 
4026
    ULONG32 Reserved;
 
4027
} MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST;
 
4028
 
 
4029
 
 
4030
//
 
4031
// Support for capturing dynamic function table state at the time of the dump.
 
4032
//
 
4033
 
 
4034
typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
 
4035
    ULONG64 MinimumAddress;
 
4036
    ULONG64 MaximumAddress;
 
4037
    ULONG64 BaseAddress;
 
4038
    ULONG32 EntryCount;
 
4039
    ULONG32 SizeOfAlignPad;
 
4040
} MINIDUMP_FUNCTION_TABLE_DESCRIPTOR, *PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
 
4041
 
 
4042
typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
 
4043
    ULONG32 SizeOfHeader;
 
4044
    ULONG32 SizeOfDescriptor;
 
4045
    ULONG32 SizeOfNativeDescriptor;
 
4046
    ULONG32 SizeOfFunctionEntry;
 
4047
    ULONG32 NumberOfDescriptors;
 
4048
    ULONG32 SizeOfAlignPad;
 
4049
} MINIDUMP_FUNCTION_TABLE_STREAM, *PMINIDUMP_FUNCTION_TABLE_STREAM;
 
4050
 
 
4051
 
 
4052
//
 
4053
// The MINIDUMP_UNLOADED_MODULE contains information about a
 
4054
// a specific module that was previously loaded but no
 
4055
// longer is.  This can help with diagnosing problems where
 
4056
// callers attempt to call code that is no longer loaded.
 
4057
//
 
4058
 
 
4059
typedef struct _MINIDUMP_UNLOADED_MODULE {
 
4060
    ULONG64 BaseOfImage;
 
4061
    ULONG32 SizeOfImage;
 
4062
    ULONG32 CheckSum;
 
4063
    ULONG32 TimeDateStamp;
 
4064
    RVA ModuleNameRva;
 
4065
} MINIDUMP_UNLOADED_MODULE, *PMINIDUMP_UNLOADED_MODULE;
 
4066
 
 
4067
 
 
4068
//
 
4069
// The minidump unloaded module list is a container for unloaded modules.
 
4070
//
 
4071
 
 
4072
typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
 
4073
    ULONG32 SizeOfHeader;
 
4074
    ULONG32 SizeOfEntry;
 
4075
    ULONG32 NumberOfEntries;
 
4076
} MINIDUMP_UNLOADED_MODULE_LIST, *PMINIDUMP_UNLOADED_MODULE_LIST;
 
4077
 
 
4078
 
 
4079
//
 
4080
// The miscellaneous information stream contains a variety
 
4081
// of small pieces of information.  A member is valid if
 
4082
// it's within the available size and its corresponding
 
4083
// bit is set.
 
4084
//
 
4085
 
 
4086
#define MINIDUMP_MISC1_PROCESS_ID            0x00000001
 
4087
#define MINIDUMP_MISC1_PROCESS_TIMES         0x00000002
 
4088
#define MINIDUMP_MISC1_PROCESSOR_POWER_INFO  0x00000004
 
4089
#define MINIDUMP_MISC3_PROCESS_INTEGRITY     0x00000010
 
4090
#define MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS 0x00000020
 
4091
#define MINIDUMP_MISC3_TIMEZONE              0x00000040
 
4092
#define MINIDUMP_MISC3_PROTECTED_PROCESS     0x00000080
 
4093
 
 
4094
typedef struct _MINIDUMP_MISC_INFO {
 
4095
    ULONG32 SizeOfInfo;
 
4096
    ULONG32 Flags1;
 
4097
    ULONG32 ProcessId;
 
4098
    ULONG32 ProcessCreateTime;
 
4099
    ULONG32 ProcessUserTime;
 
4100
    ULONG32 ProcessKernelTime;
 
4101
} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
 
4102
 
 
4103
typedef struct _MINIDUMP_MISC_INFO_2 {
 
4104
    ULONG32 SizeOfInfo;
 
4105
    ULONG32 Flags1;
 
4106
    ULONG32 ProcessId;
 
4107
    ULONG32 ProcessCreateTime;
 
4108
    ULONG32 ProcessUserTime;
 
4109
    ULONG32 ProcessKernelTime;
 
4110
    ULONG32 ProcessorMaxMhz;
 
4111
    ULONG32 ProcessorCurrentMhz;
 
4112
    ULONG32 ProcessorMhzLimit;
 
4113
    ULONG32 ProcessorMaxIdleState;
 
4114
    ULONG32 ProcessorCurrentIdleState;
 
4115
} MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2;
 
4116
 
 
4117
typedef struct _MINIDUMP_MISC_INFO_3 {
 
4118
    ULONG32 SizeOfInfo;
 
4119
    ULONG32 Flags1;
 
4120
    ULONG32 ProcessId;
 
4121
    ULONG32 ProcessCreateTime;
 
4122
    ULONG32 ProcessUserTime;
 
4123
    ULONG32 ProcessKernelTime;
 
4124
    ULONG32 ProcessorMaxMhz;
 
4125
    ULONG32 ProcessorCurrentMhz;
 
4126
    ULONG32 ProcessorMhzLimit;
 
4127
    ULONG32 ProcessorMaxIdleState;
 
4128
    ULONG32 ProcessorCurrentIdleState;
 
4129
    ULONG32 ProcessIntegrityLevel;
 
4130
    ULONG32 ProcessExecuteFlags;
 
4131
    ULONG32 ProtectedProcess;
 
4132
    ULONG32 TimeZoneId;
 
4133
    TIME_ZONE_INFORMATION TimeZone;
 
4134
} MINIDUMP_MISC_INFO_3, *PMINIDUMP_MISC_INFO_3;
 
4135
 
 
4136
// The latest MINIDUMP_MISC_INFO definition.
 
4137
typedef MINIDUMP_MISC_INFO_3 MINIDUMP_MISC_INFO_N;
 
4138
typedef MINIDUMP_MISC_INFO_N* PMINIDUMP_MISC_INFO_N;
 
4139
 
 
4140
 
 
4141
//
 
4142
// The memory information stream contains memory region
 
4143
// description information.  This stream corresponds to
 
4144
// what VirtualQuery would return for the process the
 
4145
// dump was created for.
 
4146
//
 
4147
 
 
4148
typedef struct _MINIDUMP_MEMORY_INFO {
 
4149
    ULONG64 BaseAddress;
 
4150
    ULONG64 AllocationBase;
 
4151
    ULONG32 AllocationProtect;
 
4152
    ULONG32 __alignment1;
 
4153
    ULONG64 RegionSize;
 
4154
    ULONG32 State;
 
4155
    ULONG32 Protect;
 
4156
    ULONG32 Type;
 
4157
    ULONG32 __alignment2;
 
4158
} MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO;
 
4159
 
 
4160
typedef struct _MINIDUMP_MEMORY_INFO_LIST {
 
4161
    ULONG SizeOfHeader;
 
4162
    ULONG SizeOfEntry;
 
4163
    ULONG64 NumberOfEntries;
 
4164
} MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST;
 
4165
 
 
4166
    
 
4167
//
 
4168
// The memory information stream contains memory region
 
4169
// description information.  This stream corresponds to
 
4170
// what VirtualQuery would return for the process the
 
4171
// dump was created for.
 
4172
//
 
4173
 
 
4174
// Thread dump writer status flags.
 
4175
#define MINIDUMP_THREAD_INFO_ERROR_THREAD    0x00000001
 
4176
#define MINIDUMP_THREAD_INFO_WRITING_THREAD  0x00000002
 
4177
#define MINIDUMP_THREAD_INFO_EXITED_THREAD   0x00000004
 
4178
#define MINIDUMP_THREAD_INFO_INVALID_INFO    0x00000008
 
4179
#define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010
 
4180
#define MINIDUMP_THREAD_INFO_INVALID_TEB     0x00000020
 
4181
 
 
4182
typedef struct _MINIDUMP_THREAD_INFO {
 
4183
    ULONG32 ThreadId;
 
4184
    ULONG32 DumpFlags;
 
4185
    ULONG32 DumpError;
 
4186
    ULONG32 ExitStatus;
 
4187
    ULONG64 CreateTime;
 
4188
    ULONG64 ExitTime;
 
4189
    ULONG64 KernelTime;
 
4190
    ULONG64 UserTime;
 
4191
    ULONG64 StartAddress;
 
4192
    ULONG64 Affinity;
 
4193
} MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO;
 
4194
 
 
4195
typedef struct _MINIDUMP_THREAD_INFO_LIST {
 
4196
    ULONG SizeOfHeader;
 
4197
    ULONG SizeOfEntry;
 
4198
    ULONG NumberOfEntries;
 
4199
} MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST;
 
4200
 
 
4201
//
 
4202
// Support for token information.
 
4203
//
 
4204
typedef struct _MINIDUMP_TOKEN_INFO_HEADER {
 
4205
    ULONG   TokenSize;   // The size of the token structure.
 
4206
    ULONG   TokenId;     // The PID in NtOpenProcessToken() call or TID in NtOpenThreadToken() call.
 
4207
    ULONG64 TokenHandle; // The handle value returned.
 
4208
} MINIDUMP_TOKEN_INFO_HEADER, *PMINIDUMP_TOKEN_INFO_HEADER;
 
4209
 
 
4210
typedef struct _MINIDUMP_TOKEN_INFO_LIST {
 
4211
    ULONG TokenListSize;
 
4212
    ULONG TokenListEntries;
 
4213
    ULONG ListHeaderSize;
 
4214
    ULONG ElementHeaderSize;
 
4215
} MINIDUMP_TOKEN_INFO_LIST, *PMINIDUMP_TOKEN_INFO_LIST;
 
4216
 
 
4217
//
 
4218
// Support for arbitrary user-defined information.
 
4219
//
 
4220
 
 
4221
typedef struct _MINIDUMP_USER_RECORD {
 
4222
    ULONG32 Type;
 
4223
    MINIDUMP_LOCATION_DESCRIPTOR Memory;
 
4224