home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / dbghelp.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  42KB  |  1,492 lines
  1. /*++ BUILD Version: 0001     Increment this if a change has global effects
  2.  
  3. Copyright (c) 1990-1999  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     dbghelp.h
  8.  
  9. Abstract:
  10.  
  11.     This module defines the prototypes and constants required for the image
  12.     help routines.
  13.  
  14.     Contains debugging support routines that are redistributable.
  15.  
  16. Revision History:
  17.  
  18. --*/
  19.  
  20. #ifndef _DBGHELP_
  21. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  22. #define _DBGHELP_
  23.  
  24. #if _MSC_VER > 1020
  25. #pragma once
  26. #endif
  27.  
  28.  
  29. #ifdef _WIN64
  30. #ifndef _IMAGEHLP64
  31. #define _IMAGEHLP64
  32. #endif
  33. #endif
  34.  
  35.  
  36. #ifdef __cplusplus
  37. extern "C" {
  38. #endif
  39.  
  40. #ifdef _IMAGEHLP_SOURCE_
  41. #define IMAGEAPI __stdcall
  42. #else
  43. #define IMAGEAPI DECLSPEC_IMPORT __stdcall
  44. #endif
  45.  
  46. #define IMAGE_SEPARATION (64*1024)
  47.  
  48. typedef struct _LOADED_IMAGE {
  49.     PSTR                  ModuleName;
  50.     HANDLE                hFile;
  51.     PUCHAR                MappedAddress;
  52. #ifdef _IMAGEHLP64
  53.     PIMAGE_NT_HEADERS64   FileHeader;
  54. #else
  55.     PIMAGE_NT_HEADERS32   FileHeader;
  56. #endif
  57.     PIMAGE_SECTION_HEADER LastRvaSection;
  58.     ULONG                 NumberOfSections;
  59.     PIMAGE_SECTION_HEADER Sections;
  60.     ULONG                 Characteristics;
  61.     BOOLEAN               fSystemImage;
  62.     BOOLEAN               fDOSImage;
  63.     LIST_ENTRY            Links;
  64.     ULONG                 SizeOfImage;
  65. } LOADED_IMAGE, *PLOADED_IMAGE;
  66.  
  67.  
  68.  
  69. HANDLE
  70. IMAGEAPI
  71. FindDebugInfoFile (
  72.     PSTR FileName,
  73.     PSTR SymbolPath,
  74.     PSTR DebugFilePath
  75.     );
  76.  
  77. typedef BOOL
  78. (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(
  79.     HANDLE FileHandle,
  80.     PSTR FileName,
  81.     PVOID CallerData
  82.     );
  83.  
  84. HANDLE
  85. IMAGEAPI
  86. FindDebugInfoFileEx (
  87.     PSTR FileName,
  88.     PSTR SymbolPath,
  89.     PSTR DebugFilePath,
  90.     PFIND_DEBUG_FILE_CALLBACK Callback,
  91.     PVOID CallerData
  92.     );
  93.  
  94. HANDLE
  95. IMAGEAPI
  96. FindExecutableImage(
  97.     PSTR FileName,
  98.     PSTR SymbolPath,
  99.     PSTR ImageFilePath
  100.     );
  101.  
  102. PIMAGE_NT_HEADERS
  103. IMAGEAPI
  104. ImageNtHeader (
  105.     IN PVOID Base
  106.     );
  107.  
  108. PVOID
  109. IMAGEAPI
  110. ImageDirectoryEntryToDataEx (
  111.     IN PVOID Base,
  112.     IN BOOLEAN MappedAsImage,
  113.     IN USHORT DirectoryEntry,
  114.     OUT PULONG Size,
  115.     OUT PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL
  116.     );
  117.  
  118. PVOID
  119. IMAGEAPI
  120. ImageDirectoryEntryToData (
  121.     IN PVOID Base,
  122.     IN BOOLEAN MappedAsImage,
  123.     IN USHORT DirectoryEntry,
  124.     OUT PULONG Size
  125.     );
  126.  
  127. PIMAGE_SECTION_HEADER
  128. IMAGEAPI
  129. ImageRvaToSection(
  130.     IN PIMAGE_NT_HEADERS NtHeaders,
  131.     IN PVOID Base,
  132.     IN ULONG Rva
  133.     );
  134.  
  135. PVOID
  136. IMAGEAPI
  137. ImageRvaToVa(
  138.     IN PIMAGE_NT_HEADERS NtHeaders,
  139.     IN PVOID Base,
  140.     IN ULONG Rva,
  141.     IN OUT PIMAGE_SECTION_HEADER *LastRvaSection
  142.     );
  143.  
  144. // Symbol server export
  145.  
  146. typedef BOOL (*PSYMBOLSERVERPROC)(LPCSTR, LPCSTR, DWORD, DWORD, DWORD, LPSTR);
  147. typedef BOOL (*PSYMBOLSERVEROPENPROC)(VOID);
  148. typedef BOOL (*PSYMBOLSERVERCLOSEPROC)(VOID);
  149.  
  150. #ifndef _WIN64
  151. // This api won't be ported to Win64 - Fix your code.
  152.  
  153. typedef struct _IMAGE_DEBUG_INFORMATION {
  154.     LIST_ENTRY List;
  155.     DWORD ReservedSize;
  156.     PVOID ReservedMappedBase;
  157.     USHORT ReservedMachine;
  158.     USHORT ReservedCharacteristics;
  159.     DWORD ReservedCheckSum;
  160.     DWORD ImageBase;
  161.     DWORD SizeOfImage;
  162.  
  163.     DWORD ReservedNumberOfSections;
  164.     PIMAGE_SECTION_HEADER ReservedSections;
  165.  
  166.     DWORD ReservedExportedNamesSize;
  167.     PSTR ReservedExportedNames;
  168.  
  169.     DWORD ReservedNumberOfFunctionTableEntries;
  170.     PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
  171.     DWORD ReservedLowestFunctionStartingAddress;
  172.     DWORD ReservedHighestFunctionEndingAddress;
  173.  
  174.     DWORD ReservedNumberOfFpoTableEntries;
  175.     PFPO_DATA ReservedFpoTableEntries;
  176.  
  177.     DWORD SizeOfCoffSymbols;
  178.     PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
  179.  
  180.     DWORD ReservedSizeOfCodeViewSymbols;
  181.     PVOID ReservedCodeViewSymbols;
  182.  
  183.     PSTR ImageFilePath;
  184.     PSTR ImageFileName;
  185.     PSTR ReservedDebugFilePath;
  186.  
  187.     DWORD ReservedTimeDateStamp;
  188.  
  189.     BOOL  ReservedRomImage;
  190.     PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
  191.     DWORD ReservedNumberOfDebugDirectories;
  192.  
  193.     DWORD ReservedOriginalFunctionTableBaseAddress;
  194.  
  195.     DWORD Reserved[ 2 ];
  196.  
  197. } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
  198.  
  199.  
  200. PIMAGE_DEBUG_INFORMATION
  201. IMAGEAPI
  202. MapDebugInformation(
  203.     HANDLE FileHandle,
  204.     PSTR FileName,
  205.     PSTR SymbolPath,
  206.     DWORD ImageBase
  207.     );
  208.  
  209. BOOL
  210. IMAGEAPI
  211. UnmapDebugInformation(
  212.     PIMAGE_DEBUG_INFORMATION DebugInfo
  213.     );
  214.  
  215. #endif
  216.  
  217. BOOL
  218. IMAGEAPI
  219. SearchTreeForFile(
  220.     PSTR RootPath,
  221.     PSTR InputPathName,
  222.     PSTR OutputPathBuffer
  223.     );
  224.  
  225. BOOL
  226. IMAGEAPI
  227. MakeSureDirectoryPathExists(
  228.     PCSTR DirPath
  229.     );
  230.  
  231. //
  232. // UnDecorateSymbolName Flags
  233. //
  234.  
  235. #define UNDNAME_COMPLETE                 (0x0000)  // Enable full undecoration
  236. #define UNDNAME_NO_LEADING_UNDERSCORES   (0x0001)  // Remove leading underscores from MS extended keywords
  237. #define UNDNAME_NO_MS_KEYWORDS           (0x0002)  // Disable expansion of MS extended keywords
  238. #define UNDNAME_NO_FUNCTION_RETURNS      (0x0004)  // Disable expansion of return type for primary declaration
  239. #define UNDNAME_NO_ALLOCATION_MODEL      (0x0008)  // Disable expansion of the declaration model
  240. #define UNDNAME_NO_ALLOCATION_LANGUAGE   (0x0010)  // Disable expansion of the declaration language specifier
  241. #define UNDNAME_NO_MS_THISTYPE           (0x0020)  // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
  242. #define UNDNAME_NO_CV_THISTYPE           (0x0040)  // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
  243. #define UNDNAME_NO_THISTYPE              (0x0060)  // Disable all modifiers on the 'this' type
  244. #define UNDNAME_NO_ACCESS_SPECIFIERS     (0x0080)  // Disable expansion of access specifiers for members
  245. #define UNDNAME_NO_THROW_SIGNATURES      (0x0100)  // Disable expansion of 'throw-signatures' for functions and pointers to functions
  246. #define UNDNAME_NO_MEMBER_TYPE           (0x0200)  // Disable expansion of 'static' or 'virtual'ness of members
  247. #define UNDNAME_NO_RETURN_UDT_MODEL      (0x0400)  // Disable expansion of MS model for UDT returns
  248. #define UNDNAME_32_BIT_DECODE            (0x0800)  // Undecorate 32-bit decorated names
  249. #define UNDNAME_NAME_ONLY                (0x1000)  // Crack only the name for primary declaration;
  250.                                                                                                    //  return just [scope::]name.  Does expand template params
  251. #define UNDNAME_NO_ARGUMENTS             (0x2000)  // Don't undecorate arguments to function
  252. #define UNDNAME_NO_SPECIAL_SYMS          (0x4000)  // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
  253.  
  254. DWORD
  255. IMAGEAPI
  256. WINAPI
  257. UnDecorateSymbolName(
  258.     PCSTR   DecoratedName,         // Name to undecorate
  259.     PSTR    UnDecoratedName,       // If NULL, it will be allocated
  260.     DWORD    UndecoratedLength,     // The maximym length
  261.     DWORD    Flags                  // See above.
  262.     );
  263.  
  264. //
  265. // StackWalking API
  266. //
  267.  
  268. typedef enum {
  269.     AddrMode1616,
  270.     AddrMode1632,
  271.     AddrModeReal,
  272.     AddrModeFlat
  273. } ADDRESS_MODE;
  274.  
  275. typedef struct _tagADDRESS64 {
  276.     DWORD64       Offset;
  277.     WORD          Segment;
  278.     ADDRESS_MODE  Mode;
  279. } ADDRESS64, *LPADDRESS64;
  280.  
  281. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  282. #define ADDRESS ADDRESS64
  283. #define LPADDRESS LPADDRESS64
  284. #else
  285. typedef struct _tagADDRESS {
  286.     DWORD         Offset;
  287.     WORD          Segment;
  288.     ADDRESS_MODE  Mode;
  289. } ADDRESS, *LPADDRESS;
  290.  
  291. __inline
  292. void
  293. Address32To64(
  294.     LPADDRESS a32,
  295.     LPADDRESS64 a64
  296.     )
  297. {
  298.     a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
  299.     a64->Segment = a32->Segment;
  300.     a64->Mode = a32->Mode;
  301. }
  302.  
  303. __inline
  304. void
  305. Address64To32(
  306.     LPADDRESS64 a64,
  307.     LPADDRESS a32
  308.     )
  309. {
  310.     a32->Offset = (ULONG)a64->Offset;
  311.     a32->Segment = a64->Segment;
  312.     a32->Mode = a64->Mode;
  313. }
  314. #endif
  315.  
  316. //
  317. // This structure is included in the STACKFRAME structure,
  318. // and is used to trace through usermode callbacks in a thread's
  319. // kernel stack.  The values must be copied by the kernel debugger
  320. // from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
  321. //
  322.  
  323. //
  324. // New KDHELP structure for 64 bit system support.
  325. // This structure is preferred in new code.
  326. //
  327. typedef struct _KDHELP64 {
  328.  
  329.     //
  330.     // address of kernel thread object, as provided in the
  331.     // WAIT_STATE_CHANGE packet.
  332.     //
  333.     DWORD64   Thread;
  334.  
  335.     //
  336.     // offset in thread object to pointer to the current callback frame
  337.     // in kernel stack.
  338.     //
  339.     DWORD   ThCallbackStack;
  340.  
  341.     //
  342.     // offset in thread object to pointer to the current callback backing
  343.     // store frame in kernel stack.
  344.     //
  345.     DWORD   ThCallbackBStore;
  346.  
  347.     //
  348.     // offsets to values in frame:
  349.     //
  350.     // address of next callback frame
  351.     DWORD   NextCallback;
  352.  
  353.     // address of saved frame pointer (if applicable)
  354.     DWORD   FramePointer;
  355.  
  356.  
  357.     //
  358.     // Address of the kernel function that calls out to user mode
  359.     //
  360.     DWORD64   KiCallUserMode;
  361.  
  362.     //
  363.     // Address of the user mode dispatcher function
  364.     //
  365.     DWORD64   KeUserCallbackDispatcher;
  366.  
  367.     //
  368.     // Lowest kernel mode address
  369.     //
  370.     DWORD64   SystemRangeStart;
  371.  
  372.     DWORD64  Reserved[8];
  373.  
  374. } KDHELP64, *PKDHELP64;
  375.  
  376. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  377. #define KDHELP KDHELP64
  378. #define PKDHELP PKDHELP64
  379. #else
  380. typedef struct _KDHELP {
  381.  
  382.     //
  383.     // address of kernel thread object, as provided in the
  384.     // WAIT_STATE_CHANGE packet.
  385.     //
  386.     DWORD   Thread;
  387.  
  388.     //
  389.     // offset in thread object to pointer to the current callback frame
  390.     // in kernel stack.
  391.     //
  392.     DWORD   ThCallbackStack;
  393.  
  394.     //
  395.     // offsets to values in frame:
  396.     //
  397.     // address of next callback frame
  398.     DWORD   NextCallback;
  399.  
  400.     // address of saved frame pointer (if applicable)
  401.     DWORD   FramePointer;
  402.  
  403.     //
  404.     // Address of the kernel function that calls out to user mode
  405.     //
  406.     DWORD   KiCallUserMode;
  407.  
  408.     //
  409.     // Address of the user mode dispatcher function
  410.     //
  411.     DWORD   KeUserCallbackDispatcher;
  412.  
  413.     //
  414.     // Lowest kernel mode address
  415.     //
  416.     DWORD   SystemRangeStart;
  417.  
  418.     //
  419.     // offset in thread object to pointer to the current callback backing
  420.     // store frame in kernel stack.
  421.     //
  422.     DWORD   ThCallbackBStore;
  423.  
  424.     DWORD  Reserved[8];
  425.  
  426. } KDHELP, *PKDHELP;
  427.  
  428. __inline
  429. void
  430. KdHelp32To64(
  431.     PKDHELP p32,
  432.     PKDHELP64 p64
  433.     )
  434. {
  435.     p64->Thread = p32->Thread;
  436.     p64->ThCallbackStack = p32->ThCallbackStack;
  437.     p64->NextCallback = p32->NextCallback;
  438.     p64->FramePointer = p32->FramePointer;
  439.     p64->KiCallUserMode = p32->KiCallUserMode;
  440.     p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
  441.     p64->SystemRangeStart = p32->SystemRangeStart;
  442. }
  443. #endif
  444.  
  445. typedef struct _tagSTACKFRAME64 {
  446.     ADDRESS64   AddrPC;               // program counter
  447.     ADDRESS64   AddrReturn;           // return address
  448.     ADDRESS64   AddrFrame;            // frame pointer
  449.     ADDRESS64   AddrStack;            // stack pointer
  450.     ADDRESS64   AddrBStore;           // backing store pointer
  451.     PVOID       FuncTableEntry;       // pointer to pdata/fpo or NULL
  452.     DWORD64     Params[4];            // possible arguments to the function
  453.     BOOL        Far;                  // WOW far call
  454.     BOOL        Virtual;              // is this a virtual frame?
  455.     DWORD64     Reserved[3];
  456.     KDHELP64    KdHelp;
  457. } STACKFRAME64, *LPSTACKFRAME64;
  458.  
  459. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  460. #define STACKFRAME STACKFRAME64
  461. #define LPSTACKFRAME LPSTACKFRAME64
  462. #else
  463. typedef struct _tagSTACKFRAME {
  464.     ADDRESS     AddrPC;               // program counter
  465.     ADDRESS     AddrReturn;           // return address
  466.     ADDRESS     AddrFrame;            // frame pointer
  467.     ADDRESS     AddrStack;            // stack pointer
  468.     PVOID       FuncTableEntry;       // pointer to pdata/fpo or NULL
  469.     DWORD       Params[4];            // possible arguments to the function
  470.     BOOL        Far;                  // WOW far call
  471.     BOOL        Virtual;              // is this a virtual frame?
  472.     DWORD       Reserved[3];
  473.     KDHELP      KdHelp;
  474.     ADDRESS     AddrBStore;           // backing store pointer
  475. } STACKFRAME, *LPSTACKFRAME;
  476. #endif
  477.  
  478.  
  479. typedef
  480. BOOL
  481. (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(
  482.     HANDLE      hProcess,
  483.     DWORD64     qwBaseAddress,
  484.     PVOID       lpBuffer,
  485.     DWORD       nSize,
  486.     LPDWORD     lpNumberOfBytesRead
  487.     );
  488.  
  489. typedef
  490. PVOID
  491. (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)(
  492.     HANDLE  hProcess,
  493.     DWORD64 AddrBase
  494.     );
  495.  
  496. typedef
  497. DWORD64
  498. (__stdcall *PGET_MODULE_BASE_ROUTINE64)(
  499.     HANDLE  hProcess,
  500.     DWORD64 Address
  501.     );
  502.  
  503. typedef
  504. DWORD64
  505. (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(
  506.     HANDLE    hProcess,
  507.     HANDLE    hThread,
  508.     LPADDRESS64 lpaddr
  509.     );
  510.  
  511. BOOL
  512. IMAGEAPI
  513. StackWalk64(
  514.     DWORD                             MachineType,
  515.     HANDLE                            hProcess,
  516.     HANDLE                            hThread,
  517.     LPSTACKFRAME64                    StackFrame,
  518.     PVOID                             ContextRecord,
  519.     PREAD_PROCESS_MEMORY_ROUTINE64    ReadMemoryRoutine,
  520.     PFUNCTION_TABLE_ACCESS_ROUTINE64  FunctionTableAccessRoutine,
  521.     PGET_MODULE_BASE_ROUTINE64        GetModuleBaseRoutine,
  522.     PTRANSLATE_ADDRESS_ROUTINE64      TranslateAddress
  523.     );
  524.  
  525. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  526.  
  527. #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
  528. #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
  529. #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
  530. #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
  531.  
  532. #define StackWalk StackWalk64
  533.  
  534. #else
  535.  
  536. typedef
  537. BOOL
  538. (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE)(
  539.     HANDLE  hProcess,
  540.     DWORD   lpBaseAddress,
  541.     PVOID   lpBuffer,
  542.     DWORD   nSize,
  543.     PDWORD  lpNumberOfBytesRead
  544.     );
  545.  
  546. typedef
  547. PVOID
  548. (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)(
  549.     HANDLE  hProcess,
  550.     DWORD   AddrBase
  551.     );
  552.  
  553. typedef
  554. DWORD
  555. (__stdcall *PGET_MODULE_BASE_ROUTINE)(
  556.     HANDLE  hProcess,
  557.     DWORD   Address
  558.     );
  559.  
  560. typedef
  561. DWORD
  562. (__stdcall *PTRANSLATE_ADDRESS_ROUTINE)(
  563.     HANDLE    hProcess,
  564.     HANDLE    hThread,
  565.     LPADDRESS lpaddr
  566.     );
  567.  
  568. BOOL
  569. IMAGEAPI
  570. StackWalk(
  571.     DWORD                             MachineType,
  572.     HANDLE                            hProcess,
  573.     HANDLE                            hThread,
  574.     LPSTACKFRAME                      StackFrame,
  575.     PVOID                             ContextRecord,
  576.     PREAD_PROCESS_MEMORY_ROUTINE      ReadMemoryRoutine,
  577.     PFUNCTION_TABLE_ACCESS_ROUTINE    FunctionTableAccessRoutine,
  578.     PGET_MODULE_BASE_ROUTINE          GetModuleBaseRoutine,
  579.     PTRANSLATE_ADDRESS_ROUTINE        TranslateAddress
  580.     );
  581.  
  582. #endif
  583.  
  584.  
  585. #define API_VERSION_NUMBER 9
  586.  
  587. typedef struct API_VERSION {
  588.     USHORT  MajorVersion;
  589.     USHORT  MinorVersion;
  590.     USHORT  Revision;
  591.     USHORT  Reserved;
  592. } API_VERSION, *LPAPI_VERSION;
  593.  
  594. LPAPI_VERSION
  595. IMAGEAPI
  596. ImagehlpApiVersion(
  597.     VOID
  598.     );
  599.  
  600. LPAPI_VERSION
  601. IMAGEAPI
  602. ImagehlpApiVersionEx(
  603.     LPAPI_VERSION AppVersion
  604.     );
  605.  
  606. DWORD
  607. IMAGEAPI
  608. GetTimestampForLoadedLibrary(
  609.     HMODULE Module
  610.     );
  611.  
  612. //
  613. // typedefs for function pointers
  614. //
  615. typedef BOOL
  616. (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(
  617.     PSTR ModuleName,
  618.     DWORD64 BaseOfDll,
  619.     PVOID UserContext
  620.     );
  621.  
  622. typedef BOOL
  623. (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(
  624.     PSTR SymbolName,
  625.     DWORD64 SymbolAddress,
  626.     ULONG SymbolSize,
  627.     PVOID UserContext
  628.     );
  629.  
  630. typedef BOOL
  631. (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(
  632.     PWSTR SymbolName,
  633.     DWORD64 SymbolAddress,
  634.     ULONG SymbolSize,
  635.     PVOID UserContext
  636.     );
  637.  
  638. typedef BOOL
  639. (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(
  640.     PSTR ModuleName,
  641.     DWORD64 ModuleBase,
  642.     ULONG ModuleSize,
  643.     PVOID UserContext
  644.     );
  645.  
  646. typedef BOOL
  647. (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(
  648.     HANDLE  hProcess,
  649.     ULONG   ActionCode,
  650.     ULONG64 CallbackData,
  651.     ULONG64 UserContext
  652.     );
  653.  
  654. typedef
  655. PVOID
  656. (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(
  657.     HANDLE  hProcess,
  658.     DWORD   AddrBase,
  659.     PVOID   UserContext
  660.     );
  661.  
  662. typedef
  663. PVOID
  664. (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(
  665.     HANDLE  hProcess,
  666.     ULONG64 AddrBase,
  667.     ULONG64 UserContext
  668.     );
  669.  
  670. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  671.  
  672. #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
  673. #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
  674. #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
  675. #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
  676. #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
  677. #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
  678.  
  679. #else
  680.  
  681. typedef BOOL
  682. (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(
  683.     PSTR  ModuleName,
  684.     ULONG BaseOfDll,
  685.     PVOID UserContext
  686.     );
  687.  
  688. typedef BOOL
  689. (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(
  690.     PSTR  SymbolName,
  691.     ULONG SymbolAddress,
  692.     ULONG SymbolSize,
  693.     PVOID UserContext
  694.     );
  695.  
  696. typedef BOOL
  697. (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(
  698.     PWSTR  SymbolName,
  699.     ULONG SymbolAddress,
  700.     ULONG SymbolSize,
  701.     PVOID UserContext
  702.     );
  703.  
  704. typedef BOOL
  705. (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(
  706.     PSTR  ModuleName,
  707.     ULONG ModuleBase,
  708.     ULONG ModuleSize,
  709.     PVOID UserContext
  710.     );
  711.  
  712. typedef BOOL
  713. (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(
  714.     HANDLE  hProcess,
  715.     ULONG   ActionCode,
  716.     PVOID   CallbackData,
  717.     PVOID   UserContext
  718.     );
  719.  
  720. #endif
  721.  
  722.  
  723. //
  724. // symbol flags
  725. //
  726.  
  727. #define SYMF_OMAP_GENERATED   0x00000001
  728. #define SYMF_OMAP_MODIFIED    0x00000002
  729.  
  730. //
  731. // symbol type enumeration
  732. //
  733. typedef enum {
  734.     SymNone,
  735.     SymCoff,
  736.     SymCv,
  737.     SymPdb,
  738.     SymExport,
  739.     SymDeferred,
  740.     SymSym                  // .sym file
  741. } SYM_TYPE;
  742.  
  743. //
  744. // symbol data structure
  745. //
  746.  
  747. typedef struct _IMAGEHLP_SYMBOL64 {
  748.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOL64)
  749.     DWORD64                     Address;                // virtual address including dll base address
  750.     DWORD                       Size;                   // estimated size of symbol, can be zero
  751.     DWORD                       Flags;                  // info about the symbols, see the SYMF defines
  752.     DWORD                       MaxNameLength;          // maximum size of symbol name in 'Name'
  753.     CHAR                        Name[1];                // symbol name (null terminated string)
  754. } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
  755.  
  756. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  757. #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
  758. #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
  759. #else
  760. typedef struct _IMAGEHLP_SYMBOL {
  761.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOL)
  762.     DWORD                       Address;                // virtual address including dll base address
  763.     DWORD                       Size;                   // estimated size of symbol, can be zero
  764.     DWORD                       Flags;                  // info about the symbols, see the SYMF defines
  765.     DWORD                       MaxNameLength;          // maximum size of symbol name in 'Name'
  766.     CHAR                        Name[1];                // symbol name (null terminated string)
  767. } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
  768. #endif
  769.  
  770. //
  771. // module data structure
  772. //
  773.  
  774. typedef struct _IMAGEHLP_MODULE64 {
  775.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
  776.     DWORD64                     BaseOfImage;            // base load address of module
  777.     DWORD                       ImageSize;              // virtual size of the loaded module
  778.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  779.     DWORD                       CheckSum;               // checksum from the pe header
  780.     DWORD                       NumSyms;                // number of symbols in the symbol table
  781.     SYM_TYPE                    SymType;                // type of symbols loaded
  782.     CHAR                        ModuleName[32];         // module name
  783.     CHAR                        ImageName[256];         // image name
  784.     CHAR                        LoadedImageName[256];   // symbol file name
  785. } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
  786.  
  787. typedef struct _IMAGEHLP_MODULE64W {
  788.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
  789.     DWORD64                     BaseOfImage;            // base load address of module
  790.     DWORD                       ImageSize;              // virtual size of the loaded module
  791.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  792.     DWORD                       CheckSum;               // checksum from the pe header
  793.     DWORD                       NumSyms;                // number of symbols in the symbol table
  794.     SYM_TYPE                    SymType;                // type of symbols loaded
  795.     WCHAR                       ModuleName[32];         // module name
  796.     WCHAR                       ImageName[256];         // image name
  797.     WCHAR                       LoadedImageName[256];   // symbol file name
  798. } IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
  799.  
  800. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  801. #define IMAGEHLP_MODULE IMAGEHLP_MODULE64
  802. #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
  803. #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
  804. #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
  805. #else
  806. typedef struct _IMAGEHLP_MODULE {
  807.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE)
  808.     DWORD                       BaseOfImage;            // base load address of module
  809.     DWORD                       ImageSize;              // virtual size of the loaded module
  810.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  811.     DWORD                       CheckSum;               // checksum from the pe header
  812.     DWORD                       NumSyms;                // number of symbols in the symbol table
  813.     SYM_TYPE                    SymType;                // type of symbols loaded
  814.     CHAR                        ModuleName[32];         // module name
  815.     CHAR                        ImageName[256];         // image name
  816.     CHAR                        LoadedImageName[256];   // symbol file name
  817. } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
  818.  
  819. typedef struct _IMAGEHLP_MODULEW {
  820.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE)
  821.     DWORD                       BaseOfImage;            // base load address of module
  822.     DWORD                       ImageSize;              // virtual size of the loaded module
  823.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  824.     DWORD                       CheckSum;               // checksum from the pe header
  825.     DWORD                       NumSyms;                // number of symbols in the symbol table
  826.     SYM_TYPE                    SymType;                // type of symbols loaded
  827.     WCHAR                       ModuleName[32];         // module name
  828.     WCHAR                       ImageName[256];         // image name
  829.     WCHAR                       LoadedImageName[256];   // symbol file name
  830. } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
  831. #endif
  832.  
  833. //
  834. // source file line data structure
  835. //
  836.  
  837. typedef struct _IMAGEHLP_LINE64 {
  838.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE64)
  839.     PVOID                       Key;                    // internal
  840.     DWORD                       LineNumber;             // line number in file
  841.     PCHAR                       FileName;               // full filename
  842.     DWORD64                     Address;                // first instruction of line
  843. } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
  844.  
  845. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  846. #define IMAGEHLP_LINE IMAGEHLP_LINE64
  847. #define PIMAGEHLP_LINE PIMAGEHLP_LINE64
  848. #else
  849. typedef struct _IMAGEHLP_LINE {
  850.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE)
  851.     PVOID                       Key;                    // internal
  852.     DWORD                       LineNumber;             // line number in file
  853.     PCHAR                       FileName;               // full filename
  854.     DWORD                       Address;                // first instruction of line
  855. } IMAGEHLP_LINE, *PIMAGEHLP_LINE;
  856. #endif
  857.  
  858. //
  859. // data structures used for registered symbol callbacks
  860. //
  861.  
  862. #define CBA_DEFERRED_SYMBOL_LOAD_START          0x00000001
  863. #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE       0x00000002
  864. #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE        0x00000003
  865. #define CBA_SYMBOLS_UNLOADED                    0x00000004
  866. #define CBA_DUPLICATE_SYMBOL                    0x00000005
  867. #define CBA_READ_MEMORY                         0x00000006
  868. #define CBA_DEBUG_INFO                          0x10000000
  869.  
  870. typedef struct _IMAGEHLP_CBA_READ_MEMORY {
  871.     DWORD64   addr;                                     // address to read from
  872.     PVOID     buf;                                      // buffer to read to
  873.     DWORD     bytes;                                    // amount of bytes to read
  874.     DWORD    *bytesread;                                // pointer to store amount of bytes read
  875. } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
  876.  
  877. typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
  878.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
  879.     DWORD64                     BaseOfImage;            // base load address of module
  880.     DWORD                       CheckSum;               // checksum from the pe header
  881.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  882.     CHAR                        FileName[MAX_PATH];     // symbols file or image name
  883.     BOOLEAN                     Reparse;                // load failure reparse
  884. } IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
  885.  
  886. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  887. #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
  888. #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
  889. #else
  890. typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
  891.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
  892.     DWORD                       BaseOfImage;            // base load address of module
  893.     DWORD                       CheckSum;               // checksum from the pe header
  894.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  895.     CHAR                        FileName[MAX_PATH];     // symbols file or image name
  896.     BOOLEAN                     Reparse;                // load failure reparse
  897. } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
  898. #endif
  899.  
  900. typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
  901.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
  902.     DWORD                       NumberOfDups;           // number of duplicates in the Symbol array
  903.     PIMAGEHLP_SYMBOL64          Symbol;                 // array of duplicate symbols
  904.     DWORD                       SelectedSymbol;         // symbol selected (-1 to start)
  905. } IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
  906.  
  907. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  908. #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
  909. #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
  910. #else
  911. typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
  912.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
  913.     DWORD                       NumberOfDups;           // number of duplicates in the Symbol array
  914.     PIMAGEHLP_SYMBOL            Symbol;                 // array of duplicate symbols
  915.     DWORD                       SelectedSymbol;         // symbol selected (-1 to start)
  916. } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
  917. #endif
  918.  
  919.  
  920. //
  921. // options that are set/returned by SymSetOptions() & SymGetOptions()
  922. // these are used as a mask
  923. //
  924. #define SYMOPT_CASE_INSENSITIVE  0x00000001
  925. #define SYMOPT_UNDNAME           0x00000002
  926. #define SYMOPT_DEFERRED_LOADS    0x00000004
  927. #define SYMOPT_NO_CPP            0x00000008
  928. #define SYMOPT_LOAD_LINES        0x00000010
  929. #define SYMOPT_OMAP_FIND_NEAREST 0x00000020
  930. #define SYMOPT_DEBUG             0x80000000
  931.  
  932.  
  933. DWORD
  934. IMAGEAPI
  935. SymSetOptions(
  936.     IN DWORD   SymOptions
  937.     );
  938.  
  939. DWORD
  940. IMAGEAPI
  941. SymGetOptions(
  942.     VOID
  943.     );
  944.  
  945. BOOL
  946. IMAGEAPI
  947. SymCleanup(
  948.     IN HANDLE hProcess
  949.     );
  950.  
  951. BOOL
  952. IMAGEAPI
  953. SymEnumerateModules64(
  954.     IN HANDLE                       hProcess,
  955.     IN PSYM_ENUMMODULES_CALLBACK64  EnumModulesCallback,
  956.     IN PVOID                        UserContext
  957.     );
  958.  
  959. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  960. #define SymEnumerateModules SymEnumerateModules64
  961. #else
  962. BOOL
  963. IMAGEAPI
  964. SymEnumerateModules(
  965.     IN HANDLE                     hProcess,
  966.     IN PSYM_ENUMMODULES_CALLBACK  EnumModulesCallback,
  967.     IN PVOID                      UserContext
  968.     );
  969. #endif
  970.  
  971. BOOL
  972. IMAGEAPI
  973. SymEnumerateSymbols64(
  974.     IN HANDLE                       hProcess,
  975.     IN DWORD64                      BaseOfDll,
  976.     IN PSYM_ENUMSYMBOLS_CALLBACK64  EnumSymbolsCallback,
  977.     IN PVOID                        UserContext
  978.     );
  979.  
  980. BOOL
  981. IMAGEAPI
  982. SymEnumerateSymbolsW64(
  983.     IN HANDLE                       hProcess,
  984.     IN DWORD64                      BaseOfDll,
  985.     IN PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,
  986.     IN PVOID                        UserContext
  987.     );
  988.  
  989. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  990. #define SymEnumerateSymbols SymEnumerateSymbols64
  991. #define SymEnumerateSymbolsW SymEnumerateSymbolsW64
  992. #else
  993. BOOL
  994. IMAGEAPI
  995. SymEnumerateSymbols(
  996.     IN HANDLE                     hProcess,
  997.     IN DWORD                      BaseOfDll,
  998.     IN PSYM_ENUMSYMBOLS_CALLBACK  EnumSymbolsCallback,
  999.     IN PVOID                      UserContext
  1000.     );
  1001.  
  1002. BOOL
  1003. IMAGEAPI
  1004. SymEnumerateSymbolsW(
  1005.     IN HANDLE                       hProcess,
  1006.     IN DWORD                        BaseOfDll,
  1007.     IN PSYM_ENUMSYMBOLS_CALLBACKW   EnumSymbolsCallback,
  1008.     IN PVOID                        UserContext
  1009.     );
  1010. #endif
  1011.  
  1012. BOOL
  1013. IMAGEAPI
  1014. EnumerateLoadedModules64(
  1015.     IN HANDLE                           hProcess,
  1016.     IN PENUMLOADED_MODULES_CALLBACK64   EnumLoadedModulesCallback,
  1017.     IN PVOID                            UserContext
  1018.     );
  1019.  
  1020. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1021. #define EnumerateLoadedModules EnumerateLoadedModules64
  1022. #else
  1023. BOOL
  1024. IMAGEAPI
  1025. EnumerateLoadedModules(
  1026.     IN HANDLE                         hProcess,
  1027.     IN PENUMLOADED_MODULES_CALLBACK   EnumLoadedModulesCallback,
  1028.     IN PVOID                          UserContext
  1029.     );
  1030. #endif
  1031.  
  1032. PVOID
  1033. IMAGEAPI
  1034. SymFunctionTableAccess64(
  1035.     HANDLE  hProcess,
  1036.     DWORD64 AddrBase
  1037.     );
  1038.  
  1039. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1040. #define SymFunctionTableAccess SymFunctionTableAccess64
  1041. #else
  1042. PVOID
  1043. IMAGEAPI
  1044. SymFunctionTableAccess(
  1045.     HANDLE  hProcess,
  1046.     DWORD   AddrBase
  1047.     );
  1048. #endif
  1049.  
  1050. BOOL
  1051. IMAGEAPI
  1052. SymGetModuleInfo64(
  1053.     IN  HANDLE                  hProcess,
  1054.     IN  DWORD64                 qwAddr,
  1055.     OUT PIMAGEHLP_MODULE64      ModuleInfo
  1056.     );
  1057.  
  1058. BOOL
  1059. IMAGEAPI
  1060. SymGetModuleInfoW64(
  1061.     IN  HANDLE                  hProcess,
  1062.     IN  DWORD64                 qwAddr,
  1063.     OUT PIMAGEHLP_MODULEW64     ModuleInfo
  1064.     );
  1065.  
  1066. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1067. #define SymGetModuleInfo   SymGetModuleInfo64
  1068. #define SymGetModuleInfoW  SymGetModuleInfoW64
  1069. #else
  1070. BOOL
  1071. IMAGEAPI
  1072. SymGetModuleInfo(
  1073.     IN  HANDLE              hProcess,
  1074.     IN  DWORD               dwAddr,
  1075.     OUT PIMAGEHLP_MODULE  ModuleInfo
  1076.     );
  1077.  
  1078. BOOL
  1079. IMAGEAPI
  1080. SymGetModuleInfoW(
  1081.     IN  HANDLE              hProcess,
  1082.     IN  DWORD               dwAddr,
  1083.     OUT PIMAGEHLP_MODULEW  ModuleInfo
  1084.     );
  1085. #endif
  1086.  
  1087. DWORD64
  1088. IMAGEAPI
  1089. SymGetModuleBase64(
  1090.     IN  HANDLE              hProcess,
  1091.     IN  DWORD64             qwAddr
  1092.     );
  1093.  
  1094. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1095. #define SymGetModuleBase SymGetModuleBase64
  1096. #else
  1097. DWORD
  1098. IMAGEAPI
  1099. SymGetModuleBase(
  1100.     IN  HANDLE              hProcess,
  1101.     IN  DWORD               dwAddr
  1102.     );
  1103. #endif
  1104.  
  1105. BOOL
  1106. IMAGEAPI
  1107. SymGetSymFromAddr64(
  1108.     IN  HANDLE              hProcess,
  1109.     IN  DWORD64             qwAddr,
  1110.     OUT PDWORD64            pdwDisplacement,
  1111.     OUT PIMAGEHLP_SYMBOL64  Symbol
  1112.     );
  1113.  
  1114. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1115. #define SymGetSymFromAddr SymGetSymFromAddr64
  1116. #else
  1117. BOOL
  1118. IMAGEAPI
  1119. SymGetSymFromAddr(
  1120.     IN  HANDLE            hProcess,
  1121.     IN  DWORD             dwAddr,
  1122.     OUT PDWORD            pdwDisplacement,
  1123.     OUT PIMAGEHLP_SYMBOL  Symbol
  1124.     );
  1125. #endif
  1126.  
  1127. BOOL
  1128. IMAGEAPI
  1129. SymGetSymFromName64(
  1130.     IN  HANDLE              hProcess,
  1131.     IN  PSTR                Name,
  1132.     OUT PIMAGEHLP_SYMBOL64  Symbol
  1133.     );
  1134.  
  1135. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1136. #define SymGetSymFromName SymGetSymFromName64
  1137. #else
  1138. BOOL
  1139. IMAGEAPI
  1140. SymGetSymFromName(
  1141.     IN  HANDLE            hProcess,
  1142.     IN  PSTR              Name,
  1143.     OUT PIMAGEHLP_SYMBOL  Symbol
  1144.     );
  1145. #endif
  1146.  
  1147. BOOL
  1148. IMAGEAPI
  1149. SymGetSymNext64(
  1150.     IN     HANDLE              hProcess,
  1151.     IN OUT PIMAGEHLP_SYMBOL64  Symbol
  1152.     );
  1153.  
  1154. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1155. #define SymGetSymNext SymGetSymNext64
  1156. #else
  1157. BOOL
  1158. IMAGEAPI
  1159. SymGetSymNext(
  1160.     IN     HANDLE            hProcess,
  1161.     IN OUT PIMAGEHLP_SYMBOL  Symbol
  1162.     );
  1163. #endif
  1164.  
  1165. BOOL
  1166. IMAGEAPI
  1167. SymGetSymPrev64(
  1168.     IN     HANDLE              hProcess,
  1169.     IN OUT PIMAGEHLP_SYMBOL64  Symbol
  1170.     );
  1171.  
  1172. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1173. #define SymGetSymPrev SymGetSymPrev64
  1174. #else
  1175. BOOL
  1176. IMAGEAPI
  1177. SymGetSymPrev(
  1178.     IN     HANDLE            hProcess,
  1179.     IN OUT PIMAGEHLP_SYMBOL  Symbol
  1180.     );
  1181. #endif
  1182.  
  1183. BOOL
  1184. IMAGEAPI
  1185. SymGetLineFromAddr64(
  1186.     IN  HANDLE                  hProcess,
  1187.     IN  DWORD64                 qwAddr,
  1188.     OUT PDWORD                  pdwDisplacement,
  1189.     OUT PIMAGEHLP_LINE64        Line
  1190.     );
  1191.  
  1192. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1193. #define SymGetLineFromAddr SymGetLineFromAddr64
  1194. #else
  1195. BOOL
  1196. IMAGEAPI
  1197. SymGetLineFromAddr(
  1198.     IN  HANDLE                hProcess,
  1199.     IN  DWORD                 dwAddr,
  1200.     OUT PDWORD                pdwDisplacement,
  1201.     OUT PIMAGEHLP_LINE        Line
  1202.     );
  1203. #endif
  1204.  
  1205. BOOL
  1206. IMAGEAPI
  1207. SymGetLineFromName64(
  1208.     IN     HANDLE               hProcess,
  1209.     IN     PSTR                 ModuleName,
  1210.     IN     PSTR                 FileName,
  1211.     IN     DWORD                dwLineNumber,
  1212.        OUT PLONG                plDisplacement,
  1213.     IN OUT PIMAGEHLP_LINE64     Line
  1214.     );
  1215.  
  1216. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1217. #define SymGetLineFromName SymGetLineFromName64
  1218. #else
  1219. BOOL
  1220. IMAGEAPI
  1221. SymGetLineFromName(
  1222.     IN     HANDLE             hProcess,
  1223.     IN     PSTR               ModuleName,
  1224.     IN     PSTR               FileName,
  1225.     IN     DWORD              dwLineNumber,
  1226.        OUT PLONG              plDisplacement,
  1227.     IN OUT PIMAGEHLP_LINE     Line
  1228.     );
  1229. #endif
  1230.  
  1231. BOOL
  1232. IMAGEAPI
  1233. SymGetLineNext64(
  1234.     IN     HANDLE               hProcess,
  1235.     IN OUT PIMAGEHLP_LINE64     Line
  1236.     );
  1237.  
  1238. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1239. #define SymGetLineNext SymGetLineNext64
  1240. #else
  1241. BOOL
  1242. IMAGEAPI
  1243. SymGetLineNext(
  1244.     IN     HANDLE             hProcess,
  1245.     IN OUT PIMAGEHLP_LINE     Line
  1246.     );
  1247. #endif
  1248.  
  1249. BOOL
  1250. IMAGEAPI
  1251. SymGetLinePrev64(
  1252.     IN     HANDLE               hProcess,
  1253.     IN OUT PIMAGEHLP_LINE64     Line
  1254.     );
  1255.  
  1256. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1257. #define SymGetLinePrev SymGetLinePrev64
  1258. #else
  1259. BOOL
  1260. IMAGEAPI
  1261. SymGetLinePrev(
  1262.     IN     HANDLE             hProcess,
  1263.     IN OUT PIMAGEHLP_LINE     Line
  1264.     );
  1265. #endif
  1266.  
  1267. BOOL
  1268. IMAGEAPI
  1269. SymMatchFileName(
  1270.     IN  PSTR  FileName,
  1271.     IN  PSTR  Match,
  1272.     OUT PSTR *FileNameStop,
  1273.     OUT PSTR *MatchStop
  1274.     );
  1275.  
  1276. BOOL
  1277. IMAGEAPI
  1278. SymInitialize(
  1279.     IN HANDLE   hProcess,
  1280.     IN PSTR     UserSearchPath,
  1281.     IN BOOL     fInvadeProcess
  1282.     );
  1283.  
  1284. BOOL
  1285. IMAGEAPI
  1286. SymGetSearchPath(
  1287.     IN  HANDLE          hProcess,
  1288.     OUT PSTR            SearchPath,
  1289.     IN  DWORD           SearchPathLength
  1290.     );
  1291.  
  1292. BOOL
  1293. IMAGEAPI
  1294. SymSetSearchPath(
  1295.     IN HANDLE           hProcess,
  1296.     IN PSTR             SearchPath
  1297.     );
  1298.  
  1299. DWORD64
  1300. IMAGEAPI
  1301. SymLoadModule64(
  1302.     IN  HANDLE          hProcess,
  1303.     IN  HANDLE          hFile,
  1304.     IN  PSTR            ImageName,
  1305.     IN  PSTR            ModuleName,
  1306.     IN  DWORD64         BaseOfDll,
  1307.     IN  DWORD           SizeOfDll
  1308.     );
  1309.  
  1310. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1311. #define SymLoadModule SymLoadModule64
  1312. #else
  1313. DWORD
  1314. IMAGEAPI
  1315. SymLoadModule(
  1316.     IN  HANDLE          hProcess,
  1317.     IN  HANDLE          hFile,
  1318.     IN  PSTR            ImageName,
  1319.     IN  PSTR            ModuleName,
  1320.     IN  DWORD           BaseOfDll,
  1321.     IN  DWORD           SizeOfDll
  1322.     );
  1323. #endif
  1324.  
  1325. BOOL
  1326. IMAGEAPI
  1327. SymUnloadModule64(
  1328.     IN  HANDLE          hProcess,
  1329.     IN  DWORD64         BaseOfDll
  1330.     );
  1331.  
  1332. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1333. #define SymUnloadModule SymUnloadModule64
  1334. #else
  1335. BOOL
  1336. IMAGEAPI
  1337. SymUnloadModule(
  1338.     IN  HANDLE          hProcess,
  1339.     IN  DWORD           BaseOfDll
  1340.     );
  1341. #endif
  1342.  
  1343. BOOL
  1344. IMAGEAPI
  1345. SymUnDName64(
  1346.     IN  PIMAGEHLP_SYMBOL64 sym,               // Symbol to undecorate
  1347.     OUT PSTR               UnDecName,         // Buffer to store undecorated name in
  1348.     IN  DWORD              UnDecNameLength    // Size of the buffer
  1349.     );
  1350.  
  1351. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1352. #define SymUnDName SymUnDName64
  1353. #else
  1354. BOOL
  1355. IMAGEAPI
  1356. SymUnDName(
  1357.     IN  PIMAGEHLP_SYMBOL sym,               // Symbol to undecorate
  1358.     OUT PSTR             UnDecName,         // Buffer to store undecorated name in
  1359.     IN  DWORD            UnDecNameLength    // Size of the buffer
  1360.     );
  1361. #endif
  1362.  
  1363. BOOL
  1364. IMAGEAPI
  1365. SymRegisterCallback64(
  1366.     IN HANDLE                        hProcess,
  1367.     IN PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
  1368.     IN ULONG64                       UserContext
  1369.     );
  1370.  
  1371. BOOL
  1372. IMAGEAPI
  1373. SymRegisterFunctionEntryCallback64(
  1374.     IN HANDLE                       hProcess,
  1375.     IN PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,
  1376.     IN ULONG64                      UserContext
  1377.     );
  1378.  
  1379. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1380. #define SymRegisterCallback SymRegisterCallback64
  1381. #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
  1382. #else
  1383. BOOL
  1384. IMAGEAPI
  1385. SymRegisterCallback(
  1386.     IN HANDLE                      hProcess,
  1387.     IN PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
  1388.     IN PVOID                       UserContext
  1389.     );
  1390.  
  1391. BOOL
  1392. IMAGEAPI
  1393. SymRegisterFunctionEntryCallback(
  1394.     IN HANDLE                     hProcess,
  1395.     IN PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,
  1396.     IN PVOID                      UserContext
  1397.     );
  1398. #endif
  1399.  
  1400. #ifdef __cplusplus
  1401. }
  1402. #endif
  1403.  
  1404. // Structure types
  1405. typedef enum IMAGEHLP_TYPES {
  1406.    IMAGEHLP_TYPEID_INDEX = 1,
  1407.    IMAGEHLP_TYPEID_NAME,
  1408.    IMAGEHLP_TYPEID_IMAGEHLP_SYMBOL,
  1409.    IMAGEHLP_TYPEID_IMAGEHLP_SYMBOL64,
  1410.    IMAGEHLP_TYPEID_MODULE_TYPE_INFO,
  1411.    IMAGEHLP_TYPEID_TYPE_ENUM_INFO, 
  1412. } IMAGEHLP_TYPES;
  1413.  
  1414. typedef struct _MODULE_TYPE_INFO { // AKA TYPTYP 
  1415.     USHORT      dataLength;        
  1416.     USHORT      leaf;
  1417.     BYTE        data[1];
  1418. } MODULE_TYPE_INFO, *PMODULE_TYPE_INFO;
  1419.  
  1420. typedef BOOL
  1421. (CALLBACK *PSYMBOL_TYPE_NAME_CALLBACK)(
  1422.     PSTR  MatchedName,
  1423.     ULONG typeIndex,
  1424.     PVOID CallerData
  1425.     );
  1426.  
  1427. typedef struct _TYPE_ENUM_INFO {
  1428.    PVOID   CallerData;
  1429.    PSYMBOL_TYPE_NAME_CALLBACK CallbackRoutine;
  1430. } TYPE_ENUM_INFO, *PTYPE_ENUM_INFO;
  1431.  
  1432.  
  1433.  
  1434. BOOL
  1435. IMAGEAPI
  1436. SymGetModuleInfoEx64(
  1437.     IN  HANDLE          hProcess,
  1438.     IN  DWORD64         Address,
  1439.     IN  IMAGEHLP_TYPES  TypeIn,
  1440.     IN  PBYTE           DataIn,
  1441.     IN  IMAGEHLP_TYPES  TypeOut,
  1442.     IN  OUT PULONG      SizeOut,
  1443.     IN  OUT PBYTE       DataOut
  1444.     );
  1445. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1446. #define SymGetModuleInfoEx SymGetModuleInfoEx64
  1447. #else
  1448. BOOL
  1449. IMAGEAPI
  1450. SymGetModuleInfoEx(
  1451.     IN  HANDLE          hProcess,
  1452.     IN  DWORD           Address,
  1453.     IN  IMAGEHLP_TYPES  TypeIn,
  1454.     IN  PBYTE           DataIn,
  1455.     IN  IMAGEHLP_TYPES  TypeOut,
  1456.     IN  OUT PULONG      SizeOut,
  1457.     IN  OUT PBYTE       DataOut
  1458.     );
  1459. #endif
  1460.  
  1461. BOOL 
  1462. IMAGEAPI
  1463. SymGetSymbolInfo64(
  1464.     IN  HANDLE          hProcess,
  1465.     IN  DWORD64         Address,
  1466.     IN  IMAGEHLP_TYPES  TypeIn,
  1467.     IN  PBYTE           DataIn,
  1468.     IN  IMAGEHLP_TYPES  TypeOut,
  1469.     IN  OUT PULONG      SizeOut,
  1470.     IN  OUT PBYTE       DataOut
  1471.     );
  1472.  
  1473. #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  1474. #define SymGetSymbolInfo SymGetSymbolInfo64
  1475. #else
  1476. BOOL 
  1477. IMAGEAPI
  1478. SymGetSymbolInfo(
  1479.     IN  HANDLE          hProcess,
  1480.     IN  DWORD           Address,
  1481.     IN  IMAGEHLP_TYPES  TypeIn,
  1482.     IN  PBYTE           DataIn,
  1483.     IN  IMAGEHLP_TYPES  TypeOut,
  1484.     IN  PULONG          SizeOut,
  1485.     IN  OUT PBYTE       DataOut
  1486.     );
  1487. #endif
  1488.    
  1489.  
  1490. #pragma option pop /*P_O_Pop*/
  1491. #endif // _DGGHELP_
  1492.