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