| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! DbgHelp include file |
| use shared::basetsd::{DWORD64, PDWORD64, ULONG64}; |
| use shared::guiddef::GUID; |
| use shared::minwindef::{ |
| BOOL, DWORD, HMODULE, LPDWORD, MAX_PATH, PDWORD, PUCHAR, PULONG, UCHAR, ULONG, USHORT, WORD, |
| }; |
| use um::winnt::{ |
| BOOLEAN, CHAR, HANDLE, LIST_ENTRY, PCSTR, PCWSTR, PIMAGE_NT_HEADERS, PIMAGE_SECTION_HEADER, |
| PSTR, PVOID, PWSTR, WCHAR, |
| }; |
| #[cfg(target_pointer_width = "32")] |
| use um::winnt::{ |
| PFPO_DATA, PIMAGE_COFF_SYMBOLS_HEADER, PIMAGE_DEBUG_DIRECTORY, PIMAGE_FUNCTION_ENTRY, |
| PIMAGE_NT_HEADERS32, |
| }; |
| #[cfg(target_pointer_width = "64")] |
| use um::winnt::PIMAGE_NT_HEADERS64; |
| use vc::vcruntime::size_t; |
| #[cfg(target_pointer_width = "64")] |
| STRUCT!{struct LOADED_IMAGE { |
| ModuleName: PSTR, |
| hFile: HANDLE, |
| MappedAddress: PUCHAR, |
| FileHeader: PIMAGE_NT_HEADERS64, |
| LastRvaSection: PIMAGE_SECTION_HEADER, |
| NumberOfSections: ULONG, |
| Sections: PIMAGE_SECTION_HEADER, |
| Characteristics: ULONG, |
| fSystemImage: BOOLEAN, |
| fDOSImage: BOOLEAN, |
| fReadOnly: BOOLEAN, |
| Version: UCHAR, |
| Links: LIST_ENTRY, |
| SizeOfImage: ULONG, |
| }} |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct LOADED_IMAGE { |
| ModuleName: PSTR, |
| hFile: HANDLE, |
| MappedAddress: PUCHAR, |
| FileHeader: PIMAGE_NT_HEADERS32, |
| LastRvaSection: PIMAGE_SECTION_HEADER, |
| NumberOfSections: ULONG, |
| Sections: PIMAGE_SECTION_HEADER, |
| Characteristics: ULONG, |
| fSystemImage: BOOLEAN, |
| fDOSImage: BOOLEAN, |
| fReadOnly: BOOLEAN, |
| Version: UCHAR, |
| Links: LIST_ENTRY, |
| SizeOfImage: ULONG, |
| }} |
| pub const MAX_SYM_NAME: usize = 2000; |
| pub const ERROR_IMAGE_NOT_STRIPPED: DWORD = 0x8800; |
| pub const ERROR_NO_DBG_POINTER: DWORD = 0x8801; |
| pub const ERROR_NO_PDB_POINTER: DWORD = 0x8802; |
| FN!{stdcall PFIND_DEBUG_FILE_CALLBACK( |
| FileHandle: HANDLE, |
| FileName: PCSTR, |
| CallerData: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PFIND_DEBUG_FILE_CALLBACKW( |
| FileHandle: HANDLE, |
| FileName: PCWSTR, |
| CallerData: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PFINDFILEINPATHCALLBACK( |
| filename: PCSTR, |
| context: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PFINDFILEINPATHCALLBACKW( |
| filename: PCWSTR, |
| context: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PFIND_EXE_FILE_CALLBACK( |
| FileHandle: HANDLE, |
| FileName: PCSTR, |
| CallerData: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PFIND_EXE_FILE_CALLBACKW( |
| FileHandle: HANDLE, |
| FileName: PCWSTR, |
| CallerData: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PSYM_ENUMERATESYMBOLS_CALLBACKW( |
| pSymInfo: PSYMBOL_INFOW, |
| SymbolSize: ULONG, |
| CallerData: PVOID, |
| ) -> BOOL} |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct IMAGE_DEBUG_INFORMATION { |
| List: LIST_ENTRY, |
| ReservedSize: DWORD, |
| ReservedMappedBase: PVOID, |
| ReservedMachine: USHORT, |
| ReservedCharacteristics: USHORT, |
| ReservedCheckSum: DWORD, |
| ImageBase: DWORD, |
| SizeOfImage: DWORD, |
| ReservedNumberOfSections: DWORD, |
| ReservedSections: PIMAGE_SECTION_HEADER, |
| ReservedExportedNamesSize: DWORD, |
| ReservedExportedNames: PSTR, |
| ReservedNumberOfFunctionTableEntries: DWORD, |
| ReservedFunctionTableEntries: PIMAGE_FUNCTION_ENTRY, |
| ReservedLowestFunctionStartingAddress: DWORD, |
| ReservedHighestFunctionEndingAddress: DWORD, |
| ReservedNumberOfFpoTableEntries: DWORD, |
| ReservedFpoTableEntries: PFPO_DATA, |
| SizeOfCoffSymbols: DWORD, |
| CoffSymbols: PIMAGE_COFF_SYMBOLS_HEADER, |
| ReservedSizeOfCodeViewSymbols: DWORD, |
| ReservedCodeViewSymbols: PVOID, |
| ImageFilePath: PSTR, |
| ImageFileName: PSTR, |
| ReservedDebugFilePath: PSTR, |
| ReservedTimeDateStamp: DWORD, |
| ReservedRomImage: BOOL, |
| ReservedDebugDirectory: PIMAGE_DEBUG_DIRECTORY, |
| ReservedNumberOfDebugDirectories: DWORD, |
| ReservedOriginalFunctionTableBaseAddress: DWORD, |
| Reserved: [DWORD; 2], |
| }} |
| #[cfg(target_pointer_width = "32")] |
| pub type PIMAGE_DEBUG_INFORMATION = *mut IMAGE_DEBUG_INFORMATION; |
| FN!{stdcall PENUMDIRTREE_CALLBACK( |
| FilePath: PCSTR, |
| CallerData: PVOID, |
| ) -> BOOL} |
| FN!{stdcall PENUMDIRTREE_CALLBACKW( |
| FilePath: PCWSTR, |
| CallerData: PVOID, |
| ) -> BOOL} |
| pub const UNDNAME_COMPLETE: DWORD = 0x0000; |
| pub const UNDNAME_NO_LEADING_UNDERSCORES: DWORD = 0x0001; |
| pub const UNDNAME_NO_MS_KEYWORDS: DWORD = 0x0002; |
| pub const UNDNAME_NO_FUNCTION_RETURNS: DWORD = 0x0004; |
| pub const UNDNAME_NO_ALLOCATION_MODEL: DWORD = 0x0008; |
| pub const UNDNAME_NO_ALLOCATION_LANGUAGE: DWORD = 0x0010; |
| pub const UNDNAME_NO_MS_THISTYPE: DWORD = 0x0020; |
| pub const UNDNAME_NO_CV_THISTYPE: DWORD = 0x0040; |
| pub const UNDNAME_NO_THISTYPE: DWORD = 0x0060; |
| pub const UNDNAME_NO_ACCESS_SPECIFIERS: DWORD = 0x0080; |
| pub const UNDNAME_NO_THROW_SIGNATURES: DWORD = 0x0100; |
| pub const UNDNAME_NO_MEMBER_TYPE: DWORD = 0x0200; |
| pub const UNDNAME_NO_RETURN_UDT_MODEL: DWORD = 0x0400; |
| pub const UNDNAME_32_BIT_DECODE: DWORD = 0x0800; |
| pub const UNDNAME_NAME_ONLY: DWORD = 0x1000; |
| pub const UNDNAME_NO_ARGUMENTS: DWORD = 0x2000; |
| pub const UNDNAME_NO_SPECIAL_SYMS: DWORD = 0x4000; |
| pub const DBHHEADER_DEBUGDIRS: DWORD = 0x1; |
| pub const DBHHEADER_CVMISC: DWORD = 0x2; |
| pub const DBHHEADER_PDBGUID: DWORD = 0x3; |
| STRUCT!{struct MODLOAD_DATA { |
| ssize: DWORD, |
| ssig: DWORD, |
| data: PVOID, |
| size: DWORD, |
| flags: DWORD, |
| }} |
| pub type PMODLOAD_DATA = *mut MODLOAD_DATA; |
| STRUCT!{struct MODLOAD_CVMISC { |
| oCV: DWORD, |
| cCV: size_t, |
| oMisc: DWORD, |
| cMisc: size_t, |
| dtImage: DWORD, |
| cImage: DWORD, |
| }} |
| pub type PMODLOAD_CVMISC = *mut MODLOAD_CVMISC; |
| STRUCT!{struct MODLOAD_PDBGUID_PDBAGE { |
| PdbGuid: GUID, |
| PdbAge: DWORD, |
| }} |
| pub type PMODLOAD_PDBGUID_PDBAGE = *mut MODLOAD_PDBGUID_PDBAGE; |
| ENUM!{enum ADDRESS_MODE { |
| AddrMode1616, |
| AddrMode1632, |
| AddrModeReal, |
| AddrModeFlat, |
| }} |
| STRUCT!{struct ADDRESS64 { |
| Offset: DWORD64, |
| Segment: WORD, |
| Mode: ADDRESS_MODE, |
| }} |
| pub type LPADDRESS64 = *mut ADDRESS64; |
| #[cfg(target_pointer_width = "64")] |
| pub type ADDRESS = ADDRESS64; |
| #[cfg(target_pointer_width = "64")] |
| pub type LPADDRESS = LPADDRESS64; |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct ADDRESS { |
| Offset: DWORD, |
| Segment: WORD, |
| Mode: ADDRESS_MODE, |
| }} |
| #[cfg(target_pointer_width = "32")] |
| pub type LPADDRESS = *mut ADDRESS; |
| STRUCT!{struct KDHELP64 { |
| Thread: DWORD64, |
| ThCallbackStack: DWORD, |
| ThCallbackBStore: DWORD, |
| NextCallback: DWORD, |
| FramePointer: DWORD, |
| KiCallUserMode: DWORD64, |
| KeUserCallbackDispatcher: DWORD64, |
| SystemRangeStart: DWORD64, |
| KiUserExceptionDispatcher: DWORD64, |
| StackBase: DWORD64, |
| StackLimit: DWORD64, |
| BuildVersion: DWORD, |
| Reserved0: DWORD, |
| Reserved1: [DWORD64; 4], |
| }} |
| pub type PKDHELP64 = *mut KDHELP64; |
| #[cfg(target_pointer_width = "64")] |
| pub type KDHELP = KDHELP64; |
| #[cfg(target_pointer_width = "64")] |
| pub type PKDHELP = PKDHELP64; |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct KDHELP { |
| Thread: DWORD, |
| ThCallbackStack: DWORD, |
| NextCallback: DWORD, |
| FramePointer: DWORD, |
| KiCallUserMode: DWORD, |
| KeUserCallbackDispatcher: DWORD, |
| SystemRangeStart: DWORD, |
| ThCallbackBStore: DWORD, |
| KiUserExceptionDispatcher: DWORD, |
| StackBase: DWORD, |
| StackLimit: DWORD, |
| Reserved: [DWORD; 5], |
| }} |
| #[cfg(target_pointer_width = "32")] |
| pub type PKDHELP = *mut KDHELP; |
| STRUCT!{struct STACKFRAME64 { |
| AddrPC: ADDRESS64, |
| AddrReturn: ADDRESS64, |
| AddrFrame: ADDRESS64, |
| AddrStack: ADDRESS64, |
| AddrBStore: ADDRESS64, |
| FuncTableEntry: PVOID, |
| Params: [DWORD64; 4], |
| Far: BOOL, |
| Virtual: BOOL, |
| Reserved: [DWORD64; 3], |
| KdHelp: KDHELP64, |
| }} |
| pub type LPSTACKFRAME64 = *mut STACKFRAME64; |
| pub const INLINE_FRAME_CONTEXT_INIT: DWORD = 0; |
| pub const INLINE_FRAME_CONTEXT_IGNORE: DWORD = 0xFFFFFFFF; |
| STRUCT!{struct STACKFRAME_EX { |
| AddrPC: ADDRESS64, |
| AddrReturn: ADDRESS64, |
| AddrFrame: ADDRESS64, |
| AddrStack: ADDRESS64, |
| AddrBStore: ADDRESS64, |
| FuncTableEntry: PVOID, |
| Params: [DWORD64; 4], |
| Far: BOOL, |
| Virtual: BOOL, |
| Reserved: [DWORD64; 3], |
| KdHelp: KDHELP64, |
| StackFrameSize: DWORD, |
| InlineFrameContext: DWORD, |
| }} |
| pub type LPSTACKFRAME_EX = *mut STACKFRAME_EX; |
| #[cfg(target_pointer_width = "64")] |
| pub type STACKFRAME = STACKFRAME64; |
| #[cfg(target_pointer_width = "64")] |
| pub type LPSTACKFRAME = LPSTACKFRAME64; |
| #[cfg(target_pointer_width = "32")] |
| STRUCT!{struct STACKFRAME { |
| AddrPC: ADDRESS, |
| AddrReturn: ADDRESS, |
| AddrFrame: ADDRESS, |
| AddrStack: ADDRESS, |
| FuncTableEntry: PVOID, |
| Params: [DWORD; 4], |
| Far: BOOL, |
| Virtual: BOOL, |
| Reserved: [DWORD; 3], |
| KdHelp: KDHELP, |
| AddrBStore: ADDRESS, |
| }} |
| #[cfg(target_pointer_width = "32")] |
| pub type LPSTACKFRAME = *mut STACKFRAME; |
| FN!{stdcall PREAD_PROCESS_MEMORY_ROUTINE64( |
| hProcess: HANDLE, |
| qwBaseAddress: DWORD64, |
| lpBuffer: PVOID, |
| nSize: DWORD, |
| lpNumberOfBytesRead: LPDWORD, |
| ) -> BOOL} |
| FN!{stdcall PFUNCTION_TABLE_ACCESS_ROUTINE64( |
| ahProcess: HANDLE, |
| AddrBase: DWORD64, |
| ) -> PVOID} |
| FN!{stdcall PGET_MODULE_BASE_ROUTINE64( |
| hProcess: HANDLE, |
| Address: DWORD64, |
| ) -> DWORD64} |
| FN!{stdcall PTRANSLATE_ADDRESS_ROUTINE64( |
| hProcess: HANDLE, |
| hThread: HANDLE, |
| lpaddr: LPADDRESS64, |
| ) -> DWORD64} |
| pub const SYM_STKWALK_DEFAULT: DWORD = 0x00000000; |
| pub const SYM_STKWALK_FORCE_FRAMEPTR: DWORD = 0x00000001; |
| #[cfg(target_pointer_width = "64")] |
| pub type PREAD_PROCESS_MEMORY_ROUTINE = PREAD_PROCESS_MEMORY_ROUTINE64; |
| #[cfg(target_pointer_width = "64")] |
| pub type PFUNCTION_TABLE_ACCESS_ROUTINE = PFUNCTION_TABLE_ACCESS_ROUTINE64; |
| #[cfg(target_pointer_width = "64")] |
| pub type PGET_MODULE_BASE_ROUTINE = PGET_MODULE_BASE_ROUTINE64; |
| #[cfg(target_pointer_width = "64")] |
| pub type PTRANSLATE_ADDRESS_ROUTINE = PTRANSLATE_ADDRESS_ROUTINE64; |
| #[cfg(target_pointer_width = "32")] |
| FN!{stdcall PREAD_PROCESS_MEMORY_ROUTINE( |
| hProcess: HANDLE, |
| qwBaseAddress: DWORD, |
| lpBuffer: PVOID, |
| nSize: DWORD, |
| lpNumberOfBytesRead: PDWORD, |
| ) -> BOOL} |
| #[cfg(target_pointer_width = "32")] |
| FN!{stdcall PFUNCTION_TABLE_ACCESS_ROUTINE( |
| ahProcess: HANDLE, |
| AddrBase: DWORD, |
| ) -> PVOID} |
| #[cfg(target_pointer_width = "32")] |
| FN!{stdcall PGET_MODULE_BASE_ROUTINE( |
| hProcess: HANDLE, |
| Address: DWORD, |
| ) -> DWORD} |
| #[cfg(target_pointer_width = "32")] |
| FN!{stdcall PTRANSLATE_ADDRESS_ROUTINE( |
| hProcess: HANDLE, |
| hThread: HANDLE, |
| lpaddr: LPADDRESS, |
| ) -> DWORD} |
| pub const API_VERSION_NUMBER: USHORT = 12; |
| STRUCT!{struct API_VERSION { |
| MajorVersion: USHORT, |
| MinorVersion: USHORT, |
| Revision: USHORT, |
| Reserved: USHORT, |
| }} |
| pub type LPAPI_VERSION = *mut API_VERSION; |
| STRUCT!{struct SYMBOL_INFOW { |
| SizeOfStruct: ULONG, |
| TypeIndex: ULONG, |
| Reserved: [ULONG64; 2], |
| Index: ULONG, |
| Size: ULONG, |
| ModBase: ULONG64, |
| Flags: ULONG, |
| Value: ULONG64, |
| Address: ULONG64, |
| Register: ULONG, |
| Scope: ULONG, |
| Tag: ULONG, |
| NameLen: ULONG, |
| MaxNameLen: ULONG, |
| Name: [WCHAR; 1], |
| }} |
| pub type PSYMBOL_INFOW = *mut SYMBOL_INFOW; |
| ENUM!{enum SYM_TYPE { |
| SymNone = 0, |
| SymCoff, |
| SymCv, |
| SymPdb, |
| SymExport, |
| SymDeferred, |
| SymSym, |
| SymDia, |
| SymVirtual, |
| NumSymTypes, |
| }} |
| STRUCT!{struct IMAGEHLP_SYMBOL64 { |
| SizeOfStruct: DWORD, |
| Address: DWORD64, |
| Size: DWORD, |
| Flags: DWORD, |
| MaxNameLength: DWORD, |
| Name: [CHAR; 1], |
| }} |
| pub type PIMAGEHLP_SYMBOL64 = *mut IMAGEHLP_SYMBOL64; |
| STRUCT!{struct IMAGEHLP_MODULEW64 { |
| SizeOfStruct: DWORD, |
| BaseOfImage: DWORD64, |
| ImageSize: DWORD, |
| TimeDateStamp: DWORD, |
| CheckSum: DWORD, |
| NumSyms: DWORD, |
| SymType: SYM_TYPE, |
| ModuleName: [WCHAR; 32], |
| ImageName: [WCHAR; 256], |
| LoadedImageName: [WCHAR; 256], |
| LoadedPdbName: [WCHAR; 256], |
| CVSig: DWORD, |
| CVData: [WCHAR; MAX_PATH * 3], |
| PdbSig: DWORD, |
| PdbSig70: GUID, |
| PdbAge: DWORD, |
| PdbUnmatched: BOOL, |
| DbgUnmatched: BOOL, |
| LineNumbers: BOOL, |
| GlobalSymbols: BOOL, |
| TypeInfo: BOOL, |
| SourceIndexed: BOOL, |
| Publics: BOOL, |
| MachineType: DWORD, |
| Reserved: DWORD, |
| }} |
| pub type PIMAGEHLP_MODULEW64 = *mut IMAGEHLP_MODULEW64; |
| STRUCT!{struct IMAGEHLP_LINEW64 { |
| SizeOfStruct: DWORD, |
| Key: PVOID, |
| LineNumber: DWORD, |
| FileName: PWSTR, |
| Address: DWORD64, |
| }} |
| pub type PIMAGEHLP_LINEW64 = *mut IMAGEHLP_LINEW64; |
| extern "system" { |
| pub fn EnumDirTree( |
| hProcess: HANDLE, |
| RootPath: PCSTR, |
| InputPathName: PCSTR, |
| OutputPathBuffer: PSTR, |
| cb: PENUMDIRTREE_CALLBACK, |
| data: PVOID, |
| ) -> BOOL; |
| pub fn EnumDirTreeW( |
| hProcess: HANDLE, |
| RootPath: PCWSTR, |
| InputPathName: PCWSTR, |
| OutputPathBuffer: PWSTR, |
| cb: PENUMDIRTREE_CALLBACKW, |
| data: PVOID, |
| ) -> BOOL; |
| pub fn ImagehlpApiVersion() -> LPAPI_VERSION; |
| pub fn ImagehlpApiVersionEx( |
| AppVersion: LPAPI_VERSION, |
| ) -> LPAPI_VERSION; |
| pub fn MakeSureDirectoryPathExists( |
| DirPath: PCSTR, |
| ) -> BOOL; |
| pub fn SearchTreeForFile( |
| RootPath: PCSTR, |
| InputPathName: PCSTR, |
| OutputPathBuffer: PSTR, |
| ) -> BOOL; |
| pub fn SearchTreeForFileW( |
| RootPath: PCWSTR, |
| InputPathName: PCWSTR, |
| OutputPathBuffer: PWSTR, |
| ) -> BOOL; |
| pub fn FindDebugInfoFile( |
| FileName: PCSTR, |
| SymbolPath: PCSTR, |
| DebugFilePath: PSTR, |
| ) -> HANDLE; |
| pub fn FindDebugInfoFileEx( |
| FileName: PCSTR, |
| SymbolPath: PCSTR, |
| DebugFilePath: PSTR, |
| Callback: PFIND_DEBUG_FILE_CALLBACK, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn FindDebugInfoFileExW( |
| FileName: PCWSTR, |
| SymbolPath: PCWSTR, |
| DebugFilePath: PWSTR, |
| Callback: PFIND_DEBUG_FILE_CALLBACKW, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn FindExecutableImage( |
| FileName: PCSTR, |
| SymbolPath: PCSTR, |
| ImageFilePath: PSTR, |
| ) -> HANDLE; |
| pub fn FindExecutableImageEx( |
| FileName: PCSTR, |
| SymbolPath: PCSTR, |
| ImageFilePath: PSTR, |
| Callback: PFIND_EXE_FILE_CALLBACK, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn FindExecutableImageExW( |
| FileName: PCWSTR, |
| SymbolPath: PCWSTR, |
| ImageFilePath: PWSTR, |
| Callback: PFIND_EXE_FILE_CALLBACKW, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn 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, |
| ) -> BOOL; |
| pub fn 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, |
| ) -> BOOL; |
| pub fn 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, |
| ) -> BOOL; |
| pub fn UnDecorateSymbolName( |
| name: PCSTR, |
| outputString: PSTR, |
| maxStringLength: DWORD, |
| flags: DWORD, |
| ) -> DWORD; |
| pub fn UnDecorateSymbolNameW( |
| name: PCWSTR, |
| outputString: PWSTR, |
| maxStringLength: DWORD, |
| flags: DWORD, |
| ) -> DWORD; |
| pub fn GetTimestampForLoadedLibrary( |
| Module: HMODULE, |
| ) -> DWORD; |
| pub fn ImageDirectoryEntryToData( |
| Base: PVOID, |
| MappedAsImage: BOOLEAN, |
| DirectoryEntry: USHORT, |
| Size: PULONG, |
| ) -> PVOID; |
| pub fn ImageDirectoryEntryToDataEx( |
| Base: PVOID, |
| MappedAsImage: BOOLEAN, |
| DirectoryEntry: USHORT, |
| Size: PULONG, |
| FoundHeader: *mut PIMAGE_SECTION_HEADER, |
| ) -> PVOID; |
| pub fn ImageNtHeader( |
| Base: PVOID, |
| ) -> PIMAGE_NT_HEADERS; |
| pub fn ImageRvaToSection( |
| NtHeaders: PIMAGE_NT_HEADERS, |
| Base: PVOID, |
| Rva: ULONG, |
| ) -> PIMAGE_SECTION_HEADER; |
| pub fn ImageRvaToVa( |
| NtHeaders: PIMAGE_NT_HEADERS, |
| Base: PVOID, |
| Rva: ULONG, |
| LastRvaSection: *mut PIMAGE_SECTION_HEADER, |
| ) -> PVOID; |
| } |
| pub const SYMOPT_CASE_INSENSITIVE: DWORD = 0x00000001; |
| pub const SYMOPT_UNDNAME: DWORD = 0x00000002; |
| pub const SYMOPT_DEFERRED_LOADS: DWORD = 0x00000004; |
| pub const SYMOPT_NO_CPP: DWORD = 0x00000008; |
| pub const SYMOPT_LOAD_LINES: DWORD = 0x00000010; |
| pub const SYMOPT_OMAP_FIND_NEAREST: DWORD = 0x00000020; |
| pub const SYMOPT_LOAD_ANYTHING: DWORD = 0x00000040; |
| pub const SYMOPT_IGNORE_CVREC: DWORD = 0x00000080; |
| pub const SYMOPT_NO_UNQUALIFIED_LOADS: DWORD = 0x00000100; |
| pub const SYMOPT_FAIL_CRITICAL_ERRORS: DWORD = 0x00000200; |
| pub const SYMOPT_EXACT_SYMBOLS: DWORD = 0x00000400; |
| pub const SYMOPT_ALLOW_ABSOLUTE_SYMBOLS: DWORD = 0x00000800; |
| pub const SYMOPT_IGNORE_NT_SYMPATH: DWORD = 0x00001000; |
| pub const SYMOPT_INCLUDE_32BIT_MODULES: DWORD = 0x00002000; |
| pub const SYMOPT_PUBLICS_ONLY: DWORD = 0x00004000; |
| pub const SYMOPT_NO_PUBLICS: DWORD = 0x00008000; |
| pub const SYMOPT_AUTO_PUBLICS: DWORD = 0x00010000; |
| pub const SYMOPT_NO_IMAGE_SEARCH: DWORD = 0x00020000; |
| pub const SYMOPT_SECURE: DWORD = 0x00040000; |
| pub const SYMOPT_NO_PROMPTS: DWORD = 0x00080000; |
| pub const SYMOPT_OVERWRITE: DWORD = 0x00100000; |
| pub const SYMOPT_IGNORE_IMAGEDIR: DWORD = 0x00200000; |
| pub const SYMOPT_FLAT_DIRECTORY: DWORD = 0x00400000; |
| pub const SYMOPT_FAVOR_COMPRESSED: DWORD = 0x00800000; |
| pub const SYMOPT_ALLOW_ZERO_ADDRESS: DWORD = 0x01000000; |
| pub const SYMOPT_DISABLE_SYMSRV_AUTODETECT: DWORD = 0x02000000; |
| pub const SYMOPT_READONLY_CACHE: DWORD = 0x04000000; |
| pub const SYMOPT_SYMPATH_LAST: DWORD = 0x08000000; |
| pub const SYMOPT_DISABLE_FAST_SYMBOLS: DWORD = 0x10000000; |
| pub const SYMOPT_DISABLE_SYMSRV_TIMEOUT: DWORD = 0x20000000; |
| pub const SYMOPT_DISABLE_SRVSTAR_ON_STARTUP: DWORD = 0x40000000; |
| pub const SYMOPT_DEBUG: DWORD = 0x80000000; |
| extern "system" { |
| pub fn SymSetOptions( |
| SymOptions: DWORD, |
| ) -> DWORD; |
| pub fn SymGetOptions() -> DWORD; |
| pub fn SymCleanup( |
| hProcess: HANDLE, |
| ) -> BOOL; |
| pub fn SymEnumSymbolsW( |
| hProcess: HANDLE, |
| BaseOfDll: ULONG64, |
| Mask: PCWSTR, |
| EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW, |
| CallerData: PVOID, |
| ) -> BOOL; |
| pub fn SymFindDebugInfoFile( |
| hProcess: HANDLE, |
| FileName: PCSTR, |
| DebugFilePath: PSTR, |
| Callback: PFIND_DEBUG_FILE_CALLBACK, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn SymFindDebugInfoFileW( |
| hProcess: HANDLE, |
| FileName: PCWSTR, |
| DebugFilePath: PWSTR, |
| Callback: PFIND_DEBUG_FILE_CALLBACKW, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn SymFindExecutableImage( |
| hProcess: HANDLE, |
| FileName: PCSTR, |
| ImageFilePath: PSTR, |
| Callback: PFIND_EXE_FILE_CALLBACK, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn SymFindExecutableImageW( |
| hProcess: HANDLE, |
| FileName: PCWSTR, |
| ImageFilePath: PWSTR, |
| Callback: PFIND_EXE_FILE_CALLBACKW, |
| CallerData: PVOID, |
| ) -> HANDLE; |
| pub fn SymFindFileInPath( |
| hprocess: HANDLE, |
| SearchPath: PCSTR, |
| FileName: PCSTR, |
| id: PVOID, |
| two: DWORD, |
| three: DWORD, |
| flags: DWORD, |
| FoundFile: PSTR, |
| callback: PFINDFILEINPATHCALLBACK, |
| context: PVOID, |
| ) -> BOOL; |
| pub fn SymFindFileInPathW( |
| hprocess: HANDLE, |
| SearchPath: PCWSTR, |
| FileName: PCWSTR, |
| id: PVOID, |
| two: DWORD, |
| three: DWORD, |
| flags: DWORD, |
| FoundFile: PWSTR, |
| callback: PFINDFILEINPATHCALLBACKW, |
| context: PVOID, |
| ) -> BOOL; |
| pub fn SymFromAddrW( |
| hProcess: HANDLE, |
| Address: DWORD64, |
| Displacement: PDWORD64, |
| Symbol: PSYMBOL_INFOW, |
| ) -> BOOL; |
| pub fn SymFromNameW( |
| hProcess: HANDLE, |
| Name: PCWSTR, |
| Symbol: PSYMBOL_INFOW, |
| ) -> BOOL; |
| pub fn SymFunctionTableAccess64( |
| hProcess: HANDLE, |
| AddrBase: DWORD64, |
| ) -> PVOID; |
| pub fn SymGetLineFromAddrW64( |
| hProcess: HANDLE, |
| dwAddr: DWORD64, |
| pdwDisplacement: PDWORD, |
| Line: PIMAGEHLP_LINEW64, |
| ) -> BOOL; |
| pub fn SymGetModuleInfoW64( |
| hProcess: HANDLE, |
| qwAddr: DWORD64, |
| ModuleInfo: PIMAGEHLP_MODULEW64, |
| ) -> BOOL; |
| pub fn SymGetModuleBase64( |
| hProcess: HANDLE, |
| AddrBase: DWORD64, |
| ) -> DWORD64; |
| pub fn SymGetSymFromAddr64( |
| hProcess: HANDLE, |
| Address: DWORD64, |
| Displacement: PDWORD64, |
| Symbol: PIMAGEHLP_SYMBOL64, |
| ) -> BOOL; |
| pub fn SymInitializeW( |
| hProcess: HANDLE, |
| UserSearchPath: PCWSTR, |
| fInvadeProcess: BOOL, |
| ) -> BOOL; |
| pub fn SymLoadModuleExW( |
| hProcess: HANDLE, |
| hFile: HANDLE, |
| ImageName: PCWSTR, |
| ModuleName: PCWSTR, |
| BaseOfDll: DWORD64, |
| SizeOfDll: DWORD, |
| Data: PMODLOAD_DATA, |
| Flags: DWORD, |
| ) -> DWORD64; |
| pub fn SymUnloadModule( |
| hProcess: HANDLE, |
| BaseOfDll: DWORD, |
| ) -> BOOL; |
| pub fn SymUnloadModule64( |
| hProcess: HANDLE, |
| BaseOfDll: DWORD64, |
| ) -> BOOL; |
| #[cfg(target_pointer_width = "32")] |
| pub fn MapDebugInformation( |
| FileHandle: HANDLE, |
| FileName: PCSTR, |
| SymbolPath: PCSTR, |
| ImageBase: ULONG, |
| ) -> PIMAGE_DEBUG_INFORMATION; |
| #[cfg(target_pointer_width = "32")] |
| pub fn UnmapDebugInformation( |
| DebugInfo: PIMAGE_DEBUG_INFORMATION, |
| ) -> BOOL; |
| } |