vendor/winapi/src/um/dbghelp.rs

   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" {
 393     pub fn EnumDirTree(
 394         hProcess: HANDLE,
 395         RootPath: PCSTR,
 396         InputPathName: PCSTR,
 397         OutputPathBuffer: PSTR,
 398         cb: PENUMDIRTREE_CALLBACK,
 399         data: PVOID,
 400     ) -> BOOL;
 401     pub fn EnumDirTreeW(
 402         hProcess: HANDLE,
 403         RootPath: PCWSTR,
 404         InputPathName: PCWSTR,
 405         OutputPathBuffer: PWSTR,
 406         cb: PENUMDIRTREE_CALLBACKW,
 407         data: PVOID,
 408     ) -> BOOL;
 409     pub fn ImagehlpApiVersion() -> LPAPI_VERSION;
 410     pub fn ImagehlpApiVersionEx(
 411         AppVersion: LPAPI_VERSION,
 412     ) -> LPAPI_VERSION;
 413     pub fn MakeSureDirectoryPathExists(
 414         DirPath: PCSTR,
 415     ) -> BOOL;
 416     pub fn SearchTreeForFile(
 417         RootPath: PCSTR,
 418         InputPathName: PCSTR,
 419         OutputPathBuffer: PSTR,
 420     ) -> BOOL;
 421     pub fn SearchTreeForFileW(
 422         RootPath: PCWSTR,
 423         InputPathName: PCWSTR,
 424         OutputPathBuffer: PWSTR,
 425     ) -> BOOL;
 426     pub fn FindDebugInfoFile(
 427         FileName: PCSTR,
 428         SymbolPath: PCSTR,
 429         DebugFilePath: PSTR,
 430     ) -> HANDLE;
 431     pub fn FindDebugInfoFileEx(
 432         FileName: PCSTR,
 433         SymbolPath: PCSTR,
 434         DebugFilePath: PSTR,
 435         Callback: PFIND_DEBUG_FILE_CALLBACK,
 436         CallerData: PVOID,
 437     ) -> HANDLE;
 438     pub fn FindDebugInfoFileExW(
 439         FileName: PCWSTR,
 440         SymbolPath: PCWSTR,
 441         DebugFilePath: PWSTR,
 442         Callback: PFIND_DEBUG_FILE_CALLBACKW,
 443         CallerData: PVOID,
 444     ) -> HANDLE;
 445     pub fn FindExecutableImage(
 446         FileName: PCSTR,
 447         SymbolPath: PCSTR,
 448         ImageFilePath: PSTR,
 449     ) -> HANDLE;
 450     pub fn FindExecutableImageEx(
 451         FileName: PCSTR,
 452         SymbolPath: PCSTR,
 453         ImageFilePath: PSTR,
 454         Callback: PFIND_EXE_FILE_CALLBACK,
 455         CallerData: PVOID,
 456     ) -> HANDLE;
 457     pub fn FindExecutableImageExW(
 458         FileName: PCWSTR,
 459         SymbolPath: PCWSTR,
 460         ImageFilePath: PWSTR,
 461         Callback: PFIND_EXE_FILE_CALLBACKW,
 462         CallerData: PVOID,
 463     ) -> HANDLE;
 464     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;
 475     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;
 487     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;
 498     pub fn UnDecorateSymbolName(
 499         name: PCSTR,
 500         outputString: PSTR,
 501         maxStringLength: DWORD,
 502         flags: DWORD,
 503     ) -> DWORD;
 504     pub fn UnDecorateSymbolNameW(
 505         name: PCWSTR,
 506         outputString: PWSTR,
 507         maxStringLength: DWORD,
 508         flags: DWORD,
 509     ) -> DWORD;
 510     pub fn GetTimestampForLoadedLibrary(
 511         Module: HMODULE,
 512     ) -> DWORD;
 513     pub fn ImageDirectoryEntryToData(
 514         Base: PVOID,
 515         MappedAsImage: BOOLEAN,
 516         DirectoryEntry: USHORT,
 517         Size: PULONG,
 518     ) -> PVOID;
 519     pub fn ImageDirectoryEntryToDataEx(
 520         Base: PVOID,
 521         MappedAsImage: BOOLEAN,
 522         DirectoryEntry: USHORT,
 523         Size: PULONG,
 524         FoundHeader: *mut PIMAGE_SECTION_HEADER,
 525     ) -> PVOID;
 526     pub fn ImageNtHeader(
 527         Base: PVOID,
 528     ) -> PIMAGE_NT_HEADERS;
 529     pub fn ImageRvaToSection(
 530         NtHeaders: PIMAGE_NT_HEADERS,
 531         Base: PVOID,
 532         Rva: ULONG,
 533     ) -> PIMAGE_SECTION_HEADER;
 534     pub fn ImageRvaToVa(
 535         NtHeaders: PIMAGE_NT_HEADERS,
 536         Base: PVOID,
 537         Rva: ULONG,
 538         LastRvaSection: *mut PIMAGE_SECTION_HEADER,
 539     ) -> PVOID;
 540     pub fn SymCleanup(
 541         hProcess: HANDLE,
 542     ) -> BOOL;
 543     pub fn SymEnumSymbolsW(
 544         hProcess: HANDLE,
 545         BaseOfDll: ULONG64,
 546         Mask: PCWSTR,
 547         EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACKW,
 548         CallerData: PVOID,
 549     ) -> BOOL;
 550     pub fn SymFindDebugInfoFile(
 551         hProcess: HANDLE,
 552         FileName: PCSTR,
 553         DebugFilePath: PSTR,
 554         Callback: PFIND_DEBUG_FILE_CALLBACK,
 555         CallerData: PVOID,
 556     ) -> HANDLE;
 557     pub fn SymFindDebugInfoFileW(
 558         hProcess: HANDLE,
 559         FileName: PCWSTR,
 560         DebugFilePath: PWSTR,
 561         Callback: PFIND_DEBUG_FILE_CALLBACKW,
 562         CallerData: PVOID,
 563     ) -> HANDLE;
 564     pub fn SymFindExecutableImage(
 565         hProcess: HANDLE,
 566         FileName: PCSTR,
 567         ImageFilePath: PSTR,
 568         Callback: PFIND_EXE_FILE_CALLBACK,
 569         CallerData: PVOID,
 570     ) -> HANDLE;
 571     pub fn SymFindExecutableImageW(
 572         hProcess: HANDLE,
 573         FileName: PCWSTR,
 574         ImageFilePath: PWSTR,
 575         Callback: PFIND_EXE_FILE_CALLBACKW,
 576         CallerData: PVOID,
 577     ) -> HANDLE;
 578     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;
 590     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;
 602     pub fn SymFromAddrW(
 603         hProcess: HANDLE,
 604         Address: DWORD64,
 605         Displacement: PDWORD64,
 606         Symbol: PSYMBOL_INFOW,
 607     ) -> BOOL;
 608     pub fn SymFromNameW(
 609         hProcess: HANDLE,
 610         Name: PCWSTR,
 611         Symbol: PSYMBOL_INFOW,
 612     ) -> BOOL;
 613     pub fn SymFunctionTableAccess64(
 614         hProcess: HANDLE,
 615         AddrBase: DWORD64,
 616     ) -> PVOID;
 617     pub fn SymGetLineFromAddrW64(
 618         hProcess: HANDLE,
 619         dwAddr: DWORD64,
 620         pdwDisplacement: PDWORD,
 621         Line: PIMAGEHLP_LINEW64,
 622     ) -> BOOL;
 623     pub fn SymGetModuleBase64(
 624         hProcess: HANDLE,
 625         AddrBase: DWORD64,
 626     ) -> DWORD64;
 627     pub fn SymGetSymFromAddr64(
 628         hProcess: HANDLE,
 629         Address: DWORD64,
 630         Displacement: PDWORD64,
 631         Symbol: PIMAGEHLP_SYMBOL64,
 632     ) -> BOOL;
 633     pub fn SymInitializeW(
 634         hProcess: HANDLE,
 635         UserSearchPath: PCWSTR,
 636         fInvadeProcess: BOOL,
 637     ) -> BOOL;
 638     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;
 648     pub fn SymUnloadModule(
 649         hProcess: HANDLE,
 650         BaseOfDll: DWORD,
 651     ) -> BOOL;
 652     pub fn SymUnloadModule64(
 653         hProcess: HANDLE,
 654         BaseOfDll: DWORD64,
 655     ) -> BOOL;
 656     #[cfg(target_pointer_width = "32")]
 657     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")]
 664     pub fn UnmapDebugInformation(
 665         DebugInfo: PIMAGE_DEBUG_INFORMATION,
 666     ) -> BOOL;
 667 }