1 // Copyright © 2015-2017 winapi-rs developers
2 // Licensed under the Apache License, Version 2.0
3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
5 // All files in the project carrying such notice may not be copied, modified, or distributed
6 // except according to those terms.
7 //! DbgHelp include file
8 use shared::basetsd::{DWORD64, PDWORD64, ULONG64};
9 use shared::guiddef::GUID;
10 use shared::minwindef::{
11     BOOL, DWORD, HMODULE, LPDWORD, PDWORD, PUCHAR, PULONG, UCHAR, ULONG, USHORT, WORD,
12 };
13 use um::winnt::{
14     BOOLEAN, CHAR, HANDLE, LIST_ENTRY, PCSTR, PCWSTR, PIMAGE_NT_HEADERS, PIMAGE_SECTION_HEADER,
15     PSTR, PVOID, PWSTR, WCHAR,
16 };
17 #[cfg(target_arch = "x86")]
18 use um::winnt::{
19     PFPO_DATA, PIMAGE_COFF_SYMBOLS_HEADER, PIMAGE_DEBUG_DIRECTORY, PIMAGE_FUNCTION_ENTRY,
20     PIMAGE_NT_HEADERS32,
21 };
22 #[cfg(target_arch = "x86_64")]
23 use um::winnt::PIMAGE_NT_HEADERS64;
24 use vc::vcruntime::size_t;
25 #[cfg(target_arch = "x86_64")]
26 STRUCT!{struct LOADED_IMAGE {
27     ModuleName: PSTR,
28     hFile: HANDLE,
29     MappedAddress: PUCHAR,
30     FileHeader: PIMAGE_NT_HEADERS64,
31     LastRvaSection: PIMAGE_SECTION_HEADER,
32     NumberOfSections: ULONG,
33     Sections: PIMAGE_SECTION_HEADER,
34     Characteristics: ULONG,
35     fSystemImage: BOOLEAN,
36     fDOSImage: BOOLEAN,
37     fReadOnly: BOOLEAN,
38     Version: UCHAR,
39     Links: LIST_ENTRY,
40     SizeOfImage: ULONG,
41 }}
42 #[cfg(target_arch = "x86")]
43 STRUCT!{struct LOADED_IMAGE {
44     ModuleName: PSTR,
45     hFile: HANDLE,
46     MappedAddress: PUCHAR,
47     FileHeader: PIMAGE_NT_HEADERS32,
48     LastRvaSection: PIMAGE_SECTION_HEADER,
49     NumberOfSections: ULONG,
50     Sections: PIMAGE_SECTION_HEADER,
51     Characteristics: ULONG,
52     fSystemImage: BOOLEAN,
53     fDOSImage: BOOLEAN,
54     fReadOnly: BOOLEAN,
55     Version: UCHAR,
56     Links: LIST_ENTRY,
57     SizeOfImage: ULONG,
58 }}
59 pub const MAX_SYM_NAME: usize = 2000;
60 pub const ERROR_IMAGE_NOT_STRIPPED: DWORD = 0x8800;
61 pub const ERROR_NO_DBG_POINTER: DWORD = 0x8801;
62 pub const ERROR_NO_PDB_POINTER: DWORD = 0x8802;
63 FN!{stdcall PFIND_DEBUG_FILE_CALLBACK(
64     FileHandle: HANDLE,
65     FileName: PCSTR,
66     CallerData: PVOID,
67 ) -> BOOL}
68 FN!{stdcall PFIND_DEBUG_FILE_CALLBACKW(
69     FileHandle: HANDLE,
70     FileName: PCWSTR,
71     CallerData: PVOID,
72 ) -> BOOL}
73 FN!{stdcall PFINDFILEINPATHCALLBACK(
74     filename: PCSTR,
75     context: PVOID,
76 ) -> BOOL}
77 FN!{stdcall PFINDFILEINPATHCALLBACKW(
78     filename: PCWSTR,
79     context: PVOID,
80 ) -> BOOL}
81 FN!{stdcall PFIND_EXE_FILE_CALLBACK(
82     FileHandle: HANDLE,
83     FileName: PCSTR,
84     CallerData: PVOID,
85 ) -> BOOL}
86 FN!{stdcall PFIND_EXE_FILE_CALLBACKW(
87     FileHandle: HANDLE,
88     FileName: PCWSTR,
89     CallerData: PVOID,
90 ) -> BOOL}
91 #[cfg(target_arch = "x86")]
92 STRUCT!{struct IMAGE_DEBUG_INFORMATION {
93     List: LIST_ENTRY,
94     ReservedSize: DWORD,
95     ReservedMappedBase: PVOID,
96     ReservedMachine: USHORT,
97     ReservedCharacteristics: USHORT,
98     ReservedCheckSum: DWORD,
99     ImageBase: DWORD,
100     SizeOfImage: DWORD,
101     ReservedNumberOfSections: DWORD,
102     ReservedSections: PIMAGE_SECTION_HEADER,
103     ReservedExportedNamesSize: DWORD,
104     ReservedExportedNames: PSTR,
105     ReservedNumberOfFunctionTableEntries: DWORD,
106     ReservedFunctionTableEntries: PIMAGE_FUNCTION_ENTRY,
107     ReservedLowestFunctionStartingAddress: DWORD,
108     ReservedHighestFunctionEndingAddress: DWORD,
109     ReservedNumberOfFpoTableEntries: DWORD,
110     ReservedFpoTableEntries: PFPO_DATA,
111     SizeOfCoffSymbols: DWORD,
112     CoffSymbols: PIMAGE_COFF_SYMBOLS_HEADER,
113     ReservedSizeOfCodeViewSymbols: DWORD,
114     ReservedCodeViewSymbols: PVOID,
115     ImageFilePath: PSTR,
116     ImageFileName: PSTR,
117     ReservedDebugFilePath: PSTR,
118     ReservedTimeDateStamp: DWORD,
119     ReservedRomImage: BOOL,
120     ReservedDebugDirectory: PIMAGE_DEBUG_DIRECTORY,
121     ReservedNumberOfDebugDirectories: DWORD,
122     ReservedOriginalFunctionTableBaseAddress: DWORD,
123     Reserved: [DWORD; 2],
124 }}
125 #[cfg(target_arch = "x86")]
126 pub type PIMAGE_DEBUG_INFORMATION = *mut IMAGE_DEBUG_INFORMATION;
127 FN!{stdcall PENUMDIRTREE_CALLBACK(
128     FilePath: PCSTR,
129     CallerData: PVOID,
130 ) -> BOOL}
131 FN!{stdcall PENUMDIRTREE_CALLBACKW(
132     FilePath: PCWSTR,
133     CallerData: PVOID,
134 ) -> BOOL}
135 pub const UNDNAME_COMPLETE: DWORD = 0x0000;
136 pub const UNDNAME_NO_LEADING_UNDERSCORES: DWORD = 0x0001;
137 pub const UNDNAME_NO_MS_KEYWORDS: DWORD = 0x0002;
138 pub const UNDNAME_NO_FUNCTION_RETURNS: DWORD = 0x0004;
139 pub const UNDNAME_NO_ALLOCATION_MODEL: DWORD = 0x0008;
140 pub const UNDNAME_NO_ALLOCATION_LANGUAGE: DWORD = 0x0010;
141 pub const UNDNAME_NO_MS_THISTYPE: DWORD = 0x0020;
142 pub const UNDNAME_NO_CV_THISTYPE: DWORD = 0x0040;
143 pub const UNDNAME_NO_THISTYPE: DWORD = 0x0060;
144 pub const UNDNAME_NO_ACCESS_SPECIFIERS: DWORD = 0x0080;
145 pub const UNDNAME_NO_THROW_SIGNATURES: DWORD = 0x0100;
146 pub const UNDNAME_NO_MEMBER_TYPE: DWORD = 0x0200;
147 pub const UNDNAME_NO_RETURN_UDT_MODEL: DWORD = 0x0400;
148 pub const UNDNAME_32_BIT_DECODE: DWORD = 0x0800;
149 pub const UNDNAME_NAME_ONLY: DWORD = 0x1000;
150 pub const UNDNAME_NO_ARGUMENTS: DWORD = 0x2000;
151 pub const UNDNAME_NO_SPECIAL_SYMS: DWORD = 0x4000;
152 pub const DBHHEADER_DEBUGDIRS: DWORD = 0x1;
153 pub const DBHHEADER_CVMISC: DWORD = 0x2;
154 pub const DBHHEADER_PDBGUID: DWORD = 0x3;
155 STRUCT!{struct MODLOAD_DATA {
156     ssize: DWORD,
157     ssig: DWORD,
158     data: PVOID,
159     size: DWORD,
160     flags: DWORD,
161 }}
162 pub type PMODLOAD_DATA = *mut MODLOAD_DATA;
163 STRUCT!{struct MODLOAD_CVMISC {
164     oCV: DWORD,
165     cCV: size_t,
166     oMisc: DWORD,
167     cMisc: size_t,
168     dtImage: DWORD,
169     cImage: DWORD,
170 }}
171 pub type PMODLOAD_CVMISC = *mut MODLOAD_CVMISC;
172 STRUCT!{struct MODLOAD_PDBGUID_PDBAGE {
173     PdbGuid: GUID,
174     PdbAge: DWORD,
175 }}
176 pub type PMODLOAD_PDBGUID_PDBAGE = *mut MODLOAD_PDBGUID_PDBAGE;
177 ENUM!{enum ADDRESS_MODE {
178     AddrMode1616,
179     AddrMode1632,
180     AddrModeReal,
181     AddrModeFlat,
182 }}
183 STRUCT!{struct ADDRESS64 {
184     Offset: DWORD64,
185     Segment: WORD,
186     Mode: ADDRESS_MODE,
187 }}
188 pub type LPADDRESS64 = *mut ADDRESS64;
189 #[cfg(target_arch = "x86_64")]
190 pub type ADDRESS = ADDRESS64;
191 #[cfg(target_arch = "x86_64")]
192 pub type LPADDRESS = LPADDRESS64;
193 #[cfg(target_arch = "x86")]
194 STRUCT!{struct ADDRESS {
195     Offset: DWORD,
196     Segment: WORD,
197     Mode: ADDRESS_MODE,
198 }}
199 #[cfg(target_arch = "x86")]
200 pub type LPADDRESS = *mut ADDRESS;
201 STRUCT!{struct KDHELP64 {
202     Thread: DWORD64,
203     ThCallbackStack: DWORD,
204     ThCallbackBStore: DWORD,
205     NextCallback: DWORD,
206     FramePointer: DWORD,
207     KiCallUserMode: DWORD64,
208     KeUserCallbackDispatcher: DWORD64,
209     SystemRangeStart: DWORD64,
210     KiUserExceptionDispatcher: DWORD64,
211     StackBase: DWORD64,
212     StackLimit: DWORD64,
213     BuildVersion: DWORD,
214     Reserved0: DWORD,
215     Reserved1: [DWORD64; 4],
216 }}
217 pub type PKDHELP64 = *mut KDHELP64;
218 #[cfg(target_arch = "x86_64")]
219 pub type KDHELP = KDHELP64;
220 #[cfg(target_arch = "x86_64")]
221 pub type PKDHELP = PKDHELP64;
222 #[cfg(target_arch = "x86")]
223 STRUCT!{struct KDHELP {
224     Thread: DWORD,
225     ThCallbackStack: DWORD,
226     NextCallback: DWORD,
227     FramePointer: DWORD,
228     KiCallUserMode: DWORD,
229     KeUserCallbackDispatcher: DWORD,
230     SystemRangeStart: DWORD,
231     ThCallbackBStore: DWORD,
232     KiUserExceptionDispatcher: DWORD,
233     StackBase: DWORD,
234     StackLimit: DWORD,
235     Reserved: [DWORD; 5],
236 }}
237 #[cfg(target_arch = "x86")]
238 pub type PKDHELP = *mut KDHELP;
239 STRUCT!{struct STACKFRAME64 {
240     AddrPC: ADDRESS64,
241     AddrReturn: ADDRESS64,
242     AddrFrame: ADDRESS64,
243     AddrStack: ADDRESS64,
244     AddrBStore: ADDRESS64,
245     FuncTableEntry: PVOID,
246     Params: [DWORD64; 4],
247     Far: BOOL,
248     Virtual: BOOL,
249     Reserved: [DWORD64; 3],
250     KdHelp: KDHELP64,
251 }}
252 pub type LPSTACKFRAME64 = *mut STACKFRAME64;
253 pub const INLINE_FRAME_CONTEXT_INIT: DWORD = 0;
254 pub const INLINE_FRAME_CONTEXT_IGNORE: DWORD = 0xFFFFFFFF;
255 STRUCT!{struct STACKFRAME_EX {
256     AddrPC: ADDRESS64,
257     AddrReturn: ADDRESS64,
258     AddrFrame: ADDRESS64,
259     AddrStack: ADDRESS64,
260     AddrBStore: ADDRESS64,
261     FuncTableEntry: PVOID,
262     Params: [DWORD64; 4],
263     Far: BOOL,
264     Virtual: BOOL,
265     Reserved: [DWORD64; 3],
266     KdHelp: KDHELP64,
267     StackFrameSize: DWORD,
268     InlineFrameContext: DWORD,
269 }}
270 pub type LPSTACKFRAME_EX = *mut STACKFRAME_EX;
271 #[cfg(target_arch = "x86_64")]
272 pub type STACKFRAME = STACKFRAME64;
273 #[cfg(target_arch = "x86_64")]
274 pub type LPSTACKFRAME = LPSTACKFRAME64;
275 #[cfg(target_arch = "x86")]
276 STRUCT!{struct STACKFRAME {
277     AddrPC: ADDRESS,
278     AddrReturn: ADDRESS,
279     AddrFrame: ADDRESS,
280     AddrStack: ADDRESS,
281     FuncTableEntry: PVOID,
282     Params: [DWORD; 4],
283     Far: BOOL,
284     Virtual: BOOL,
285     Reserved: [DWORD; 3],
286     KdHelp: KDHELP,
287     AddrBStore: ADDRESS,
288 }}
289 #[cfg(target_arch = "x86")]
290 pub type LPSTACKFRAME = *mut STACKFRAME;
291 FN!{stdcall PREAD_PROCESS_MEMORY_ROUTINE64(
292     hProcess: HANDLE,
293     qwBaseAddress: DWORD64,
294     lpBuffer: PVOID,
295     nSize: DWORD,
296     lpNumberOfBytesRead: LPDWORD,
297 ) -> BOOL}
298 FN!{stdcall PFUNCTION_TABLE_ACCESS_ROUTINE64(
299     ahProcess: HANDLE,
300     AddrBase: DWORD64,
301 ) -> PVOID}
302 FN!{stdcall PGET_MODULE_BASE_ROUTINE64(
303     hProcess: HANDLE,
304     Address: DWORD64,
305 ) -> DWORD64}
306 FN!{stdcall PTRANSLATE_ADDRESS_ROUTINE64(
307     hProcess: HANDLE,
308     hThread: HANDLE,
309     lpaddr: LPADDRESS64,
310 ) -> DWORD64}
311 pub const SYM_STKWALK_DEFAULT: DWORD = 0x00000000;
312 pub const SYM_STKWALK_FORCE_FRAMEPTR: DWORD = 0x00000001;
313 #[cfg(target_arch = "x86_64")]
314 pub type PREAD_PROCESS_MEMORY_ROUTINE = PREAD_PROCESS_MEMORY_ROUTINE64;
315 #[cfg(target_arch = "x86_64")]
316 pub type PFUNCTION_TABLE_ACCESS_ROUTINE = PFUNCTION_TABLE_ACCESS_ROUTINE64;
317 #[cfg(target_arch = "x86_64")]
318 pub type PGET_MODULE_BASE_ROUTINE = PGET_MODULE_BASE_ROUTINE64;
319 #[cfg(target_arch = "x86_64")]
320 pub type PTRANSLATE_ADDRESS_ROUTINE = PTRANSLATE_ADDRESS_ROUTINE64;
321 #[cfg(target_arch = "x86")]
322 FN!{stdcall PREAD_PROCESS_MEMORY_ROUTINE(
323     hProcess: HANDLE,
324     qwBaseAddress: DWORD,
325     lpBuffer: PVOID,
326     nSize: DWORD,
327     lpNumberOfBytesRead: PDWORD,
328 ) -> BOOL}
329 #[cfg(target_arch = "x86")]
330 FN!{stdcall PFUNCTION_TABLE_ACCESS_ROUTINE(
331     ahProcess: HANDLE,
332     AddrBase: DWORD,
333 ) -> PVOID}
334 #[cfg(target_arch = "x86")]
335 FN!{stdcall PGET_MODULE_BASE_ROUTINE(
336     hProcess: HANDLE,
337     Address: DWORD,
338 ) -> DWORD}
339 #[cfg(target_arch = "x86")]
340 FN!{stdcall PTRANSLATE_ADDRESS_ROUTINE(
341     hProcess: HANDLE,
342     hThread: HANDLE,
343     lpaddr: LPADDRESS,
344 ) -> DWORD}
345 pub const API_VERSION_NUMBER: USHORT = 12;
346 STRUCT!{struct API_VERSION {
347     MajorVersion: USHORT,
348     MinorVersion: USHORT,
349     Revision: USHORT,
350     Reserved: USHORT,
351 }}
352 pub type LPAPI_VERSION = *mut API_VERSION;
353 STRUCT!{struct SYMBOL_INFOW {
354     SizeOfStruct: ULONG,
355     TypeIndex: ULONG,
356     Reserved: [ULONG64; 2],
357     Index: ULONG,
358     Size: ULONG,
359     ModBase: ULONG64,
360     Flags: ULONG,
361     Value: ULONG64,
362     Address: ULONG64,
363     Register: ULONG,
364     Scope: ULONG,
365     Tag: ULONG,
366     NameLen: ULONG,
367     MaxNameLen: ULONG,
368     Name: [WCHAR; 1],
369 }}
370 pub type PSYMBOL_INFOW = *mut SYMBOL_INFOW;
371 STRUCT!{struct IMAGEHLP_SYMBOL64 {
372     SizeOfStruct: DWORD,
373     Address: DWORD64,
374     Size: DWORD,
375     Flags: DWORD,
376     MaxNameLength: DWORD,
377     Name: [CHAR; 1],
378 }}
379 pub type PIMAGEHLP_SYMBOL64 = *mut IMAGEHLP_SYMBOL64;
380 STRUCT!{struct IMAGEHLP_LINEW64 {
381     SizeOfStruct: DWORD,
382     Key: PVOID,
383     LineNumber: DWORD,
384     FileName: PWSTR,
385     Address: DWORD64,
386 }}
387 pub type PIMAGEHLP_LINEW64 = *mut IMAGEHLP_LINEW64;
388 extern "system" {
EnumDirTree( hProcess: HANDLE, RootPath: PCSTR, InputPathName: PCSTR, OutputPathBuffer: PSTR, cb: PENUMDIRTREE_CALLBACK, data: PVOID, ) -> BOOL389     pub fn EnumDirTree(
390         hProcess: HANDLE,
391         RootPath: PCSTR,
392         InputPathName: PCSTR,
393         OutputPathBuffer: PSTR,
394         cb: PENUMDIRTREE_CALLBACK,
395         data: PVOID,
396     ) -> BOOL;
EnumDirTreeW( hProcess: HANDLE, RootPath: PCWSTR, InputPathName: PCWSTR, OutputPathBuffer: PWSTR, cb: PENUMDIRTREE_CALLBACKW, data: PVOID, ) -> BOOL397     pub fn EnumDirTreeW(
398         hProcess: HANDLE,
399         RootPath: PCWSTR,
400         InputPathName: PCWSTR,
401         OutputPathBuffer: PWSTR,
402         cb: PENUMDIRTREE_CALLBACKW,
403         data: PVOID,
404     ) -> BOOL;
ImagehlpApiVersion() -> LPAPI_VERSION405     pub fn ImagehlpApiVersion() -> LPAPI_VERSION;
ImagehlpApiVersionEx( AppVersion: LPAPI_VERSION, ) -> LPAPI_VERSION406     pub fn ImagehlpApiVersionEx(
407         AppVersion: LPAPI_VERSION,
408     ) -> LPAPI_VERSION;
MakeSureDirectoryPathExists( DirPath: PCSTR, ) -> BOOL409     pub fn MakeSureDirectoryPathExists(
410         DirPath: PCSTR,
411     ) -> BOOL;
SearchTreeForFile( RootPath: PCSTR, InputPathName: PCSTR, OutputPathBuffer: PSTR, ) -> BOOL412     pub fn SearchTreeForFile(
413         RootPath: PCSTR,
414         InputPathName: PCSTR,
415         OutputPathBuffer: PSTR,
416     ) -> BOOL;
SearchTreeForFileW( RootPath: PCWSTR, InputPathName: PCWSTR, OutputPathBuffer: PWSTR, ) -> BOOL417     pub fn SearchTreeForFileW(
418         RootPath: PCWSTR,
419         InputPathName: PCWSTR,
420         OutputPathBuffer: PWSTR,
421     ) -> BOOL;
FindDebugInfoFile( FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR ) -> HANDLE422     pub fn FindDebugInfoFile(
423         FileName: PCSTR,
424         SymbolPath: PCSTR,
425         DebugFilePath: PSTR
426     ) -> HANDLE;
FindDebugInfoFileEx( FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE427     pub fn FindDebugInfoFileEx(
428         FileName: PCSTR,
429         SymbolPath: PCSTR,
430         DebugFilePath: PSTR,
431         Callback: PFIND_DEBUG_FILE_CALLBACK,
432         CallerData: PVOID,
433     ) -> HANDLE;
FindDebugInfoFileExW( FileName: PCWSTR, SymbolPath: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE434     pub fn FindDebugInfoFileExW(
435         FileName: PCWSTR,
436         SymbolPath: PCWSTR,
437         DebugFilePath: PWSTR,
438         Callback: PFIND_DEBUG_FILE_CALLBACKW,
439         CallerData: PVOID,
440     ) -> HANDLE;
FindExecutableImage( FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR ) -> HANDLE441     pub fn FindExecutableImage(
442         FileName: PCSTR,
443         SymbolPath: PCSTR,
444         ImageFilePath: PSTR
445     ) -> HANDLE;
FindExecutableImageEx( FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE446     pub fn FindExecutableImageEx(
447         FileName: PCSTR,
448         SymbolPath: PCSTR,
449         ImageFilePath: PSTR,
450         Callback: PFIND_EXE_FILE_CALLBACK,
451         CallerData: PVOID,
452     ) -> HANDLE;
FindExecutableImageExW( FileName: PCWSTR, SymbolPath: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE453     pub fn FindExecutableImageExW(
454         FileName: PCWSTR,
455         SymbolPath: PCWSTR,
456         ImageFilePath: PWSTR,
457         Callback: PFIND_EXE_FILE_CALLBACKW,
458         CallerData: PVOID,
459     ) -> 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, ) -> BOOL460     pub fn StackWalk(
461         MachineType: DWORD,
462         hProcess: HANDLE,
463         hThread: HANDLE,
464         StackFrame: LPSTACKFRAME,
465         ContextRecord: PVOID,
466         ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE,
467         FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE,
468         GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE,
469         TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE,
470     ) -> BOOL;
StackWalkEx( 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, Flags: DWORD, ) -> BOOL471     pub fn StackWalkEx(
472         MachineType: DWORD,
473         hProcess: HANDLE,
474         hThread: HANDLE,
475         StackFrame: LPSTACKFRAME64,
476         ContextRecord: PVOID,
477         ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64,
478         FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64,
479         GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64,
480         TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64,
481         Flags: DWORD,
482     ) -> 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, ) -> BOOL483     pub fn StackWalk64(
484         MachineType: DWORD,
485         hProcess: HANDLE,
486         hThread: HANDLE,
487         StackFrame: LPSTACKFRAME64,
488         ContextRecord: PVOID,
489         ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64,
490         FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64,
491         GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64,
492         TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64,
493     ) -> BOOL;
UnDecorateSymbolName( name: PCSTR, outputString: PSTR, maxStringLength: DWORD, flags: DWORD, ) -> DWORD494     pub fn UnDecorateSymbolName(
495         name: PCSTR,
496         outputString: PSTR,
497         maxStringLength: DWORD,
498         flags: DWORD,
499     ) -> DWORD;
UnDecorateSymbolNameW( name: PCWSTR, outputString: PWSTR, maxStringLength: DWORD, flags: DWORD, ) -> DWORD500     pub fn UnDecorateSymbolNameW(
501         name: PCWSTR,
502         outputString: PWSTR,
503         maxStringLength: DWORD,
504         flags: DWORD,
505     ) -> DWORD;
GetTimestampForLoadedLibrary( Module: HMODULE, ) -> DWORD506     pub fn GetTimestampForLoadedLibrary(
507         Module: HMODULE,
508     ) -> DWORD;
ImageDirectoryEntryToData( Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, ) -> PVOID509     pub fn ImageDirectoryEntryToData(
510         Base: PVOID,
511         MappedAsImage: BOOLEAN,
512         DirectoryEntry: USHORT,
513         Size: PULONG,
514     ) -> PVOID;
ImageDirectoryEntryToDataEx( Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, FoundHeader: *mut PIMAGE_SECTION_HEADER, ) -> PVOID515     pub fn ImageDirectoryEntryToDataEx(
516         Base: PVOID,
517         MappedAsImage: BOOLEAN,
518         DirectoryEntry: USHORT,
519         Size: PULONG,
520         FoundHeader: *mut PIMAGE_SECTION_HEADER,
521     ) -> PVOID;
ImageNtHeader( Base: PVOID, ) -> PIMAGE_NT_HEADERS522     pub fn ImageNtHeader(
523         Base: PVOID,
524     ) -> PIMAGE_NT_HEADERS;
ImageRvaToSection( NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, ) -> PIMAGE_SECTION_HEADER525     pub fn ImageRvaToSection(
526         NtHeaders: PIMAGE_NT_HEADERS,
527         Base: PVOID,
528         Rva: ULONG,
529     ) -> PIMAGE_SECTION_HEADER;
ImageRvaToVa( NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, LastRvaSection: *mut PIMAGE_SECTION_HEADER, ) -> PVOID530     pub fn ImageRvaToVa(
531         NtHeaders: PIMAGE_NT_HEADERS,
532         Base: PVOID,
533         Rva: ULONG,
534         LastRvaSection: *mut PIMAGE_SECTION_HEADER,
535     ) -> PVOID;
SymCleanup( hProcess: HANDLE ) -> BOOL536     pub fn SymCleanup(
537         hProcess: HANDLE
538     ) -> BOOL;
SymFindDebugInfoFile( hProcess: HANDLE, FileName: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE539     pub fn SymFindDebugInfoFile(
540         hProcess: HANDLE,
541         FileName: PCSTR,
542         DebugFilePath: PSTR,
543         Callback: PFIND_DEBUG_FILE_CALLBACK,
544         CallerData: PVOID,
545     ) -> HANDLE;
SymFindDebugInfoFileW( hProcess: HANDLE, FileName: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE546     pub fn SymFindDebugInfoFileW(
547         hProcess: HANDLE,
548         FileName: PCWSTR,
549         DebugFilePath: PWSTR,
550         Callback: PFIND_DEBUG_FILE_CALLBACKW,
551         CallerData: PVOID,
552     ) -> HANDLE;
SymFindExecutableImage( hProcess: HANDLE, FileName: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE553     pub fn SymFindExecutableImage(
554         hProcess: HANDLE,
555         FileName: PCSTR,
556         ImageFilePath: PSTR,
557         Callback: PFIND_EXE_FILE_CALLBACK,
558         CallerData: PVOID,
559     ) -> HANDLE;
SymFindExecutableImageW( hProcess: HANDLE, FileName: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE560     pub fn SymFindExecutableImageW(
561         hProcess: HANDLE,
562         FileName: PCWSTR,
563         ImageFilePath: PWSTR,
564         Callback: PFIND_EXE_FILE_CALLBACKW,
565         CallerData: PVOID,
566     ) -> HANDLE;
SymFindFileInPath( hprocess: HANDLE, SearchPath: PCSTR, FileName: PCSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: PSTR, callback: PFINDFILEINPATHCALLBACK, context: PVOID, ) -> BOOL567     pub fn SymFindFileInPath(
568         hprocess: HANDLE,
569         SearchPath: PCSTR,
570         FileName: PCSTR,
571         id: PVOID,
572         two: DWORD,
573         three: DWORD,
574         flags: DWORD,
575         FoundFile: PSTR,
576         callback: PFINDFILEINPATHCALLBACK,
577         context: PVOID,
578     ) -> BOOL;
SymFindFileInPathW( hprocess: HANDLE, SearchPath: PCWSTR, FileName: PCWSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: PWSTR, callback: PFINDFILEINPATHCALLBACKW, context: PVOID, ) -> BOOL579     pub fn SymFindFileInPathW(
580         hprocess: HANDLE,
581         SearchPath: PCWSTR,
582         FileName: PCWSTR,
583         id: PVOID,
584         two: DWORD,
585         three: DWORD,
586         flags: DWORD,
587         FoundFile: PWSTR,
588         callback: PFINDFILEINPATHCALLBACKW,
589         context: PVOID,
590     ) -> BOOL;
SymFromAddrW( hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PSYMBOL_INFOW, ) -> BOOL591     pub fn SymFromAddrW(
592         hProcess: HANDLE,
593         Address: DWORD64,
594         Displacement: PDWORD64,
595         Symbol: PSYMBOL_INFOW,
596     ) -> BOOL;
SymFunctionTableAccess64( hProcess: HANDLE, AddrBase: DWORD64, ) -> PVOID597     pub fn SymFunctionTableAccess64(
598         hProcess: HANDLE,
599         AddrBase: DWORD64,
600     ) -> PVOID;
SymGetLineFromAddrW64( hProcess: HANDLE, dwAddr: DWORD64, pdwDisplacement: PDWORD, Line: PIMAGEHLP_LINEW64, ) -> BOOL601     pub fn SymGetLineFromAddrW64(
602         hProcess: HANDLE,
603         dwAddr: DWORD64,
604         pdwDisplacement: PDWORD,
605         Line: PIMAGEHLP_LINEW64,
606     ) -> BOOL;
SymGetModuleBase64( hProcess: HANDLE, AddrBase: DWORD64, ) -> DWORD64607     pub fn SymGetModuleBase64(
608         hProcess: HANDLE,
609         AddrBase: DWORD64,
610     ) -> DWORD64;
SymGetSymFromAddr64( hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PIMAGEHLP_SYMBOL64, ) -> BOOL611     pub fn SymGetSymFromAddr64(
612         hProcess: HANDLE,
613         Address: DWORD64,
614         Displacement: PDWORD64,
615         Symbol: PIMAGEHLP_SYMBOL64,
616     ) -> BOOL;
SymInitializeW( hProcess: HANDLE, UserSearchPath: PCWSTR, fInvadeProcess: BOOL, ) -> BOOL617     pub fn SymInitializeW(
618         hProcess: HANDLE,
619         UserSearchPath: PCWSTR,
620         fInvadeProcess: BOOL,
621     ) -> BOOL;
622     #[cfg(any(target_arch = "x86", target_arch = "arm"))]
MapDebugInformation( FileHandle: HANDLE, FileName: PCSTR, SymbolPath: PCSTR, ImageBase: ULONG, ) -> PIMAGE_DEBUG_INFORMATION623     pub fn MapDebugInformation(
624         FileHandle: HANDLE,
625         FileName: PCSTR,
626         SymbolPath: PCSTR,
627         ImageBase: ULONG,
628     ) -> PIMAGE_DEBUG_INFORMATION;
629     #[cfg(any(target_arch = "x86", target_arch = "arm"))]
UnmapDebugInformation( DebugInfo: PIMAGE_DEBUG_INFORMATION, ) -> BOOL630     pub fn UnmapDebugInformation(
631         DebugInfo: PIMAGE_DEBUG_INFORMATION,
632     ) -> BOOL;
633 }
634