Source code
Revision control
Copy as Markdown
Other Tools
// Licensed under the Apache License, Version 2.0
// 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;
}