home *** CD-ROM | disk | FTP | other *** search
/ Kompuutteri K-CD 2002 #1 / K-CD_2002-01.iso / Delphi / INSTALL / program files / Borland / Delphi6 / Source / Rtl / Win / ImageHlp.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  2001-05-22  |  31.4 KB  |  755 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Run-time Library                 }
  5. {                            }
  6. {    Prototypes and constants required for the       }
  7. {       Win32 image help routines.                      }
  8. {                            }
  9. {       Copyright (c) 1985-1999, Microsoft Corporation  }
  10. {                                                       }
  11. {       Translator: Borland Software Corporation        }
  12. {                                                       }
  13. {*******************************************************}
  14.  
  15. unit ImageHlp;
  16.  
  17. interface
  18.  
  19. {$HPPEMIT '#include <imagehlp.h>'}
  20.  
  21. uses Windows;
  22.  
  23. {$Z4}
  24.  
  25. { Define checksum return codes. }
  26. const
  27.   {$EXTERNALSYM CHECKSUM_SUCCESS}
  28.   CHECKSUM_SUCCESS                = 0;
  29.   {$EXTERNALSYM CHECKSUM_OPEN_FAILURE}
  30.   CHECKSUM_OPEN_FAILURE           = 1;
  31.   {$EXTERNALSYM CHECKSUM_MAP_FAILURE}
  32.   CHECKSUM_MAP_FAILURE            = 2;
  33.   {$EXTERNALSYM CHECKSUM_MAPVIEW_FAILURE}
  34.   CHECKSUM_MAPVIEW_FAILURE        = 3;
  35.   {$EXTERNALSYM CHECKSUM_UNICODE_FAILURE}
  36.   CHECKSUM_UNICODE_FAILURE        = 4;
  37.  
  38. { Define Splitsym flags. }
  39.  
  40.   {$EXTERNALSYM SPLITSYM_REMOVE_PRIVATE}
  41.   SPLITSYM_REMOVE_PRIVATE         = $00000001;      { Remove CV types/symbols and Fixup debug }
  42. {  Used for creating .dbg files that ship }
  43. {  as part of the product. }
  44.  
  45.   {$EXTERNALSYM SPLITSYM_EXTRACT_ALL}
  46.   SPLITSYM_EXTRACT_ALL            = $00000002;      { Extract all debug info from image. }
  47. {  Normally, FPO is left in the image }
  48. {  to allow stack traces through the code. }
  49. {  Using this switch is similar to linking }
  50. {  with -debug:none except the .dbg file }
  51. {  exists... }
  52.  
  53. { Define checksum function prototypes. }
  54. {$EXTERNALSYM CheckSumMappedFile}
  55. function CheckSumMappedFile(BaseAddress: Pointer; FileLength: DWORD;
  56.   HeaderSum: PDWORD; CheckSum: PDWORD): PImageNtHeaders; stdcall;
  57.  
  58. {$EXTERNALSYM MapFileAndCheckSum}
  59. function MapFileAndCheckSum(Filename: PChar; var HeaderSum,
  60.   CheckSum: DWORD): DWORD; stdcall;
  61. {$EXTERNALSYM MapFileAndCheckSumA}
  62. function MapFileAndCheckSumA(Filename: PAnsiChar; var HeaderSum,
  63.   CheckSum: DWORD): DWORD; stdcall;
  64. {$EXTERNALSYM MapFileAndCheckSumW}
  65. function MapFileAndCheckSumW(Filename: PWideChar; var HeaderSum,
  66.   CheckSum: DWORD): DWORD; stdcall;
  67.  
  68.  
  69. {$EXTERNALSYM TouchFileTimes}
  70. function TouchFileTimes(FileHandle: THandle; const lpSystemTime: TSystemTime):
  71.   Bool; stdcall;
  72.  
  73. {$EXTERNALSYM SplitSymbols}
  74. function SplitSymbols(ImageName, SymbolsPath, SymbolFilePath: LPSTR;
  75.   Flags: DWORD): Bool; stdcall;
  76.  
  77. {$EXTERNALSYM FindDebugInfoFile}
  78. function FindDebugInfoFile(FileName, SymbolPath, DebugFilePath: LPSTR): THandle; stdcall;
  79.  
  80. {$EXTERNALSYM FindExecutableImage}
  81. function FindExecutableImage(FileName, SymbolPath, ImageFilePath: LPSTR): THandle; stdcall;
  82.  
  83. {$EXTERNALSYM UpdateDebugInfoFile}
  84. function UpdateDebugInfoFile(ImageFileName, SymbolPath, DebugFilePath: LPSTR;
  85.   NtHeaders: PImageNtHeaders): Bool; stdcall;
  86.  
  87. {$EXTERNALSYM UpdateDebugInfoFileEx}
  88. function UpdateDebugInfoFileEx(ImageFileName, SymbolPath, DebugFilePath: LPSTR;
  89.   NtHeaders: PImageNtHeaders; OldChecksum: DWORD): Bool; stdcall;
  90.  
  91. {$EXTERNALSYM BindImage}
  92. function BindImage(ImageName, DllPath, SymbolPath: LPSTR): Bool; stdcall;
  93.  
  94. type
  95.   {$EXTERNALSYM _IMAGEHLP_STATUS_REASON}
  96.   _IMAGEHLP_STATUS_REASON = (
  97.     BindOutOfMemory,
  98.     BindRvaToVaFailed,
  99.     BindNoRoomInImage,
  100.     BindImportModuleFailed,
  101.     BindImportProcedureFailed,
  102.     BindImportModule,
  103.     BindImportProcedure,
  104.     BindForwarder,
  105.     BindForwarderNOT,
  106.     BindImageModified,
  107.     BindExpandFileHeaders,
  108.     BindImageComplete,
  109.     BindMismatchedSymbols,
  110.     BindSymbolsNotUpdated
  111.   );
  112.   {$EXTERNALSYM IMAGEHLP_STATUS_REASON}
  113.   IMAGEHLP_STATUS_REASON = _IMAGEHLP_STATUS_REASON;
  114.   TImagehlpStatusReason = _IMAGEHLP_STATUS_REASON;
  115.  
  116. type
  117.   {$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE}
  118.   PIMAGEHLP_STATUS_ROUTINE = function(Reason: TImagehlpStatusReason;
  119.     ImageName, DllName: LPSTR; Va, Parameter: ULONG): Bool; stdcall;
  120.   TImagehlpStatusRoutine = PIMAGEHLP_STATUS_ROUTINE;
  121.  
  122. {$EXTERNALSYM BindImageEx}
  123. function BindImageEx(Flags: DWORD; ImageName, DllPath, SymbolPath: LPSTR;
  124.   var StatusRoutine: TImagehlpStatusReason): Bool; stdcall;
  125.  
  126. const
  127.   {$EXTERNALSYM BIND_NO_BOUND_IMPORTS}
  128.   BIND_NO_BOUND_IMPORTS     = $00000001;
  129.   {$EXTERNALSYM BIND_NO_UPDATE}
  130.   BIND_NO_UPDATE            = $00000002;
  131.   {$EXTERNALSYM BIND_ALL_IMAGES}
  132.   BIND_ALL_IMAGES           = $00000004;
  133.  
  134. {$EXTERNALSYM ReBaseImage}
  135. function ReBaseImage(CurrentImageName, SymbolPath: LPSTR; fReBase,
  136.   fRebaseSysfileOk, fGoingDown: Bool; CheckImageSize: ULONG;
  137.   var OldImageSize, OldImageBase, NewImageSize, NewImageBase: ULONG;
  138.   TimeStamp: ULONG): Bool; stdcall;
  139.  
  140. const
  141.   {$EXTERNALSYM IMAGE_SEPARATION}
  142.   IMAGE_SEPARATION     = 64 * 1024;
  143.  
  144. type
  145.   PloadedImage = ^TLoadedImage;
  146.   {$EXTERNALSYM _LOADED_IMAGE}
  147.   _LOADED_IMAGE = record
  148.     ModuleName: LPSTR;
  149.     hFile: THandle;
  150.     MappedAddress: PChar;
  151.     FileHeader: PImageNtHeaders;
  152.     LastRvaSection: PImageSectionHeader;
  153.     NumberOfSections: ULONG;
  154.     Sections: PImageSectionHeader;
  155.     Characteristics: ULONG;
  156.     fSystemImage: ByteBool;
  157.     fDOSImage: ByteBool;
  158.     Links: TListEntry;
  159.     SizeOfImage: ULONG;
  160.   end;
  161.   {$EXTERNALSYM LOADED_IMAGE}
  162.   LOADED_IMAGE = _LOADED_IMAGE;
  163.   LoadedImage = _LOADED_IMAGE;
  164.   TLoadedImage = _Loaded_IMAGE;
  165.  
  166.  
  167. {$EXTERNALSYM ImageLoad}
  168. function ImageLoad(DllName, DllPath: LPSTR): PLoadedImage; stdcall;
  169.  
  170. {$EXTERNALSYM ImageUnload}
  171. function ImageUnload(LoadedImage: PLoadedImage): Bool; stdcall;
  172.  
  173. {$EXTERNALSYM ImageNtHeader}
  174. function ImageNtHeader(Base: Pointer): PImageNtHeaders; stdcall;
  175.  
  176. {$EXTERNALSYM ImageDirectoryEntryToData}
  177. function ImageDirectoryEntryToData(Base: Pointer; MappedAsImage: ByteBool;
  178.   DirectoryEntry: Word; var Size: ULONG): Pointer; stdcall;
  179.  
  180. {$EXTERNALSYM ImageRvaToSection}
  181. function ImageRvaToSection(NtHeaders: PImageNtHeaders; Base: Pointer;
  182.   Rva: ULONG): PImageSectionHeader; stdcall;
  183.  
  184. {$EXTERNALSYM ImageRvaToVa}
  185. function ImageRvaToVa(NtHeaders: PImageNtHeaders; Base: Pointer;
  186.   Rva: ULONG; var LastRvaSection: PImageSectionHeader): Pointer; stdcall;
  187.  
  188. {$EXTERNALSYM MapAndLoad}
  189. function MapAndLoad(ImageName, DllPath: LPSTR; LoadedImage: PLoadedImage;
  190.   DotDll, ReadOnly: Bool): Bool; stdcall;
  191.  
  192. {$EXTERNALSYM GetImageConfigInformation}
  193. function GetImageConfigInformation(LoadedImage: PLoadedImage;
  194.   var ImageConfigInformation: TImageLoadConfigDirectory): Bool; stdcall;
  195.  
  196. {$EXTERNALSYM GetImageUnusedHeaderBytes}
  197. function GetImageUnusedHeaderBytes(LoadedImage: PLoadedImage;
  198.   var SizeUnusedHeaderBytes: DWORD): DWORD; stdcall;
  199.  
  200. {$EXTERNALSYM SetImageConfigInformation}
  201. function SetImageConfigInformation(LoadedImage: PLoadedImage;
  202.   const ImageConfigInformation: TImageLoadConfigDirectory): Bool; stdcall;
  203.  
  204. {$EXTERNALSYM UnMapAndLoad}
  205. function UnMapAndLoad(LoadedImage: PLoadedImage): Bool; stdcall;
  206.  
  207. type
  208.   PimageDebugInformation = ^TImageDebugInformation;
  209.   {$EXTERNALSYM _IMAGE_DEBUG_INFORMATION}
  210.   _IMAGE_DEBUG_INFORMATION = packed record
  211.     List: TListEntry;
  212.     Size: DWORD;
  213.     MappedBase: Pointer;
  214.     Machine: Word;
  215.     Characteristics: Word;
  216.     CheckSum: DWORD;
  217.     ImageBase: DWORD;
  218.     SizeOfImage: DWORD;
  219.     NumberOfSections: DWORD;
  220.     Sections: PImageSectionHeader;
  221.     ExportedNamesSize: DWORD;
  222.     ExportedNames: LPSTR;
  223.     NumberOfFunctionTableEntries: DWORD;
  224.     FunctionTableEntries: PImageFunctionEntry;
  225.     LowestFunctionStartingAddress: DWORD;
  226.     HighestFunctionEndingAddress: DWORD;
  227.     NumberOfFpoTableEntries: DWORD;
  228.     FpoTableEntries: PFpoData;
  229.     SizeOfCoffSymbols: DWORD;
  230.     CoffSymbols: PImageCOFFSymbolsHeader;
  231.     SizeOfCodeViewSymbols: DWORD;
  232.     CodeViewSymbols: Pointer;
  233.     ImageFilePath: LPSTR;
  234.     ImageFileName: LPSTR;
  235.     DebugFilePath: LPSTR;
  236.     TimeDateStamp: DWORD;
  237.     RomImage: Bool;
  238.     DebugDirectory: PImageDebugDirectory;
  239.     NumberOfDebugDirectories: DWORD;
  240.     Reserved: packed array[0..2] of DWORD;
  241.   end;
  242.   {$EXTERNALSYM IMAGE_DEBUG_INFORMATION}
  243.   IMAGE_DEBUG_INFORMATION = _IMAGE_DEBUG_INFORMATION;
  244.   TImageDebugInformation = _IMAGE_DEBUG_INFORMATION;
  245.  
  246. {$EXTERNALSYM MapDebugInformation}
  247. function MapDebugInformation(FileHandle: THandle; FileName, SymbolPath: LPSTR;
  248.   ImageBase: DWORD): PImageDebugInformation; stdcall;
  249.  
  250. {$EXTERNALSYM UnmapDebugInformation}
  251. function UnmapDebugInformation(DebugInfo: PImageDebugInformation): Bool; stdcall;
  252.  
  253. {$EXTERNALSYM SearchTreeForFile}
  254. function SearchTreeForFile(RootPath, InputPathName, OutputPathBuffer: LPSTR):
  255.   Bool; stdcall;
  256.  
  257. {$EXTERNALSYM MakeSureDirectoryPathExists}
  258. function MakeSureDirectoryPathExists(DirPath: LPCSTR): Bool; stdcall;
  259.  
  260. { UnDecorateSymbolName Flags }
  261. const
  262.   {$EXTERNALSYM UNDNAME_COMPLETE}
  263.   UNDNAME_COMPLETE                     = $0000;    { Enable full undecoration }
  264.   {$EXTERNALSYM UNDNAME_NO_LEADING_UNDERSCORES}
  265.   UNDNAME_NO_LEADING_UNDERSCORES       = $0001;    { Remove leading underscores from MS extended keywords }
  266.   {$EXTERNALSYM UNDNAME_NO_MS_KEYWORDS}
  267.   UNDNAME_NO_MS_KEYWORDS               = $0002;    { Disable expansion of MS extended keywords }
  268.   {$EXTERNALSYM UNDNAME_NO_FUNCTION_RETURNS}
  269.   UNDNAME_NO_FUNCTION_RETURNS          = $0004;    { Disable expansion of return type for primary declaration }
  270.   {$EXTERNALSYM UNDNAME_NO_ALLOCATION_MODEL}
  271.   UNDNAME_NO_ALLOCATION_MODEL          = $0008;    { Disable expansion of the declaration model }
  272.   {$EXTERNALSYM UNDNAME_NO_ALLOCATION_LANGUAGE}
  273.   UNDNAME_NO_ALLOCATION_LANGUAGE       = $0010;    { Disable expansion of the declaration language specifier }
  274.   {$EXTERNALSYM UNDNAME_NO_MS_THISTYPE}
  275.   UNDNAME_NO_MS_THISTYPE               = $0020;    { NYI Disable expansion of MS keywords on the 'this' type for primary declaration }
  276.   {$EXTERNALSYM UNDNAME_NO_CV_THISTYPE}
  277.   UNDNAME_NO_CV_THISTYPE               = $0040;    { NYI Disable expansion of CV modifiers on the 'this' type for primary declaration }
  278.   {$EXTERNALSYM UNDNAME_NO_THISTYPE}
  279.   UNDNAME_NO_THISTYPE                  = $0060;    { Disable all modifiers on the 'this' type }
  280.   {$EXTERNALSYM UNDNAME_NO_ACCESS_SPECIFIERS}
  281.   UNDNAME_NO_ACCESS_SPECIFIERS         = $0080;    { Disable expansion of access specifiers for members }
  282.   {$EXTERNALSYM UNDNAME_NO_THROW_SIGNATURES}
  283.   UNDNAME_NO_THROW_SIGNATURES          = $0100;    { Disable expansion of 'throw-signatures' for functions and pointers to functions }
  284.   {$EXTERNALSYM UNDNAME_NO_MEMBER_TYPE}
  285.   UNDNAME_NO_MEMBER_TYPE               = $0200;    { Disable expansion of 'static' or 'virtual'ness of members }
  286.   {$EXTERNALSYM UNDNAME_NO_RETURN_UDT_MODEL}
  287.   UNDNAME_NO_RETURN_UDT_MODEL          = $0400;    { Disable expansion of MS model for UDT returns }
  288.   {$EXTERNALSYM UNDNAME_32_BIT_DECODE}
  289.   UNDNAME_32_BIT_DECODE                = $0800;    { Undecorate 32-bit decorated names }
  290.   {$EXTERNALSYM UNDNAME_NAME_ONLY}
  291.   UNDNAME_NAME_ONLY                    = $1000;    { Crack only the name for primary declaration; }
  292. {  return just [scope::]name.  Does expand template params }
  293.   {$EXTERNALSYM UNDNAME_NO_ARGUMENTS}
  294.   UNDNAME_NO_ARGUMENTS                 = $2000;    { Don't undecorate arguments to function }
  295.   {$EXTERNALSYM UNDNAME_NO_SPECIAL_SYMS}
  296.   UNDNAME_NO_SPECIAL_SYMS              = $4000;    { Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc) }
  297.  
  298. {$EXTERNALSYM UnDecorateSymbolName}
  299. function UnDecorateSymbolName(DecoratedName, UnDecoratedName: LPSTR;
  300.   UndecoratedLength, Flags: DWORD): DWORD; stdcall;
  301.  
  302.  
  303. { StackWalking API }
  304. type
  305.   {$EXTERNALSYM ADDRESS_MODE}
  306.   ADDRESS_MODE = (
  307.     AddrMode1616,
  308.     AddrMode1632,
  309.     AddrModeReal,
  310.     AddrModeFlat
  311.   );
  312.   TAddressMode = ADDRESS_MODE;
  313.  
  314.   PAddress = ^TAddress;
  315.   {$EXTERNALSYM _tagADDRESS}
  316.   _tagADDRESS = record
  317.     Offset: DWORD;
  318.     Segment: Word;
  319.     Mode: TAddressMode;
  320.   end;
  321.   {$EXTERNALSYM ADDRESS}
  322.   ADDRESS = _tagADDRESS;
  323.   TAddress = _tagADDRESS;
  324.  
  325. { This structure is included in the STACKFRAME structure, }
  326. { and is used to trace through usermode callbacks in a thread's }
  327. { kernel stack.  The values must be copied by the kernel debugger }
  328. { from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets. }
  329.  
  330.   PKdHelp = ^TKdHelp;
  331.   {$EXTERNALSYM _KDHELP}
  332.   _KDHELP = packed record { address of kernel thread object, as provided }
  333.                           { in the WAIT_STATE_CHANGE packet. }
  334.     Thread: DWORD;
  335.     { offset in thread object to pointer to the current callback frame }
  336.     { in kernel stack. }
  337.     ThCallbackStack: DWORD;
  338.     { offsets to values in frame: }
  339.     { address of next callback frame }
  340.     NextCallback: DWORD;
  341.     { address of saved frame pointer (if applicable) }
  342.     FramePointer: DWORD;
  343.     { Address of the kernel function that calls out to user mode }
  344.     KiCallUserMode: DWORD;
  345.     { Address of the user mode dispatcher function }
  346.     KeUserCallbackDispatcher: DWORD;
  347.   end;
  348.   {$EXTERNALSYM KDHELP}
  349.   KDHELP = _KDHELP;
  350.   TKdHelp = _KDHELP;
  351.  
  352.   PStackFrame = ^TStackFrame;
  353.   {$EXTERNALSYM _tagSTACKFRAME}
  354.   _tagSTACKFRAME = packed record
  355.     AddrPC: TAddress;                  { program counter }
  356.     AddrReturn: TAddress;              { return address }
  357.     AddrFrame: TAddress;               { frame pointer }
  358.     AddrStack: TAddress;               { stack pointer }
  359.     FuncTableEntry: Pointer;          { pointer to pdata/fpo or NULL }
  360.     Params: packed array[0..3] of DWORD;{ possible arguments to the function }
  361.     _Far: Bool;                        { WOW far call }
  362.     _Virtual: Bool;                    { is this a virtual frame? }
  363.     Reserved: packed array[0..2] of DWORD;{ used internally by StackWalk api }
  364.     KdHelp: TKdHelp;
  365.   end;
  366.   {$EXTERNALSYM STACKFRAME}
  367.   STACKFRAME = _tagSTACKFRAME;
  368.   TStackFrame = _tagSTACKFRAME;
  369.  
  370. type
  371.   {$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE}
  372.   PREAD_PROCESS_MEMORY_ROUTINE = function(hProcess: THandle;
  373.     lpBaseAddress, lpBuffer: Pointer; nSize: DWORD;
  374.     var lpNumberOfBytesRead: DWORD): Bool; stdcall;
  375.   TReadProcessMemoryRoutine = PREAD_PROCESS_MEMORY_ROUTINE;
  376.  
  377.   {$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE}
  378.   PFUNCTION_TABLE_ACCESS_ROUTINE = function(hProcess: THandle;
  379.     AddrBase: DWORD): Pointer; stdcall;
  380.   TFunctionTableAccessRoutine = PFUNCTION_TABLE_ACCESS_ROUTINE;
  381.  
  382.   {$EXTERNALSYM PGET_MODULE_BASE_ROUTINE}
  383.   PGET_MODULE_BASE_ROUTINE = function(hProcess: THandle;
  384.     ReturnAddress: DWORD): DWORD; stdcall;
  385.   TGetModuleBaseRoutine = PGET_MODULE_BASE_ROUTINE;
  386.  
  387.   {$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE}
  388.   PTRANSLATE_ADDRESS_ROUTINE = function(hProcess, hThread: THandle;
  389.     lpaddr: PAddress): DWORD; stdcall;
  390.   TTranslateAddressRoutine = PTRANSLATE_ADDRESS_ROUTINE;
  391.  
  392. {$EXTERNALSYM StackWalk}
  393. function StackWalk(MachineType: DWORD; hProcess, hThread: THandle;
  394.   StackFrame: PStackFrame; ContextRecord: Pointer;
  395.   ReadMemoryRoutine: TReadProcessMemoryRoutine;
  396.   FunctionTableAccessRoutine: TFunctionTableAccessRoutine;
  397.   GetModuleBaseRoutine: TGetModuleBaseRoutine;
  398.   TranslateAddress: TTranslateAddressRoutine): Bool; stdcall;
  399.  
  400. const
  401.   {$EXTERNALSYM API_VERSION_NUMBER}
  402.   API_VERSION_NUMBER     = 5;
  403.  
  404. type
  405.   PApiVersion = ^TApiVersion;
  406.   {$EXTERNALSYM API_VERSION}
  407.   API_VERSION = packed record
  408.     MajorVersion: Word;
  409.     MinorVersion: Word;
  410.     Revision: Word;
  411.     Reserved: Word;
  412.   end;
  413.   TApiVersion = API_VERSION;
  414.  
  415. {$EXTERNALSYM ImagehlpApiVersion}
  416. function ImagehlpApiVersion: PApiVersion; stdcall;
  417.  
  418. {$EXTERNALSYM ImagehlpApiVersionEx}
  419. function ImagehlpApiVersionEx(var AppVersion: TApiVersion): PApiVersion; stdcall;
  420.  
  421. {$EXTERNALSYM GetTimestampForLoadedLibrary}
  422. function GetTimestampForLoadedLibrary(Module: HMODULE): DWORD; stdcall;
  423.  
  424. {$EXTERNALSYM RemovePrivateCvSymbolic}
  425. function RemovePrivateCvSymbolic(DebugData: PChar; var NewDebugData: PChar;
  426.   var NewDebugSize: ULONG): Bool; stdcall;
  427.  
  428. {$EXTERNALSYM RemoveRelocations}
  429. procedure RemoveRelocations(ImageName: PChar); stdcall;
  430.  
  431.  
  432. { typedefs for function pointers }
  433. type
  434.   {$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK}
  435.   PSYM_ENUMMODULES_CALLBACK = function(ModuleName: LPSTR; BaseOfDll: ULONG;
  436.     UserContext: Pointer): Bool; stdcall;
  437.   TSymEnummodulesCallback = PSYM_ENUMMODULES_CALLBACK;
  438.  
  439.   {$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK}
  440.   PSYM_ENUMSYMBOLS_CALLBACK = function(SymbolName: LPSTR; SymbolAddress,
  441.     SymbolSize: ULONG; UserContext: Pointer): Bool; stdcall;
  442.   TSymEnumsymbolsCallback = PSYM_ENUMSYMBOLS_CALLBACK;
  443.  
  444.   {$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK}
  445.   PENUMLOADED_MODULES_CALLBACK = function(ModuleName: LPSTR; ModuleBase,
  446.     ModuleSize: ULONG; UserContext: Pointer): Bool; stdcall;
  447.   TEnumloadedModulesCallback = PENUMLOADED_MODULES_CALLBACK;
  448.  
  449.   {$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK}
  450.   PSYMBOL_REGISTERED_CALLBACK = function(hProcess: THandle; ActionCode: ULONG;
  451.     CallbackData, UserContext: Pointer): Bool; stdcall;
  452.   TSymbolRegisteredCallback = PSYMBOL_REGISTERED_CALLBACK;
  453.  
  454.  
  455. { symbol flags }
  456. const
  457.   {$EXTERNALSYM SYMF_OMAP_GENERATED}
  458.   SYMF_OMAP_GENERATED       = $00000001;
  459.   {$EXTERNALSYM SYMF_OMAP_MODIFIED}
  460.   SYMF_OMAP_MODIFIED        = $00000002;
  461.  
  462.  
  463. { symbol type enumeration }
  464. type
  465.   {$EXTERNALSYM SYM_TYPE}
  466.   SYM_TYPE = (
  467.     SymNone,
  468.     SymCoff,
  469.     SymCv,
  470.     SymPdb,
  471.     SymExport,
  472.     SymDeferred,
  473.     SymSym                  { .sym file }
  474.   );
  475.   TSymType = SYM_TYPE;
  476.  
  477. { symbol data structure }
  478.   PImagehlpSymbol = ^TImagehlpSymbol;
  479.   {$EXTERNALSYM _IMAGEHLP_SYMBOL}
  480.   _IMAGEHLP_SYMBOL = packed record
  481.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_SYMBOL) }
  482.     Address: DWORD;                                     { virtual address including dll base address }
  483.     Size: DWORD;                                        { estimated size of symbol, can be zero }
  484.     Flags: DWORD;                                       { info about the symbols, see the SYMF defines }
  485.     MaxNameLength: DWORD;                               { maximum size of symbol name in 'Name' }
  486.     Name: packed array[0..0] of Char;                   { symbol name (null terminated string) }
  487.   end;
  488.   {$EXTERNALSYM IMAGEHLP_SYMBOL}
  489.   IMAGEHLP_SYMBOL = _IMAGEHLP_SYMBOL;
  490.   TImagehlpSymbol = _IMAGEHLP_SYMBOL;
  491.  
  492.  
  493. { module data structure }
  494.   PImagehlpModule = ^TImagehlpModule;
  495.   {$EXTERNALSYM _IMAGEHLP_MODULE}
  496.   _IMAGEHLP_MODULE = record
  497.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_MODULE) }
  498.     BaseOfImage: DWORD;                                 { base load address of module }
  499.     ImageSize: DWORD;                                   { virtual size of the loaded module }
  500.     TimeDateStamp: DWORD;                               { date/time stamp from pe header }
  501.     CheckSum: DWORD;                                    { checksum from the pe header }
  502.     NumSyms: DWORD;                                     { number of symbols in the symbol table }
  503.     SymType: TSymType;                                  { type of symbols loaded }
  504.     ModuleName: packed array[0..31] of Char;            { module name }
  505.     ImageName: packed array[0..255] of Char;            { image name }
  506.     LoadedImageName: packed array[0..255] of Char;      { symbol file name }
  507.   end;
  508.   {$EXTERNALSYM IMAGEHLP_MODULE}
  509.   IMAGEHLP_MODULE = _IMAGEHLP_MODULE;
  510.   TImagehlpModule = _IMAGEHLP_MODULE;
  511.  
  512.  
  513. { data structures used for registered symbol callbacks }
  514. const
  515.   {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_START}
  516.   CBA_DEFERRED_SYMBOL_LOAD_START              = $00000001;
  517.   {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_COMPLETE}
  518.   CBA_DEFERRED_SYMBOL_LOAD_COMPLETE           = $00000002;
  519.   {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_FAILURE}
  520.   CBA_DEFERRED_SYMBOL_LOAD_FAILURE            = $00000003;
  521.   {$EXTERNALSYM CBA_SYMBOLS_UNLOADED}
  522.   CBA_SYMBOLS_UNLOADED                        = $00000004;
  523.   {$EXTERNALSYM CBA_DUPLICATE_SYMBOL}
  524.   CBA_DUPLICATE_SYMBOL                        = $00000005;
  525.  
  526. type
  527.   PImagehlpDeferredSymbolLoad = ^TImagehlpDeferredSymbolLoad;
  528.   {$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD}
  529.   _IMAGEHLP_DEFERRED_SYMBOL_LOAD = packed record
  530.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD) }
  531.     BaseOfImage: DWORD;                                 { base load address of module }
  532.     CheckSum: DWORD;                                    { checksum from the pe header }
  533.     TimeDateStamp: DWORD;                               { date/time stamp from pe header }
  534.     FileName: packed array[0..MAX_PATH-1] of Char;      { symbols file or image name }
  535.   end;
  536.   {$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD}
  537.   IMAGEHLP_DEFERRED_SYMBOL_LOAD = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  538.   TImagehlpDeferredSymbolLoad = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  539.  
  540.   PImagehlpDuplicateSymbol = ^TImagehlpDuplicateSymbol;
  541.   {$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL}
  542.   _IMAGEHLP_DUPLICATE_SYMBOL = packed record
  543.     SizeOfStruct: DWORD;                                { set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL) }
  544.     NumberOfDups: DWORD;                                { number of duplicates in the Symbol array }
  545.     Symbol: PImagehlpSymbol;                            { array of duplicate symbols }
  546.     SelectedSymbol: ULONG;                           { symbol selected (-1 to start) }
  547.   end;
  548.   {$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL}
  549.   IMAGEHLP_DUPLICATE_SYMBOL = _IMAGEHLP_DUPLICATE_SYMBOL;
  550.   TImagehlpDuplicateSymbol = _IMAGEHLP_DUPLICATE_SYMBOL;
  551.  
  552.  
  553.  
  554. { options that are set/returned by SymSetOptions() & SymGetOptions() }
  555. { these are used as a mask }
  556.  
  557. const
  558.   {$EXTERNALSYM SYMOPT_CASE_INSENSITIVE}
  559.   SYMOPT_CASE_INSENSITIVE      = $00000001;
  560.   {$EXTERNALSYM SYMOPT_UNDNAME}
  561.   SYMOPT_UNDNAME               = $00000002;
  562.   {$EXTERNALSYM SYMOPT_DEFERRED_LOADS}
  563.   SYMOPT_DEFERRED_LOADS        = $00000004;
  564.   {$EXTERNALSYM SYMOPT_NO_CPP}
  565.   SYMOPT_NO_CPP                = $00000008;
  566.  
  567.  
  568. {$EXTERNALSYM SymSetOptions}
  569. function SymSetOptions(SymOptions: DWORD): DWORD; stdcall;
  570.  
  571. {$EXTERNALSYM SymGetOptions}
  572. function SymGetOptions: DWORD; stdcall;
  573.  
  574. {$EXTERNALSYM SymCleanup}
  575. function SymCleanup(hProcess: THandle): Bool; stdcall;
  576.  
  577. {$EXTERNALSYM SymEnumerateModules}
  578. function SymEnumerateModules(hProcess: THandle;
  579.   EnumModulesCallback: TSymEnumModulesCallback; UserContext: Pointer): Bool; stdcall;
  580.  
  581. {$EXTERNALSYM SymEnumerateSymbols}
  582. function SymEnumerateSymbols(hProcess: THandle; BaseOfDll: DWORD;
  583.   EnumSymbolsCallback: TSymEnumSymbolsCallback; UserContext: Pointer): Bool; stdcall;
  584.  
  585. {$EXTERNALSYM EnumerateLoadedModules}
  586. function EnumerateLoadedModules(hProcess: THandle;
  587.   EnumLoadedModulesCallback: TEnumLoadedModulesCallback;
  588.   UserContext: Pointer): Bool; stdcall;
  589.  
  590. {$EXTERNALSYM SymFunctionTableAccess}
  591. function SymFunctionTableAccess(hProcess: THandle; AddrBase: DWORD): Pointer; stdcall;
  592.  
  593. {$EXTERNALSYM SymGetModuleInfo}
  594. function SymGetModuleInfo(hProcess: THandle; dwAddr: DWORD;
  595.   var ModuleInfo: TImagehlpModule): Bool; stdcall;
  596.  
  597. {$EXTERNALSYM SymGetModuleBase}
  598. function SymGetModuleBase(hProcess: THandle; dwAddr: DWORD): DWORD; stdcall;
  599.  
  600. {$EXTERNALSYM SymGetSymFromAddr}
  601. function SymGetSymFromAddr(hProcess: THandle; dwAddr: DWORD;
  602.   pdwDisplacement: PDWORD; var Symbol: TImagehlpSymbol): Bool; stdcall;
  603.  
  604. {$EXTERNALSYM SymGetSymFromName}
  605. function SymGetSymFromName(hProcess: THandle; Name: LPSTR;
  606.   var Symbol: TImagehlpSymbol): Bool; stdcall;
  607.  
  608. {$EXTERNALSYM SymGetSymNext}
  609. function SymGetSymNext(hProcess: THandle; var Symbol: TImagehlpSymbol): Bool; stdcall;
  610.  
  611. {$EXTERNALSYM SymGetSymPrev}
  612. function SymGetSymPrev(hProcess: THandle; var Symbol: TImagehlpSymbol): Bool; stdcall;
  613.  
  614. {$EXTERNALSYM SymInitialize}
  615. function SymInitialize(hProcess: THandle; UserSearchPath: LPSTR;
  616.   fInvadeProcess: Bool): Bool; stdcall;
  617.  
  618. {$EXTERNALSYM SymGetSearchPath}
  619. function SymGetSearchPath(hProcess: THandle; SearchPath: LPSTR;
  620.   SearchPathLength: DWORD): Bool; stdcall;
  621.  
  622. {$EXTERNALSYM SymSetSearchPath}
  623. function SymSetSearchPath(hProcess: THandle; SearchPath: LPSTR): Bool; stdcall;
  624.  
  625. {$EXTERNALSYM SymLoadModule}
  626. function SymLoadModule(hProcess: THandle; hFile: THandle; ImageName,
  627.   ModuleName: LPSTR; BaseOfDll, SizeOfDll: DWORD): Bool; stdcall;
  628.  
  629. {$EXTERNALSYM SymUnloadModule}
  630. function SymUnloadModule(hProcess: THandle; BaseOfDll: DWORD): Bool; stdcall;
  631.  
  632. {$EXTERNALSYM SymUnDName}
  633. function SymUnDName(sym: PImagehlpSymbol; UnDecName: LPSTR;
  634.   UnDecNameLength: DWORD): Bool; stdcall;
  635.  
  636. {$EXTERNALSYM SymRegisterCallback}
  637. function SymRegisterCallback(hProcess: THandle;
  638.   CallbackFunction: TSymbolRegisteredCallback; UserContext: Pointer): Bool; stdcall;
  639.  
  640. { Image Integrity API's }
  641.  
  642. const
  643.   {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_DEBUG_INFO}
  644.   CERT_PE_IMAGE_DIGEST_DEBUG_INFO             = $01;
  645.   {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_RESOURCES}
  646.   CERT_PE_IMAGE_DIGEST_RESOURCES              = $02;
  647.   {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO}
  648.   CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO        = $04;
  649.  
  650.   {$EXTERNALSYM CERT_SECTION_TYPE_ANY}
  651.   CERT_SECTION_TYPE_ANY                       = $FF;      { Any Certificate type }
  652.  
  653. type
  654.   {$EXTERNALSYM DIGEST_HANDLE}
  655.   DIGEST_HANDLE = Pointer;
  656.   TDigestHandle = DIGEST_HANDLE;
  657.  
  658. type
  659.   {$EXTERNALSYM DIGEST_FUNCTION}
  660.   DIGEST_FUNCTION = function(refdata: TDigestHandle; pData: PByte;
  661.     dwLength: DWORD): Bool; stdcall;
  662.   TDigestFunction = DIGEST_FUNCTION;
  663.  
  664. {$EXTERNALSYM ImageGetDigestStream}
  665. function ImageGetDigestStream(FileHandle: THandle; DigestLevel: DWORD;
  666.   DigestFunction: TDigestFunction; DigestHandle: TDigestHandle): Bool; stdcall;
  667.  
  668. {$EXTERNALSYM ImageAddCertificate}
  669. function ImageAddCertificate(FileHandle: THandle;
  670.   var Certificate: PWinCertificate; var Index: DWORD): Bool; stdcall;
  671.  
  672. {$EXTERNALSYM ImageRemoveCertificate}
  673. function ImageRemoveCertificate(FileHandle: THandle; Index: DWORD): Bool; stdcall;
  674.  
  675. {$EXTERNALSYM ImageEnumerateCertificates}
  676. function ImageEnumerateCertificates(FileHandle: THandle; TypeFilter: Word;
  677.   CertificateCount, Indices, IndexCount: PDWORD): Bool; stdcall;
  678.  
  679. {$EXTERNALSYM ImageGetCertificateData}
  680. function ImageGetCertificateData(FileHandle: THandle; CertificateIndex: DWORD;
  681.   Certificate: PWinCertificate; var RequiredLength: DWORD): Bool; stdcall;
  682.  
  683. {$EXTERNALSYM ImageGetCertificateHeader}
  684. function ImageGetCertificateHeader(FileHandle: THandle; CertificateIndex: DWORD;
  685.   var Certificateheader: PWinCertificate): Bool; stdcall;
  686.  
  687. implementation
  688.  
  689. const
  690.   ImagehlpLib = 'IMAGEHLP.DLL';
  691.  
  692. function BindImage;                     external ImagehlpLib name 'BindImage';
  693. function BindImageEx;                   external ImagehlpLib name 'BindImageEx';
  694. function CheckSumMappedFile;            external ImagehlpLib name 'CheckSumMappedFile';
  695. function EnumerateLoadedModules;        external ImagehlpLib name 'EnumerateLoadedModules';
  696. function FindDebugInfoFile;             external ImagehlpLib name 'FindDebugInfoFile';
  697. function FindExecutableImage;           external ImagehlpLib name 'FindExecutableImage';
  698. function GetImageConfigInformation;     external ImagehlpLib name 'GetImageConfigInformation';
  699. function GetImageUnusedHeaderBytes;     external ImagehlpLib name 'GetImageUnusedHeaderBytes';
  700. function GetTimestampForLoadedLibrary;  external ImagehlpLib name 'GetTimestampForLoadedLibrary';
  701. function ImageAddCertificate;           external ImagehlpLib name 'ImageAddCertificate';
  702. function ImageDirectoryEntryToData;     external ImagehlpLib name 'ImageDirectoryEntryToData';
  703. function ImageEnumerateCertificates;    external ImagehlpLib name 'ImageEnumerateCertificates';
  704. function ImageGetCertificateData;       external ImagehlpLib name 'ImageGetCertificateData';
  705. function ImageGetCertificateHeader;     external ImagehlpLib name 'ImageGetCertificateHeader';
  706. function ImageGetDigestStream;          external ImagehlpLib name 'ImageGetDigestStream';
  707. function ImagehlpApiVersion;            external ImagehlpLib name 'ImagehlpApiVersion';
  708. function ImagehlpApiVersionEx;          external ImagehlpLib name 'ImagehlpApiVersionEx';
  709. function ImageLoad;                     external ImagehlpLib name 'ImageLoad';
  710. function ImageNtHeader;                 external ImagehlpLib name 'ImageNtHeader';
  711. function ImageRemoveCertificate;        external ImagehlpLib name 'ImageRemoveCertificate';
  712. function ImageRvaToSection;             external ImagehlpLib name 'ImageRvaToSection';
  713. function ImageRvaToVa;                  external ImagehlpLib name 'ImageRvaToVa';
  714. function ImageUnload;                   external ImagehlpLib name 'ImageUnload';
  715. function MakeSureDirectoryPathExists;   external ImagehlpLib name 'MakeSureDirectoryPathExists';
  716. function MapAndLoad;                    external ImagehlpLib name 'MapAndLoad';
  717. function MapDebugInformation;           external ImagehlpLib name 'MapDebugInformation';
  718. function MapFileAndCheckSum;           external ImagehlpLib name 'MapFileAndCheckSumA';
  719. function MapFileAndCheckSumA;           external ImagehlpLib name 'MapFileAndCheckSumA';
  720. function MapFileAndCheckSumW;           external ImagehlpLib name 'MapFileAndCheckSumW';
  721. function ReBaseImage;                   external ImagehlpLib name 'ReBaseImage';
  722. function RemovePrivateCvSymbolic;       external ImagehlpLib name 'RemovePrivateCvSymbolic';
  723. procedure RemoveRelocations;            external ImagehlpLib name 'RemoveRelocations';
  724. function SearchTreeForFile;             external ImagehlpLib name 'SearchTreeForFile';
  725. function SetImageConfigInformation;     external ImagehlpLib name 'SetImageConfigInformation';
  726. function SplitSymbols;                  external ImagehlpLib name 'SplitSymbols';
  727. function StackWalk;                     external ImagehlpLib name 'StackWalk';
  728. function SymCleanup;                    external ImagehlpLib name 'SymCleanup';
  729. function SymEnumerateModules;           external ImagehlpLib name 'SymEnumerateModules';
  730. function SymEnumerateSymbols;           external ImagehlpLib name 'SymEnumerateSymbols';
  731. function SymFunctionTableAccess;        external ImagehlpLib name 'SymFunctionTableAccess';
  732. function SymGetModuleBase;              external ImagehlpLib name 'SymGetModuleBase';
  733. function SymGetModuleInfo;              external ImagehlpLib name 'SymGetModuleInfo';
  734. function SymGetOptions;                 external ImagehlpLib name 'SymGetOptions';
  735. function SymGetSearchPath;              external ImagehlpLib name 'SymGetSearchPath';
  736. function SymGetSymFromAddr;             external ImagehlpLib name 'SymGetSymFromAddr';
  737. function SymGetSymFromName;             external ImagehlpLib name 'SymGetSymFromName';
  738. function SymGetSymNext;                 external ImagehlpLib name 'SymGetSymNext';
  739. function SymGetSymPrev;                 external ImagehlpLib name 'SymGetSymPrev';
  740. function SymInitialize;                 external ImagehlpLib name 'SymInitialize';
  741. function SymLoadModule;                 external ImagehlpLib name 'SymLoadModule';
  742. function SymRegisterCallback;           external ImagehlpLib name 'SymRegisterCallback';
  743. function SymSetOptions;                 external ImagehlpLib name 'SymSetOptions';
  744. function SymSetSearchPath;              external ImagehlpLib name 'SymSetSearchPath';
  745. function SymUnDName;                    external ImagehlpLib name 'SymUnDName';
  746. function SymUnloadModule;               external ImagehlpLib name 'SymUnloadModule';
  747. function TouchFileTimes;                external ImagehlpLib name 'TouchFileTimes';
  748. function UnDecorateSymbolName;          external ImagehlpLib name 'UnDecorateSymbolName';
  749. function UnMapAndLoad;                  external ImagehlpLib name 'UnMapAndLoad';
  750. function UnmapDebugInformation;         external ImagehlpLib name 'UnmapDebugInformation';
  751. function UpdateDebugInfoFile;           external ImagehlpLib name 'UpdateDebugInfoFile';
  752. function UpdateDebugInfoFileEx;         external ImagehlpLib name 'UpdateDebugInfoFileEx';
  753.  
  754. end.
  755.