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