VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/shaderlib/wine/include/dbghelp.h@ 53201

最後變更 在這個檔案從53201是 53201,由 vboxsync 提交於 10 年 前

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

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