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, 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 STRUCT!{struct IMAGEHLP_SYMBOL64 { 376 SizeOfStruct: DWORD, 377 Address: DWORD64, 378 Size: DWORD, 379 Flags: DWORD, 380 MaxNameLength: DWORD, 381 Name: [CHAR; 1], 382 }} 383 pub type PIMAGEHLP_SYMBOL64 = *mut IMAGEHLP_SYMBOL64; 384 STRUCT!{struct IMAGEHLP_LINEW64 { 385 SizeOfStruct: DWORD, 386 Key: PVOID, 387 LineNumber: DWORD, 388 FileName: PWSTR, 389 Address: DWORD64, 390 }} 391 pub type PIMAGEHLP_LINEW64 = *mut IMAGEHLP_LINEW64; 392 extern "system" { EnumDirTree( hProcess: HANDLE, RootPath: PCSTR, InputPathName: PCSTR, OutputPathBuffer: PSTR, cb: PENUMDIRTREE_CALLBACK, data: PVOID, ) -> BOOL393 pub fn EnumDirTree( 394 hProcess: HANDLE, 395 RootPath: PCSTR, 396 InputPathName: PCSTR, 397 OutputPathBuffer: PSTR, 398 cb: PENUMDIRTREE_CALLBACK, 399 data: PVOID, 400 ) -> BOOL; EnumDirTreeW( hProcess: HANDLE, RootPath: PCWSTR, InputPathName: PCWSTR, OutputPathBuffer: PWSTR, cb: PENUMDIRTREE_CALLBACKW, data: PVOID, ) -> BOOL401 pub fn EnumDirTreeW( 402 hProcess: HANDLE, 403 RootPath: PCWSTR, 404 InputPathName: PCWSTR, 405 OutputPathBuffer: PWSTR, 406 cb: PENUMDIRTREE_CALLBACKW, 407 data: PVOID, 408 ) -> BOOL; ImagehlpApiVersion() -> LPAPI_VERSION409 pub fn ImagehlpApiVersion() -> LPAPI_VERSION; ImagehlpApiVersionEx( AppVersion: LPAPI_VERSION, ) -> LPAPI_VERSION410 pub fn ImagehlpApiVersionEx( 411 AppVersion: LPAPI_VERSION, 412 ) -> LPAPI_VERSION; MakeSureDirectoryPathExists( DirPath: PCSTR, ) -> BOOL413 pub fn MakeSureDirectoryPathExists( 414 DirPath: PCSTR, 415 ) -> BOOL; SearchTreeForFile( RootPath: PCSTR, InputPathName: PCSTR, OutputPathBuffer: PSTR, ) -> BOOL416 pub fn SearchTreeForFile( 417 RootPath: PCSTR, 418 InputPathName: PCSTR, 419 OutputPathBuffer: PSTR, 420 ) -> BOOL; SearchTreeForFileW( RootPath: PCWSTR, InputPathName: PCWSTR, OutputPathBuffer: PWSTR, ) -> BOOL421 pub fn SearchTreeForFileW( 422 RootPath: PCWSTR, 423 InputPathName: PCWSTR, 424 OutputPathBuffer: PWSTR, 425 ) -> BOOL; FindDebugInfoFile( FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, ) -> HANDLE426 pub fn FindDebugInfoFile( 427 FileName: PCSTR, 428 SymbolPath: PCSTR, 429 DebugFilePath: PSTR, 430 ) -> HANDLE; FindDebugInfoFileEx( FileName: PCSTR, SymbolPath: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE431 pub fn FindDebugInfoFileEx( 432 FileName: PCSTR, 433 SymbolPath: PCSTR, 434 DebugFilePath: PSTR, 435 Callback: PFIND_DEBUG_FILE_CALLBACK, 436 CallerData: PVOID, 437 ) -> HANDLE; FindDebugInfoFileExW( FileName: PCWSTR, SymbolPath: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE438 pub fn FindDebugInfoFileExW( 439 FileName: PCWSTR, 440 SymbolPath: PCWSTR, 441 DebugFilePath: PWSTR, 442 Callback: PFIND_DEBUG_FILE_CALLBACKW, 443 CallerData: PVOID, 444 ) -> HANDLE; FindExecutableImage( FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR, ) -> HANDLE445 pub fn FindExecutableImage( 446 FileName: PCSTR, 447 SymbolPath: PCSTR, 448 ImageFilePath: PSTR, 449 ) -> HANDLE; FindExecutableImageEx( FileName: PCSTR, SymbolPath: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE450 pub fn FindExecutableImageEx( 451 FileName: PCSTR, 452 SymbolPath: PCSTR, 453 ImageFilePath: PSTR, 454 Callback: PFIND_EXE_FILE_CALLBACK, 455 CallerData: PVOID, 456 ) -> HANDLE; FindExecutableImageExW( FileName: PCWSTR, SymbolPath: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE457 pub fn FindExecutableImageExW( 458 FileName: PCWSTR, 459 SymbolPath: PCWSTR, 460 ImageFilePath: PWSTR, 461 Callback: PFIND_EXE_FILE_CALLBACKW, 462 CallerData: PVOID, 463 ) -> 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, ) -> BOOL464 pub fn StackWalk( 465 MachineType: DWORD, 466 hProcess: HANDLE, 467 hThread: HANDLE, 468 StackFrame: LPSTACKFRAME, 469 ContextRecord: PVOID, 470 ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE, 471 FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE, 472 GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE, 473 TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE, 474 ) -> 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, ) -> BOOL475 pub fn StackWalkEx( 476 MachineType: DWORD, 477 hProcess: HANDLE, 478 hThread: HANDLE, 479 StackFrame: LPSTACKFRAME_EX, 480 ContextRecord: PVOID, 481 ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64, 482 FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64, 483 GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64, 484 TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64, 485 Flags: DWORD, 486 ) -> 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, ) -> BOOL487 pub fn StackWalk64( 488 MachineType: DWORD, 489 hProcess: HANDLE, 490 hThread: HANDLE, 491 StackFrame: LPSTACKFRAME64, 492 ContextRecord: PVOID, 493 ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64, 494 FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64, 495 GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64, 496 TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64, 497 ) -> BOOL; UnDecorateSymbolName( name: PCSTR, outputString: PSTR, maxStringLength: DWORD, flags: DWORD, ) -> DWORD498 pub fn UnDecorateSymbolName( 499 name: PCSTR, 500 outputString: PSTR, 501 maxStringLength: DWORD, 502 flags: DWORD, 503 ) -> DWORD; UnDecorateSymbolNameW( name: PCWSTR, outputString: PWSTR, maxStringLength: DWORD, flags: DWORD, ) -> DWORD504 pub fn UnDecorateSymbolNameW( 505 name: PCWSTR, 506 outputString: PWSTR, 507 maxStringLength: DWORD, 508 flags: DWORD, 509 ) -> DWORD; GetTimestampForLoadedLibrary( Module: HMODULE, ) -> DWORD510 pub fn GetTimestampForLoadedLibrary( 511 Module: HMODULE, 512 ) -> DWORD; ImageDirectoryEntryToData( Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, ) -> PVOID513 pub fn ImageDirectoryEntryToData( 514 Base: PVOID, 515 MappedAsImage: BOOLEAN, 516 DirectoryEntry: USHORT, 517 Size: PULONG, 518 ) -> PVOID; ImageDirectoryEntryToDataEx( Base: PVOID, MappedAsImage: BOOLEAN, DirectoryEntry: USHORT, Size: PULONG, FoundHeader: *mut PIMAGE_SECTION_HEADER, ) -> PVOID519 pub fn ImageDirectoryEntryToDataEx( 520 Base: PVOID, 521 MappedAsImage: BOOLEAN, 522 DirectoryEntry: USHORT, 523 Size: PULONG, 524 FoundHeader: *mut PIMAGE_SECTION_HEADER, 525 ) -> PVOID; ImageNtHeader( Base: PVOID, ) -> PIMAGE_NT_HEADERS526 pub fn ImageNtHeader( 527 Base: PVOID, 528 ) -> PIMAGE_NT_HEADERS; ImageRvaToSection( NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, ) -> PIMAGE_SECTION_HEADER529 pub fn ImageRvaToSection( 530 NtHeaders: PIMAGE_NT_HEADERS, 531 Base: PVOID, 532 Rva: ULONG, 533 ) -> PIMAGE_SECTION_HEADER; ImageRvaToVa( NtHeaders: PIMAGE_NT_HEADERS, Base: PVOID, Rva: ULONG, LastRvaSection: *mut PIMAGE_SECTION_HEADER, ) -> PVOID534 pub fn ImageRvaToVa( 535 NtHeaders: PIMAGE_NT_HEADERS, 536 Base: PVOID, 537 Rva: ULONG, 538 LastRvaSection: *mut PIMAGE_SECTION_HEADER, 539 ) -> PVOID; SymCleanup( hProcess: HANDLE, ) -> BOOL540 pub fn SymCleanup( 541 hProcess: HANDLE, 542 ) -> BOOL; SymEnumSymbolsW( hProcess: HANDLE, BaseOfDll: ULONG64, Mask: PCWSTR, EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, CallerData: PVOID, ) -> BOOL543 pub fn SymEnumSymbolsW( 544 hProcess: HANDLE, 545 BaseOfDll: ULONG64, 546 Mask: PCWSTR, 547 EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, 548 CallerData: PVOID, 549 ) -> BOOL; SymFindDebugInfoFile( hProcess: HANDLE, FileName: PCSTR, DebugFilePath: PSTR, Callback: PFIND_DEBUG_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE550 pub fn SymFindDebugInfoFile( 551 hProcess: HANDLE, 552 FileName: PCSTR, 553 DebugFilePath: PSTR, 554 Callback: PFIND_DEBUG_FILE_CALLBACK, 555 CallerData: PVOID, 556 ) -> HANDLE; SymFindDebugInfoFileW( hProcess: HANDLE, FileName: PCWSTR, DebugFilePath: PWSTR, Callback: PFIND_DEBUG_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE557 pub fn SymFindDebugInfoFileW( 558 hProcess: HANDLE, 559 FileName: PCWSTR, 560 DebugFilePath: PWSTR, 561 Callback: PFIND_DEBUG_FILE_CALLBACKW, 562 CallerData: PVOID, 563 ) -> HANDLE; SymFindExecutableImage( hProcess: HANDLE, FileName: PCSTR, ImageFilePath: PSTR, Callback: PFIND_EXE_FILE_CALLBACK, CallerData: PVOID, ) -> HANDLE564 pub fn SymFindExecutableImage( 565 hProcess: HANDLE, 566 FileName: PCSTR, 567 ImageFilePath: PSTR, 568 Callback: PFIND_EXE_FILE_CALLBACK, 569 CallerData: PVOID, 570 ) -> HANDLE; SymFindExecutableImageW( hProcess: HANDLE, FileName: PCWSTR, ImageFilePath: PWSTR, Callback: PFIND_EXE_FILE_CALLBACKW, CallerData: PVOID, ) -> HANDLE571 pub fn SymFindExecutableImageW( 572 hProcess: HANDLE, 573 FileName: PCWSTR, 574 ImageFilePath: PWSTR, 575 Callback: PFIND_EXE_FILE_CALLBACKW, 576 CallerData: PVOID, 577 ) -> HANDLE; SymFindFileInPath( hprocess: HANDLE, SearchPath: PCSTR, FileName: PCSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: PSTR, callback: PFINDFILEINPATHCALLBACK, context: PVOID, ) -> BOOL578 pub fn SymFindFileInPath( 579 hprocess: HANDLE, 580 SearchPath: PCSTR, 581 FileName: PCSTR, 582 id: PVOID, 583 two: DWORD, 584 three: DWORD, 585 flags: DWORD, 586 FoundFile: PSTR, 587 callback: PFINDFILEINPATHCALLBACK, 588 context: PVOID, 589 ) -> BOOL; SymFindFileInPathW( hprocess: HANDLE, SearchPath: PCWSTR, FileName: PCWSTR, id: PVOID, two: DWORD, three: DWORD, flags: DWORD, FoundFile: PWSTR, callback: PFINDFILEINPATHCALLBACKW, context: PVOID, ) -> BOOL590 pub fn SymFindFileInPathW( 591 hprocess: HANDLE, 592 SearchPath: PCWSTR, 593 FileName: PCWSTR, 594 id: PVOID, 595 two: DWORD, 596 three: DWORD, 597 flags: DWORD, 598 FoundFile: PWSTR, 599 callback: PFINDFILEINPATHCALLBACKW, 600 context: PVOID, 601 ) -> BOOL; SymFromAddrW( hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PSYMBOL_INFOW, ) -> BOOL602 pub fn SymFromAddrW( 603 hProcess: HANDLE, 604 Address: DWORD64, 605 Displacement: PDWORD64, 606 Symbol: PSYMBOL_INFOW, 607 ) -> BOOL; SymFromNameW( hProcess: HANDLE, Name: PCWSTR, Symbol: PSYMBOL_INFOW, ) -> BOOL608 pub fn SymFromNameW( 609 hProcess: HANDLE, 610 Name: PCWSTR, 611 Symbol: PSYMBOL_INFOW, 612 ) -> BOOL; SymFunctionTableAccess64( hProcess: HANDLE, AddrBase: DWORD64, ) -> PVOID613 pub fn SymFunctionTableAccess64( 614 hProcess: HANDLE, 615 AddrBase: DWORD64, 616 ) -> PVOID; SymGetLineFromAddrW64( hProcess: HANDLE, dwAddr: DWORD64, pdwDisplacement: PDWORD, Line: PIMAGEHLP_LINEW64, ) -> BOOL617 pub fn SymGetLineFromAddrW64( 618 hProcess: HANDLE, 619 dwAddr: DWORD64, 620 pdwDisplacement: PDWORD, 621 Line: PIMAGEHLP_LINEW64, 622 ) -> BOOL; SymGetModuleBase64( hProcess: HANDLE, AddrBase: DWORD64, ) -> DWORD64623 pub fn SymGetModuleBase64( 624 hProcess: HANDLE, 625 AddrBase: DWORD64, 626 ) -> DWORD64; SymGetSymFromAddr64( hProcess: HANDLE, Address: DWORD64, Displacement: PDWORD64, Symbol: PIMAGEHLP_SYMBOL64, ) -> BOOL627 pub fn SymGetSymFromAddr64( 628 hProcess: HANDLE, 629 Address: DWORD64, 630 Displacement: PDWORD64, 631 Symbol: PIMAGEHLP_SYMBOL64, 632 ) -> BOOL; SymInitializeW( hProcess: HANDLE, UserSearchPath: PCWSTR, fInvadeProcess: BOOL, ) -> BOOL633 pub fn SymInitializeW( 634 hProcess: HANDLE, 635 UserSearchPath: PCWSTR, 636 fInvadeProcess: BOOL, 637 ) -> BOOL; SymLoadModuleExW( hProcess: HANDLE, hFile: HANDLE, ImageName: PCWSTR, ModuleName: PCWSTR, BaseOfDll: DWORD64, SizeOfDll: DWORD, Data: PMODLOAD_DATA, Flags: DWORD, ) -> DWORD64638 pub fn SymLoadModuleExW( 639 hProcess: HANDLE, 640 hFile: HANDLE, 641 ImageName: PCWSTR, 642 ModuleName: PCWSTR, 643 BaseOfDll: DWORD64, 644 SizeOfDll: DWORD, 645 Data: PMODLOAD_DATA, 646 Flags: DWORD, 647 ) -> DWORD64; SymUnloadModule( hProcess: HANDLE, BaseOfDll: DWORD, ) -> BOOL648 pub fn SymUnloadModule( 649 hProcess: HANDLE, 650 BaseOfDll: DWORD, 651 ) -> BOOL; SymUnloadModule64( hProcess: HANDLE, BaseOfDll: DWORD64, ) -> BOOL652 pub fn SymUnloadModule64( 653 hProcess: HANDLE, 654 BaseOfDll: DWORD64, 655 ) -> BOOL; 656 #[cfg(target_pointer_width = "32")] MapDebugInformation( FileHandle: HANDLE, FileName: PCSTR, SymbolPath: PCSTR, ImageBase: ULONG, ) -> PIMAGE_DEBUG_INFORMATION657 pub fn MapDebugInformation( 658 FileHandle: HANDLE, 659 FileName: PCSTR, 660 SymbolPath: PCSTR, 661 ImageBase: ULONG, 662 ) -> PIMAGE_DEBUG_INFORMATION; 663 #[cfg(target_pointer_width = "32")] UnmapDebugInformation( DebugInfo: PIMAGE_DEBUG_INFORMATION, ) -> BOOL664 pub fn UnmapDebugInformation( 665 DebugInfo: PIMAGE_DEBUG_INFORMATION, 666 ) -> BOOL; 667 } 668