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