home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / imagehlp.h < prev    next >
C/C++ Source or Header  |  1998-04-25  |  26KB  |  1,012 lines

  1. /*++ BUILD Version: 0001     Increment this if a change has global effects
  2.  
  3. Copyright 1993 - 1998 Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     imagehlp.h
  8.  
  9. Abstract:
  10.  
  11.     This module defines the prptotypes and constants required for the image
  12.     help routines.
  13.  
  14. Revision History:
  15.  
  16. --*/
  17.  
  18. #ifndef _IMAGEHLP_
  19. #define _IMAGEHLP_
  20.  
  21. #ifdef __cplusplus
  22. extern "C" {
  23. #endif
  24.  
  25. //
  26. // Define checksum return codes.
  27. //
  28.  
  29. #define CHECKSUM_SUCCESS            0
  30. #define CHECKSUM_OPEN_FAILURE       1
  31. #define CHECKSUM_MAP_FAILURE        2
  32. #define CHECKSUM_MAPVIEW_FAILURE    3
  33. #define CHECKSUM_UNICODE_FAILURE    4
  34.  
  35. // Define Splitsym flags.
  36.  
  37. #define SPLITSYM_REMOVE_PRIVATE     0x00000001      // Remove CV types/symbols and Fixup debug
  38.                                                     //  Used for creating .dbg files that ship
  39.                                                     //  as part of the product.
  40.  
  41. #define SPLITSYM_EXTRACT_ALL        0x00000002      // Extract all debug info from image.
  42.                                                     //  Normally, FPO is left in the image
  43.                                                     //  to allow stack traces through the code.
  44.                                                     //  Using this switch is similar to linking
  45.                                                     //  with -debug:none except the .dbg file
  46.                                                     //  exists...
  47.  
  48. #define SPLITSYM_SYMBOLPATH_IS_SRC  0x00000004      // The SymbolFilePath contains an alternate
  49.                                                     //  path to locate the pdb.
  50.  
  51.  
  52. #ifdef _IMAGEHLP_SOURCE_
  53. #define IMAGEAPI __stdcall
  54. #else
  55. #define IMAGEAPI DECLSPEC_IMPORT __stdcall
  56. #endif
  57.  
  58. //
  59. // Define checksum function prototypes.
  60. //
  61.  
  62. PIMAGE_NT_HEADERS
  63. IMAGEAPI
  64. CheckSumMappedFile (
  65.     LPVOID BaseAddress,
  66.     DWORD FileLength,
  67.     LPDWORD HeaderSum,
  68.     LPDWORD CheckSum
  69.     );
  70.  
  71. DWORD
  72. IMAGEAPI
  73. MapFileAndCheckSumA (
  74.     LPSTR Filename,
  75.     LPDWORD HeaderSum,
  76.     LPDWORD CheckSum
  77.     );
  78.  
  79. DWORD
  80. IMAGEAPI
  81. MapFileAndCheckSumW (
  82.     PWSTR Filename,
  83.     LPDWORD HeaderSum,
  84.     LPDWORD CheckSum
  85.     );
  86.  
  87. #ifdef UNICODE
  88. #define MapFileAndCheckSum  MapFileAndCheckSumW
  89. #else
  90. #define MapFileAndCheckSum  MapFileAndCheckSumA
  91. #endif // !UNICODE
  92.  
  93.  
  94. BOOL
  95. IMAGEAPI
  96. TouchFileTimes (
  97.     HANDLE FileHandle,
  98.     LPSYSTEMTIME lpSystemTime
  99.     );
  100.  
  101. BOOL
  102. IMAGEAPI
  103. SplitSymbols (
  104.     LPSTR ImageName,
  105.     LPSTR SymbolsPath,
  106.     LPSTR SymbolFilePath,
  107.     DWORD Flags                 // Combination of flags above
  108.     );
  109.  
  110. HANDLE
  111. IMAGEAPI
  112. FindDebugInfoFile (
  113.     LPSTR FileName,
  114.     LPSTR SymbolPath,
  115.     LPSTR DebugFilePath
  116.     );
  117.  
  118. HANDLE
  119. IMAGEAPI
  120. FindExecutableImage(
  121.     LPSTR FileName,
  122.     LPSTR SymbolPath,
  123.     LPSTR ImageFilePath
  124.     );
  125.  
  126. BOOL
  127. IMAGEAPI
  128. UpdateDebugInfoFile(
  129.     LPSTR ImageFileName,
  130.     LPSTR SymbolPath,
  131.     LPSTR DebugFilePath,
  132.     PIMAGE_NT_HEADERS NtHeaders
  133.     );
  134.  
  135. BOOL
  136. IMAGEAPI
  137. UpdateDebugInfoFileEx(
  138.     LPSTR ImageFileName,
  139.     LPSTR SymbolPath,
  140.     LPSTR DebugFilePath,
  141.     PIMAGE_NT_HEADERS NtHeaders,
  142.     DWORD OldChecksum
  143.     );
  144.  
  145. BOOL
  146. IMAGEAPI
  147. BindImage(
  148.     IN LPSTR ImageName,
  149.     IN LPSTR DllPath,
  150.     IN LPSTR SymbolPath
  151.     );
  152.  
  153. typedef enum _IMAGEHLP_STATUS_REASON {
  154.     BindOutOfMemory,
  155.     BindRvaToVaFailed,
  156.     BindNoRoomInImage,
  157.     BindImportModuleFailed,
  158.     BindImportProcedureFailed,
  159.     BindImportModule,
  160.     BindImportProcedure,
  161.     BindForwarder,
  162.     BindForwarderNOT,
  163.     BindImageModified,
  164.     BindExpandFileHeaders,
  165.     BindImageComplete,
  166.     BindMismatchedSymbols,
  167.     BindSymbolsNotUpdated
  168. } IMAGEHLP_STATUS_REASON;
  169.  
  170. typedef
  171. BOOL
  172. (__stdcall *PIMAGEHLP_STATUS_ROUTINE)(
  173.     IMAGEHLP_STATUS_REASON Reason,
  174.     LPSTR ImageName,
  175.     LPSTR DllName,
  176.     ULONG Va,
  177.     ULONG Parameter
  178.     );
  179.  
  180.  
  181. BOOL
  182. IMAGEAPI
  183. BindImageEx(
  184.     IN DWORD Flags,
  185.     IN LPSTR ImageName,
  186.     IN LPSTR DllPath,
  187.     IN LPSTR SymbolPath,
  188.     IN PIMAGEHLP_STATUS_ROUTINE StatusRoutine
  189.     );
  190.  
  191. #define BIND_NO_BOUND_IMPORTS  0x00000001
  192. #define BIND_NO_UPDATE         0x00000002
  193. #define BIND_ALL_IMAGES        0x00000004
  194. #define BIND_CACHE_IMPORT_DLLS 0x00000008       // Cache dll's across
  195.                                                 //  calls to BindImageEx
  196.                                                 //  (same as NT 3.1->NT 4.0)
  197.  
  198. BOOL
  199. IMAGEAPI
  200. ReBaseImage(
  201.     IN     LPSTR CurrentImageName,
  202.     IN     LPSTR SymbolPath,
  203.     IN     BOOL  fReBase,          // TRUE if actually rebasing, false if only summing
  204.     IN     BOOL  fRebaseSysfileOk, // TRUE is system images s/b rebased
  205.     IN     BOOL  fGoingDown,       // TRUE if the image s/b rebased below the given base
  206.     IN     ULONG CheckImageSize,   // Max size allowed  (0 if don't care)
  207.     OUT    ULONG *OldImageSize,    // Returned from the header
  208.     OUT    ULONG *OldImageBase,    // Returned from the header
  209.     OUT    ULONG *NewImageSize,    // Image size rounded to next separation boundary
  210.     IN OUT ULONG *NewImageBase,    // (in) Desired new address.
  211.                                    // (out) Next address (actual if going down)
  212.     IN     ULONG TimeStamp         // new timestamp for image, if non-zero
  213.     );
  214.  
  215. #define IMAGE_SEPARATION (64*1024)
  216.  
  217.  
  218. typedef struct _LOADED_IMAGE {
  219.     LPSTR                 ModuleName;
  220.     HANDLE                hFile;
  221.     PUCHAR                MappedAddress;
  222.     PIMAGE_NT_HEADERS     FileHeader;
  223.     PIMAGE_SECTION_HEADER LastRvaSection;
  224.     ULONG                 NumberOfSections;
  225.     PIMAGE_SECTION_HEADER Sections;
  226.     ULONG                 Characteristics;
  227.     BOOLEAN               fSystemImage;
  228.     BOOLEAN               fDOSImage;
  229.     LIST_ENTRY            Links;
  230.     ULONG                 SizeOfImage;
  231. } LOADED_IMAGE, *PLOADED_IMAGE;
  232.  
  233.  
  234. PLOADED_IMAGE
  235. IMAGEAPI
  236. ImageLoad(
  237.     LPSTR DllName,
  238.     LPSTR DllPath
  239.     );
  240.  
  241. BOOL
  242. IMAGEAPI
  243. ImageUnload(
  244.     PLOADED_IMAGE LoadedImage
  245.     );
  246.  
  247. PIMAGE_NT_HEADERS
  248. IMAGEAPI
  249. ImageNtHeader (
  250.     IN PVOID Base
  251.     );
  252.  
  253. PVOID
  254. IMAGEAPI
  255. ImageDirectoryEntryToData (
  256.     IN PVOID Base,
  257.     IN BOOLEAN MappedAsImage,
  258.     IN USHORT DirectoryEntry,
  259.     OUT PULONG Size
  260.     );
  261.  
  262. PIMAGE_SECTION_HEADER
  263. IMAGEAPI
  264. ImageRvaToSection(
  265.     IN PIMAGE_NT_HEADERS NtHeaders,
  266.     IN PVOID Base,
  267.     IN ULONG Rva
  268.     );
  269.  
  270. PVOID
  271. IMAGEAPI
  272. ImageRvaToVa(
  273.     IN PIMAGE_NT_HEADERS NtHeaders,
  274.     IN PVOID Base,
  275.     IN ULONG Rva,
  276.     IN OUT PIMAGE_SECTION_HEADER *LastRvaSection
  277.     );
  278.  
  279. BOOL
  280. IMAGEAPI
  281. MapAndLoad(
  282.     LPSTR ImageName,
  283.     LPSTR DllPath,
  284.     PLOADED_IMAGE LoadedImage,
  285.     BOOL DotDll,
  286.     BOOL ReadOnly
  287.     );
  288.  
  289. BOOL
  290. IMAGEAPI
  291. GetImageConfigInformation(
  292.     PLOADED_IMAGE LoadedImage,
  293.     PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation
  294.     );
  295.  
  296. DWORD
  297. IMAGEAPI
  298. GetImageUnusedHeaderBytes(
  299.     PLOADED_IMAGE LoadedImage,
  300.     LPDWORD SizeUnusedHeaderBytes
  301.     );
  302.  
  303. BOOL
  304. IMAGEAPI
  305. SetImageConfigInformation(
  306.     PLOADED_IMAGE LoadedImage,
  307.     PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation
  308.     );
  309.  
  310. BOOL
  311. IMAGEAPI
  312. UnMapAndLoad(
  313.    PLOADED_IMAGE LoadedImage
  314.    );
  315.  
  316. typedef struct _IMAGE_DEBUG_INFORMATION {
  317.     LIST_ENTRY List;
  318.     DWORD Size;
  319.     PVOID MappedBase;
  320.     USHORT Machine;
  321.     USHORT Characteristics;
  322.     DWORD CheckSum;
  323.     DWORD ImageBase;
  324.     DWORD SizeOfImage;
  325.  
  326.     DWORD NumberOfSections;
  327.     PIMAGE_SECTION_HEADER Sections;
  328.  
  329.     DWORD ExportedNamesSize;
  330.     LPSTR ExportedNames;
  331.  
  332.     DWORD NumberOfFunctionTableEntries;
  333.     PIMAGE_FUNCTION_ENTRY FunctionTableEntries;
  334.     DWORD LowestFunctionStartingAddress;
  335.     DWORD HighestFunctionEndingAddress;
  336.  
  337.     DWORD NumberOfFpoTableEntries;
  338.     PFPO_DATA FpoTableEntries;
  339.  
  340.     DWORD SizeOfCoffSymbols;
  341.     PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
  342.  
  343.     DWORD SizeOfCodeViewSymbols;
  344.     PVOID CodeViewSymbols;
  345.  
  346.     LPSTR ImageFilePath;
  347.     LPSTR ImageFileName;
  348.     LPSTR DebugFilePath;
  349.  
  350.     DWORD TimeDateStamp;
  351.  
  352.     BOOL  RomImage;
  353.     PIMAGE_DEBUG_DIRECTORY DebugDirectory;
  354.     DWORD NumberOfDebugDirectories;
  355.  
  356.     DWORD Reserved[ 3 ];
  357.  
  358. } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
  359.  
  360.  
  361. PIMAGE_DEBUG_INFORMATION
  362. IMAGEAPI
  363. MapDebugInformation (
  364.     HANDLE FileHandle,
  365.     LPSTR FileName,
  366.     LPSTR SymbolPath,
  367.     DWORD ImageBase
  368.     );
  369.  
  370. BOOL
  371. IMAGEAPI
  372. UnmapDebugInformation(
  373.     PIMAGE_DEBUG_INFORMATION DebugInfo
  374.     );
  375.  
  376. HANDLE
  377. IMAGEAPI
  378. FindExecutableImage(
  379.     LPSTR FileName,
  380.     LPSTR SymbolPath,
  381.     LPSTR ImageFilePath
  382.     );
  383.  
  384. BOOL
  385. IMAGEAPI
  386. SearchTreeForFile(
  387.     LPSTR RootPath,
  388.     LPSTR InputPathName,
  389.     LPSTR OutputPathBuffer
  390.     );
  391.  
  392. BOOL
  393. IMAGEAPI
  394. MakeSureDirectoryPathExists(
  395.     LPCSTR DirPath
  396.     );
  397.  
  398. //
  399. // UnDecorateSymbolName Flags
  400. //
  401.  
  402. #define UNDNAME_COMPLETE                 (0x0000)  // Enable full undecoration
  403. #define UNDNAME_NO_LEADING_UNDERSCORES   (0x0001)  // Remove leading underscores from MS extended keywords
  404. #define UNDNAME_NO_MS_KEYWORDS           (0x0002)  // Disable expansion of MS extended keywords
  405. #define UNDNAME_NO_FUNCTION_RETURNS      (0x0004)  // Disable expansion of return type for primary declaration
  406. #define UNDNAME_NO_ALLOCATION_MODEL      (0x0008)  // Disable expansion of the declaration model
  407. #define UNDNAME_NO_ALLOCATION_LANGUAGE   (0x0010)  // Disable expansion of the declaration language specifier
  408. #define UNDNAME_NO_MS_THISTYPE           (0x0020)  // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
  409. #define UNDNAME_NO_CV_THISTYPE           (0x0040)  // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
  410. #define UNDNAME_NO_THISTYPE              (0x0060)  // Disable all modifiers on the 'this' type
  411. #define UNDNAME_NO_ACCESS_SPECIFIERS     (0x0080)  // Disable expansion of access specifiers for members
  412. #define UNDNAME_NO_THROW_SIGNATURES      (0x0100)  // Disable expansion of 'throw-signatures' for functions and pointers to functions
  413. #define UNDNAME_NO_MEMBER_TYPE           (0x0200)  // Disable expansion of 'static' or 'virtual'ness of members
  414. #define UNDNAME_NO_RETURN_UDT_MODEL      (0x0400)  // Disable expansion of MS model for UDT returns
  415. #define UNDNAME_32_BIT_DECODE            (0x0800)  // Undecorate 32-bit decorated names
  416. #define UNDNAME_NAME_ONLY                (0x1000)  // Crack only the name for primary declaration;
  417.                                                                                                    //  return just [scope::]name.  Does expand template params
  418. #define UNDNAME_NO_ARGUMENTS             (0x2000)  // Don't undecorate arguments to function
  419. #define UNDNAME_NO_SPECIAL_SYMS          (0x4000)  // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
  420.  
  421. DWORD
  422. IMAGEAPI
  423. WINAPI
  424. UnDecorateSymbolName(
  425.     LPCSTR   DecoratedName,         // Name to undecorate
  426.     LPSTR    UnDecoratedName,       // If NULL, it will be allocated
  427.     DWORD    UndecoratedLength,     // The maximym length
  428.     DWORD    Flags                  // See above.
  429.     );
  430.  
  431. //
  432. // StackWalking API
  433. //
  434.  
  435. typedef enum {
  436.     AddrMode1616,
  437.     AddrMode1632,
  438.     AddrModeReal,
  439.     AddrModeFlat
  440. } ADDRESS_MODE;
  441.  
  442. typedef struct _tagADDRESS {
  443.     DWORD         Offset;
  444.     WORD          Segment;
  445.     ADDRESS_MODE  Mode;
  446. } ADDRESS, *LPADDRESS;
  447.  
  448.  
  449. //
  450. // This structure is included in the STACKFRAME structure,
  451. // and is used to trace through usermode callbacks in a thread's
  452. // kernel stack.  The values must be copied by the kernel debugger
  453. // from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
  454. //
  455. typedef struct _KDHELP {
  456.  
  457.     //
  458.     // address of kernel thread object, as provided in the
  459.     // WAIT_STATE_CHANGE packet.
  460.     //
  461.     DWORD   Thread;
  462.  
  463.     //
  464.     // offset in thread object to pointer to the current callback frame
  465.     // in kernel stack.
  466.     //
  467.     DWORD   ThCallbackStack;
  468.  
  469.     //
  470.     // offsets to values in frame:
  471.     //
  472.     // address of next callback frame
  473.     DWORD   NextCallback;
  474.  
  475.     // address of saved frame pointer (if applicable)
  476.     DWORD   FramePointer;
  477.  
  478.     //
  479.     // Address of the kernel function that calls out to user mode
  480.     //
  481.     DWORD   KiCallUserMode;
  482.  
  483.     //
  484.     // Address of the user mode dispatcher function
  485.     //
  486.     DWORD   KeUserCallbackDispatcher;
  487.  
  488.     //
  489.     // Lowest kernel mode address
  490.     //
  491.     DWORD   SystemRangeStart;
  492.  
  493. } KDHELP, *PKDHELP;
  494.  
  495.  
  496. typedef struct _tagSTACKFRAME {
  497.     ADDRESS     AddrPC;               // program counter
  498.     ADDRESS     AddrReturn;           // return address
  499.     ADDRESS     AddrFrame;            // frame pointer
  500.     ADDRESS     AddrStack;            // stack pointer
  501.     LPVOID      FuncTableEntry;       // pointer to pdata/fpo or NULL
  502.     DWORD       Params[4];            // possible arguments to the function
  503.     BOOL        Far;                  // WOW far call
  504.     BOOL        Virtual;              // is this a virtual frame?
  505.     DWORD       Reserved[3];
  506.     KDHELP      KdHelp;
  507. } STACKFRAME, *LPSTACKFRAME;
  508.  
  509. typedef
  510. BOOL
  511. (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE)(
  512.     HANDLE  hProcess,
  513.     LPCVOID lpBaseAddress,
  514.     LPVOID  lpBuffer,
  515.     DWORD   nSize,
  516.     LPDWORD lpNumberOfBytesRead
  517.     );
  518.  
  519. typedef
  520. LPVOID
  521. (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)(
  522.     HANDLE  hProcess,
  523.     DWORD   AddrBase
  524.     );
  525.  
  526. typedef
  527. DWORD
  528. (__stdcall *PGET_MODULE_BASE_ROUTINE)(
  529.     HANDLE  hProcess,
  530.     DWORD   ReturnAddress
  531.     );
  532.  
  533.  
  534. typedef
  535. DWORD
  536. (__stdcall *PTRANSLATE_ADDRESS_ROUTINE)(
  537.     HANDLE    hProcess,
  538.     HANDLE    hThread,
  539.     LPADDRESS lpaddr
  540.     );
  541.  
  542. BOOL
  543. IMAGEAPI
  544. StackWalk(
  545.     DWORD                             MachineType,
  546.     HANDLE                            hProcess,
  547.     HANDLE                            hThread,
  548.     LPSTACKFRAME                      StackFrame,
  549.     LPVOID                            ContextRecord,
  550.     PREAD_PROCESS_MEMORY_ROUTINE      ReadMemoryRoutine,
  551.     PFUNCTION_TABLE_ACCESS_ROUTINE    FunctionTableAccessRoutine,
  552.     PGET_MODULE_BASE_ROUTINE          GetModuleBaseRoutine,
  553.     PTRANSLATE_ADDRESS_ROUTINE        TranslateAddress
  554.     );
  555.  
  556. #define API_VERSION_NUMBER 7
  557.  
  558. typedef struct API_VERSION {
  559.     USHORT  MajorVersion;
  560.     USHORT  MinorVersion;
  561.     USHORT  Revision;
  562.     USHORT  Reserved;
  563. } API_VERSION, *LPAPI_VERSION;
  564.  
  565. LPAPI_VERSION
  566. IMAGEAPI
  567. ImagehlpApiVersion(
  568.     VOID
  569.     );
  570.  
  571. LPAPI_VERSION
  572. IMAGEAPI
  573. ImagehlpApiVersionEx(
  574.     LPAPI_VERSION AppVersion
  575.     );
  576.  
  577. DWORD
  578. IMAGEAPI
  579. GetTimestampForLoadedLibrary(
  580.     HMODULE Module
  581.     );
  582.  
  583. BOOL
  584. IMAGEAPI
  585. RemovePrivateCvSymbolic(
  586.     PCHAR   DebugData,
  587.     PCHAR * NewDebugData,
  588.     ULONG * NewDebugSize
  589.     );
  590.  
  591. VOID
  592. IMAGEAPI
  593. RemoveRelocations(
  594.     PCHAR ImageName
  595.     );
  596.  
  597. //
  598. // typedefs for function pointers
  599. //
  600. typedef BOOL
  601. (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(
  602.     LPSTR ModuleName,
  603.     ULONG BaseOfDll,
  604.     PVOID UserContext
  605.     );
  606.  
  607. typedef BOOL
  608. (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(
  609.     LPSTR SymbolName,
  610.     ULONG SymbolAddress,
  611.     ULONG SymbolSize,
  612.     PVOID UserContext
  613.     );
  614.  
  615. typedef BOOL
  616. (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(
  617.     LPSTR ModuleName,
  618.     ULONG ModuleBase,
  619.     ULONG ModuleSize,
  620.     PVOID UserContext
  621.     );
  622.  
  623. typedef BOOL
  624. (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(
  625.     HANDLE  hProcess,
  626.     ULONG   ActionCode,
  627.     PVOID   CallbackData,
  628.     PVOID   UserContext
  629.     );
  630.  
  631. //
  632. // symbol flags
  633. //
  634. #define SYMF_OMAP_GENERATED   0x00000001
  635. #define SYMF_OMAP_MODIFIED    0x00000002
  636.  
  637. //
  638. // symbol type enumeration
  639. //
  640. typedef enum {
  641.     SymNone,
  642.     SymCoff,
  643.     SymCv,
  644.     SymPdb,
  645.     SymExport,
  646.     SymDeferred,
  647.     SymSym                  // .sym file
  648. } SYM_TYPE;
  649.  
  650. //
  651. // symbol data structure
  652. //
  653. typedef struct _IMAGEHLP_SYMBOL {
  654.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOL)
  655.     DWORD                       Address;                // virtual address including dll base address
  656.     DWORD                       Size;                   // estimated size of symbol, can be zero
  657.     DWORD                       Flags;                  // info about the symbols, see the SYMF defines
  658.     DWORD                       MaxNameLength;          // maximum size of symbol name in 'Name'
  659.     CHAR                        Name[1];                // symbol name (null terminated string)
  660. } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
  661.  
  662. //
  663. // module data structure
  664. //
  665. typedef struct _IMAGEHLP_MODULE {
  666.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE)
  667.     DWORD                       BaseOfImage;            // base load address of module
  668.     DWORD                       ImageSize;              // virtual size of the loaded module
  669.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  670.     DWORD                       CheckSum;               // checksum from the pe header
  671.     DWORD                       NumSyms;                // number of symbols in the symbol table
  672.     SYM_TYPE                    SymType;                // type of symbols loaded
  673.     CHAR                        ModuleName[32];         // module name
  674.     CHAR                        ImageName[256];         // image name
  675.     CHAR                        LoadedImageName[256];   // symbol file name
  676. } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
  677.  
  678. //
  679. // source file line data structure
  680. //
  681. typedef struct _IMAGEHLP_LINE
  682. {
  683.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE)
  684.     DWORD                       Key;                    // internal
  685.     DWORD                       LineNumber;             // line number in file
  686.     PCHAR                       FileName;               // full filename
  687.     DWORD                       Address;                // first instruction of line
  688. } IMAGEHLP_LINE, *PIMAGEHLP_LINE;
  689.  
  690. //
  691. // data structures used for registered symbol callbacks
  692. //
  693.  
  694. #define CBA_DEFERRED_SYMBOL_LOAD_START          0x00000001
  695. #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE       0x00000002
  696. #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE        0x00000003
  697. #define CBA_SYMBOLS_UNLOADED                    0x00000004
  698. #define CBA_DUPLICATE_SYMBOL                    0x00000005
  699.  
  700. typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
  701.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
  702.     DWORD                       BaseOfImage;            // base load address of module
  703.     DWORD                       CheckSum;               // checksum from the pe header
  704.     DWORD                       TimeDateStamp;          // date/time stamp from pe header
  705.     CHAR                        FileName[MAX_PATH];     // symbols file or image name
  706.     BOOLEAN                     Reparse;                // load failure reparse
  707. } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
  708.  
  709. typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
  710.     DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
  711.     DWORD                       NumberOfDups;           // number of duplicates in the Symbol array
  712.     PIMAGEHLP_SYMBOL            Symbol;                 // array of duplicate symbols
  713.     ULONG                       SelectedSymbol;         // symbol selected (-1 to start)
  714. } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
  715.  
  716.  
  717. //
  718. // options that are set/returned by SymSetOptions() & SymGetOptions()
  719. // these are used as a mask
  720. //
  721. #define SYMOPT_CASE_INSENSITIVE  0x00000001
  722. #define SYMOPT_UNDNAME           0x00000002
  723. #define SYMOPT_DEFERRED_LOADS    0x00000004
  724. #define SYMOPT_NO_CPP            0x00000008
  725. #define SYMOPT_LOAD_LINES        0x00000010
  726. #define SYMOPT_OMAP_FIND_NEAREST 0x00000020
  727.  
  728.  
  729. DWORD
  730. IMAGEAPI
  731. SymSetOptions(
  732.     IN DWORD   SymOptions
  733.     );
  734.  
  735. DWORD
  736. IMAGEAPI
  737. SymGetOptions(
  738.     VOID
  739.     );
  740.  
  741. BOOL
  742. IMAGEAPI
  743. SymCleanup(
  744.     IN HANDLE hProcess
  745.     );
  746.  
  747. BOOL
  748. IMAGEAPI
  749. SymEnumerateModules(
  750.     IN HANDLE                       hProcess,
  751.     IN PSYM_ENUMMODULES_CALLBACK    EnumModulesCallback,
  752.     IN PVOID                        UserContext
  753.     );
  754.  
  755. BOOL
  756. IMAGEAPI
  757. SymEnumerateSymbols(
  758.     IN HANDLE                       hProcess,
  759.     IN DWORD                        BaseOfDll,
  760.     IN PSYM_ENUMSYMBOLS_CALLBACK    EnumSymbolsCallback,
  761.     IN PVOID                        UserContext
  762.     );
  763.  
  764. BOOL
  765. IMAGEAPI
  766. EnumerateLoadedModules(
  767.     IN HANDLE                           hProcess,
  768.     IN PENUMLOADED_MODULES_CALLBACK     EnumLoadedModulesCallback,
  769.     IN PVOID                            UserContext
  770.     );
  771.  
  772. LPVOID
  773. IMAGEAPI
  774. SymFunctionTableAccess(
  775.     HANDLE  hProcess,
  776.     DWORD   AddrBase
  777.     );
  778.  
  779. BOOL
  780. IMAGEAPI
  781. SymGetModuleInfo(
  782.     IN  HANDLE              hProcess,
  783.     IN  DWORD               dwAddr,
  784.     OUT PIMAGEHLP_MODULE    ModuleInfo
  785.     );
  786.  
  787. DWORD
  788. IMAGEAPI
  789. SymGetModuleBase(
  790.     IN  HANDLE              hProcess,
  791.     IN  DWORD               dwAddr
  792.     );
  793.  
  794. BOOL
  795. IMAGEAPI
  796. SymGetSymFromAddr(
  797.     IN  HANDLE              hProcess,
  798.     IN  DWORD               dwAddr,
  799.     OUT PDWORD              pdwDisplacement,
  800.     OUT PIMAGEHLP_SYMBOL    Symbol
  801.     );
  802.  
  803. BOOL
  804. IMAGEAPI
  805. SymGetSymFromName(
  806.     IN  HANDLE              hProcess,
  807.     IN  LPSTR               Name,
  808.     OUT PIMAGEHLP_SYMBOL    Symbol
  809.     );
  810.  
  811. BOOL
  812. IMAGEAPI
  813. SymGetSymNext(
  814.     IN     HANDLE              hProcess,
  815.     IN OUT PIMAGEHLP_SYMBOL    Symbol
  816.     );
  817.  
  818. BOOL
  819. IMAGEAPI
  820. SymGetSymPrev(
  821.     IN     HANDLE              hProcess,
  822.     IN OUT PIMAGEHLP_SYMBOL    Symbol
  823.     );
  824.  
  825. BOOL
  826. IMAGEAPI
  827. SymGetLineFromAddr(
  828.     IN  HANDLE                  hProcess,
  829.     IN  DWORD                   dwAddr,
  830.     OUT PDWORD                  pdwDisplacement,
  831.     OUT PIMAGEHLP_LINE          Line
  832.     );
  833.  
  834. BOOL
  835. IMAGEAPI
  836. SymGetLineFromName(
  837.     IN     HANDLE               hProcess,
  838.     IN     LPSTR                ModuleName,
  839.     IN     LPSTR                FileName,
  840.     IN     DWORD                dwLineNumber,
  841.        OUT PLONG                plDisplacement,
  842.     IN OUT PIMAGEHLP_LINE       Line
  843.     );
  844.  
  845. BOOL
  846. IMAGEAPI
  847. SymGetLineNext(
  848.     IN     HANDLE               hProcess,
  849.     IN OUT PIMAGEHLP_LINE       Line
  850.     );
  851.  
  852. BOOL
  853. IMAGEAPI
  854. SymGetLinePrev(
  855.     IN     HANDLE               hProcess,
  856.     IN OUT PIMAGEHLP_LINE       Line
  857.     );
  858.  
  859. BOOL
  860. IMAGEAPI
  861. SymMatchFileName(
  862.     IN  LPSTR  FileName,
  863.     IN  LPSTR  Match,
  864.     OUT LPSTR *FileNameStop,
  865.     OUT LPSTR *MatchStop
  866.     );
  867.  
  868. BOOL
  869. IMAGEAPI
  870. SymInitialize(
  871.     IN HANDLE   hProcess,
  872.     IN LPSTR    UserSearchPath,
  873.     IN BOOL     fInvadeProcess
  874.     );
  875.  
  876. BOOL
  877. IMAGEAPI
  878. SymGetSearchPath(
  879.     IN  HANDLE          hProcess,
  880.     OUT LPSTR           SearchPath,
  881.     IN  DWORD           SearchPathLength
  882.     );
  883.  
  884. BOOL
  885. IMAGEAPI
  886. SymSetSearchPath(
  887.     IN HANDLE           hProcess,
  888.     IN LPSTR            SearchPath
  889.     );
  890.  
  891. BOOL
  892. IMAGEAPI
  893. SymLoadModule(
  894.     IN  HANDLE          hProcess,
  895.     IN  HANDLE          hFile,
  896.     IN  PSTR            ImageName,
  897.     IN  PSTR            ModuleName,
  898.     IN  DWORD           BaseOfDll,
  899.     IN  DWORD           SizeOfDll
  900.     );
  901.  
  902. BOOL
  903. IMAGEAPI
  904. SymUnloadModule(
  905.     IN  HANDLE          hProcess,
  906.     IN  DWORD           BaseOfDll
  907.     );
  908.  
  909. BOOL
  910. IMAGEAPI
  911. SymUnDName(
  912.     IN  PIMAGEHLP_SYMBOL sym,               // Symbol to undecorate
  913.     OUT LPSTR            UnDecName,         // Buffer to store undecorated name in
  914.     IN  DWORD            UnDecNameLength    // Size of the buffer
  915.     );
  916.  
  917. BOOL
  918. IMAGEAPI
  919. SymRegisterCallback(
  920.     IN HANDLE                       hProcess,
  921.     IN PSYMBOL_REGISTERED_CALLBACK  CallbackFunction,
  922.     IN PVOID                        UserContext
  923.     );
  924.  
  925. // Image Integrity API's
  926.  
  927. #define CERT_PE_IMAGE_DIGEST_DEBUG_INFO         0x01
  928. #define CERT_PE_IMAGE_DIGEST_RESOURCES          0x02
  929. #define CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO    0x04
  930. #define CERT_PE_IMAGE_DIGEST_NON_PE_INFO        0x08      // include data outside the PE image
  931.  
  932. #define CERT_SECTION_TYPE_ANY                   0xFF      // Any Certificate type
  933.  
  934. typedef PVOID DIGEST_HANDLE;
  935.  
  936. typedef BOOL (WINAPI *DIGEST_FUNCTION) (DIGEST_HANDLE refdata, PBYTE pData, DWORD dwLength);
  937.  
  938. BOOL
  939. IMAGEAPI
  940. ImageGetDigestStream(
  941.     IN      HANDLE  FileHandle,
  942.     IN      DWORD   DigestLevel,
  943.     IN      DIGEST_FUNCTION DigestFunction,
  944.     IN      DIGEST_HANDLE   DigestHandle
  945.     );
  946.  
  947. BOOL
  948. IMAGEAPI
  949. ImageAddCertificate(
  950.     IN      HANDLE  FileHandle,
  951.     IN      LPWIN_CERTIFICATE   Certificate,
  952.     OUT     PDWORD  Index
  953.     );
  954.  
  955. BOOL
  956. IMAGEAPI
  957. ImageRemoveCertificate(
  958.     IN      HANDLE   FileHandle,
  959.     IN      DWORD    Index
  960.     );
  961.  
  962. BOOL
  963. IMAGEAPI
  964. ImageEnumerateCertificates(
  965.     IN      HANDLE  FileHandle,
  966.     IN      WORD    TypeFilter,
  967.     OUT     PDWORD  CertificateCount,
  968.     IN OUT  PDWORD  Indices OPTIONAL,
  969.     IN OUT  DWORD   IndexCount  OPTIONAL
  970.     );
  971.  
  972. BOOL
  973. IMAGEAPI
  974. ImageGetCertificateData(
  975.     IN      HANDLE  FileHandle,
  976.     IN      DWORD   CertificateIndex,
  977.     OUT     LPWIN_CERTIFICATE Certificate,
  978.     IN OUT  PDWORD  RequiredLength
  979.     );
  980.  
  981. BOOL
  982. IMAGEAPI
  983. ImageGetCertificateHeader(
  984.     IN      HANDLE  FileHandle,
  985.     IN      DWORD   CertificateIndex,
  986.     IN OUT  LPWIN_CERTIFICATE Certificateheader
  987.     );
  988.  
  989. BOOL
  990. IMAGEAPI
  991. CopyPdb(
  992.     CHAR const * SrcPdb,
  993.     CHAR const * DestPdb,
  994.     BOOL StripPrivate
  995.     );
  996.  
  997. BOOL
  998. IMAGEAPI
  999. RemovePrivateCvSymbolicEx(
  1000.     PCHAR   DebugData,
  1001.     ULONG   DebugSize,
  1002.     PCHAR * NewDebugData,
  1003.     ULONG * NewDebugSize
  1004.     );
  1005.  
  1006.  
  1007. #ifdef __cplusplus
  1008. }
  1009. #endif
  1010.  
  1011. #endif  // _IMAGEHLP_
  1012.