1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! DbgHelp include file
7 use shared::basetsd::{DWORD64, PDWORD64, ULONG64};
8 use shared::guiddef::GUID;
9 use shared::minwindef::{
10     BOOL, DWORD, HMODULE, LPDWORD, MAX_PATH, PDWORD, PUCHAR, PULONG, UCHAR, ULONG, USHORT, WORD,
11 };
12 use um::winnt::{
13     BOOLEAN, CHAR, HANDLE, LIST_ENTRY, PCSTR, PCWSTR, PIMAGE_NT_HEADERS, PIMAGE_SECTION_HEADER,
14     PSTR, PVOID, PWSTR, WCHAR,
15 };
16 #[cfg(target_pointer_width = "32")]
17 use um::winnt::{
18     PFPO_DATA, PIMAGE_COFF_SYMBOLS_HEADER, PIMAGE_DEBUG_DIRECTORY, PIMAGE_FUNCTION_ENTRY,
19     PIMAGE_NT_HEADERS32,
20 };
21 #[cfg(target_pointer_width = "64")]
22 use um::winnt::PIMAGE_NT_HEADERS64;
23 use vc::vcruntime::size_t;
24 #[cfg(target_pointer_width = "64")]
25 STRUCT!{struct LOADED_IMAGE {
26     ModuleName: PSTR,
27     hFile: HANDLE,
28     MappedAddress: PUCHAR,
29     FileHeader: PIMAGE_NT_HEADERS64,
30     LastRvaSection: PIMAGE_SECTION_HEADER,
31     NumberOfSections: ULONG,
32     Sections: PIMAGE_SECTION_HEADER,
33     Characteristics: ULONG,
34     fSystemImage: BOOLEAN,
35     fDOSImage: BOOLEAN,
36     fReadOnly: BOOLEAN,
37     Version: UCHAR,
38     Links: LIST_ENTRY,
39     SizeOfImage: ULONG,
40 }}
41 #[cfg(target_pointer_width = "32")]
42 STRUCT!{struct LOADED_IMAGE {
43     ModuleName: PSTR,
44     hFile: HANDLE,
45     MappedAddress: PUCHAR,
46     FileHeader: PIMAGE_NT_HEADERS32,
47     LastRvaSection: PIMAGE_SECTION_HEADER,
48     NumberOfSections: ULONG,
49     Sections: PIMAGE_SECTION_HEADER,
50     Characteristics: ULONG,
51     fSystemImage: BOOLEAN,
52     fDOSImage: BOOLEAN,
53     fReadOnly: BOOLEAN,
54     Version: UCHAR,
55     Links: LIST_ENTRY,
56     SizeOfImage: ULONG,
57 }}
58 pub const MAX_SYM_NAME: usize = 2000;
59 pub const ERROR_IMAGE_NOT_STRIPPED: DWORD = 0x8800;
60 pub const ERROR_NO_DBG_POINTER: DWORD = 0x8801;
61 pub const ERROR_NO_PDB_POINTER: DWORD = 0x8802;
62 FN!{stdcall PFIND_DEBUG_FILE_CALLBACK(
63     FileHandle: HANDLE,
64     FileName: PCSTR,
65     CallerData: PVOID,
66 ) -> BOOL}
67 FN!{stdcall PFIND_DEBUG_FILE_CALLBACKW(
68     FileHandle: HANDLE,
69     FileName: PCWSTR,
70     CallerData: PVOID,
71 ) -> BOOL}
72 FN!{stdcall PFINDFILEINPATHCALLBACK(
73     filename: PCSTR,
74     context: PVOID,
75 ) -> BOOL}
76 FN!{stdcall PFINDFILEINPATHCALLBACKW(
77     filename: PCWSTR,
78     context: PVOID,
79 ) -> BOOL}
80 FN!{stdcall PFIND_EXE_FILE_CALLBACK(
81     FileHandle: HANDLE,
82     FileName: PCSTR,
83     CallerData: PVOID,
84 ) -> BOOL}
85 FN!{stdcall PFIND_EXE_FILE_CALLBACKW(
86     FileHandle: HANDLE,
87     FileName: PCWSTR,
88     CallerData: PVOID,
89 ) -> BOOL}
90 FN!{stdcall PSYM_ENUMERATESYMBOLS_CALLBACKW(
91     pSymInfo: PSYMBOL_INFOW,
92     SymbolSize: ULONG,
93     CallerData: PVOID,
94 ) -> BOOL}
95 #[cfg(target_pointer_width = "32")]
96 STRUCT!{struct IMAGE_DEBUG_INFORMATION {
97     List: LIST_ENTRY,
98     ReservedSize: DWORD,
99     ReservedMappedBase: PVOID,
100     ReservedMachine: USHORT,
101     ReservedCharacteristics: USHORT,
102     ReservedCheckSum: DWORD,
103     ImageBase: DWORD,
104     SizeOfImage: DWORD,
105     ReservedNumberOfSections: DWORD,
106     ReservedSections: PIMAGE_SECTION_HEADER,
107     ReservedExportedNamesSize: DWORD,
108     ReservedExportedNames: PSTR,
109     ReservedNumberOfFunctionTableEntries: DWORD,
110     ReservedFunctionTableEntries: PIMAGE_FUNCTION_ENTRY,
111     ReservedLowestFunctionStartingAddress: DWORD,
112     ReservedHighestFunctionEndingAddress: DWORD,
113     ReservedNumberOfFpoTableEntries: DWORD,
114     ReservedFpoTableEntries: PFPO_DATA,
115     SizeOfCoffSymbols: DWORD,
116     CoffSymbols: PIMAGE_COFF_SYMBOLS_HEADER,
117     ReservedSizeOfCodeViewSymbols: DWORD,
118     ReservedCodeViewSymbols: PVOID,
119     ImageFilePath: PSTR,
120     ImageFileName: PSTR,
121     ReservedDebugFilePath: PSTR,
122     ReservedTimeDateStamp: DWORD,
123     ReservedRomImage: BOOL,
124     ReservedDebugDirectory: PIMAGE_DEBUG_DIRECTORY,
125     ReservedNumberOfDebugDirectories: DWORD,
126     ReservedOriginalFunctionTableBaseAddress: DWORD,
127     Reserved: [DWORD; 2],
128 }}
129 #[cfg(target_pointer_width = "32")]
130 pub type PIMAGE_DEBUG_INFORMATION = *mut IMAGE_DEBUG_INFORMATION;
131 FN!{stdcall PENUMDIRTREE_CALLBACK(
132     FilePath: PCSTR,
133     CallerData: PVOID,
134 ) -> BOOL}
135 FN!{stdcall PENUMDIRTREE_CALLBACKW(
136     FilePath: PCWSTR,
137     CallerData: PVOID,
138 ) -> BOOL}
139 pub const UNDNAME_COMPLETE: DWORD = 0x0000;
140 pub const UNDNAME_NO_LEADING_UNDERSCORES: DWORD = 0x0001;
141 pub const UNDNAME_NO_MS_KEYWORDS: DWORD = 0x0002;
142 pub const UNDNAME_NO_FUNCTION_RETURNS: DWORD = 0x0004;
143 pub const UNDNAME_NO_ALLOCATION_MODEL: DWORD = 0x0008;
144 pub const UNDNAME_NO_ALLOCATION_LANGUAGE: DWORD = 0x0010;
145 pub const UNDNAME_NO_MS_THISTYPE: DWORD = 0x0020;
146 pub const UNDNAME_NO_CV_THISTYPE: DWORD = 0x0040;
147 pub const UNDNAME_NO_THISTYPE: DWORD = 0x0060;
148 pub const UNDNAME_NO_ACCESS_SPECIFIERS: DWORD = 0x0080;
149 pub const UNDNAME_NO_THROW_SIGNATURES: DWORD = 0x0100;
150 pub const UNDNAME_NO_MEMBER_TYPE: DWORD = 0x0200;
151 pub const UNDNAME_NO_RETURN_UDT_MODEL: DWORD = 0x0400;
152 pub const UNDNAME_32_BIT_DECODE: DWORD = 0x0800;
153 pub const UNDNAME_NAME_ONLY: DWORD = 0x1000;
154 pub const UNDNAME_NO_ARGUMENTS: DWORD = 0x2000;
155 pub const UNDNAME_NO_SPECIAL_SYMS: DWORD = 0x4000;
156 pub const DBHHEADER_DEBUGDIRS: DWORD = 0x1;
157 pub const DBHHEADER_CVMISC: DWORD = 0x2;
158 pub const DBHHEADER_PDBGUID: DWORD = 0x3;
159 STRUCT!{struct MODLOAD_DATA {
160     ssize: DWORD,
161     ssig: DWORD,
162     data: PVOID,
163     size: DWORD,
164     flags: DWORD,
165 }}
166 pub type PMODLOAD_DATA = *mut MODLOAD_DATA;
167 STRUCT!{struct MODLOAD_CVMISC {
168     oCV: DWORD,
169     cCV: size_t,
170     oMisc: DWORD,
171     cMisc: size_t,
172     dtImage: DWORD,
173     cImage: DWORD,
174 }}
175 pub type PMODLOAD_CVMISC = *mut MODLOAD_CVMISC;
176 STRUCT!{struct MODLOAD_PDBGUID_PDBAGE {
177     PdbGuid: GUID,
178     PdbAge: DWORD,
179 }}
180 pub type PMODLOAD_PDBGUID_PDBAGE = *mut MODLOAD_PDBGUID_PDBAGE;
181 ENUM!{enum ADDRESS_MODE {
182     AddrMode1616,
183     AddrMode1632,
184     AddrModeReal,
185     AddrModeFlat,
186 }}
187 STRUCT!{struct ADDRESS64 {
188     Offset: DWORD64,
189     Segment: WORD,
190     Mode: ADDRESS_MODE,
191 }}
192 pub type LPADDRESS64 = *mut ADDRESS64;
193 #[cfg(target_pointer_width = "64")]
194 pub type ADDRESS = ADDRESS64;
195 #[cfg(target_pointer_width = "64")]
196 pub type LPADDRESS = LPADDRESS64;
197 #[cfg(target_pointer_width = "32")]
198 STRUCT!{struct ADDRESS {
199     Offset: DWORD,
200     Segment: WORD,
201     Mode: ADDRESS_MODE,
202 }}
203 #[cfg(target_pointer_width = "32")]
204 pub type LPADDRESS = *mut ADDRESS;
205 STRUCT!{struct KDHELP64 {
206     Thread: DWORD64,
207     ThCallbackStack: DWORD,
208     ThCallbackBStore: DWORD,
209     NextCallback: DWORD,
210     FramePointer: DWORD,
211     KiCallUserMode: DWORD64,
212     KeUserCallbackDispatcher: DWORD64,
213     SystemRangeStart: DWORD64,
214     KiUserExceptionDispatcher: DWORD64,
215     StackBase: DWORD64,
216     StackLimit: DWORD64,
217     BuildVersion: DWORD,
218     Reserved0: DWORD,
219     Reserved1: [DWORD64; 4],
220 }}
221 pub type PKDHELP64 = *mut KDHELP64;
222 #[cfg(target_pointer_width = "64")]
223 pub type KDHELP = KDHELP64;
224 #[cfg(target_pointer_width = "64")]
225 pub type PKDHELP = PKDHELP64;
226 #[cfg(target_pointer_width = "32")]
227 STRUCT!{struct KDHELP {
228     Thread: DWORD,
229     ThCallbackStack: DWORD,
230     NextCallback: DWORD,
231     FramePointer: DWORD,
232     KiCallUserMode: DWORD,
233     KeUserCallbackDispatcher: DWORD,
234     SystemRangeStart: DWORD,
235     ThCallbackBStore: DWORD,
236     KiUserExceptionDispatcher: DWORD,
237     StackBase: DWORD,
238     StackLimit: DWORD,
239     Reserved: [DWORD; 5],
240 }}
241 #[cfg(target_pointer_width = "32")]
242 pub type PKDHELP = *mut KDHELP;
243 STRUCT!{struct STACKFRAME64 {
244     AddrPC: ADDRESS64,
245     AddrReturn: ADDRESS64,
246     AddrFrame: ADDRESS64,
247     AddrStack: ADDRESS64,
248     AddrBStore: ADDRESS64,
249     FuncTableEntry: PVOID,
250     Params: [DWORD64; 4],
251     Far: BOOL,
252     Virtual: BOOL,
253     Reserved: [DWORD64; 3],
254     KdHelp: KDHELP64,
255 }}
256 pub type LPSTACKFRAME64 = *mut STACKFRAME64;
257 pub const INLINE_FRAME_CONTEXT_INIT: DWORD = 0;
258 pub const INLINE_FRAME_CONTEXT_IGNORE: DWORD = 0xFFFFFFFF;
259 STRUCT!{struct STACKFRAME_EX {
260     AddrPC: ADDRESS64,
261     AddrReturn: ADDRESS64,
262     AddrFrame: ADDRESS64,
263     AddrStack: ADDRESS64,
264     AddrBStore: ADDRESS64,
265     FuncTableEntry: PVOID,
266     Params: [DWORD64; 4],
267     Far: BOOL,
268     Virtual: BOOL,
269     Reserved: [DWORD64; 3],
270     KdHelp: KDHELP64,
271     StackFrameSize: DWORD,
272     InlineFrameContext: DWORD,
273 }}
274 pub type LPSTACKFRAME_EX = *mut STACKFRAME_EX;
275 #[cfg(target_pointer_width = "64")]
276 pub type STACKFRAME = STACKFRAME64;
277 #[cfg(target_pointer_width = "64")]
278 pub type LPSTACKFRAME = LPSTACKFRAME64;
279 #[cfg(target_pointer_width = "32")]
280 STRUCT!{struct STACKFRAME {
281     AddrPC: ADDRESS,
282     AddrReturn: ADDRESS,
283     AddrFrame: ADDRESS,
284     AddrStack: ADDRESS,
285     FuncTableEntry: PVOID,
286     Params: [DWORD; 4],
287     Far: BOOL,
288     Virtual: BOOL,
289     Reserved: [DWORD; 3],
290     KdHelp: KDHELP,
291     AddrBStore: ADDRESS,
292 }}
293 #[cfg(target_pointer_width = "32")]
294 pub type LPSTACKFRAME = *mut STACKFRAME;
295 FN!{stdcall PREAD_PROCESS_MEMORY_ROUTINE64(
296     hProcess: HANDLE,
297     qwBaseAddress: DWORD64,
298     lpBuffer: PVOID,
299     nSize: DWORD,
300     lpNumberOfBytesRead: LPDWORD,
301 ) -> BOOL}
302 FN!{stdcall PFUNCTION_TABLE_ACCESS_ROUTINE64(
303     ahProcess: HANDLE,
304     AddrBase: DWORD64,
305 ) -> PVOID}
306 FN!{stdcall PGET_MODULE_BASE_ROUTINE64(
307     hProcess: HANDLE,
308     Address: DWORD64,
309 ) -> DWORD64}
310 FN!{stdcall PTRANSLATE_ADDRESS_ROUTINE64(
311     hProcess: HANDLE,
312     hThread: HANDLE,
313     lpaddr: LPADDRESS64,
314 ) -> DWORD64}
315 pub const SYM_STKWALK_DEFAULT: DWORD = 0x00000000;
316 pub const SYM_STKWALK_FORCE_FRAMEPTR: DWORD = 0x00000001;
317 #[cfg(target_pointer_width = "64")]
318 pub type PREAD_PROCESS_MEMORY_ROUTINE = PREAD_PROCESS_MEMORY_ROUTINE64;
319 #[cfg(target_pointer_width = "64")]
320 pub type PFUNCTION_TABLE_ACCESS_ROUTINE = PFUNCTION_TABLE_ACCESS_ROUTINE64;
321 #[cfg(target_pointer_width = "64")]
322 pub type PGET_MODULE_BASE_ROUTINE = PGET_MODULE_BASE_ROUTINE64;
323 #[cfg(target_pointer_width = "64")]
324 pub type PTRANSLATE_ADDRESS_ROUTINE = PTRANSLATE_ADDRESS_ROUTINE64;
325 #[cfg(target_pointer_width = "32")]
326 FN!{stdcall PREAD_PROCESS_MEMORY_ROUTINE(
327     hProcess: HANDLE,
328     qwBaseAddress: DWORD,
329     lpBuffer: PVOID,
330     nSize: DWORD,
331     lpNumberOfBytesRead: PDWORD,
332 ) -> BOOL}
333 #[cfg(target_pointer_width = "32")]
334 FN!{stdcall PFUNCTION_TABLE_ACCESS_ROUTINE(
335     ahProcess: HANDLE,
336     AddrBase: DWORD,
337 ) -> PVOID}
338 #[cfg(target_pointer_width = "32")]
339 FN!{stdcall PGET_MODULE_BASE_ROUTINE(
340     hProcess: HANDLE,
341     Address: DWORD,
342 ) -> DWORD}
343 #[cfg(target_pointer_width = "32")]
344 FN!{stdcall PTRANSLATE_ADDRESS_ROUTINE(
345     hProcess: HANDLE,
346     hThread: HANDLE,
347     lpaddr: LPADDRESS,
348 ) -> DWORD}
349 pub const API_VERSION_NUMBER: USHORT = 12;
350 STRUCT!{struct API_VERSION {
351     MajorVersion: USHORT,
352     MinorVersion: USHORT,
353     Revision: USHORT,
354     Reserved: USHORT,
355 }}
356 pub type LPAPI_VERSION = *mut API_VERSION;
357 STRUCT!{struct SYMBOL_INFOW {
358     SizeOfStruct: ULONG,
359     TypeIndex: ULONG,
360     Reserved: [ULONG64; 2],
361     Index: ULONG,
362     Size: ULONG,
363     ModBase: ULONG64,
364     Flags: ULONG,
365     Value: ULONG64,
366     Address: ULONG64,
367     Register: ULONG,
368     Scope: ULONG,
369     Tag: ULONG,
370     NameLen: ULONG,
371     MaxNameLen: ULONG,
372     Name: [WCHAR; 1],
373 }}
374 pub type PSYMBOL_INFOW = *mut SYMBOL_INFOW;
375 ENUM!{enum SYM_TYPE {
376     SymNone = 0,
377     SymCoff,
378     SymCv,
379     SymPdb,
380     SymExport,
381     SymDeferred,
382     SymSym,
383     SymDia,
384     SymVirtual,
385     NumSymTypes,
386 }}
387 STRUCT!{struct IMAGEHLP_SYMBOL64 {
388     SizeOfStruct: DWORD,
389     Address: DWORD64,
390     Size: DWORD,
391     Flags: DWORD,
392     MaxNameLength: DWORD,
393     Name: [CHAR; 1],
394 }}
395 pub type PIMAGEHLP_SYMBOL64 = *mut IMAGEHLP_SYMBOL64;
396 STRUCT!{struct IMAGEHLP_MODULEW64 {
397     SizeOfStruct: DWORD,
398     BaseOfImage: DWORD64,
399     ImageSize: DWORD,
400     TimeDateStamp: DWORD,
401     CheckSum: DWORD,
402     NumSyms: DWORD,
403     SymType: SYM_TYPE,
404     ModuleName: [WCHAR; 32],
405     ImageName: [WCHAR; 256],
406     LoadedImageName: [WCHAR; 256],
407     LoadedPdbName: [WCHAR; 256],
408     CVSig: DWORD,
409     CVData: [WCHAR; MAX_PATH * 3],
410     PdbSig: DWORD,
411     PdbSig70: GUID,
412     PdbAge: DWORD,
413     PdbUnmatched: BOOL,
414     DbgUnmatched: BOOL,
415     LineNumbers: BOOL,
416     GlobalSymbols: BOOL,
417     TypeInfo: BOOL,
418     SourceIndexed: BOOL,
419     Publics: BOOL,
420     MachineType: DWORD,
421     Reserved: DWORD,
422 }}
423 pub type PIMAGEHLP_MODULEW64 = *mut IMAGEHLP_MODULEW64;
424 STRUCT!{struct IMAGEHLP_LINEW64 {
425     SizeOfStruct: DWORD,
426     Key: PVOID,
427     LineNumber: DWORD,
428     FileName: PWSTR,
429     Address: DWORD64,
430 }}
431 pub type PIMAGEHLP_LINEW64 = *mut IMAGEHLP_LINEW64;
432 extern "system" {
EnumDirTree( hProcess: HANDLE, RootPath: PCSTR, InputPathName: PCSTR, OutputPathBuffer: PSTR, cb: PENUMDIRTREE_CALLBACK, data: PVOID, ) -> BOOL433     pub fn EnumDirTree(
434         hProcess: HANDLE,
435         RootPath: PCSTR,
436         InputPathName: PCSTR,
437         OutputPathBuffer: PSTR,
438         cb: PENUMDIRTREE_CALLBACK,
439         data: PVOID,
440     ) -> BOOL;
EnumDirTreeW( hProcess: HANDLE, RootPath: PCWSTR, InputPathName: PCWSTR, OutputPathBuffer: PWSTR, cb: PENUMDIRTREE_CALLBACKW, data: PVOID, ) -> BOOL441     pub fn EnumDirTreeW(
442         hProcess: HANDLE,
443         RootPath: PCWSTR,
444         InputPathName: PCWSTR,
445         OutputPathBuffer: PWSTR,
446         cb: PENUMDIRTREE_CALLBACKW,
447         data: PVOID,
448     ) -> BOOL;
ImagehlpApiVersion() -> LPAPI_VERSION449     pub fn ImagehlpApiVersion() -> LPAPI_VERSION;
ImagehlpApiVersionEx( AppVersion: LPAPI_VERSION, ) -> LPAPI_VERSION450     pub fn ImagehlpApiVersionEx(
451         AppVersion: LPAPI_VERSION,
452     ) -> LPAPI_VERSION;
MakeSureDirectoryPathExists( DirPath: PCSTR, ) -> BOOL453     pub fn MakeSureDirectoryPathExists(
454         DirPath: PCSTR,
455     ) -> BOOL;
SearchTreeForFile( RootPath: PCSTR, InputPathName: PCSTR, OutputPathBuffer: PSTR, ) -> BOOL456     pub fn SearchTreeForFile(
457         RootPath: PCSTR,
458         InputPathName: PCSTR,
459         OutputPathBuffer: PSTR,
460     ) -> BOOL;
SearchTreeForFileW( RootPath: PCWSTR, InputPathName: PCWSTR, OutputPathBuffer: PWSTR, ) -> BOOL461     pub fn SearchTreeForFileW(
462         RootPath: PCWSTR,
463         InputPathName: PCWSTR,
464         OutputPathBuffer: PWSTR,
465     ) -> BOOL;
FindDebugInfoFile( FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, ) -> HANDLE466     pub fn FindDebugInfoFile(
467         FileName: PCSTR,
468         SymbolPath: PCSTR,
469         DebugFilePath: PSTR,
470     ) -> HANDLE;
FindDebugInfoFileEx( FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE471     pub fn FindDebugInfoFileEx(
472         FileName: PCSTR,
473         SymbolPath: PCSTR,
474         DebugFilePath: PSTR,
475         Callback: PFIND_DEBUG_FILE_CALLBACK,
476         CallerData: PVOID,
477     ) -> HANDLE;
FindDebugInfoFileExW( FileName: PCWSTR, SymbolPath: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE478     pub fn FindDebugInfoFileExW(
479         FileName: PCWSTR,
480         SymbolPath: PCWSTR,
481         DebugFilePath: PWSTR,
482         Callback: PFIND_DEBUG_FILE_CALLBACKW,
483         CallerData: PVOID,
484     ) -> HANDLE;
FindExecutableImage( FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR, ) -> HANDLE485     pub fn FindExecutableImage(
486         FileName: PCSTR,
487         SymbolPath: PCSTR,
488         ImageFilePath: PSTR,
489     ) -> HANDLE;
FindExecutableImageEx( FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE490     pub fn FindExecutableImageEx(
491         FileName: PCSTR,
492         SymbolPath: PCSTR,
493         ImageFilePath: PSTR,
494         Callback: PFIND_EXE_FILE_CALLBACK,
495         CallerData: PVOID,
496     ) -> HANDLE;
FindExecutableImageExW( FileName: PCWSTR, SymbolPath: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE497     pub fn FindExecutableImageExW(
498         FileName: PCWSTR,
499         SymbolPath: PCWSTR,
500         ImageFilePath: PWSTR,
501         Callback: PFIND_EXE_FILE_CALLBACKW,
502         CallerData: PVOID,
503     ) -> HANDLE;
StackWalk( MachineType: DWORD, hProcess: HANDLE, hThread: HANDLE, StackFrame: LPSTACKFRAME, ContextRecord: PVOID, ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE, FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE, GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE, TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE, ) -> BOOL504     pub fn StackWalk(
505         MachineType: DWORD,
506         hProcess: HANDLE,
507         hThread: HANDLE,
508         StackFrame: LPSTACKFRAME,
509         ContextRecord: PVOID,
510         ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE,
511         FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE,
512         GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE,
513         TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE,
514     ) -> BOOL;
StackWalkEx( MachineType: DWORD, hProcess: HANDLE, hThread: HANDLE, StackFrame: LPSTACKFRAME_EX, ContextRecord: PVOID, ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64, FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64, GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64, TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64, Flags: DWORD, ) -> BOOL515     pub fn StackWalkEx(
516         MachineType: DWORD,
517         hProcess: HANDLE,
518         hThread: HANDLE,
519         StackFrame: LPSTACKFRAME_EX,
520         ContextRecord: PVOID,
521         ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64,
522         FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64,
523         GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64,
524         TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64,
525         Flags: DWORD,
526     ) -> BOOL;
StackWalk64( MachineType: DWORD, hProcess: HANDLE, hThread: HANDLE, StackFrame: LPSTACKFRAME64, ContextRecord: PVOID, ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64, FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64, GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64, TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64, ) -> BOOL527     pub fn StackWalk64(
528         MachineType: DWORD,
529         hProcess: HANDLE,
530         hThread: HANDLE,
531         StackFrame: LPSTACKFRAME64,
532         ContextRecord: PVOID,
533         ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64,
534         FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64,
535         GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64,
536         TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64,
537     ) -> BOOL;
UnDecorateSymbolName( name: PCSTR, outputString: PSTR, maxStringLength: DWORD, flags: DWORD, ) -> DWORD538     pub fn UnDecorateSymbolName(
539         name: PCSTR,
540         outputString: PSTR,
541         maxStringLength: DWORD,
542         flags: DWORD,
543     ) -> DWORD;
UnDecorateSymbolNameW( name: PCWSTR, outputString: PWSTR, maxStringLength: DWORD, flags: DWORD, ) -> DWORD544     pub fn UnDecorateSymbolNameW(
545         name: PCWSTR,
546         outputString: PWSTR,
547         maxStringLength: DWORD,
548         flags: DWORD,
549     ) -> DWORD;
GetTimestampForLoadedLibrary( Module: HMODULE, ) -> DWORD550     pub fn GetTimestampForLoadedLibrary(
551         Module: HMODULE,
552     ) -> DWORD;
ImageDirectoryEntryToData( Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, ) -> PVOID553     pub fn ImageDirectoryEntryToData(
554         Base: PVOID,
555         MappedAsImage: BOOLEAN,
556         DirectoryEntry: USHORT,
557         Size: PULONG,
558     ) -> PVOID;
ImageDirectoryEntryToDataEx( Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, FoundHeader: *mut PIMAGE_SECTION_HEADER, ) -> PVOID559     pub fn ImageDirectoryEntryToDataEx(
560         Base: PVOID,
561         MappedAsImage: BOOLEAN,
562         DirectoryEntry: USHORT,
563         Size: PULONG,
564         FoundHeader: *mut PIMAGE_SECTION_HEADER,
565     ) -> PVOID;
ImageNtHeader( Base: PVOID, ) -> PIMAGE_NT_HEADERS566     pub fn ImageNtHeader(
567         Base: PVOID,
568     ) -> PIMAGE_NT_HEADERS;
ImageRvaToSection( NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, ) -> PIMAGE_SECTION_HEADER569     pub fn ImageRvaToSection(
570         NtHeaders: PIMAGE_NT_HEADERS,
571         Base: PVOID,
572         Rva: ULONG,
573     ) -> PIMAGE_SECTION_HEADER;
ImageRvaToVa( NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, LastRvaSection: *mut PIMAGE_SECTION_HEADER, ) -> PVOID574     pub fn ImageRvaToVa(
575         NtHeaders: PIMAGE_NT_HEADERS,
576         Base: PVOID,
577         Rva: ULONG,
578         LastRvaSection: *mut PIMAGE_SECTION_HEADER,
579     ) -> PVOID;
580 }
581 pub const SYMOPT_CASE_INSENSITIVE: DWORD = 0x00000001;
582 pub const SYMOPT_UNDNAME: DWORD = 0x00000002;
583 pub const SYMOPT_DEFERRED_LOADS: DWORD = 0x00000004;
584 pub const SYMOPT_NO_CPP: DWORD = 0x00000008;
585 pub const SYMOPT_LOAD_LINES: DWORD = 0x00000010;
586 pub const SYMOPT_OMAP_FIND_NEAREST: DWORD = 0x00000020;
587 pub const SYMOPT_LOAD_ANYTHING: DWORD = 0x00000040;
588 pub const SYMOPT_IGNORE_CVREC: DWORD = 0x00000080;
589 pub const SYMOPT_NO_UNQUALIFIED_LOADS: DWORD = 0x00000100;
590 pub const SYMOPT_FAIL_CRITICAL_ERRORS: DWORD = 0x00000200;
591 pub const SYMOPT_EXACT_SYMBOLS: DWORD = 0x00000400;
592 pub const SYMOPT_ALLOW_ABSOLUTE_SYMBOLS: DWORD = 0x00000800;
593 pub const SYMOPT_IGNORE_NT_SYMPATH: DWORD = 0x00001000;
594 pub const SYMOPT_INCLUDE_32BIT_MODULES: DWORD = 0x00002000;
595 pub const SYMOPT_PUBLICS_ONLY: DWORD = 0x00004000;
596 pub const SYMOPT_NO_PUBLICS: DWORD = 0x00008000;
597 pub const SYMOPT_AUTO_PUBLICS: DWORD = 0x00010000;
598 pub const SYMOPT_NO_IMAGE_SEARCH: DWORD = 0x00020000;
599 pub const SYMOPT_SECURE: DWORD = 0x00040000;
600 pub const SYMOPT_NO_PROMPTS: DWORD = 0x00080000;
601 pub const SYMOPT_OVERWRITE: DWORD = 0x00100000;
602 pub const SYMOPT_IGNORE_IMAGEDIR: DWORD = 0x00200000;
603 pub const SYMOPT_FLAT_DIRECTORY: DWORD = 0x00400000;
604 pub const SYMOPT_FAVOR_COMPRESSED: DWORD = 0x00800000;
605 pub const SYMOPT_ALLOW_ZERO_ADDRESS: DWORD = 0x01000000;
606 pub const SYMOPT_DISABLE_SYMSRV_AUTODETECT: DWORD = 0x02000000;
607 pub const SYMOPT_READONLY_CACHE: DWORD = 0x04000000;
608 pub const SYMOPT_SYMPATH_LAST: DWORD = 0x08000000;
609 pub const SYMOPT_DISABLE_FAST_SYMBOLS: DWORD = 0x10000000;
610 pub const SYMOPT_DISABLE_SYMSRV_TIMEOUT: DWORD = 0x20000000;
611 pub const SYMOPT_DISABLE_SRVSTAR_ON_STARTUP: DWORD = 0x40000000;
612 pub const SYMOPT_DEBUG: DWORD = 0x80000000;
613 extern "system" {
SymSetOptions( SymOptions: DWORD, ) -> DWORD614     pub fn SymSetOptions(
615         SymOptions: DWORD,
616     ) -> DWORD;
SymGetOptions() -> DWORD617     pub fn SymGetOptions() -> DWORD;
SymCleanup( hProcess: HANDLE, ) -> BOOL618     pub fn SymCleanup(
619         hProcess: HANDLE,
620     ) -> BOOL;
SymEnumSymbolsW( hProcess: HANDLE, BaseOfDll: ULONG64, Mask: PCWSTR, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, CallerData: PVOID, ) -> BOOL621     pub fn SymEnumSymbolsW(
622         hProcess: HANDLE,
623         BaseOfDll: ULONG64,
624         Mask: PCWSTR,
625         EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW,
626         CallerData: PVOID,
627     ) -> BOOL;
SymFindDebugInfoFile( hProcess: HANDLE, FileName: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE628     pub fn SymFindDebugInfoFile(
629         hProcess: HANDLE,
630         FileName: PCSTR,
631         DebugFilePath: PSTR,
632         Callback: PFIND_DEBUG_FILE_CALLBACK,
633         CallerData: PVOID,
634     ) -> HANDLE;
SymFindDebugInfoFileW( hProcess: HANDLE, FileName: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE635     pub fn SymFindDebugInfoFileW(
636         hProcess: HANDLE,
637         FileName: PCWSTR,
638         DebugFilePath: PWSTR,
639         Callback: PFIND_DEBUG_FILE_CALLBACKW,
640         CallerData: PVOID,
641     ) -> HANDLE;
SymFindExecutableImage( hProcess: HANDLE, FileName: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE642     pub fn SymFindExecutableImage(
643         hProcess: HANDLE,
644         FileName: PCSTR,
645         ImageFilePath: PSTR,
646         Callback: PFIND_EXE_FILE_CALLBACK,
647         CallerData: PVOID,
648     ) -> HANDLE;
SymFindExecutableImageW( hProcess: HANDLE, FileName: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE649     pub fn SymFindExecutableImageW(
650         hProcess: HANDLE,
651         FileName: PCWSTR,
652         ImageFilePath: PWSTR,
653         Callback: PFIND_EXE_FILE_CALLBACKW,
654         CallerData: PVOID,
655     ) -> HANDLE;
SymFindFileInPath( hprocess: HANDLE, SearchPath: PCSTR, FileName: PCSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: PSTR, callback: PFINDFILEINPATHCALLBACK, context: PVOID, ) -> BOOL656     pub fn SymFindFileInPath(
657         hprocess: HANDLE,
658         SearchPath: PCSTR,
659         FileName: PCSTR,
660         id: PVOID,
661         two: DWORD,
662         three: DWORD,
663         flags: DWORD,
664         FoundFile: PSTR,
665         callback: PFINDFILEINPATHCALLBACK,
666         context: PVOID,
667     ) -> BOOL;
SymFindFileInPathW( hprocess: HANDLE, SearchPath: PCWSTR, FileName: PCWSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: PWSTR, callback: PFINDFILEINPATHCALLBACKW, context: PVOID, ) -> BOOL668     pub fn SymFindFileInPathW(
669         hprocess: HANDLE,
670         SearchPath: PCWSTR,
671         FileName: PCWSTR,
672         id: PVOID,
673         two: DWORD,
674         three: DWORD,
675         flags: DWORD,
676         FoundFile: PWSTR,
677         callback: PFINDFILEINPATHCALLBACKW,
678         context: PVOID,
679     ) -> BOOL;
SymFromAddrW( hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PSYMBOL_INFOW, ) -> BOOL680     pub fn SymFromAddrW(
681         hProcess: HANDLE,
682         Address: DWORD64,
683         Displacement: PDWORD64,
684         Symbol: PSYMBOL_INFOW,
685     ) -> BOOL;
SymFromNameW( hProcess: HANDLE, Name: PCWSTR, Symbol: PSYMBOL_INFOW, ) -> BOOL686     pub fn SymFromNameW(
687         hProcess: HANDLE,
688         Name: PCWSTR,
689         Symbol: PSYMBOL_INFOW,
690     ) -> BOOL;
SymFunctionTableAccess64( hProcess: HANDLE, AddrBase: DWORD64, ) -> PVOID691     pub fn SymFunctionTableAccess64(
692         hProcess: HANDLE,
693         AddrBase: DWORD64,
694     ) -> PVOID;
SymGetLineFromAddrW64( hProcess: HANDLE, dwAddr: DWORD64, pdwDisplacement: PDWORD, Line: PIMAGEHLP_LINEW64, ) -> BOOL695     pub fn SymGetLineFromAddrW64(
696         hProcess: HANDLE,
697         dwAddr: DWORD64,
698         pdwDisplacement: PDWORD,
699         Line: PIMAGEHLP_LINEW64,
700     ) -> BOOL;
SymGetModuleInfoW64( hProcess: HANDLE, qwAddr: DWORD64, ModuleInfo: PIMAGEHLP_MODULEW64, ) -> BOOL701     pub fn SymGetModuleInfoW64(
702         hProcess: HANDLE,
703         qwAddr: DWORD64,
704         ModuleInfo: PIMAGEHLP_MODULEW64,
705     ) -> BOOL;
SymGetModuleBase64( hProcess: HANDLE, AddrBase: DWORD64, ) -> DWORD64706     pub fn SymGetModuleBase64(
707         hProcess: HANDLE,
708         AddrBase: DWORD64,
709     ) -> DWORD64;
SymGetSymFromAddr64( hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PIMAGEHLP_SYMBOL64, ) -> BOOL710     pub fn SymGetSymFromAddr64(
711         hProcess: HANDLE,
712         Address: DWORD64,
713         Displacement: PDWORD64,
714         Symbol: PIMAGEHLP_SYMBOL64,
715     ) -> BOOL;
SymInitializeW( hProcess: HANDLE, UserSearchPath: PCWSTR, fInvadeProcess: BOOL, ) -> BOOL716     pub fn SymInitializeW(
717         hProcess: HANDLE,
718         UserSearchPath: PCWSTR,
719         fInvadeProcess: BOOL,
720     ) -> BOOL;
SymLoadModuleExW( hProcess: HANDLE, hFile: HANDLE, ImageName: PCWSTR, ModuleName: PCWSTR, BaseOfDll: DWORD64, SizeOfDll: DWORD, Data: PMODLOAD_DATA, Flags: DWORD, ) -> DWORD64721     pub fn SymLoadModuleExW(
722         hProcess: HANDLE,
723         hFile: HANDLE,
724         ImageName: PCWSTR,
725         ModuleName: PCWSTR,
726         BaseOfDll: DWORD64,
727         SizeOfDll: DWORD,
728         Data: PMODLOAD_DATA,
729         Flags: DWORD,
730     ) -> DWORD64;
SymUnloadModule( hProcess: HANDLE, BaseOfDll: DWORD, ) -> BOOL731     pub fn SymUnloadModule(
732         hProcess: HANDLE,
733         BaseOfDll: DWORD,
734     ) -> BOOL;
SymUnloadModule64( hProcess: HANDLE, BaseOfDll: DWORD64, ) -> BOOL735     pub fn SymUnloadModule64(
736         hProcess: HANDLE,
737         BaseOfDll: DWORD64,
738     ) -> BOOL;
739     #[cfg(target_pointer_width = "32")]
MapDebugInformation( FileHandle: HANDLE, FileName: PCSTR, SymbolPath: PCSTR, ImageBase: ULONG, ) -> PIMAGE_DEBUG_INFORMATION740     pub fn MapDebugInformation(
741         FileHandle: HANDLE,
742         FileName: PCSTR,
743         SymbolPath: PCSTR,
744         ImageBase: ULONG,
745     ) -> PIMAGE_DEBUG_INFORMATION;
746     #[cfg(target_pointer_width = "32")]
UnmapDebugInformation( DebugInfo: PIMAGE_DEBUG_INFORMATION, ) -> BOOL747     pub fn UnmapDebugInformation(
748         DebugInfo: PIMAGE_DEBUG_INFORMATION,
749     ) -> BOOL;
750 }
751