VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/dbghelp.h@ 33252

Last change on this file since 33252 was 25949, checked in by vboxsync, 15 years ago

crOpenGL: update to wine 1.1.36 and disable unnecessary fbo state poll
  • Property svn:eol-style set to native
File size: 55.4 KB
Line 
1/*
2 * Declarations for DBGHELP
3 *
4 * Copyright (C) 2003 Eric Pouech
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21/*
22 * Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
23 * other than GPL or LGPL is available it will apply instead, Sun elects to use only
24 * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
25 * a choice of LGPL license versions is made available with the language indicating
26 * that LGPLv2 or any later version may be used, or where a choice of which version
27 * of the LGPL is applied is otherwise unspecified.
28 */
29
30#ifndef __WINE_DBGHELP_H
31#define __WINE_DBGHELP_H
32
33#ifdef __cplusplus
34extern "C" {
35#endif /* defined(__cplusplus) */
36
37#ifdef _WIN64
38#ifndef _IMAGEHLP64
39#define _IMAGEHLP64
40#endif
41#endif
42
43#define IMAGEAPI WINAPI
44#define DBHLPAPI IMAGEAPI
45
46typedef struct _LOADED_IMAGE
47{
48 PSTR ModuleName;
49 HANDLE hFile;
50 PUCHAR MappedAddress;
51 PIMAGE_NT_HEADERS FileHeader;
52 PIMAGE_SECTION_HEADER LastRvaSection;
53 ULONG NumberOfSections;
54 PIMAGE_SECTION_HEADER Sections;
55 ULONG Characteristics;
56 BOOLEAN fSystemImage;
57 BOOLEAN fDOSImage;
58 BOOLEAN fReadOnly;
59 UCHAR Version;
60 LIST_ENTRY Links;
61 ULONG SizeOfImage;
62} LOADED_IMAGE, *PLOADED_IMAGE;
63
64/*************************
65 * IMAGEHLP equiv *
66 *************************/
67
68typedef enum
69{
70 AddrMode1616,
71 AddrMode1632,
72 AddrModeReal,
73 AddrModeFlat
74} ADDRESS_MODE;
75
76#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
77#define ADDRESS ADDRESS64
78#define LPADDRESS LPADDRESS64
79#else
80typedef struct _tagADDRESS
81{
82 DWORD Offset;
83 WORD Segment;
84 ADDRESS_MODE Mode;
85} ADDRESS, *LPADDRESS;
86#endif
87
88typedef struct _tagADDRESS64
89{
90 DWORD64 Offset;
91 WORD Segment;
92 ADDRESS_MODE Mode;
93} ADDRESS64, *LPADDRESS64;
94
95#define SYMF_OMAP_GENERATED 0x00000001
96#define SYMF_OMAP_MODIFIED 0x00000002
97#define SYMF_USER_GENERATED 0x00000004
98#define SYMF_REGISTER 0x00000008
99#define SYMF_REGREL 0x00000010
100#define SYMF_FRAMEREL 0x00000020
101#define SYMF_PARAMETER 0x00000040
102#define SYMF_LOCAL 0x00000080
103#define SYMF_CONSTANT 0x00000100
104#define SYMF_EXPORT 0x00000200
105#define SYMF_FORWARDER 0x00000400
106#define SYMF_FUNCTION 0x00000800
107#define SYMF_VIRTUAL 0x00001000
108#define SYMF_THUNK 0x00002000
109#define SYMF_TLSREL 0x00004000
110
111typedef enum
112{
113 SymNone = 0,
114 SymCoff,
115 SymCv,
116 SymPdb,
117 SymExport,
118 SymDeferred,
119 SymSym,
120 SymDia,
121 SymVirtual,
122 NumSymTypes
123} SYM_TYPE;
124
125#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
126#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
127#define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64
128#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
129#define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64
130#else
131typedef struct _IMAGEHLP_SYMBOL
132{
133 DWORD SizeOfStruct;
134 DWORD Address;
135 DWORD Size;
136 DWORD Flags;
137 DWORD MaxNameLength;
138 CHAR Name[1];
139} IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
140
141typedef struct _IMAGEHLP_SYMBOLW
142{
143 DWORD SizeOfStruct;
144 DWORD Address;
145 DWORD Size;
146 DWORD Flags;
147 DWORD MaxNameLength;
148 WCHAR Name[1];
149} IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW;
150#endif
151
152typedef struct _IMAGEHLP_SYMBOL64
153{
154 DWORD SizeOfStruct;
155 DWORD64 Address;
156 DWORD Size;
157 DWORD Flags;
158 DWORD MaxNameLength;
159 CHAR Name[1];
160} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
161
162typedef struct _IMAGEHLP_SYMBOLW64
163{
164 DWORD SizeOfStruct;
165 DWORD64 Address;
166 DWORD Size;
167 DWORD Flags;
168 DWORD MaxNameLength;
169 WCHAR Name[1];
170} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
171
172#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
173#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
174#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
175#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
176#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
177#else
178typedef struct _IMAGEHLP_MODULE
179{
180 DWORD SizeOfStruct;
181 DWORD BaseOfImage;
182 DWORD ImageSize;
183 DWORD TimeDateStamp;
184 DWORD CheckSum;
185 DWORD NumSyms;
186 SYM_TYPE SymType;
187 CHAR ModuleName[32];
188 CHAR ImageName[256];
189 CHAR LoadedImageName[256];
190} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
191
192typedef struct _IMAGEHLP_MODULEW
193{
194 DWORD SizeOfStruct;
195 DWORD BaseOfImage;
196 DWORD ImageSize;
197 DWORD TimeDateStamp;
198 DWORD CheckSum;
199 DWORD NumSyms;
200 SYM_TYPE SymType;
201 WCHAR ModuleName[32];
202 WCHAR ImageName[256];
203 WCHAR LoadedImageName[256];
204} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
205#endif
206
207typedef struct _IMAGEHLP_MODULE64
208{
209 DWORD SizeOfStruct;
210 DWORD64 BaseOfImage;
211 DWORD ImageSize;
212 DWORD TimeDateStamp;
213 DWORD CheckSum;
214 DWORD NumSyms;
215 SYM_TYPE SymType;
216 CHAR ModuleName[32];
217 CHAR ImageName[256];
218 CHAR LoadedImageName[256];
219 CHAR LoadedPdbName[256];
220 DWORD CVSig;
221 CHAR CVData[MAX_PATH*3];
222 DWORD PdbSig;
223 GUID PdbSig70;
224 DWORD PdbAge;
225 BOOL PdbUnmatched;
226 BOOL DbgUnmatched;
227 BOOL LineNumbers;
228 BOOL GlobalSymbols;
229 BOOL TypeInfo;
230 BOOL SourceIndexed;
231 BOOL Publics;
232} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
233
234typedef struct _IMAGEHLP_MODULEW64
235{
236 DWORD SizeOfStruct;
237 DWORD64 BaseOfImage;
238 DWORD ImageSize;
239 DWORD TimeDateStamp;
240 DWORD CheckSum;
241 DWORD NumSyms;
242 SYM_TYPE SymType;
243 WCHAR ModuleName[32];
244 WCHAR ImageName[256];
245 WCHAR LoadedImageName[256];
246 WCHAR LoadedPdbName[256];
247 DWORD CVSig;
248 WCHAR CVData[MAX_PATH*3];
249 DWORD PdbSig;
250 GUID PdbSig70;
251 DWORD PdbAge;
252 BOOL PdbUnmatched;
253 BOOL DbgUnmatched;
254 BOOL LineNumbers;
255 BOOL GlobalSymbols;
256 BOOL TypeInfo;
257 BOOL SourceIndexed;
258 BOOL Publics;
259} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
260
261#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
262#define IMAGEHLP_LINE IMAGEHLP_LINE64
263#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
264#define IMAGEHLP_LINEW IMAGEHLP_LINEW64
265#define PIMAGEHLP_LINEW PIMAGEHLP_LINEW64
266#else
267typedef struct _IMAGEHLP_LINE
268{
269 DWORD SizeOfStruct;
270 PVOID Key;
271 DWORD LineNumber;
272 PCHAR FileName;
273 DWORD Address;
274} IMAGEHLP_LINE, *PIMAGEHLP_LINE;
275
276typedef struct _IMAGEHLP_LINEW
277{
278 DWORD SizeOfStruct;
279 PVOID Key;
280 DWORD LineNumber;
281 PWSTR FileName;
282 DWORD Address;
283} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
284#endif
285
286typedef struct _IMAGEHLP_LINE64
287{
288 DWORD SizeOfStruct;
289 PVOID Key;
290 DWORD LineNumber;
291 PCHAR FileName;
292 DWORD64 Address;
293} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
294
295typedef struct _IMAGEHLP_LINEW64
296{
297 DWORD SizeOfStruct;
298 PVOID Key;
299 DWORD LineNumber;
300 PWSTR FileName;
301 DWORD64 Address;
302} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
303
304typedef struct _SOURCEFILE
305{
306 DWORD64 ModBase;
307 PCHAR FileName;
308} SOURCEFILE, *PSOURCEFILE;
309
310typedef struct _SOURCEFILEW
311{
312 DWORD64 ModBase;
313 PWSTR FileName;
314} SOURCEFILEW, *PSOURCEFILEW;
315
316#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
317#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
318#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
319#define CBA_SYMBOLS_UNLOADED 0x00000004
320#define CBA_DUPLICATE_SYMBOL 0x00000005
321#define CBA_READ_MEMORY 0x00000006
322#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
323#define CBA_SET_OPTIONS 0x00000008
324#define CBA_EVENT 0x00000010
325#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
326#define CBA_DEBUG_INFO 0x10000000
327
328typedef struct _IMAGEHLP_CBA_READ_MEMORY
329{
330 DWORD64 addr;
331 PVOID buf;
332 DWORD bytes;
333 DWORD *bytesread;
334} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
335
336enum
337{
338 sevInfo = 0,
339 sevProblem,
340 sevAttn,
341 sevFatal,
342 sevMax
343};
344
345#define EVENT_SRCSPEW_START 100
346#define EVENT_SRCSPEW 100
347#define EVENT_SRCSPEW_END 199
348
349typedef struct _IMAGEHLP_CBA_EVENT
350{
351 DWORD severity;
352 DWORD code;
353 PCHAR desc;
354 PVOID object;
355} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
356
357typedef struct _IMAGEHLP_CBA_EVENTW
358{
359 DWORD severity;
360 DWORD code;
361 PCWSTR desc;
362 PVOID object;
363} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
364
365#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
366#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
367#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
368#else
369typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
370{
371 DWORD SizeOfStruct;
372 DWORD BaseOfImage;
373 DWORD CheckSum;
374 DWORD TimeDateStamp;
375 CHAR FileName[MAX_PATH];
376 BOOLEAN Reparse;
377 HANDLE hFile;
378} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
379#endif
380
381typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64
382{
383 DWORD SizeOfStruct;
384 DWORD64 BaseOfImage;
385 DWORD CheckSum;
386 DWORD TimeDateStamp;
387 CHAR FileName[MAX_PATH];
388 BOOLEAN Reparse;
389 HANDLE hFile;
390 DWORD Flags;
391} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
392
393typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64
394{
395 DWORD SizeOfStruct;
396 DWORD64 BaseOfImage;
397 DWORD CheckSum;
398 DWORD TimeDateStamp;
399 WCHAR FileName[MAX_PATH + 1];
400 BOOLEAN Reparse;
401 HANDLE hFile;
402 DWORD Flags;
403} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
404
405#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
406#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
407#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
408#else
409typedef struct _IMAGEHLP_DUPLICATE_SYMBOL
410{
411 DWORD SizeOfStruct;
412 DWORD NumberOfDups;
413 PIMAGEHLP_SYMBOL Symbol;
414 DWORD SelectedSymbol;
415} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
416#endif
417
418typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64
419{
420 DWORD SizeOfStruct;
421 DWORD NumberOfDups;
422 PIMAGEHLP_SYMBOL64 Symbol;
423 DWORD SelectedSymbol;
424} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
425
426#define SYMOPT_CASE_INSENSITIVE 0x00000001
427#define SYMOPT_UNDNAME 0x00000002
428#define SYMOPT_DEFERRED_LOADS 0x00000004
429#define SYMOPT_NO_CPP 0x00000008
430#define SYMOPT_LOAD_LINES 0x00000010
431#define SYMOPT_OMAP_FIND_NEAREST 0x00000020
432#define SYMOPT_LOAD_ANYTHING 0x00000040
433#define SYMOPT_IGNORE_CVREC 0x00000080
434#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
435#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
436#define SYMOPT_EXACT_SYMBOLS 0x00000400
437#define SYMOPT_WILD_UNDERSCORE 0x00000800
438#define SYMOPT_USE_DEFAULTS 0x00001000
439/* latest SDK defines:
440#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
441#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
442*/
443#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
444#define SYMOPT_PUBLICS_ONLY 0x00004000
445#define SYMOPT_NO_PUBLICS 0x00008000
446#define SYMOPT_AUTO_PUBLICS 0x00010000
447#define SYMOPT_NO_IMAGE_SEARCH 0x00020000
448#define SYMOPT_SECURE 0x00040000
449#define SYMOPT_NO_PROMPTS 0x00080000
450#define SYMOPT_OVERWRITE 0x00100000
451#define SYMOPT_IGNORE_IMAGEDIR 0x00200000
452
453#define SYMOPT_DEBUG 0x80000000
454
455typedef struct _IMAGEHLP_STACK_FRAME
456{
457 ULONG64 InstructionOffset;
458 ULONG64 ReturnOffset;
459 ULONG64 FrameOffset;
460 ULONG64 StackOffset;
461 ULONG64 BackingStoreOffset;
462 ULONG64 FuncTableEntry;
463 ULONG64 Params[4];
464 ULONG64 Reserved[5];
465 BOOL Virtual;
466 ULONG Reserved2;
467} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
468
469typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
470
471#define DBHHEADER_DEBUGDIRS 0x1
472typedef struct _DBGHELP_MODLOAD_DATA
473{
474 DWORD ssize;
475 DWORD ssig;
476 PVOID data;
477 DWORD size;
478 DWORD flags;
479} MODLOAD_DATA, *PMODLOAD_DATA;
480
481/*************************
482 * MiniDUMP *
483 *************************/
484
485#include <pshpack4.h>
486/* DebugHelp */
487
488#define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */
489#define MINIDUMP_VERSION (42899)
490
491typedef DWORD RVA;
492typedef ULONG64 RVA64;
493
494typedef enum _MINIDUMP_TYPE
495{
496 MiniDumpNormal = 0x0000,
497 MiniDumpWithDataSegs = 0x0001,
498 MiniDumpWithFullMemory = 0x0002,
499 MiniDumpWithHandleData = 0x0004,
500 MiniDumpFilterMemory = 0x0008,
501 MiniDumpScanMemory = 0x0010,
502 MiniDumpWithUnloadedModules = 0x0020,
503 MiniDumpWithIndirectlyReferencedMemory = 0x0040,
504 MiniDumpFilterModulePaths = 0x0080,
505 MiniDumpWithProcessThreadData = 0x0100,
506 MiniDumpWithPrivateReadWriteMemory = 0x0200,
507 MiniDumpWithoutOptionalData = 0x0400,
508 MiniDumpWithFullMemoryInfo = 0x0800,
509 MiniDumpWithThreadInfo = 0x1000,
510 MiniDumpWithCodeSegs = 0x2000
511} MINIDUMP_TYPE;
512
513typedef enum _MINIDUMP_CALLBACK_TYPE
514{
515 ModuleCallback,
516 ThreadCallback,
517 ThreadExCallback,
518 IncludeThreadCallback,
519 IncludeModuleCallback,
520 MemoryCallback,
521} MINIDUMP_CALLBACK_TYPE;
522
523typedef struct _MINIDUMP_THREAD_CALLBACK
524{
525 ULONG ThreadId;
526 HANDLE ThreadHandle;
527 CONTEXT Context;
528 ULONG SizeOfContext;
529 ULONG64 StackBase;
530 ULONG64 StackEnd;
531} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
532
533typedef struct _MINIDUMP_THREAD_EX_CALLBACK
534{
535 ULONG ThreadId;
536 HANDLE ThreadHandle;
537 CONTEXT Context;
538 ULONG SizeOfContext;
539 ULONG64 StackBase;
540 ULONG64 StackEnd;
541 ULONG64 BackingStoreBase;
542 ULONG64 BackingStoreEnd;
543} MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
544
545typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
546{
547 ULONG ThreadId;
548} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
549
550typedef enum _THREAD_WRITE_FLAGS
551{
552 ThreadWriteThread = 0x0001,
553 ThreadWriteStack = 0x0002,
554 ThreadWriteContext = 0x0004,
555 ThreadWriteBackingStore = 0x0008,
556 ThreadWriteInstructionWindow = 0x0010,
557 ThreadWriteThreadData = 0x0020,
558 ThreadWriteThreadInfo = 0x0040
559} THREAD_WRITE_FLAGS;
560
561typedef struct _MINIDUMP_MODULE_CALLBACK
562{
563 PWCHAR FullPath;
564 ULONG64 BaseOfImage;
565 ULONG SizeOfImage;
566 ULONG CheckSum;
567 ULONG TimeDateStamp;
568 VS_FIXEDFILEINFO VersionInfo;
569 PVOID CvRecord;
570 ULONG SizeOfCvRecord;
571 PVOID MiscRecord;
572 ULONG SizeOfMiscRecord;
573} MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
574
575typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
576{
577 ULONG64 BaseOfImage;
578} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
579
580typedef enum _MODULE_WRITE_FLAGS
581{
582 ModuleWriteModule = 0x0001,
583 ModuleWriteDataSeg = 0x0002,
584 ModuleWriteMiscRecord = 0x0004,
585 ModuleWriteCvRecord = 0x0008,
586 ModuleReferencedByMemory = 0x0010,
587 ModuleWriteTlsData = 0x0020,
588 ModuleWriteCodeSegs = 0x0040,
589} MODULE_WRITE_FLAGS;
590
591typedef struct _MINIDUMP_CALLBACK_INPUT
592{
593 ULONG ProcessId;
594 HANDLE ProcessHandle;
595 ULONG CallbackType;
596 union
597 {
598 MINIDUMP_THREAD_CALLBACK Thread;
599 MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
600 MINIDUMP_MODULE_CALLBACK Module;
601 MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
602 MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
603 } DUMMYUNIONNAME;
604} MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
605
606typedef struct _MINIDUMP_CALLBACK_OUTPUT
607{
608 union
609 {
610 ULONG ModuleWriteFlags;
611 ULONG ThreadWriteFlags;
612 struct
613 {
614 ULONG64 MemoryBase;
615 ULONG MemorySize;
616 } DUMMYSTRUCTNAME;
617 } DUMMYUNIONNAME;
618} MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
619
620typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT);
621
622typedef struct _MINIDUMP_CALLBACK_INFORMATION
623{
624 MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
625 void* CallbackParam;
626} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
627
628typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
629{
630 ULONG DataSize;
631 RVA Rva;
632} MINIDUMP_LOCATION_DESCRIPTOR;
633
634typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64
635{
636 ULONG64 DataSize;
637 RVA64 Rva;
638} MINIDUMP_LOCATION_DESCRIPTOR64;
639
640typedef struct _MINIDUMP_DIRECTORY
641{
642 ULONG StreamType;
643 MINIDUMP_LOCATION_DESCRIPTOR Location;
644} MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
645
646typedef struct _MINIDUMP_EXCEPTION
647{
648 ULONG ExceptionCode;
649 ULONG ExceptionFlags;
650 ULONG64 ExceptionRecord;
651 ULONG64 ExceptionAddress;
652 ULONG NumberParameters;
653 ULONG __unusedAlignment;
654 ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
655} MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
656
657typedef struct _MINIDUMP_EXCEPTION_INFORMATION
658{
659 DWORD ThreadId;
660 PEXCEPTION_POINTERS ExceptionPointers;
661 BOOL ClientPointers;
662} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
663
664typedef struct MINIDUMP_EXCEPTION_STREAM
665{
666 ULONG ThreadId;
667 ULONG __alignment;
668 MINIDUMP_EXCEPTION ExceptionRecord;
669 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
670} MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
671
672typedef struct _MINIDUMP_HEADER
673{
674 DWORD Signature;
675 DWORD Version;
676 DWORD NumberOfStreams;
677 RVA StreamDirectoryRva;
678 DWORD CheckSum;
679 union
680 {
681 DWORD Reserved;
682 DWORD TimeDateStamp;
683 } DUMMYUNIONNAME;
684 ULONG64 Flags;
685} MINIDUMP_HEADER, *PMINIDUMP_HEADER;
686
687typedef struct _MINIDUMP_MEMORY_DESCRIPTOR
688{
689 ULONG64 StartOfMemoryRange;
690 MINIDUMP_LOCATION_DESCRIPTOR Memory;
691} MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
692
693typedef struct _MINIDUMP_MEMORY_LIST
694{
695 ULONG NumberOfMemoryRanges;
696 MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[1]; /* FIXME: 0-sized array not supported */
697} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
698
699#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
700#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
701
702typedef struct _MINIDUMP_MISC_INFO
703{
704 ULONG SizeOfInfo;
705 ULONG Flags1;
706 ULONG ProcessId;
707 ULONG ProcessCreateTime;
708 ULONG ProcessUserTime;
709 ULONG ProcessKernelTime;
710} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
711
712typedef struct _MINIDUMP_MODULE
713{
714 ULONG64 BaseOfImage;
715 ULONG SizeOfImage;
716 ULONG CheckSum;
717 ULONG TimeDateStamp;
718 RVA ModuleNameRva;
719 VS_FIXEDFILEINFO VersionInfo;
720 MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
721 MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
722 ULONG64 Reserved0;
723 ULONG64 Reserved1;
724} MINIDUMP_MODULE, *PMINIDUMP_MODULE;
725
726typedef struct _MINIDUMP_MODULE_LIST
727{
728 ULONG NumberOfModules;
729 MINIDUMP_MODULE Modules[1]; /* FIXME: 0-sized array not supported */
730} MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
731
732typedef struct _MINIDUMP_STRING
733{
734 ULONG Length;
735 WCHAR Buffer[1]; /* FIXME: O-sized array not supported */
736} MINIDUMP_STRING, *PMINIDUMP_STRING;
737
738typedef struct _MINIDUMP_SYSTEM_INFO
739{
740 USHORT ProcessorArchitecture;
741 USHORT ProcessorLevel;
742 USHORT ProcessorRevision;
743 union
744 {
745 USHORT Reserved0;
746 struct
747 {
748 UCHAR NumberOfProcessors;
749 UCHAR ProductType;
750 } DUMMYSTRUCTNAME;
751 } DUMMYUNIONNAME;
752
753 ULONG MajorVersion;
754 ULONG MinorVersion;
755 ULONG BuildNumber;
756 ULONG PlatformId;
757
758 RVA CSDVersionRva;
759 union
760 {
761 ULONG Reserved1;
762 struct
763 {
764 USHORT SuiteMask;
765 USHORT Reserved2;
766 } DUMMYSTRUCTNAME;
767 } DUMMYUNIONNAME1;
768 union _CPU_INFORMATION
769 {
770 struct
771 {
772 ULONG VendorId[3];
773 ULONG VersionInformation;
774 ULONG FeatureInformation;
775 ULONG AMDExtendedCpuFeatures;
776 } X86CpuInfo;
777 struct
778 {
779 ULONG64 ProcessorFeatures[2];
780 } OtherCpuInfo;
781 } Cpu;
782
783} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
784
785typedef struct _MINIDUMP_THREAD
786{
787 ULONG ThreadId;
788 ULONG SuspendCount;
789 ULONG PriorityClass;
790 ULONG Priority;
791 ULONG64 Teb;
792 MINIDUMP_MEMORY_DESCRIPTOR Stack;
793 MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
794} MINIDUMP_THREAD, *PMINIDUMP_THREAD;
795
796typedef struct _MINIDUMP_THREAD_LIST
797{
798 ULONG NumberOfThreads;
799 MINIDUMP_THREAD Threads[1]; /* FIXME: no support of 0 sized array */
800} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
801
802typedef struct _MINIDUMP_USER_STREAM
803{
804 ULONG Type;
805 ULONG BufferSize;
806 void* Buffer;
807} MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
808
809typedef struct _MINIDUMP_USER_STREAM_INFORMATION
810{
811 ULONG UserStreamCount;
812 PMINIDUMP_USER_STREAM UserStreamArray;
813} MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
814
815typedef enum _MINIDUMP_STREAM_TYPE
816{
817 UnusedStream = 0,
818 ReservedStream0 = 1,
819 ReservedStream1 = 2,
820 ThreadListStream = 3,
821 ModuleListStream = 4,
822 MemoryListStream = 5,
823 ExceptionStream = 6,
824 SystemInfoStream = 7,
825 ThreadExListStream = 8,
826 Memory64ListStream = 9,
827 CommentStreamA = 10,
828 CommentStreamW = 11,
829 HandleDataStream = 12,
830 FunctionTableStream = 13,
831 UnloadedModuleListStream = 14,
832 MiscInfoStream = 15,
833 MemoryInfoListStream = 16,
834 ThreadInfoListStream = 17,
835
836 LastReservedStream = 0xffff
837} MINIDUMP_STREAM_TYPE;
838
839BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
840 const PMINIDUMP_EXCEPTION_INFORMATION,
841 const PMINIDUMP_USER_STREAM_INFORMATION,
842 const PMINIDUMP_CALLBACK_INFORMATION);
843BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*,
844 ULONG*);
845
846#include <poppack.h>
847
848/*************************
849 * MODULE handling *
850 *************************/
851
852/* flags for SymLoadModuleEx */
853#define SLMFLAG_VIRTUAL 0x1
854#define SLMFLAG_NO_SYMBOLS 0x4
855
856typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
857BOOL WINAPI EnumerateLoadedModules64(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID);
858typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID);
859BOOL WINAPI EnumerateLoadedModulesW64(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID);
860typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID);
861BOOL WINAPI SymEnumerateModules64(HANDLE, PSYM_ENUMMODULES_CALLBACK64, PVOID);
862typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID);
863BOOL WINAPI SymEnumerateModulesW64(HANDLE, PSYM_ENUMMODULES_CALLBACKW64, PVOID);
864BOOL WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64);
865BOOL WINAPI SymGetModuleInfoW64(HANDLE, DWORD64, PIMAGEHLP_MODULEW64);
866DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64);
867DWORD64 WINAPI SymLoadModule64(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD);
868DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD,
869 PMODLOAD_DATA, DWORD);
870DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD,
871 PMODLOAD_DATA, DWORD);
872BOOL WINAPI SymUnloadModule64(HANDLE, DWORD64);
873
874/*************************
875 * Symbol Handling *
876 *************************/
877
878#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
879#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER /* 0x08 */
880#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL /* 0x10 */
881#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL /* 0x20 */
882#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER /* 0x40 */
883#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL /* 0x80 */
884#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT /* 0x100 */
885#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION /* 0x800 */
886
887#define SYMFLAG_VALUEPRESENT 0x00000001
888#define SYMFLAG_REGISTER 0x00000008
889#define SYMFLAG_REGREL 0x00000010
890#define SYMFLAG_FRAMEREL 0x00000020
891#define SYMFLAG_PARAMETER 0x00000040
892#define SYMFLAG_LOCAL 0x00000080
893#define SYMFLAG_CONSTANT 0x00000100
894#define SYMFLAG_EXPORT 0x00000200
895#define SYMFLAG_FORWARDER 0x00000400
896#define SYMFLAG_FUNCTION 0x00000800
897#define SYMFLAG_VIRTUAL 0x00001000
898#define SYMFLAG_THUNK 0x00002000
899#define SYMFLAG_TLSREL 0x00004000
900#define SYMFLAG_SLOT 0x00008000
901
902#define MAX_SYM_NAME 2000
903
904typedef struct _SYMBOL_INFO
905{
906 ULONG SizeOfStruct;
907 ULONG TypeIndex;
908 ULONG64 Reserved[2];
909 ULONG info; /* sdk states info, while MSDN says it's Index... */
910 ULONG Size;
911 ULONG64 ModBase;
912 ULONG Flags;
913 ULONG64 Value;
914 ULONG64 Address;
915 ULONG Register;
916 ULONG Scope;
917 ULONG Tag;
918 ULONG NameLen;
919 ULONG MaxNameLen;
920 CHAR Name[1];
921} SYMBOL_INFO, *PSYMBOL_INFO;
922
923typedef struct _SYMBOL_INFOW
924{
925 ULONG SizeOfStruct;
926 ULONG TypeIndex;
927 ULONG64 Reserved[2];
928 ULONG Index;
929 ULONG Size;
930 ULONG64 ModBase;
931 ULONG Flags;
932 ULONG64 Value;
933 ULONG64 Address;
934 ULONG Register;
935 ULONG Scope;
936 ULONG Tag;
937 ULONG NameLen;
938 ULONG MaxNameLen;
939 WCHAR Name[1];
940} SYMBOL_INFOW, *PSYMBOL_INFOW;
941
942typedef struct _SYMBOL_INFO_PACKAGE
943{
944 SYMBOL_INFO si;
945 CHAR name[MAX_SYM_NAME+1];
946} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
947
948typedef struct _SYMBOL_INFO_PACKAGEW
949{
950 SYMBOL_INFOW si;
951 WCHAR name[MAX_SYM_NAME+1];
952} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
953
954typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
955{
956 TI_GET_SYMTAG,
957 TI_GET_SYMNAME,
958 TI_GET_LENGTH,
959 TI_GET_TYPE,
960 TI_GET_TYPEID,
961 TI_GET_BASETYPE,
962 TI_GET_ARRAYINDEXTYPEID,
963 TI_FINDCHILDREN,
964 TI_GET_DATAKIND,
965 TI_GET_ADDRESSOFFSET,
966 TI_GET_OFFSET,
967 TI_GET_VALUE,
968 TI_GET_COUNT,
969 TI_GET_CHILDRENCOUNT,
970 TI_GET_BITPOSITION,
971 TI_GET_VIRTUALBASECLASS,
972 TI_GET_VIRTUALTABLESHAPEID,
973 TI_GET_VIRTUALBASEPOINTEROFFSET,
974 TI_GET_CLASSPARENTID,
975 TI_GET_NESTED,
976 TI_GET_SYMINDEX,
977 TI_GET_LEXICALPARENT,
978 TI_GET_ADDRESS,
979 TI_GET_THISADJUST,
980 TI_GET_UDTKIND,
981 TI_IS_EQUIV_TO,
982 TI_GET_CALLING_CONVENTION,
983} IMAGEHLP_SYMBOL_TYPE_INFO;
984
985#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001
986#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002
987typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS
988{
989 ULONG SizeOfStruct;
990 ULONG Flags;
991 ULONG NumIds;
992 PULONG TypeIds;
993 ULONG64 TagFilter;
994 ULONG NumReqs;
995 IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
996 PULONG_PTR ReqOffsets;
997 PULONG ReqSizes;
998 ULONG_PTR ReqStride;
999 ULONG_PTR BufferSize;
1000 PVOID Buffer;
1001 ULONG EntriesMatched;
1002 ULONG EntriesFilled;
1003 ULONG64 TagsFound;
1004 ULONG64 AllReqsValid;
1005 ULONG NumReqsValid;
1006 PULONG64 ReqsValid;
1007} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
1008
1009typedef struct _TI_FINDCHILDREN_PARAMS
1010{
1011 ULONG Count;
1012 ULONG Start;
1013 ULONG ChildId[1];
1014} TI_FINDCHILDREN_PARAMS;
1015
1016#define UNDNAME_COMPLETE (0x0000)
1017#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001)
1018#define UNDNAME_NO_MS_KEYWORDS (0x0002)
1019#define UNDNAME_NO_FUNCTION_RETURNS (0x0004)
1020#define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
1021#define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
1022#define UNDNAME_NO_MS_THISTYPE (0x0020)
1023#define UNDNAME_NO_CV_THISTYPE (0x0040)
1024#define UNDNAME_NO_THISTYPE (0x0060)
1025#define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080)
1026#define UNDNAME_NO_THROW_SIGNATURES (0x0100)
1027#define UNDNAME_NO_MEMBER_TYPE (0x0200)
1028#define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
1029#define UNDNAME_32_BIT_DECODE (0x0800)
1030#define UNDNAME_NAME_ONLY (0x1000)
1031#define UNDNAME_NO_ARGUMENTS (0x2000)
1032#define UNDNAME_NO_SPECIAL_SYMS (0x4000)
1033
1034#define SYMSEARCH_MASKOBJS 0x01
1035#define SYMSEARCH_RECURSE 0x02
1036#define SYMSEARCH_GLOBALSONLY 0x04
1037
1038BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID);
1039BOOL WINAPI SymGetTypeInfoEx(HANDLE, DWORD64, PIMAGEHLP_GET_TYPE_INFO_PARAMS);
1040typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID);
1041typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID);
1042BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
1043BOOL WINAPI SymEnumTypesW(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
1044BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*);
1045BOOL WINAPI SymFromAddrW(HANDLE, DWORD64, DWORD64*, SYMBOL_INFOW*);
1046BOOL WINAPI SymFromToken(HANDLE, DWORD64, DWORD, PSYMBOL_INFO);
1047BOOL WINAPI SymFromTokenW(HANDLE, DWORD64, DWORD, PSYMBOL_INFOW);
1048BOOL WINAPI SymFromName(HANDLE, PCSTR, PSYMBOL_INFO);
1049BOOL WINAPI SymFromNameW(HANDLE, PCWSTR, PSYMBOL_INFOW);
1050BOOL WINAPI SymGetSymFromAddr64(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
1051BOOL WINAPI SymGetSymFromName64(HANDLE, PCSTR, PIMAGEHLP_SYMBOL64);
1052BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, PCSTR, PSYMBOL_INFO);
1053BOOL WINAPI SymGetTypeFromNameW(HANDLE, ULONG64, PCWSTR, PSYMBOL_INFOW);
1054BOOL WINAPI SymGetSymNext64(HANDLE, PIMAGEHLP_SYMBOL64);
1055BOOL WINAPI SymGetSymNextW64(HANDLE, PIMAGEHLP_SYMBOLW64);
1056BOOL WINAPI SymGetSymPrev64(HANDLE, PIMAGEHLP_SYMBOL64);
1057BOOL WINAPI SymGetSymPrevW64(HANDLE, PIMAGEHLP_SYMBOLW64);
1058BOOL WINAPI SymEnumSym(HANDLE,ULONG64,PSYM_ENUMERATESYMBOLS_CALLBACK,PVOID);
1059BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK,
1060 PVOID);
1061BOOL WINAPI SymEnumSymbolsW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMERATESYMBOLS_CALLBACKW,
1062 PVOID);
1063typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
1064typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID);
1065BOOL WINAPI SymEnumerateSymbols64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64, PVOID);
1066BOOL WINAPI SymEnumerateSymbolsW64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64W, PVOID);
1067BOOL WINAPI SymEnumSymbolsForAddr(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
1068BOOL WINAPI SymEnumSymbolsForAddrW(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
1069typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64);
1070BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
1071BOOL WINAPI SymRegisterCallbackW64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
1072BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64, PSTR, DWORD);
1073BOOL WINAPI SymMatchString(PCSTR, PCSTR, BOOL);
1074BOOL WINAPI SymMatchStringA(PCSTR, PCSTR, BOOL);
1075BOOL WINAPI SymMatchStringW(PCWSTR, PCWSTR, BOOL);
1076BOOL WINAPI SymSearch(HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD);
1077BOOL WINAPI SymSearchW(HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD);
1078DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD);
1079DWORD WINAPI UnDecorateSymbolNameW(PCWSTR, PWSTR, DWORD, DWORD);
1080BOOL WINAPI SymGetScope(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
1081BOOL WINAPI SymGetScopeW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
1082BOOL WINAPI SymFromIndex(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
1083BOOL WINAPI SymFromIndexW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
1084BOOL WINAPI SymAddSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD, DWORD);
1085BOOL WINAPI SymAddSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD, DWORD);
1086BOOL WINAPI SymDeleteSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD);
1087BOOL WINAPI SymDeleteSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD);
1088
1089/*************************
1090 * Source Files *
1091 *************************/
1092typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID);
1093typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID);
1094
1095BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, PCSTR, PSYM_ENUMSOURCEFILES_CALLBACK,
1096 PVOID);
1097BOOL WINAPI SymEnumSourceFilesW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMSOURCEFILES_CALLBACKW, PVOID);
1098BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
1099BOOL WINAPI SymGetLineFromAddrW64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINEW64);
1100BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64);
1101BOOL WINAPI SymGetLinePrevW64(HANDLE, PIMAGEHLP_LINEW64);
1102BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64);
1103BOOL WINAPI SymGetLineNextW64(HANDLE, PIMAGEHLP_LINEW64);
1104BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64);
1105BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64);
1106ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG);
1107BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD);
1108BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD);
1109BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*);
1110BOOL WINAPI SymGetSourceFileTokenW(HANDLE, ULONG64, PCWSTR, PVOID*, DWORD*);
1111BOOL WINAPI SymGetSourceFileFromToken(HANDLE, PVOID, PCSTR, PSTR, DWORD);
1112BOOL WINAPI SymGetSourceFileFromTokenW(HANDLE, PVOID, PCWSTR, PWSTR, DWORD);
1113BOOL WINAPI SymGetSourceVarFromToken(HANDLE, PVOID, PCSTR, PCSTR, PSTR, DWORD);
1114BOOL WINAPI SymGetSourceVarFromTokenW(HANDLE, PVOID, PCWSTR, PCWSTR, PWSTR, DWORD);
1115
1116typedef struct _SRCCODEINFO
1117{
1118 DWORD SizeOfStruct;
1119 PVOID Key;
1120 DWORD64 ModBase;
1121 CHAR Obj[MAX_PATH+1];
1122 CHAR FileName[MAX_PATH+1];
1123 DWORD LineNumber;
1124 DWORD64 Address;
1125} SRCCODEINFO, *PSRCCODEINFO;
1126
1127typedef struct _SRCCODEINFOW
1128{
1129 DWORD SizeOfStruct;
1130 PVOID Key;
1131 DWORD64 ModBase;
1132 WCHAR Obj[MAX_PATH+1];
1133 WCHAR FileName[MAX_PATH+1];
1134 DWORD LineNumber;
1135 DWORD64 Address;
1136} SRCCODEINFOW, *PSRCCODEINFOW;
1137
1138typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID);
1139typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID);
1140BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID);
1141BOOL WINAPI SymEnumLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, PSYM_ENUMLINES_CALLBACKW, PVOID);
1142BOOL WINAPI SymEnumSourceLines(HANDLE, ULONG64, PCSTR, PCSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACK, PVOID);
1143BOOL WINAPI SymEnumSourceLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACKW, PVOID);
1144
1145/*************************
1146 * File & image handling *
1147 *************************/
1148BOOL WINAPI SymInitialize(HANDLE, PCSTR, BOOL);
1149BOOL WINAPI SymInitializeW(HANDLE, PCWSTR, BOOL);
1150BOOL WINAPI SymCleanup(HANDLE);
1151
1152HANDLE WINAPI FindDebugInfoFile(PCSTR, PCSTR, PSTR);
1153typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
1154typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
1155HANDLE WINAPI FindDebugInfoFileEx(PCSTR, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
1156HANDLE WINAPI FindDebugInfoFileExW(PCWSTR, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
1157HANDLE WINAPI SymFindDebugInfoFile(HANDLE, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
1158HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
1159typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID);
1160typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID);
1161BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
1162 PSTR, PFINDFILEINPATHCALLBACK, PVOID);
1163BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
1164 PSTR, PFINDFILEINPATHCALLBACK, PVOID);
1165BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD,
1166 PWSTR, PFINDFILEINPATHCALLBACKW, PVOID);
1167HANDLE WINAPI FindExecutableImage(PCSTR, PCSTR, PSTR);
1168typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
1169typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
1170HANDLE WINAPI FindExecutableImageEx(PCSTR, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
1171HANDLE WINAPI FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
1172HANDLE WINAPI SymFindExecutableImage(HANDLE, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
1173HANDLE WINAPI SymFindExecutableImageW(HANDLE, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
1174PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID);
1175PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG,
1176 PIMAGE_SECTION_HEADER *);
1177PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG);
1178PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG);
1179PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*);
1180BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD);
1181BOOL WINAPI SymGetSearchPathW(HANDLE, PWSTR, DWORD);
1182BOOL WINAPI SymSetSearchPath(HANDLE, PCSTR);
1183BOOL WINAPI SymSetSearchPathW(HANDLE, PCWSTR);
1184DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE);
1185BOOL WINAPI MakeSureDirectoryPathExists(PCSTR);
1186BOOL WINAPI SearchTreeForFile(PCSTR, PCSTR, PSTR);
1187BOOL WINAPI SearchTreeForFileW(PCWSTR, PCWSTR, PWSTR);
1188typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(PCSTR, PVOID);
1189typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID);
1190BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, PSTR, PENUMDIRTREE_CALLBACK, PVOID);
1191BOOL WINAPI EnumDirTreeW(HANDLE, PCWSTR, PCWSTR, PWSTR, PENUMDIRTREE_CALLBACKW, PVOID);
1192BOOL WINAPI SymMatchFileName(PCSTR, PCSTR, PSTR*, PSTR*);
1193BOOL WINAPI SymMatchFileNameW(PCWSTR, PCWSTR, PWSTR*, PWSTR*);
1194PCHAR WINAPI SymSetHomeDirectory(HANDLE, PCSTR);
1195PWSTR WINAPI SymSetHomeDirectoryW(HANDLE, PCWSTR);
1196PCHAR WINAPI SymGetHomeDirectory(DWORD, PSTR, size_t);
1197PWSTR WINAPI SymGetHomeDirectoryW(DWORD, PWSTR, size_t);
1198#define hdBase 0
1199#define hdSym 1
1200#define hdSrc 2
1201#define hdMax 3
1202
1203/*************************
1204 * Context management *
1205 *************************/
1206BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT);
1207
1208
1209/*************************
1210 * Stack management *
1211 *************************/
1212
1213#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
1214#define KDHELP KDHELP64
1215#define PKDHELP PKDHELP64
1216#else
1217typedef struct _KDHELP
1218{
1219 DWORD Thread;
1220 DWORD ThCallbackStack;
1221 DWORD NextCallback;
1222 DWORD FramePointer;
1223 DWORD KiCallUserMode;
1224 DWORD KeUserCallbackDispatcher;
1225 DWORD SystemRangeStart;
1226} KDHELP, *PKDHELP;
1227#endif
1228
1229typedef struct _KDHELP64
1230{
1231 DWORD64 Thread;
1232 DWORD ThCallbackStack;
1233 DWORD ThCallbackBStore;
1234 DWORD NextCallback;
1235 DWORD FramePointer;
1236 DWORD64 KiCallUserMode;
1237 DWORD64 KeUserCallbackDispatcher;
1238 DWORD64 SystemRangeStart;
1239 DWORD64 Reserved[8];
1240} KDHELP64, *PKDHELP64;
1241
1242#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
1243#define STACKFRAME STACKFRAME64
1244#define LPSTACKFRAME LPSTACKFRAME64
1245#else
1246typedef struct _STACKFRAME
1247{
1248 ADDRESS AddrPC;
1249 ADDRESS AddrReturn;
1250 ADDRESS AddrFrame;
1251 ADDRESS AddrStack;
1252 PVOID FuncTableEntry;
1253 DWORD Params[4];
1254 BOOL Far;
1255 BOOL Virtual;
1256 DWORD Reserved[3];
1257 KDHELP KdHelp;
1258 ADDRESS AddrBStore;
1259} STACKFRAME, *LPSTACKFRAME;
1260#endif
1261
1262typedef struct _STACKFRAME64
1263{
1264 ADDRESS64 AddrPC;
1265 ADDRESS64 AddrReturn;
1266 ADDRESS64 AddrFrame;
1267 ADDRESS64 AddrStack;
1268 ADDRESS64 AddrBStore;
1269 PVOID FuncTableEntry;
1270 DWORD64 Params[4];
1271 BOOL Far;
1272 BOOL Virtual;
1273 DWORD64 Reserved[3];
1274 KDHELP64 KdHelp;
1275} STACKFRAME64, *LPSTACKFRAME64;
1276
1277typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64)
1278 (HANDLE, DWORD64, PVOID, DWORD, PDWORD);
1279typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64);
1280typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64);
1281typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64);
1282BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID,
1283 PREAD_PROCESS_MEMORY_ROUTINE64,
1284 PFUNCTION_TABLE_ACCESS_ROUTINE64,
1285 PGET_MODULE_BASE_ROUTINE64,
1286 PTRANSLATE_ADDRESS_ROUTINE64);
1287
1288PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64);
1289
1290typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64);
1291
1292BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64);
1293
1294/*************************
1295 * Version, global stuff *
1296 *************************/
1297
1298#define API_VERSION_NUMBER 9
1299
1300typedef struct API_VERSION
1301{
1302 USHORT MajorVersion;
1303 USHORT MinorVersion;
1304 USHORT Revision;
1305 USHORT Reserved;
1306} API_VERSION, *LPAPI_VERSION;
1307
1308LPAPI_VERSION WINAPI ImagehlpApiVersion(void);
1309LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION);
1310
1311typedef struct _IMAGE_DEBUG_INFORMATION
1312{
1313 LIST_ENTRY List;
1314 DWORD ReservedSize;
1315 PVOID ReservedMappedBase;
1316 USHORT ReservedMachine;
1317 USHORT ReservedCharacteristics;
1318 DWORD ReservedCheckSum;
1319 DWORD ImageBase;
1320 DWORD SizeOfImage;
1321 DWORD ReservedNumberOfSections;
1322 PIMAGE_SECTION_HEADER ReservedSections;
1323 DWORD ReservedExportedNamesSize;
1324 PSTR ReservedExportedNames;
1325 DWORD ReservedNumberOfFunctionTableEntries;
1326 PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
1327 DWORD ReservedLowestFunctionStartingAddress;
1328 DWORD ReservedHighestFunctionEndingAddress;
1329 DWORD ReservedNumberOfFpoTableEntries;
1330 PFPO_DATA ReservedFpoTableEntries;
1331 DWORD SizeOfCoffSymbols;
1332 PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
1333 DWORD ReservedSizeOfCodeViewSymbols;
1334 PVOID ReservedCodeViewSymbols;
1335 PSTR ImageFilePath;
1336 PSTR ImageFileName;
1337 PSTR ReservedDebugFilePath;
1338 DWORD ReservedTimeDateStamp;
1339 BOOL ReservedRomImage;
1340 PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
1341 DWORD ReservedNumberOfDebugDirectories;
1342 DWORD ReservedOriginalFunctionTableBaseAddress;
1343 DWORD Reserved[ 2 ];
1344} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
1345
1346
1347PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PCSTR, PCSTR, ULONG);
1348
1349BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
1350
1351DWORD WINAPI SymGetOptions(void);
1352DWORD WINAPI SymSetOptions(DWORD);
1353
1354BOOL WINAPI SymSetParentWindow(HWND);
1355
1356/*************************
1357 * Version, global stuff *
1358 *************************/
1359
1360typedef BOOL (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
1361typedef BOOL (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
1362typedef BOOL (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR);
1363typedef BOOL (WINAPI* PSYMBOLSERVEROPENPROC)(void);
1364typedef BOOL (WINAPI* PSYMBOLSERVERCLOSEPROC)(void);
1365typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
1366typedef BOOL (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64);
1367typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void);
1368typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR);
1369typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR);
1370typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR);
1371
1372#define SSRVOPT_CALLBACK 0x0001
1373#define SSRVOPT_DWORD 0x0002
1374#define SSRVOPT_DWORDPTR 0x0004
1375#define SSRVOPT_GUIDPTR 0x0008
1376#define SSRVOPT_OLDGUIDPTR 0x0010
1377#define SSRVOPT_UNATTENDED 0x0020
1378#define SSRVOPT_NOCOPY 0x0040
1379#define SSRVOPT_PARENTWIN 0x0080
1380#define SSRVOPT_PARAMTYPE 0x0100
1381#define SSRVOPT_SECURE 0x0200
1382#define SSRVOPT_TRACE 0x0400
1383#define SSRVOPT_SETCONTEXT 0x0800
1384#define SSRVOPT_PROXY 0x1000
1385#define SSRVOPT_DOWNSTREAM_STORE 0x2000
1386#define SSRVOPT_RESET ((ULONG_PTR)-1)
1387
1388#define SSRVACTION_TRACE 1
1389#define SSRVACTION_QUERYCANCEL 2
1390#define SSRVACTION_EVENT 3
1391
1392/* 32-bit functions */
1393
1394#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
1395
1396#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
1397#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
1398#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
1399#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
1400#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
1401#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
1402#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
1403#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
1404#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACKW64
1405#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
1406
1407#define EnumerateLoadedModules EnumerateLoadedModules64
1408#define StackWalk StackWalk64
1409#define SymEnumerateModules SymEnumerateModules64
1410#define SymEnumerateSymbols SymEnumerateSymbols64
1411#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
1412#define SymFunctionTableAccess SymFunctionTableAccess64
1413#define SymGetLineFromAddr SymGetLineFromAddr64
1414#define SymGetLineFromAddrW SymGetLineFromAddrW64
1415#define SymGetLineFromName SymGetLineFromName64
1416#define SymGetLineNext SymGetLineNext64
1417#define SymGetLineNextW SymGetLineNextW64
1418#define SymGetLinePrev SymGetLinePrev64
1419#define SymGetLinePrevW SymGetLinePrevW64
1420#define SymGetModuleBase SymGetModuleBase64
1421#define SymGetModuleInfo SymGetModuleInfo64
1422#define SymGetModuleInfoW SymGetModuleInfoW64
1423#define SymGetSymFromAddr SymGetSymFromAddr64
1424#define SymGetSymFromName SymGetSymFromName64
1425#define SymGetSymNext SymGetSymNext64
1426#define SymGetSymNextW SymGetSymNextW64
1427#define SymGetSymPrev SymGetSymPrev64
1428#define SymGetSymPrevW SymGetSymPrevW64
1429#define SymLoadModule SymLoadModule64
1430#define SymRegisterCallback SymRegisterCallback64
1431#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
1432#define SymUnDName SymUnDName64
1433#define SymUnloadModule SymUnloadModule64
1434
1435#else
1436
1437typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
1438typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD);
1439typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD);
1440typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE, DWORD, PVOID, DWORD, PDWORD);
1441typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID);
1442typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
1443typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, ULONG, ULONG, PVOID);
1444typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID);
1445typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID);
1446typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS);
1447
1448BOOL WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID);
1449BOOL WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID, PREAD_PROCESS_MEMORY_ROUTINE, PFUNCTION_TABLE_ACCESS_ROUTINE, PGET_MODULE_BASE_ROUTINE, PTRANSLATE_ADDRESS_ROUTINE);
1450BOOL WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID);
1451BOOL WINAPI SymEnumerateSymbols(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACK, PVOID);
1452BOOL WINAPI SymEnumerateSymbolsW(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACKW, PVOID);
1453PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD);
1454BOOL WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE);
1455BOOL WINAPI SymGetLineFromAddrW(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINEW);
1456BOOL WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE);
1457BOOL WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE);
1458BOOL WINAPI SymGetLineNextW(HANDLE, PIMAGEHLP_LINEW);
1459BOOL WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE);
1460BOOL WINAPI SymGetLinePrevW(HANDLE, PIMAGEHLP_LINEW);
1461DWORD WINAPI SymGetModuleBase(HANDLE, DWORD);
1462BOOL WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE);
1463BOOL WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW);
1464BOOL WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
1465BOOL WINAPI SymGetSymFromName(HANDLE, PCSTR, PIMAGEHLP_SYMBOL);
1466BOOL WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL);
1467BOOL WINAPI SymGetSymNextW(HANDLE, PIMAGEHLP_SYMBOLW);
1468BOOL WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL);
1469BOOL WINAPI SymGetSymPrevW(HANDLE, PIMAGEHLP_SYMBOLW);
1470DWORD WINAPI SymLoadModule(HANDLE, HANDLE, PCSTR, PCSTR, DWORD, DWORD);
1471BOOL WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID);
1472BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID);
1473BOOL WINAPI SymRefreshModuleList(HANDLE);
1474BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD);
1475BOOL WINAPI SymUnloadModule(HANDLE, DWORD);
1476
1477#endif
1478
1479#ifdef __cplusplus
1480} /* extern "C" */
1481#endif /* defined(__cplusplus) */
1482
1483#endif /* __WINE_DBGHELP_H */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette