jwaimagehlp.pas

比较全面的win32api开发包

  {$EXTERNALSYM IMAGEHLP_MODULE64}
  TImageHlpModule64 = IMAGEHLP_MODULE64;
  PImageHlpModule64 = PIMAGEHLP_MODULE64;

  PIMAGEHLP_MODULEW64 = ^IMAGEHLP_MODULEW64;
  {$EXTERNALSYM PIMAGEHLP_MODULEW64}
  _IMAGEHLP_MODULE64W = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
    BaseOfImage: DWORD64; // base load address of module
    ImageSize: DWORD; // virtual size of the loaded module
    TimeDateStamp: DWORD; // date/time stamp from pe header
    CheckSum: DWORD; // checksum from the pe header
    NumSyms: DWORD; // number of symbols in the symbol table
    SymType: SYM_TYPE; // type of symbols loaded
    ModuleName: array [0..31] of WCHAR; // module name
    ImageName: array [0..255] of WCHAR; // image name
    LoadedImageName: array [0..255] of WCHAR; // symbol file name
  end;
  {$EXTERNALSYM _IMAGEHLP_MODULE64W}
  IMAGEHLP_MODULEW64 = _IMAGEHLP_MODULE64W;
  {$EXTERNALSYM IMAGEHLP_MODULEW64}
  TImageHlpModuleW64 = IMAGEHLP_MODULEW64;
  PImageHlpModuleW64 = PIMAGEHLP_MODULEW64;

  PIMAGEHLP_MODULE = ^IMAGEHLP_MODULE;
  {$EXTERNALSYM PIMAGEHLP_MODULE}
  _IMAGEHLP_MODULE = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
    BaseOfImage: DWORD; // base load address of module
    ImageSize: DWORD; // virtual size of the loaded module
    TimeDateStamp: DWORD; // date/time stamp from pe header
    CheckSum: DWORD; // checksum from the pe header
    NumSyms: DWORD; // number of symbols in the symbol table
    SymType: SYM_TYPE; // type of symbols loaded
    ModuleName: array [0..31] of CHAR; // module name
    ImageName: array [0..255] of CHAR; // image name
    LoadedImageName: array [0..255] of CHAR; // symbol file name
  end;
  {$EXTERNALSYM _IMAGEHLP_MODULE}
  IMAGEHLP_MODULE = _IMAGEHLP_MODULE;
  {$EXTERNALSYM IMAGEHLP_MODULE}
  TImageHlpModule = IMAGEHLP_MODULE;
  PImageHlpModule = PIMAGEHLP_MODULE;

  PIMAGEHLP_MODULEW = ^IMAGEHLP_MODULEW;
  {$EXTERNALSYM PIMAGEHLP_MODULEW}
  _IMAGEHLP_MODULEW = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
    BaseOfImage: DWORD; // base load address of module
    ImageSize: DWORD; // virtual size of the loaded module
    TimeDateStamp: DWORD; // date/time stamp from pe header
    CheckSum: DWORD; // checksum from the pe header
    NumSyms: DWORD; // number of symbols in the symbol table
    SymType: SYM_TYPE; // type of symbols loaded
    ModuleName: array [0..31] of WCHAR; // module name
    ImageName: array [0..255] of WCHAR; // image name
    LoadedImageName: array [0..255] of WCHAR; // symbol file name
  end;
  {$EXTERNALSYM _IMAGEHLP_MODULEW}
  IMAGEHLP_MODULEW = _IMAGEHLP_MODULEW;
  {$EXTERNALSYM IMAGEHLP_MODULEW}
  TImageHlpModuleW = IMAGEHLP_MODULEW;
  PImageHlpModuleW = PIMAGEHLP_MODULEW;

//
// source file line data structure
//

  PIMAGEHLP_LINE64 = ^IMAGEHLP_LINE64;
  {$EXTERNALSYM PIMAGEHLP_LINE64}
  _IMAGEHLP_LINE64 = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE64)
    Key: PVOID; // internal
    LineNumber: DWORD; // line number in file
    FileName: PCHAR; // full filename
    Address: DWORD64; // first instruction of line
  end;
  {$EXTERNALSYM _IMAGEHLP_LINE64}
  IMAGEHLP_LINE64 = _IMAGEHLP_LINE64;
  {$EXTERNALSYM IMAGEHLP_LINE64}
  TImageHlpLine64 = IMAGEHLP_LINE64;
  PImageHlpLine64 = PIMAGEHLP_LINE64;

  PIMAGEHLP_LINE = ^IMAGEHLP_LINE;
  {$EXTERNALSYM PIMAGEHLP_LINE}
  _IMAGEHLP_LINE = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE)
    Key: PVOID; // internal
    LineNumber: DWORD; // line number in file
    FileName: PCHAR; // full filename
    Address: DWORD; // first instruction of line
  end;
  {$EXTERNALSYM _IMAGEHLP_LINE}
  IMAGEHLP_LINE = _IMAGEHLP_LINE;
  {$EXTERNALSYM IMAGEHLP_LINE}
  TImageHlpLine = IMAGEHLP_LINE;
  PImageHlpLine = PIMAGEHLP_LINE;

//
// source file structure
//

type
  _SOURCEFILE = record
    ModBase: DWORD64;                // base address of loaded module
    FileName: PCHAR;                 // full filename of source
  end;
  {$EXTERNALSYM _SOURCEFILE}
  SOURCEFILE = _SOURCEFILE;
  {$EXTERNALSYM SOURCEFILE}
  PSOURCEFILE = ^SOURCEFILE;
  {$EXTERNALSYM PSOURCEFILE}
  TSourceFile = SOURCEFILE;

//
// data structures used for registered symbol callbacks
//

const
  CBA_DEFERRED_SYMBOL_LOAD_START    = $00000001;
  {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_START}
  CBA_DEFERRED_SYMBOL_LOAD_COMPLETE = $00000002;
  {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_COMPLETE}
  CBA_DEFERRED_SYMBOL_LOAD_FAILURE  = $00000003;
  {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_FAILURE}
  CBA_SYMBOLS_UNLOADED              = $00000004;
  {$EXTERNALSYM CBA_SYMBOLS_UNLOADED}
  CBA_DUPLICATE_SYMBOL              = $00000005;
  {$EXTERNALSYM CBA_DUPLICATE_SYMBOL}
  CBA_READ_MEMORY                   = $00000006;
  {$EXTERNALSYM CBA_READ_MEMORY}
  CBA_DEFERRED_SYMBOL_LOAD_CANCEL   = $00000007;
  {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_CANCEL}
  CBA_SET_OPTIONS                   = $00000008;
  {$EXTERNALSYM CBA_SET_OPTIONS}
  CBA_EVENT                         = $00000010;
  {$EXTERNALSYM CBA_EVENT}
  CBA_DEFERRED_SYMBOL_LOAD_PARTIAL  = $00000020;
  {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_PARTIAL}
  CBA_DEBUG_INFO                    = $10000000;
  {$EXTERNALSYM CBA_DEBUG_INFO}

type
  PIMAGEHLP_CBA_READ_MEMORY = ^IMAGEHLP_CBA_READ_MEMORY;
  {$EXTERNALSYM PIMAGEHLP_CBA_READ_MEMORY}
  _IMAGEHLP_CBA_READ_MEMORY = record
    addr: DWORD64; // address to read from
    buf: PVOID; // buffer to read to
    bytes: DWORD; // amount of bytes to read
    bytesread: LPDWORD; // pointer to store amount of bytes read
  end;
  {$EXTERNALSYM _IMAGEHLP_CBA_READ_MEMORY}
  IMAGEHLP_CBA_READ_MEMORY = _IMAGEHLP_CBA_READ_MEMORY;
  {$EXTERNALSYM IMAGEHLP_CBA_READ_MEMORY}
  TImageHlpCbaReadMemory = IMAGEHLP_CBA_READ_MEMORY;
  PImageHlpCbaReadMemory = PIMAGEHLP_CBA_READ_MEMORY;

const
  sevInfo    = 0;
  {$EXTERNALSYM sevInfo}
  sevProblem = 1;
  {$EXTERNALSYM sevProblem}
  sevAttn    = 2;
  {$EXTERNALSYM sevAttn}
  sevFatal   = 3;
  {$EXTERNALSYM sevFatal}
  sevMax     = 4; // unused
  {$EXTERNALSYM sevMax}

type
  _IMAGEHLP_CBA_EVENT = record
    severity: DWORD;                                     // values from sevInfo to sevFatal
    code: DWORD;                                         // numerical code IDs the error
    desc: PCHAR;                                         // may contain a text description of the error
    object_: PVOID;                                      // value dependant upon the error code
  end;
  {$EXTERNALSYM _IMAGEHLP_CBA_EVENT}
  IMAGEHLP_CBA_EVENT = _IMAGEHLP_CBA_EVENT;
  {$EXTERNALSYM IMAGEHLP_CBA_EVENT}
  PIMAGEHLP_CBA_EVENT = ^IMAGEHLP_CBA_EVENT;
  {$EXTERNALSYM PIMAGEHLP_CBA_EVENT}
  TImageHlpCbaEvent = IMAGEHLP_CBA_EVENT;
  PImageHlpCbaEvent = PIMAGEHLP_CBA_EVENT;

  PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
  {$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD64}
  _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
    BaseOfImage: DWORD64; // base load address of module
    CheckSum: DWORD; // checksum from the pe header
    TimeDateStamp: DWORD; // date/time stamp from pe header
    FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
    Reparse: ByteBool; // load failure reparse
    hFile: HANDLE; // file handle, if passed
    Flags: DWORD; //
  end;
  {$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
  IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = _IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
  {$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
  TImageHlpDeferredSymbolLoad64 = IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
  PImageHlpDeferredSymbolLoad64 = PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;

const
  DSLFLAG_MISMATCHED_PDB = $1;
  {$EXTERNALSYM DSLFLAG_MISMATCHED_PDB}
  DSLFLAG_MISMATCHED_DBG = $2;
  {$EXTERNALSYM DSLFLAG_MISMATCHED_DBG}

type
  PIMAGEHLP_DEFERRED_SYMBOL_LOAD = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  {$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD}
  _IMAGEHLP_DEFERRED_SYMBOL_LOAD = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
    BaseOfImage: DWORD; // base load address of module
    CheckSum: DWORD; // checksum from the pe header
    TimeDateStamp: DWORD; // date/time stamp from pe header
    FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
    Reparse: ByteBool; // load failure reparse
    hFile: HANDLE; // file handle, if passed    
  end;
  {$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD}
  IMAGEHLP_DEFERRED_SYMBOL_LOAD = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  {$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD}
  TImageHlpDeferredSymbolLoad = IMAGEHLP_DEFERRED_SYMBOL_LOAD;
  PImageHlpDeferredSymbolLoad = PIMAGEHLP_DEFERRED_SYMBOL_LOAD;

  PIMAGEHLP_DUPLICATE_SYMBOL64 = ^IMAGEHLP_DUPLICATE_SYMBOL64;
  {$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL64}
  _IMAGEHLP_DUPLICATE_SYMBOL64 = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
    NumberOfDups: DWORD; // number of duplicates in the Symbol array
    Symbol: PIMAGEHLP_SYMBOL64; // array of duplicate symbols
    SelectedSymbol: DWORD; // symbol selected (-1 to start)
  end;
  {$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL64}
  IMAGEHLP_DUPLICATE_SYMBOL64 = _IMAGEHLP_DUPLICATE_SYMBOL64;
  {$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL64}
  TImageHlpDuplicateSymbol64 = IMAGEHLP_DUPLICATE_SYMBOL64;
  PImageHlpDuplicateSymbol64 = PIMAGEHLP_DUPLICATE_SYMBOL64;

  PIMAGEHLP_DUPLICATE_SYMBOL = ^IMAGEHLP_DUPLICATE_SYMBOL;
  {$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL}
  _IMAGEHLP_DUPLICATE_SYMBOL = record
    SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
    NumberOfDups: DWORD; // number of duplicates in the Symbol array
    Symbol: PIMAGEHLP_SYMBOL; // array of duplicate symbols
    SelectedSymbol: DWORD; // symbol selected (-1 to start)
  end;
  {$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL}
  IMAGEHLP_DUPLICATE_SYMBOL = _IMAGEHLP_DUPLICATE_SYMBOL;
  {$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL}
  TImageHlpDuplicateSymbol = IMAGEHLP_DUPLICATE_SYMBOL;
  PImageHlpDuplicateSymbol = PIMAGEHLP_DUPLICATE_SYMBOL;

// If dbghelp ever needs to display graphical UI, it will use this as the parent window.

//BOOL
//SymSetParentWindow(
//    HWND hwnd
//    );

//
// options that are set/returned by SymSetOptions() & SymGetOptions()
// these are used as a mask
//

const
  SYMOPT_CASE_INSENSITIVE  = $00000001;
  {$EXTERNALSYM SYMOPT_CASE_INSENSITIVE}
  SYMOPT_UNDNAME           = $00000002;
  {$EXTERNALSYM SYMOPT_UNDNAME}
  SYMOPT_DEFERRED_LOADS    = $00000004;
  {$EXTERNALSYM SYMOPT_DEFERRED_LOADS}
  SYMOPT_NO_CPP            = $00000008;
  {$EXTERNALSYM SYMOPT_NO_CPP}
  SYMOPT_LOAD_LINES        = $00000010;
  {$EXTERNALSYM SYMOPT_LOAD_LINES}
  SYMOPT_OMAP_FIND_NEAREST = $00000020;
  {$EXTERNALSYM SYMOPT_OMAP_FIND_NEAREST}
  SYMOPT_LOAD_ANYTHING         = $00000040;
  {$EXTERNALSYM SYMOPT_LOAD_ANYTHING}
  SYMOPT_IGNORE_CVREC          = $00000080;
  {$EXTERNALSYM SYMOPT_IGNORE_CVREC}
  SYMOPT_NO_UNQUALIFIED_LOADS  = $00000100;
  {$EXTERNALSYM SYMOPT_NO_UNQUALIFIED_LOADS}
  SYMOPT_FAIL_CRITICAL_ERRORS  = $00000200;
  {$EXTERNALSYM SYMOPT_FAIL_CRITICAL_ERRORS}
  SYMOPT_EXACT_SYMBOLS         = $00000400;
  {$EXTERNALSYM SYMOPT_EXACT_SYMBOLS}
  SYMOPT_ALLOW_ABSOLUTE_SYMBOLS = $00000800;
  {$EXTERNALSYM SYMOPT_ALLOW_ABSOLUTE_SYMBOLS}
  SYMOPT_IGNORE_NT_SYMPATH      = $00001000;
  {$EXTERNALSYM SYMOPT_IGNORE_NT_SYMPATH}
  SYMOPT_INCLUDE_32BIT_MODULES = $00002000;
  {$EXTERNALSYM SYMOPT_INCLUDE_32BIT_MODULES}
  SYMOPT_PUBLICS_ONLY          = $00004000;
  {$EXTERNALSYM SYMOPT_PUBLICS_ONLY}
  SYMOPT_NO_PUBLICS            = $00008000;
  {$EXTERNALSYM SYMOPT_NO_PUBLICS}
  SYMOPT_AUTO_PUBLICS          = $00010000;
  {$EXTERNALSYM SYMOPT_AUTO_PUBLICS}
  SYMOPT_NO_IMAGE_SEARCH       = $00020000;
  {$EXTERNALSYM SYMOPT_NO_IMAGE_SEARCH}
  SYMOPT_SECURE                = $00040000;
  {$EXTERNALSYM SYMOPT_SECURE}

  SYMOPT_DEBUG             = DWORD($80000000);
  {$EXTERNALSYM SYMOPT_DEBUG}

function SymSetOptions(SymOptions: DWORD): DWORD; stdcall;
{$EXTERNALSYM SymSetOptions}

function SymGetOptions: DWORD; stdcall;
{$EXTERNALSYM SymGetOptions}

function SymCleanup(hProcess: HANDLE): BOOL; stdcall;
{$EXTERNALSYM SymCleanup}

function SymMatchString(string_, expression: LPSTR; fCase: BOOL): BOOL; stdcall;
{$EXTERNALSYM SymMatchString}

type
  PSYM_ENUMSOURCFILES_CALLBACK = function (pSourceFile: PSOURCEFILE; UserContext: PVOID): BOOL; stdcall;
  {$EXTERNALSYM PSYM_ENUMSOURCFILES_CALLBACK}
  PSymEnumSourceFilesCallback = PSYM_ENUMSOURCFILES_CALLBACK;

function SymEnumSourceFiles(hProcess: HANDLE; ModBase: ULONG64; Mask: LPSTR;
  cbSrcFiles: PSYM_ENUMSOURCFILES_CALLBACK; UserContext: PVOID): BOOL; stdcall;
{$EXTERNALSYM SymEnumSourceFiles}

function SymEnumerateModules64(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK64;
  UserContext: PVOID): BOOL; stdcall;
{$EXTERNALSYM SymEnumerateModules64}

function SymEnumerateModules(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK;
  UserContext: PVOID): BOOL; stdcall;
{$EXTERNALSYM SymEnumerateModules}