Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 750 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/dbghelp.rs b/vendor/winapi/src/um/dbghelp.rs
new file mode 100644
index 000000000..ddcfbb92d
--- /dev/null
+++ b/vendor/winapi/src/um/dbghelp.rs
@@ -0,0 +1,750 @@
+// 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;
+}