Windows编程

开发平台：

Delphi

JwaImageHlp.pas：源码内容

//
const
MINIDUMP_MISC1_PROCESS_ID = $00000001;
{$EXTERNALSYM MINIDUMP_MISC1_PROCESS_ID}
MINIDUMP_MISC1_PROCESS_TIMES = $00000002;
{$EXTERNALSYM MINIDUMP_MISC1_PROCESS_TIMES}
type
_MINIDUMP_MISC_INFO = record
SizeOfInfo: ULONG32;
Flags1: ULONG32;
ProcessId: ULONG32;
ProcessCreateTime: ULONG32;
ProcessUserTime: ULONG32;
ProcessKernelTime: ULONG32;
end;
{$EXTERNALSYM _MINIDUMP_MISC_INFO}
MINIDUMP_MISC_INFO = _MINIDUMP_MISC_INFO;
{$EXTERNALSYM MINIDUMP_MISC_INFO}
PMINIDUMP_MISC_INFO = ^MINIDUMP_MISC_INFO;
{$EXTERNALSYM PMINIDUMP_MISC_INFO}
TMiniDumpMiscInfo = MINIDUMP_MISC_INFO;
PMiniDumpMiscInfo = PMINIDUMP_MISC_INFO;
//
// Support for arbitrary user-defined information.
//
PMINIDUMP_USER_RECORD = ^MINIDUMP_USER_RECORD;
{$EXTERNALSYM PMINIDUMP_USER_RECORD}
_MINIDUMP_USER_RECORD = record
Type_: ULONG32;
Memory: MINIDUMP_LOCATION_DESCRIPTOR;
end;
{$EXTERNALSYM _MINIDUMP_USER_RECORD}
MINIDUMP_USER_RECORD = _MINIDUMP_USER_RECORD;
{$EXTERNALSYM MINIDUMP_USER_RECORD}
TMinidumpUserRecord = MINIDUMP_USER_RECORD;
PMinidumpUserRecord = PMINIDUMP_USER_RECORD;
PMINIDUMP_USER_STREAM = ^MINIDUMP_USER_STREAM;
{$EXTERNALSYM PMINIDUMP_USER_STREAM}
_MINIDUMP_USER_STREAM = record
Type_: ULONG32;
BufferSize: ULONG;
Buffer: PVOID;
end;
{$EXTERNALSYM _MINIDUMP_USER_STREAM}
MINIDUMP_USER_STREAM = _MINIDUMP_USER_STREAM;
{$EXTERNALSYM MINIDUMP_USER_STREAM}
TMinidumpUserStream = MINIDUMP_USER_STREAM;
PMinidumpUserStream = PMINIDUMP_USER_STREAM;
PMINIDUMP_USER_STREAM_INFORMATION = ^MINIDUMP_USER_STREAM_INFORMATION;
{$EXTERNALSYM PMINIDUMP_USER_STREAM_INFORMATION}
_MINIDUMP_USER_STREAM_INFORMATION = record
UserStreamCount: ULONG;
UserStreamArray: PMINIDUMP_USER_STREAM;
end;
{$EXTERNALSYM _MINIDUMP_USER_STREAM_INFORMATION}
MINIDUMP_USER_STREAM_INFORMATION = _MINIDUMP_USER_STREAM_INFORMATION;
{$EXTERNALSYM MINIDUMP_USER_STREAM_INFORMATION}
TMinidumpUserStreamInformation = MINIDUMP_USER_STREAM_INFORMATION;
PMinidumpUserStreamInformation = PMINIDUMP_USER_STREAM_INFORMATION;
//
// Callback support.
//
_MINIDUMP_CALLBACK_TYPE = (
ModuleCallback,
ThreadCallback,
ThreadExCallback,
IncludeThreadCallback,
IncludeModuleCallback);
{$EXTERNALSYM _MINIDUMP_CALLBACK_TYPE}
MINIDUMP_CALLBACK_TYPE = _MINIDUMP_CALLBACK_TYPE;
{$EXTERNALSYM MINIDUMP_CALLBACK_TYPE}
TMinidumpCallbackType = MINIDUMP_CALLBACK_TYPE;
PMINIDUMP_THREAD_CALLBACK = ^MINIDUMP_THREAD_CALLBACK;
{$EXTERNALSYM PMINIDUMP_THREAD_CALLBACK}
_MINIDUMP_THREAD_CALLBACK = record
ThreadId: ULONG;
ThreadHandle: HANDLE;
Context: CONTEXT;
SizeOfContext: ULONG;
StackBase: ULONG64;
StackEnd: ULONG64;
end;
{$EXTERNALSYM _MINIDUMP_THREAD_CALLBACK}
MINIDUMP_THREAD_CALLBACK = _MINIDUMP_THREAD_CALLBACK;
{$EXTERNALSYM MINIDUMP_THREAD_CALLBACK}
TMinidumpThreadCallback = MINIDUMP_THREAD_CALLBACK;
PMinidumpThreadCallback = PMINIDUMP_THREAD_CALLBACK;
PMINIDUMP_THREAD_EX_CALLBACK = ^MINIDUMP_THREAD_EX_CALLBACK;
{$EXTERNALSYM PMINIDUMP_THREAD_EX_CALLBACK}
_MINIDUMP_THREAD_EX_CALLBACK = record
ThreadId: ULONG;
ThreadHandle: HANDLE;
Context: CONTEXT;
SizeOfContext: ULONG;
StackBase: ULONG64;
StackEnd: ULONG64;
BackingStoreBase: ULONG64;
BackingStoreEnd: ULONG64;
end;
{$EXTERNALSYM _MINIDUMP_THREAD_EX_CALLBACK}
MINIDUMP_THREAD_EX_CALLBACK = _MINIDUMP_THREAD_EX_CALLBACK;
{$EXTERNALSYM MINIDUMP_THREAD_EX_CALLBACK}
TMinidumpThreadExCallback = MINIDUMP_THREAD_EX_CALLBACK;
PMinidumpThreadExCallback = PMINIDUMP_THREAD_EX_CALLBACK;
PMINIDUMP_INCLUDE_THREAD_CALLBACK = ^MINIDUMP_INCLUDE_THREAD_CALLBACK;
{$EXTERNALSYM PMINIDUMP_INCLUDE_THREAD_CALLBACK}
_MINIDUMP_INCLUDE_THREAD_CALLBACK = record
ThreadId: ULONG;
end;
{$EXTERNALSYM _MINIDUMP_INCLUDE_THREAD_CALLBACK}
MINIDUMP_INCLUDE_THREAD_CALLBACK = _MINIDUMP_INCLUDE_THREAD_CALLBACK;
{$EXTERNALSYM MINIDUMP_INCLUDE_THREAD_CALLBACK}
TMinidumpIncludeThreadCallback = MINIDUMP_INCLUDE_THREAD_CALLBACK;
PMinidumpIncludeThreadCallback = PMINIDUMP_INCLUDE_THREAD_CALLBACK;
const
ThreadWriteThread = $0001;
{$EXTERNALSYM ThreadWriteThread}
ThreadWriteStack = $0002;
{$EXTERNALSYM ThreadWriteStack}
ThreadWriteContext = $0004;
{$EXTERNALSYM ThreadWriteContext}
ThreadWriteBackingStore = $0008;
{$EXTERNALSYM ThreadWriteBackingStore}
ThreadWriteInstructionWindow = $0010;
{$EXTERNALSYM ThreadWriteInstructionWindow}
ThreadWriteThreadData = $0020;
{$EXTERNALSYM ThreadWriteThreadData}
type
_THREAD_WRITE_FLAGS = DWORD;
{$EXTERNALSYM _THREAD_WRITE_FLAGS}
THREAD_WRITE_FLAGS = _THREAD_WRITE_FLAGS;
{$EXTERNALSYM THREAD_WRITE_FLAGS}
TThreadWriteFlags = THREAD_WRITE_FLAGS;
type
PMINIDUMP_MODULE_CALLBACK = ^MINIDUMP_MODULE_CALLBACK;
{$EXTERNALSYM PMINIDUMP_MODULE_CALLBACK}
_MINIDUMP_MODULE_CALLBACK = record
FullPath: PWCHAR;
BaseOfImage: ULONG64;
SizeOfImage: ULONG;
CheckSum: ULONG;
TimeDateStamp: ULONG;
VersionInfo: VS_FIXEDFILEINFO;
CvRecord: PVOID;
SizeOfCvRecord: ULONG;
MiscRecord: PVOID;
SizeOfMiscRecord: ULONG;
end;
{$EXTERNALSYM _MINIDUMP_MODULE_CALLBACK}
MINIDUMP_MODULE_CALLBACK = _MINIDUMP_MODULE_CALLBACK;
{$EXTERNALSYM MINIDUMP_MODULE_CALLBACK}
TMinidumpModuleCallback = MINIDUMP_MODULE_CALLBACK;
PMinidumpModuleCallback = PMINIDUMP_MODULE_CALLBACK;
PMINIDUMP_INCLUDE_MODULE_CALLBACK = ^MINIDUMP_INCLUDE_MODULE_CALLBACK;
{$EXTERNALSYM PMINIDUMP_INCLUDE_MODULE_CALLBACK}
_MINIDUMP_INCLUDE_MODULE_CALLBACK = record
BaseOfImage: ULONG64;
end;
{$EXTERNALSYM _MINIDUMP_INCLUDE_MODULE_CALLBACK}
MINIDUMP_INCLUDE_MODULE_CALLBACK = _MINIDUMP_INCLUDE_MODULE_CALLBACK;
{$EXTERNALSYM MINIDUMP_INCLUDE_MODULE_CALLBACK}
TMinidumpIncludeModuleCallback = MINIDUMP_INCLUDE_MODULE_CALLBACK;
PMinidumpIncludeModuleCallback = PMINIDUMP_INCLUDE_MODULE_CALLBACK;
const
ModuleWriteModule = $0001;
{$EXTERNALSYM ModuleWriteModule}
ModuleWriteDataSeg = $0002;
{$EXTERNALSYM ModuleWriteDataSeg}
ModuleWriteMiscRecord = $0004;
{$EXTERNALSYM ModuleWriteMiscRecord}
ModuleWriteCvRecord = $0008;
{$EXTERNALSYM ModuleWriteCvRecord}
ModuleReferencedByMemory = $0010;
{$EXTERNALSYM ModuleReferencedByMemory}
type
_MODULE_WRITE_FLAGS = DWORD;
{$EXTERNALSYM _MODULE_WRITE_FLAGS}
MODULE_WRITE_FLAGS = _MODULE_WRITE_FLAGS;
{$EXTERNALSYM MODULE_WRITE_FLAGS}
TModuleWriteFlags = MODULE_WRITE_FLAGS;
_MINIDUMP_CALLBACK_INPUT = record
ProcessId: ULONG;
ProcessHandle: HANDLE;
CallbackType: ULONG;
case Integer of
0: (Thread: MINIDUMP_THREAD_CALLBACK);
1: (ThreadEx: MINIDUMP_THREAD_EX_CALLBACK);
2: (Module: MINIDUMP_MODULE_CALLBACK);
3: (IncludeThread: MINIDUMP_INCLUDE_THREAD_CALLBACK);
4: (IncludeModule: MINIDUMP_INCLUDE_MODULE_CALLBACK);
end;
{$EXTERNALSYM _MINIDUMP_CALLBACK_INPUT}
MINIDUMP_CALLBACK_INPUT = _MINIDUMP_CALLBACK_INPUT;
{$EXTERNALSYM MINIDUMP_CALLBACK_INPUT}
PMINIDUMP_CALLBACK_INPUT = ^MINIDUMP_CALLBACK_INPUT;
{$EXTERNALSYM PMINIDUMP_CALLBACK_INPUT}
TminidumpCallbackInput = MINIDUMP_CALLBACK_INPUT;
PMINIDUMP_CALLBACK_OUTPUT = ^MINIDUMP_CALLBACK_OUTPUT;
{$EXTERNALSYM PMINIDUMP_CALLBACK_OUTPUT}
_MINIDUMP_CALLBACK_OUTPUT = record
case Integer of
0: (ModuleWriteFlags: ULONG);
1: (ThreadWriteFlags: ULONG);
end;
{$EXTERNALSYM _MINIDUMP_CALLBACK_OUTPUT}
MINIDUMP_CALLBACK_OUTPUT = _MINIDUMP_CALLBACK_OUTPUT;
{$EXTERNALSYM MINIDUMP_CALLBACK_OUTPUT}
TMinidumpCallbackOutput = MINIDUMP_CALLBACK_OUTPUT;
PMinidumpCallbackOutput = PMINIDUMP_CALLBACK_OUTPUT;
//
// A normal minidump contains just the information
// necessary to capture stack traces for all of the
// existing threads in a process.
//
// A minidump with data segments includes all of the data
// sections from loaded modules in order to capture
// global variable contents. This can make the dump much
// larger if many modules have global data.
//
// A minidump with full memory includes all of the accessible
// memory in the process and can be very large. A minidump
// with full memory always has the raw memory data at the end
// of the dump so that the initial structures in the dump can
// be mapped directly without having to include the raw
// memory information.
//
// Stack and backing store memory can be filtered to remove
// data unnecessary for stack walking. This can improve
// compression of stacks and also deletes data that may
// be private and should not be stored in a dump.
// Memory can also be scanned to see what modules are
// referenced by stack and backing store memory to allow
// omission of other modules to reduce dump size.
// In either of these modes the ModuleReferencedByMemory flag
// is set for all modules referenced before the base
// module callbacks occur.
//
// On some operating systems a list of modules that were
// recently unloaded is kept in addition to the currently
// loaded module list. This information can be saved in
// the dump if desired.
//
// Stack and backing store memory can be scanned for referenced
// pages in order to pick up data referenced by locals or other
// stack memory. This can increase the size of a dump significantly.
//
// Module paths may contain undesired information such as user names
// or other important directory names so they can be stripped. This
// option reduces the ability to locate the proper image later
// and should only be used in certain situations.
//
// Complete operating system per-process and per-thread information can
// be gathered and stored in the dump.
//
// The virtual address space can be scanned for various types
// of memory to be included in the dump.
//
const
MiniDumpNormal = $0000;
{$EXTERNALSYM MiniDumpNormal}
MiniDumpWithDataSegs = $0001;
{$EXTERNALSYM MiniDumpWithDataSegs}
MiniDumpWithFullMemory = $0002;
{$EXTERNALSYM MiniDumpWithFullMemory}
MiniDumpWithHandleData = $0004;
{$EXTERNALSYM MiniDumpWithHandleData}
MiniDumpFilterMemory = $0008;
{$EXTERNALSYM MiniDumpFilterMemory}
MiniDumpScanMemory = $0010;
{$EXTERNALSYM MiniDumpScanMemory}
MiniDumpWithUnloadedModules = $0020;
{$EXTERNALSYM MiniDumpWithUnloadedModules}
MiniDumpWithIndirectlyReferencedMemory = $0040;
{$EXTERNALSYM MiniDumpWithIndirectlyReferencedMemory}
MiniDumpFilterModulePaths = $0080;
{$EXTERNALSYM MiniDumpFilterModulePaths}
MiniDumpWithProcessThreadData = $0100;
{$EXTERNALSYM MiniDumpWithProcessThreadData}
MiniDumpWithPrivateReadWriteMemory = $0200;
{$EXTERNALSYM MiniDumpWithPrivateReadWriteMemory}
type
_MINIDUMP_TYPE = DWORD;
{$EXTERNALSYM _MINIDUMP_TYPE}
MINIDUMP_TYPE = _MINIDUMP_TYPE;
{$EXTERNALSYM MINIDUMP_TYPE}
TMinidumpType = MINIDUMP_TYPE;
//
// The minidump callback should modify the FieldsToWrite parameter to reflect
// what portions of the specified thread or module should be written to the
// file.
//
MINIDUMP_CALLBACK_ROUTINE = function (CallbackParam: PVOID; CallbackInput: PMINIDUMP_CALLBACK_INPUT;
CallbackOutput: PMINIDUMP_CALLBACK_OUTPUT): BOOL; stdcall;
{$EXTERNALSYM MINIDUMP_CALLBACK_ROUTINE}
TMinidumpCallbackRoutine = MINIDUMP_CALLBACK_ROUTINE;
PMINIDUMP_CALLBACK_INFORMATION = ^MINIDUMP_CALLBACK_INFORMATION;
{$EXTERNALSYM PMINIDUMP_CALLBACK_INFORMATION}
_MINIDUMP_CALLBACK_INFORMATION = record
CallbackRoutine: MINIDUMP_CALLBACK_ROUTINE;
CallbackParam: PVOID;
end;
{$EXTERNALSYM _MINIDUMP_CALLBACK_INFORMATION}
MINIDUMP_CALLBACK_INFORMATION = _MINIDUMP_CALLBACK_INFORMATION;
{$EXTERNALSYM MINIDUMP_CALLBACK_INFORMATION}
TMinidumpCallbackInformation = MINIDUMP_CALLBACK_INFORMATION;
PMinidumpCallbackInformation = PMINIDUMP_CALLBACK_INFORMATION;
//++
//
// PVOID
// RVA_TO_ADDR(
// PVOID Mapping,
// ULONG Rva
// )
//
// Routine Description:
//
// Map an RVA that is contained within a mapped file to it's associated
// flat address.
//
// Arguments:
//
// Mapping - Base address of mapped file containing the RVA.
//
// Rva - An Rva to fixup.
//
// Return Values:
//
// A pointer to the desired data.
//
//--
function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
{$EXTERNALSYM RVA_TO_ADDR}
function MiniDumpWriteDump(hProcess: HANDLE; ProcessId: DWORD; hFile: HANDLE; DumpType: MINIDUMP_TYPE; ExceptionParam: PMINIDUMP_EXCEPTION_INFORMATION; UserStreamParam: PMINIDUMP_USER_STREAM_INFORMATION; CallbackParam: PMINIDUMP_CALLBACK_INFORMATION): BOOL; stdcall;
{$EXTERNALSYM MiniDumpWriteDump}
function MiniDumpReadDumpStream(BaseOfDump: PVOID; StreamNumber: ULONG; var Dir: PMINIDUMP_DIRECTORY; var StreamPointer: PVOID; var StreamSize: ULONG): BOOL; stdcall;
{$EXTERNALSYM MiniDumpReadDumpStream}
implementation
procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
begin
a64^.Offset := {ULONG64(LONG64(LONG(}a32^.Offset{)))};
a64^.Segment := a32^.Segment;
a64^.Mode := a32^.Mode;
end;
procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
begin
a32^.Offset := ULONG(a64^.Offset);
a32^.Segment := a64^.Segment;
a32^.Mode := a64^.Mode;
end;
procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
begin
p64^.Thread := p32^.Thread;
p64^.ThCallbackStack := p32^.ThCallbackStack;
p64^.NextCallback := p32^.NextCallback;
p64^.FramePointer := p32^.FramePointer;
p64^.KiCallUserMode := p32^.KiCallUserMode;
p64^.KeUserCallbackDispatcher := p32^.KeUserCallbackDispatcher;
p64^.SystemRangeStart := p32^.SystemRangeStart;
end;
const
ImageHlpLib = 'imagehlp.dll';
{$IFDEF DYNAMIC_LINK}
var
_BindImage: Pointer;
function BindImage;
begin
GetProcedureAddress(_BindImage, ImageHlpLib, 'BindImage');
asm
mov esp, ebp
pop ebp
jmp [_BindImage]
end;
end;
{$ELSE}
function BindImage; external ImageHlpLib name 'BindImage';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_BindImageEx: Pointer;
function BindImageEx;
begin
GetProcedureAddress(_BindImageEx, ImageHlpLib, 'BindImageEx');
asm
mov esp, ebp
pop ebp
jmp [_BindImageEx]
end;
end;
{$ELSE}
function BindImageEx; external ImageHlpLib name 'BindImageEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ReBaseImage: Pointer;
function ReBaseImage;
begin
GetProcedureAddress(_ReBaseImage, ImageHlpLib, 'ReBaseImage');
asm
mov esp, ebp
pop ebp
jmp [_ReBaseImage]
end;
end;
{$ELSE}
function ReBaseImage; external ImageHlpLib name 'ReBaseImage';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ReBaseImage64: Pointer;
function ReBaseImage64;
begin
GetProcedureAddress(_ReBaseImage64, ImageHlpLib, 'ReBaseImage64');
asm
mov esp, ebp
pop ebp
jmp [_ReBaseImage64]
end;
end;
{$ELSE}
function ReBaseImage64; external ImageHlpLib name 'ReBaseImage64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_CheckSumMappedFile: Pointer;
function CheckSumMappedFile;
begin
GetProcedureAddress(_CheckSumMappedFile, ImageHlpLib, 'CheckSumMappedFile');
asm
mov esp, ebp
pop ebp
jmp [_CheckSumMappedFile]
end;
end;
{$ELSE}
function CheckSumMappedFile; external ImageHlpLib name 'CheckSumMappedFile';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_MapFileAndCheckSumA: Pointer;
function MapFileAndCheckSumA;
begin
GetProcedureAddress(_MapFileAndCheckSumA, ImageHlpLib, 'MapFileAndCheckSumA');
asm
mov esp, ebp
pop ebp
jmp [_MapFileAndCheckSumA]
end;
end;
{$ELSE}
function MapFileAndCheckSumA; external ImageHlpLib name 'MapFileAndCheckSumA';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_MapFileAndCheckSumW: Pointer;
function MapFileAndCheckSumW;
begin
GetProcedureAddress(_MapFileAndCheckSumW, ImageHlpLib, 'MapFileAndCheckSumW');
asm
mov esp, ebp
pop ebp
jmp [_MapFileAndCheckSumW]
end;
end;
{$ELSE}
function MapFileAndCheckSumW; external ImageHlpLib name 'MapFileAndCheckSumW';
{$ENDIF DYNAMIC_LINK}
{$IFDEF UNICODE}
{$IFDEF DYNAMIC_LINK}
var
_MapFileAndCheckSum: Pointer;
function MapFileAndCheckSum;
begin
GetProcedureAddress(_MapFileAndCheckSum, ImageHlpLib, 'MapFileAndCheckSumW');
asm
mov esp, ebp
pop ebp
jmp [_MapFileAndCheckSum]
end;
end;
{$ELSE}
function MapFileAndCheckSum; external ImageHlpLib name 'MapFileAndCheckSumW';
{$ENDIF DYNAMIC_LINK}
{$ELSE}
{$IFDEF DYNAMIC_LINK}
var
_MapFileAndCheckSum: Pointer;
function MapFileAndCheckSum;
begin
GetProcedureAddress(_MapFileAndCheckSum, ImageHlpLib, 'MapFileAndCheckSumA');
asm
mov esp, ebp
pop ebp
jmp [_MapFileAndCheckSum]
end;
end;
{$ELSE}
function MapFileAndCheckSum; external ImageHlpLib name 'MapFileAndCheckSumA';
{$ENDIF DYNAMIC_LINK}
{$ENDIF}
{$IFDEF DYNAMIC_LINK}
var
_GetImageConfigInformation: Pointer;
function GetImageConfigInformation;
begin
GetProcedureAddress(_GetImageConfigInformation, ImageHlpLib, 'GetImageConfigInformation');
asm
mov esp, ebp
pop ebp
jmp [_GetImageConfigInformation]
end;
end;
{$ELSE}
function GetImageConfigInformation; external ImageHlpLib name 'GetImageConfigInformation';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_GetImageUnusedHeaderBytes: Pointer;
function GetImageUnusedHeaderBytes;
begin
GetProcedureAddress(_GetImageUnusedHeaderBytes, ImageHlpLib, 'GetImageUnusedHeaderBytes');
asm
mov esp, ebp
pop ebp
jmp [_GetImageUnusedHeaderBytes]
end;
end;
{$ELSE}
function GetImageUnusedHeaderBytes; external ImageHlpLib name 'GetImageUnusedHeaderBytes';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SetImageConfigInformation: Pointer;
function SetImageConfigInformation;
begin
GetProcedureAddress(_SetImageConfigInformation, ImageHlpLib, 'SetImageConfigInformation');
asm
mov esp, ebp
pop ebp
jmp [_SetImageConfigInformation]
end;
end;
{$ELSE}
function SetImageConfigInformation; external ImageHlpLib name 'SetImageConfigInformation';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageGetDigestStream: Pointer;
function ImageGetDigestStream;
begin
GetProcedureAddress(_ImageGetDigestStream, ImageHlpLib, 'ImageGetDigestStream');
asm
mov esp, ebp
pop ebp
jmp [_ImageGetDigestStream]
end;
end;
{$ELSE}
function ImageGetDigestStream; external ImageHlpLib name 'ImageGetDigestStream';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageAddCertificate: Pointer;
function ImageAddCertificate;
begin
GetProcedureAddress(_ImageAddCertificate, ImageHlpLib, 'ImageAddCertificate');
asm
mov esp, ebp
pop ebp
jmp [_ImageAddCertificate]
end;
end;
{$ELSE}
function ImageAddCertificate; external ImageHlpLib name 'ImageAddCertificate';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageRemoveCertificate: Pointer;
function ImageRemoveCertificate;
begin
GetProcedureAddress(_ImageRemoveCertificate, ImageHlpLib, 'ImageRemoveCertificate');
asm
mov esp, ebp
pop ebp
jmp [_ImageRemoveCertificate]
end;
end;
{$ELSE}
function ImageRemoveCertificate; external ImageHlpLib name 'ImageRemoveCertificate';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageEnumerateCertificates: Pointer;
function ImageEnumerateCertificates;
begin
GetProcedureAddress(_ImageEnumerateCertificates, ImageHlpLib, 'ImageEnumerateCertificates');
asm
mov esp, ebp
pop ebp
jmp [_ImageEnumerateCertificates]
end;
end;
{$ELSE}
function ImageEnumerateCertificates; external ImageHlpLib name 'ImageEnumerateCertificates';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageGetCertificateData: Pointer;
function ImageGetCertificateData;
begin
GetProcedureAddress(_ImageGetCertificateData, ImageHlpLib, 'ImageGetCertificateData');
asm
mov esp, ebp
pop ebp
jmp [_ImageGetCertificateData]
end;
end;
{$ELSE}
function ImageGetCertificateData; external ImageHlpLib name 'ImageGetCertificateData';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageGetCertificateHeader: Pointer;
function ImageGetCertificateHeader;
begin
GetProcedureAddress(_ImageGetCertificateHeader, ImageHlpLib, 'ImageGetCertificateHeader');
asm
mov esp, ebp
pop ebp
jmp [_ImageGetCertificateHeader]
end;
end;
{$ELSE}
function ImageGetCertificateHeader; external ImageHlpLib name 'ImageGetCertificateHeader';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageLoad: Pointer;
function ImageLoad;
begin
GetProcedureAddress(_ImageLoad, ImageHlpLib, 'ImageLoad');
asm
mov esp, ebp
pop ebp
jmp [_ImageLoad]
end;
end;
{$ELSE}
function ImageLoad; external ImageHlpLib name 'ImageLoad';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageUnload: Pointer;
function ImageUnload;
begin
GetProcedureAddress(_ImageUnload, ImageHlpLib, 'ImageUnload');
asm
mov esp, ebp
pop ebp
jmp [_ImageUnload]
end;
end;
{$ELSE}
function ImageUnload; external ImageHlpLib name 'ImageUnload';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_MapAndLoad: Pointer;
function MapAndLoad;
begin
GetProcedureAddress(_MapAndLoad, ImageHlpLib, 'MapAndLoad');
asm
mov esp, ebp
pop ebp
jmp [_MapAndLoad]
end;
end;
{$ELSE}
function MapAndLoad; external ImageHlpLib name 'MapAndLoad';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_UnMapAndLoad: Pointer;
function UnMapAndLoad;
begin
GetProcedureAddress(_UnMapAndLoad, ImageHlpLib, 'UnMapAndLoad');
asm
mov esp, ebp
pop ebp
jmp [_UnMapAndLoad]
end;
end;
{$ELSE}
function UnMapAndLoad; external ImageHlpLib name 'UnMapAndLoad';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_TouchFileTimes: Pointer;
function TouchFileTimes;
begin
GetProcedureAddress(_TouchFileTimes, ImageHlpLib, 'TouchFileTimes');
asm
mov esp, ebp
pop ebp
jmp [_TouchFileTimes]
end;
end;
{$ELSE}
function TouchFileTimes; external ImageHlpLib name 'TouchFileTimes';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SplitSymbols: Pointer;
function SplitSymbols;
begin
GetProcedureAddress(_SplitSymbols, ImageHlpLib, 'SplitSymbols');
asm
mov esp, ebp
pop ebp
jmp [_SplitSymbols]
end;
end;
{$ELSE}
function SplitSymbols; external ImageHlpLib name 'SplitSymbols';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_UpdateDebugInfoFile: Pointer;
function UpdateDebugInfoFile;
begin
GetProcedureAddress(_UpdateDebugInfoFile, ImageHlpLib, 'UpdateDebugInfoFile');
asm
mov esp, ebp
pop ebp
jmp [_UpdateDebugInfoFile]
end;
end;
{$ELSE}
function UpdateDebugInfoFile; external ImageHlpLib name 'UpdateDebugInfoFile';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_UpdateDebugInfoFileEx: Pointer;
function UpdateDebugInfoFileEx;
begin
GetProcedureAddress(_UpdateDebugInfoFileEx, ImageHlpLib, 'UpdateDebugInfoFileEx');
asm
mov esp, ebp
pop ebp
jmp [_UpdateDebugInfoFileEx]
end;
end;
{$ELSE}
function UpdateDebugInfoFileEx; external ImageHlpLib name 'UpdateDebugInfoFileEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_FindDebugInfoFile: Pointer;
function FindDebugInfoFile;
begin
GetProcedureAddress(_FindDebugInfoFile, ImageHlpLib, 'FindDebugInfoFile');
asm
mov esp, ebp
pop ebp
jmp [_FindDebugInfoFile]
end;
end;
{$ELSE}
function FindDebugInfoFile; external ImageHlpLib name 'FindDebugInfoFile';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_FindDebugInfoFileEx: Pointer;
function FindDebugInfoFileEx;
begin
GetProcedureAddress(_FindDebugInfoFileEx, ImageHlpLib, 'FindDebugInfoFileEx');
asm
mov esp, ebp
pop ebp
jmp [_FindDebugInfoFileEx]
end;
end;
{$ELSE}
function FindDebugInfoFileEx; external ImageHlpLib name 'FindDebugInfoFileEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymFindFileInPath: Pointer;
function SymFindFileInPath;
begin
GetProcedureAddress(_SymFindFileInPath, ImageHlpLib, 'SymFindFileInPath');
asm
mov esp, ebp
pop ebp
jmp [_SymFindFileInPath]
end;
end;
{$ELSE}
function SymFindFileInPath; external ImageHlpLib name 'SymFindFileInPath';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_FindExecutableImage: Pointer;
function FindExecutableImage;
begin
GetProcedureAddress(_FindExecutableImage, ImageHlpLib, 'FindExecutableImage');
asm
mov esp, ebp
pop ebp
jmp [_FindExecutableImage]
end;
end;
{$ELSE}
function FindExecutableImage; external ImageHlpLib name 'FindExecutableImage';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_FindExecutableImageEx: Pointer;
function FindExecutableImageEx;
begin
GetProcedureAddress(_FindExecutableImageEx, ImageHlpLib, 'FindExecutableImageEx');
asm
mov esp, ebp
pop ebp
jmp [_FindExecutableImageEx]
end;
end;
{$ELSE}
function FindExecutableImageEx; external ImageHlpLib name 'FindExecutableImageEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageNtHeader: Pointer;
function ImageNtHeader;
begin
GetProcedureAddress(_ImageNtHeader, ImageHlpLib, 'ImageNtHeader');
asm
mov esp, ebp
pop ebp
jmp [_ImageNtHeader]
end;
end;
{$ELSE}
function ImageNtHeader; external ImageHlpLib name 'ImageNtHeader';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageDirectoryEntryToDataEx: Pointer;
function ImageDirectoryEntryToDataEx;
begin
GetProcedureAddress(_ImageDirectoryEntryToDataEx, ImageHlpLib, 'ImageDirectoryEntryToDataEx');
asm
mov esp, ebp
pop ebp
jmp [_ImageDirectoryEntryToDataEx]
end;
end;
{$ELSE}
function ImageDirectoryEntryToDataEx; external ImageHlpLib name 'ImageDirectoryEntryToDataEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageDirectoryEntryToData: Pointer;
function ImageDirectoryEntryToData;
begin
GetProcedureAddress(_ImageDirectoryEntryToData, ImageHlpLib, 'ImageDirectoryEntryToData');
asm
mov esp, ebp
pop ebp
jmp [_ImageDirectoryEntryToData]
end;
end;
{$ELSE}
function ImageDirectoryEntryToData; external ImageHlpLib name 'ImageDirectoryEntryToData';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageRvaToSection: Pointer;
function ImageRvaToSection;
begin
GetProcedureAddress(_ImageRvaToSection, ImageHlpLib, 'ImageRvaToSection');
asm
mov esp, ebp
pop ebp
jmp [_ImageRvaToSection]
end;
end;
{$ELSE}
function ImageRvaToSection; external ImageHlpLib name 'ImageRvaToSection';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImageRvaToVa: Pointer;
function ImageRvaToVa;
begin
GetProcedureAddress(_ImageRvaToVa, ImageHlpLib, 'ImageRvaToVa');
asm
mov esp, ebp
pop ebp
jmp [_ImageRvaToVa]
end;
end;
{$ELSE}
function ImageRvaToVa; external ImageHlpLib name 'ImageRvaToVa';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_MapDebugInformation: Pointer;
function MapDebugInformation;
begin
GetProcedureAddress(_MapDebugInformation, ImageHlpLib, 'MapDebugInformation');
asm
mov esp, ebp
pop ebp
jmp [_MapDebugInformation]
end;
end;
{$ELSE}
function MapDebugInformation; external ImageHlpLib name 'MapDebugInformation';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_UnmapDebugInformation: Pointer;
function UnmapDebugInformation;
begin
GetProcedureAddress(_UnmapDebugInformation, ImageHlpLib, 'UnmapDebugInformation');
asm
mov esp, ebp
pop ebp
jmp [_UnmapDebugInformation]
end;
end;
{$ELSE}
function UnmapDebugInformation; external ImageHlpLib name 'UnmapDebugInformation';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SearchTreeForFile: Pointer;
function SearchTreeForFile;
begin
GetProcedureAddress(_SearchTreeForFile, ImageHlpLib, 'SearchTreeForFile');
asm
mov esp, ebp
pop ebp
jmp [_SearchTreeForFile]
end;
end;
{$ELSE}
function SearchTreeForFile; external ImageHlpLib name 'SearchTreeForFile';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_EnumDirTree: Pointer;
function EnumDirTree;
begin
GetProcedureAddress(_EnumDirTree, ImageHlpLib, 'EnumDirTree');
asm
mov esp, ebp
pop ebp
jmp [_EnumDirTree]
end;
end;
{$ELSE}
function EnumDirTree; external ImageHlpLib name 'EnumDirTree';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_MakeSureDirectoryPathExists: Pointer;
function MakeSureDirectoryPathExists;
begin
GetProcedureAddress(_MakeSureDirectoryPathExists, ImageHlpLib, 'MakeSureDirectoryPathExists');
asm
mov esp, ebp
pop ebp
jmp [_MakeSureDirectoryPathExists]
end;
end;
{$ELSE}
function MakeSureDirectoryPathExists; external ImageHlpLib name 'MakeSureDirectoryPathExists';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_UnDecorateSymbolName: Pointer;
function UnDecorateSymbolName;
begin
GetProcedureAddress(_UnDecorateSymbolName, ImageHlpLib, 'UnDecorateSymbolName');
asm
mov esp, ebp
pop ebp
jmp [_UnDecorateSymbolName]
end;
end;
{$ELSE}
function UnDecorateSymbolName; external ImageHlpLib name 'UnDecorateSymbolName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_StackWalk64: Pointer;
function StackWalk64;
begin
GetProcedureAddress(_StackWalk64, ImageHlpLib, 'StackWalk64');
asm
mov esp, ebp
pop ebp
jmp [_StackWalk64]
end;
end;
{$ELSE}
function StackWalk64; external ImageHlpLib name 'StackWalk64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_StackWalk: Pointer;
function StackWalk;
begin
GetProcedureAddress(_StackWalk, ImageHlpLib, 'StackWalk');
asm
mov esp, ebp
pop ebp
jmp [_StackWalk]
end;
end;
{$ELSE}
function StackWalk; external ImageHlpLib name 'StackWalk';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImagehlpApiVersion: Pointer;
function ImagehlpApiVersion;
begin
GetProcedureAddress(_ImagehlpApiVersion, ImageHlpLib, 'ImagehlpApiVersion');
asm
mov esp, ebp
pop ebp
jmp [_ImagehlpApiVersion]
end;
end;
{$ELSE}
function ImagehlpApiVersion; external ImageHlpLib name 'ImagehlpApiVersion';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_ImagehlpApiVersionEx: Pointer;
function ImagehlpApiVersionEx;
begin
GetProcedureAddress(_ImagehlpApiVersionEx, ImageHlpLib, 'ImagehlpApiVersionEx');
asm
mov esp, ebp
pop ebp
jmp [_ImagehlpApiVersionEx]
end;
end;
{$ELSE}
function ImagehlpApiVersionEx; external ImageHlpLib name 'ImagehlpApiVersionEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_GetTimestampForLoadedLibrary: Pointer;
function GetTimestampForLoadedLibrary;
begin
GetProcedureAddress(_GetTimestampForLoadedLibrary, ImageHlpLib, 'GetTimestampForLoadedLibrary');
asm
mov esp, ebp
pop ebp
jmp [_GetTimestampForLoadedLibrary]
end;
end;
{$ELSE}
function GetTimestampForLoadedLibrary; external ImageHlpLib name 'GetTimestampForLoadedLibrary';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymSetOptions: Pointer;
function SymSetOptions;
begin
GetProcedureAddress(_SymSetOptions, ImageHlpLib, 'SymSetOptions');
asm
mov esp, ebp
pop ebp
jmp [_SymSetOptions]
end;
end;
{$ELSE}
function SymSetOptions; external ImageHlpLib name 'SymSetOptions';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetOptions: Pointer;
function SymGetOptions;
begin
GetProcedureAddress(_SymGetOptions, ImageHlpLib, 'SymGetOptions');
asm
mov esp, ebp
pop ebp
jmp [_SymGetOptions]
end;
end;
{$ELSE}
function SymGetOptions; external ImageHlpLib name 'SymGetOptions';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymCleanup: Pointer;
function SymCleanup;
begin
GetProcedureAddress(_SymCleanup, ImageHlpLib, 'SymCleanup');
asm
mov esp, ebp
pop ebp
jmp [_SymCleanup]
end;
end;
{$ELSE}
function SymCleanup; external ImageHlpLib name 'SymCleanup';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymMatchString: Pointer;
function SymMatchString;
begin
GetProcedureAddress(_SymMatchString, ImageHlpLib, 'SymMatchString');
asm
mov esp, ebp
pop ebp
jmp [_SymMatchString]
end;
end;
{$ELSE}
function SymMatchString; external ImageHlpLib name 'SymMatchString';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumSourceFiles: Pointer;
function SymEnumSourceFiles;
begin
GetProcedureAddress(_SymEnumSourceFiles, ImageHlpLib, 'SymEnumSourceFiles');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumSourceFiles]
end;
end;
{$ELSE}
function SymEnumSourceFiles; external ImageHlpLib name 'SymEnumSourceFiles';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumerateModules64: Pointer;
function SymEnumerateModules64;
begin
GetProcedureAddress(_SymEnumerateModules64, ImageHlpLib, 'SymEnumerateModules64');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumerateModules64]
end;
end;
{$ELSE}
function SymEnumerateModules64; external ImageHlpLib name 'SymEnumerateModules64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumerateModules: Pointer;
function SymEnumerateModules;
begin
GetProcedureAddress(_SymEnumerateModules, ImageHlpLib, 'SymEnumerateModules');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumerateModules]
end;
end;
{$ELSE}
function SymEnumerateModules; external ImageHlpLib name 'SymEnumerateModules';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumerateSymbols64: Pointer;
function SymEnumerateSymbols64;
begin
GetProcedureAddress(_SymEnumerateSymbols64, ImageHlpLib, 'SymEnumerateSymbols64');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumerateSymbols64]
end;
end;
{$ELSE}
function SymEnumerateSymbols64; external ImageHlpLib name 'SymEnumerateSymbols64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumerateSymbolsW64: Pointer;
function SymEnumerateSymbolsW64;
begin
GetProcedureAddress(_SymEnumerateSymbolsW64, ImageHlpLib, 'SymEnumerateSymbolsW64');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumerateSymbolsW64]
end;
end;
{$ELSE}
function SymEnumerateSymbolsW64; external ImageHlpLib name 'SymEnumerateSymbolsW64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumerateSymbols: Pointer;
function SymEnumerateSymbols;
begin
GetProcedureAddress(_SymEnumerateSymbols, ImageHlpLib, 'SymEnumerateSymbols');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumerateSymbols]
end;
end;
{$ELSE}
function SymEnumerateSymbols; external ImageHlpLib name 'SymEnumerateSymbols';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumerateSymbolsW: Pointer;
function SymEnumerateSymbolsW;
begin
GetProcedureAddress(_SymEnumerateSymbolsW, ImageHlpLib, 'SymEnumerateSymbolsW');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumerateSymbolsW]
end;
end;
{$ELSE}
function SymEnumerateSymbolsW; external ImageHlpLib name 'SymEnumerateSymbolsW';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_EnumerateLoadedModules64: Pointer;
function EnumerateLoadedModules64;
begin
GetProcedureAddress(_EnumerateLoadedModules64, ImageHlpLib, 'EnumerateLoadedModules64');
asm
mov esp, ebp
pop ebp
jmp [_EnumerateLoadedModules64]
end;
end;
{$ELSE}
function EnumerateLoadedModules64; external ImageHlpLib name 'EnumerateLoadedModules64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_EnumerateLoadedModules: Pointer;
function EnumerateLoadedModules;
begin
GetProcedureAddress(_EnumerateLoadedModules, ImageHlpLib, 'EnumerateLoadedModules');
asm
mov esp, ebp
pop ebp
jmp [_EnumerateLoadedModules]
end;
end;
{$ELSE}
function EnumerateLoadedModules; external ImageHlpLib name 'EnumerateLoadedModules';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymFunctionTableAccess64: Pointer;
function SymFunctionTableAccess64;
begin
GetProcedureAddress(_SymFunctionTableAccess64, ImageHlpLib, 'SymFunctionTableAccess64');
asm
mov esp, ebp
pop ebp
jmp [_SymFunctionTableAccess64]
end;
end;
{$ELSE}
function SymFunctionTableAccess64; external ImageHlpLib name 'SymFunctionTableAccess64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymFunctionTableAccess: Pointer;
function SymFunctionTableAccess;
begin
GetProcedureAddress(_SymFunctionTableAccess, ImageHlpLib, 'SymFunctionTableAccess');
asm
mov esp, ebp
pop ebp
jmp [_SymFunctionTableAccess]
end;
end;
{$ELSE}
function SymFunctionTableAccess; external ImageHlpLib name 'SymFunctionTableAccess';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetModuleInfo64: Pointer;
function SymGetModuleInfo64;
begin
GetProcedureAddress(_SymGetModuleInfo64, ImageHlpLib, 'SymGetModuleInfo64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetModuleInfo64]
end;
end;
{$ELSE}
function SymGetModuleInfo64; external ImageHlpLib name 'SymGetModuleInfo64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetModuleInfoW64: Pointer;
function SymGetModuleInfoW64;
begin
GetProcedureAddress(_SymGetModuleInfoW64, ImageHlpLib, 'SymGetModuleInfoW64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetModuleInfoW64]
end;
end;
{$ELSE}
function SymGetModuleInfoW64; external ImageHlpLib name 'SymGetModuleInfoW64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetModuleInfo: Pointer;
function SymGetModuleInfo;
begin
GetProcedureAddress(_SymGetModuleInfo, ImageHlpLib, 'SymGetModuleInfo');
asm
mov esp, ebp
pop ebp
jmp [_SymGetModuleInfo]
end;
end;
{$ELSE}
function SymGetModuleInfo; external ImageHlpLib name 'SymGetModuleInfo';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetModuleInfoW: Pointer;
function SymGetModuleInfoW;
begin
GetProcedureAddress(_SymGetModuleInfoW, ImageHlpLib, 'SymGetModuleInfoW');
asm
mov esp, ebp
pop ebp
jmp [_SymGetModuleInfoW]
end;
end;
{$ELSE}
function SymGetModuleInfoW; external ImageHlpLib name 'SymGetModuleInfoW';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetModuleBase64: Pointer;
function SymGetModuleBase64;
begin
GetProcedureAddress(_SymGetModuleBase64, ImageHlpLib, 'SymGetModuleBase64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetModuleBase64]
end;
end;
{$ELSE}
function SymGetModuleBase64; external ImageHlpLib name 'SymGetModuleBase64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetModuleBase: Pointer;
function SymGetModuleBase;
begin
GetProcedureAddress(_SymGetModuleBase, ImageHlpLib, 'SymGetModuleBase');
asm
mov esp, ebp
pop ebp
jmp [_SymGetModuleBase]
end;
end;
{$ELSE}
function SymGetModuleBase; external ImageHlpLib name 'SymGetModuleBase';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymNext64: Pointer;
function SymGetSymNext64;
begin
GetProcedureAddress(_SymGetSymNext64, ImageHlpLib, 'SymGetSymNext64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymNext64]
end;
end;
{$ELSE}
function SymGetSymNext64; external ImageHlpLib name 'SymGetSymNext64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymNext: Pointer;
function SymGetSymNext;
begin
GetProcedureAddress(_SymGetSymNext, ImageHlpLib, 'SymGetSymNext');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymNext]
end;
end;
{$ELSE}
function SymGetSymNext; external ImageHlpLib name 'SymGetSymNext';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymPrev64: Pointer;
function SymGetSymPrev64;
begin
GetProcedureAddress(_SymGetSymPrev64, ImageHlpLib, 'SymGetSymPrev64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymPrev64]
end;
end;
{$ELSE}
function SymGetSymPrev64; external ImageHlpLib name 'SymGetSymPrev64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymPrev: Pointer;
function SymGetSymPrev;
begin
GetProcedureAddress(_SymGetSymPrev, ImageHlpLib, 'SymGetSymPrev');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymPrev]
end;
end;
{$ELSE}
function SymGetSymPrev; external ImageHlpLib name 'SymGetSymPrev';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLineFromAddr64: Pointer;
function SymGetLineFromAddr64;
begin
GetProcedureAddress(_SymGetLineFromAddr64, ImageHlpLib, 'SymGetLineFromAddr64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLineFromAddr64]
end;
end;
{$ELSE}
function SymGetLineFromAddr64; external ImageHlpLib name 'SymGetLineFromAddr64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLineFromAddr: Pointer;
function SymGetLineFromAddr;
begin
GetProcedureAddress(_SymGetLineFromAddr, ImageHlpLib, 'SymGetLineFromAddr');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLineFromAddr]
end;
end;
{$ELSE}
function SymGetLineFromAddr; external ImageHlpLib name 'SymGetLineFromAddr';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLineFromName64: Pointer;
function SymGetLineFromName64;
begin
GetProcedureAddress(_SymGetLineFromName64, ImageHlpLib, 'SymGetLineFromName64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLineFromName64]
end;
end;
{$ELSE}
function SymGetLineFromName64; external ImageHlpLib name 'SymGetLineFromName64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLineFromName: Pointer;
function SymGetLineFromName;
begin
GetProcedureAddress(_SymGetLineFromName, ImageHlpLib, 'SymGetLineFromName');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLineFromName]
end;
end;
{$ELSE}
function SymGetLineFromName; external ImageHlpLib name 'SymGetLineFromName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLineNext64: Pointer;
function SymGetLineNext64;
begin
GetProcedureAddress(_SymGetLineNext64, ImageHlpLib, 'SymGetLineNext64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLineNext64]
end;
end;
{$ELSE}
function SymGetLineNext64; external ImageHlpLib name 'SymGetLineNext64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLineNext: Pointer;
function SymGetLineNext;
begin
GetProcedureAddress(_SymGetLineNext, ImageHlpLib, 'SymGetLineNext');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLineNext]
end;
end;
{$ELSE}
function SymGetLineNext; external ImageHlpLib name 'SymGetLineNext';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLinePrev64: Pointer;
function SymGetLinePrev64;
begin
GetProcedureAddress(_SymGetLinePrev64, ImageHlpLib, 'SymGetLinePrev64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLinePrev64]
end;
end;
{$ELSE}
function SymGetLinePrev64; external ImageHlpLib name 'SymGetLinePrev64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetLinePrev: Pointer;
function SymGetLinePrev;
begin
GetProcedureAddress(_SymGetLinePrev, ImageHlpLib, 'SymGetLinePrev');
asm
mov esp, ebp
pop ebp
jmp [_SymGetLinePrev]
end;
end;
{$ELSE}
function SymGetLinePrev; external ImageHlpLib name 'SymGetLinePrev';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymMatchFileName: Pointer;
function SymMatchFileName;
begin
GetProcedureAddress(_SymMatchFileName, ImageHlpLib, 'SymMatchFileName');
asm
mov esp, ebp
pop ebp
jmp [_SymMatchFileName]
end;
end;
{$ELSE}
function SymMatchFileName; external ImageHlpLib name 'SymMatchFileName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymInitialize: Pointer;
function SymInitialize;
begin
GetProcedureAddress(_SymInitialize, ImageHlpLib, 'SymInitialize');
asm
mov esp, ebp
pop ebp
jmp [_SymInitialize]
end;
end;
{$ELSE}
function SymInitialize; external ImageHlpLib name 'SymInitialize';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSearchPath: Pointer;
function SymGetSearchPath;
begin
GetProcedureAddress(_SymGetSearchPath, ImageHlpLib, 'SymGetSearchPath');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSearchPath]
end;
end;
{$ELSE}
function SymGetSearchPath; external ImageHlpLib name 'SymGetSearchPath';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymSetSearchPath: Pointer;
function SymSetSearchPath;
begin
GetProcedureAddress(_SymSetSearchPath, ImageHlpLib, 'SymSetSearchPath');
asm
mov esp, ebp
pop ebp
jmp [_SymSetSearchPath]
end;
end;
{$ELSE}
function SymSetSearchPath; external ImageHlpLib name 'SymSetSearchPath';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymLoadModuleEx: Pointer;
function SymLoadModuleEx;
begin
GetProcedureAddress(_SymLoadModuleEx, ImageHlpLib, 'SymLoadModuleEx');
asm
mov esp, ebp
pop ebp
jmp [_SymLoadModuleEx]
end;
end;
{$ELSE}
function SymLoadModuleEx; external ImageHlpLib name 'SymLoadModuleEx';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymLoadModule64: Pointer;
function SymLoadModule64;
begin
GetProcedureAddress(_SymLoadModule64, ImageHlpLib, 'SymLoadModule64');
asm
mov esp, ebp
pop ebp
jmp [_SymLoadModule64]
end;
end;
{$ELSE}
function SymLoadModule64; external ImageHlpLib name 'SymLoadModule64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymLoadModule: Pointer;
function SymLoadModule;
begin
GetProcedureAddress(_SymLoadModule, ImageHlpLib, 'SymLoadModule');
asm
mov esp, ebp
pop ebp
jmp [_SymLoadModule]
end;
end;
{$ELSE}
function SymLoadModule; external ImageHlpLib name 'SymLoadModule';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymUnloadModule64: Pointer;
function SymUnloadModule64;
begin
GetProcedureAddress(_SymUnloadModule64, ImageHlpLib, 'SymUnloadModule64');
asm
mov esp, ebp
pop ebp
jmp [_SymUnloadModule64]
end;
end;
{$ELSE}
function SymUnloadModule64; external ImageHlpLib name 'SymUnloadModule64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymUnloadModule: Pointer;
function SymUnloadModule;
begin
GetProcedureAddress(_SymUnloadModule, ImageHlpLib, 'SymUnloadModule');
asm
mov esp, ebp
pop ebp
jmp [_SymUnloadModule]
end;
end;
{$ELSE}
function SymUnloadModule; external ImageHlpLib name 'SymUnloadModule';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymUnDName64: Pointer;
function SymUnDName64;
begin
GetProcedureAddress(_SymUnDName64, ImageHlpLib, 'SymUnDName64');
asm
mov esp, ebp
pop ebp
jmp [_SymUnDName64]
end;
end;
{$ELSE}
function SymUnDName64; external ImageHlpLib name 'SymUnDName64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymUnDName: Pointer;
function SymUnDName;
begin
GetProcedureAddress(_SymUnDName, ImageHlpLib, 'SymUnDName');
asm
mov esp, ebp
pop ebp
jmp [_SymUnDName]
end;
end;
{$ELSE}
function SymUnDName; external ImageHlpLib name 'SymUnDName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymRegisterCallback64: Pointer;
function SymRegisterCallback64;
begin
GetProcedureAddress(_SymRegisterCallback64, ImageHlpLib, 'SymRegisterCallback64');
asm
mov esp, ebp
pop ebp
jmp [_SymRegisterCallback64]
end;
end;
{$ELSE}
function SymRegisterCallback64; external ImageHlpLib name 'SymRegisterCallback64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymRegFuncEntryCallback64: Pointer;
function SymRegisterFunctionEntryCallback64;
begin
GetProcedureAddress(_SymRegFuncEntryCallback64, ImageHlpLib, 'SymRegisterFunctionEntryCallback64');
asm
mov esp, ebp
pop ebp
jmp [_SymRegFuncEntryCallback64]
end;
end;
{$ELSE}
function SymRegisterFunctionEntryCallback64; external ImageHlpLib name 'SymRegisterFunctionEntryCallback64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymRegisterCallback: Pointer;
function SymRegisterCallback;
begin
GetProcedureAddress(_SymRegisterCallback, ImageHlpLib, 'SymRegisterCallback');
asm
mov esp, ebp
pop ebp
jmp [_SymRegisterCallback]
end;
end;
{$ELSE}
function SymRegisterCallback; external ImageHlpLib name 'SymRegisterCallback';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymRegisterFuncEntryCallback: Pointer;
function SymRegisterFunctionEntryCallback;
begin
GetProcedureAddress(_SymRegisterFuncEntryCallback, ImageHlpLib, 'SymRegisterFunctionEntryCallback');
asm
mov esp, ebp
pop ebp
jmp [_SymRegisterFuncEntryCallback]
end;
end;
{$ELSE}
function SymRegisterFunctionEntryCallback; external ImageHlpLib name 'SymRegisterFunctionEntryCallback';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymSetContext: Pointer;
function SymSetContext;
begin
GetProcedureAddress(_SymSetContext, ImageHlpLib, 'SymSetContext');
asm
mov esp, ebp
pop ebp
jmp [_SymSetContext]
end;
end;
{$ELSE}
function SymSetContext; external ImageHlpLib name 'SymSetContext';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymFromAddr: Pointer;
function SymFromAddr;
begin
GetProcedureAddress(_SymFromAddr, ImageHlpLib, 'SymFromAddr');
asm
mov esp, ebp
pop ebp
jmp [_SymFromAddr]
end;
end;
{$ELSE}
function SymFromAddr; external ImageHlpLib name 'SymFromAddr';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymFromName: Pointer;
function SymFromName;
begin
GetProcedureAddress(_SymFromName, ImageHlpLib, 'SymFromName');
asm
mov esp, ebp
pop ebp
jmp [_SymFromName]
end;
end;
{$ELSE}
function SymFromName; external ImageHlpLib name 'SymFromName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumSymbolsForAddr: Pointer;
function SymEnumSymbolsForAddr;
begin
GetProcedureAddress(_SymEnumSymbolsForAddr, ImageHlpLib, 'SymEnumSymbolsForAddr');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumSymbolsForAddr]
end;
end;
{$ELSE}
function SymEnumSymbolsForAddr; external ImageHlpLib name 'SymEnumSymbolsForAddr';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumSymbols: Pointer;
function SymEnumSymbols;
begin
GetProcedureAddress(_SymEnumSymbols, ImageHlpLib, 'SymEnumSymbols');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumSymbols]
end;
end;
{$ELSE}
function SymEnumSymbols; external ImageHlpLib name 'SymEnumSymbols';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetTypeInfo: Pointer;
function SymGetTypeInfo;
begin
GetProcedureAddress(_SymGetTypeInfo, ImageHlpLib, 'SymGetTypeInfo');
asm
mov esp, ebp
pop ebp
jmp [_SymGetTypeInfo]
end;
end;
{$ELSE}
function SymGetTypeInfo; external ImageHlpLib name 'SymGetTypeInfo';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumTypes: Pointer;
function SymEnumTypes;
begin
GetProcedureAddress(_SymEnumTypes, ImageHlpLib, 'SymEnumTypes');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumTypes]
end;
end;
{$ELSE}
function SymEnumTypes; external ImageHlpLib name 'SymEnumTypes';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetTypeFromName: Pointer;
function SymGetTypeFromName;
begin
GetProcedureAddress(_SymGetTypeFromName, ImageHlpLib, 'SymGetTypeFromName');
asm
mov esp, ebp
pop ebp
jmp [_SymGetTypeFromName]
end;
end;
{$ELSE}
function SymGetTypeFromName; external ImageHlpLib name 'SymGetTypeFromName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymAddSymbol: Pointer;
function SymAddSymbol;
begin
GetProcedureAddress(_SymAddSymbol, ImageHlpLib, 'SymAddSymbol');
asm
mov esp, ebp
pop ebp
jmp [_SymAddSymbol]
end;
end;
{$ELSE}
function SymAddSymbol; external ImageHlpLib name 'SymAddSymbol';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymDeleteSymbol: Pointer;
function SymDeleteSymbol;
begin
GetProcedureAddress(_SymDeleteSymbol, ImageHlpLib, 'SymDeleteSymbol');
asm
mov esp, ebp
pop ebp
jmp [_SymDeleteSymbol]
end;
end;
{$ELSE}
function SymDeleteSymbol; external ImageHlpLib name 'SymDeleteSymbol';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_DbgHelpCreateUserDump: Pointer;
function DbgHelpCreateUserDump;
begin
GetProcedureAddress(_DbgHelpCreateUserDump, ImageHlpLib, 'DbgHelpCreateUserDump');
asm
mov esp, ebp
pop ebp
jmp [_DbgHelpCreateUserDump]
end;
end;
{$ELSE}
function DbgHelpCreateUserDump; external ImageHlpLib name 'DbgHelpCreateUserDump';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_DbgHelpCreateUserDumpW: Pointer;
function DbgHelpCreateUserDumpW;
begin
GetProcedureAddress(_DbgHelpCreateUserDumpW, ImageHlpLib, 'DbgHelpCreateUserDumpW');
asm
mov esp, ebp
pop ebp
jmp [_DbgHelpCreateUserDumpW]
end;
end;
{$ELSE}
function DbgHelpCreateUserDumpW; external ImageHlpLib name 'DbgHelpCreateUserDumpW';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymFromAddr64: Pointer;
function SymGetSymFromAddr64;
begin
GetProcedureAddress(_SymGetSymFromAddr64, ImageHlpLib, 'SymGetSymFromAddr64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymFromAddr64]
end;
end;
{$ELSE}
function SymGetSymFromAddr64; external ImageHlpLib name 'SymGetSymFromAddr64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymFromAddr: Pointer;
function SymGetSymFromAddr;
begin
GetProcedureAddress(_SymGetSymFromAddr, ImageHlpLib, 'SymGetSymFromAddr');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymFromAddr]
end;
end;
{$ELSE}
function SymGetSymFromAddr; external ImageHlpLib name 'SymGetSymFromAddr';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymFromName64: Pointer;
function SymGetSymFromName64;
begin
GetProcedureAddress(_SymGetSymFromName64, ImageHlpLib, 'SymGetSymFromName64');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymFromName64]
end;
end;
{$ELSE}
function SymGetSymFromName64; external ImageHlpLib name 'SymGetSymFromName64';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymGetSymFromName: Pointer;
function SymGetSymFromName;
begin
GetProcedureAddress(_SymGetSymFromName, ImageHlpLib, 'SymGetSymFromName');
asm
mov esp, ebp
pop ebp
jmp [_SymGetSymFromName]
end;
end;
{$ELSE}
function SymGetSymFromName; external ImageHlpLib name 'SymGetSymFromName';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_FindFileInPath: Pointer;
function FindFileInPath;
begin
GetProcedureAddress(_FindFileInPath, ImageHlpLib, 'FindFileInPath');
asm
mov esp, ebp
pop ebp
jmp [_FindFileInPath]
end;
end;
{$ELSE}
function FindFileInPath; external ImageHlpLib name 'FindFileInPath';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_FindFileInSearchPath: Pointer;
function FindFileInSearchPath;
begin
GetProcedureAddress(_FindFileInSearchPath, ImageHlpLib, 'FindFileInSearchPath');
asm
mov esp, ebp
pop ebp
jmp [_FindFileInSearchPath]
end;
end;
{$ELSE}
function FindFileInSearchPath; external ImageHlpLib name 'FindFileInSearchPath';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_SymEnumSym: Pointer;
function SymEnumSym;
begin
GetProcedureAddress(_SymEnumSym, ImageHlpLib, 'SymEnumSym');
asm
mov esp, ebp
pop ebp
jmp [_SymEnumSym]
end;
end;
{$ELSE}
function SymEnumSym; external ImageHlpLib name 'SymEnumSym';
{$ENDIF DYNAMIC_LINK}
function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
begin
Result := Pointer(Cardinal(Mapping) + Cardinal(Rva));
end;
{$IFDEF DYNAMIC_LINK}
var
_MiniDumpWriteDump: Pointer;
function MiniDumpWriteDump;
begin
GetProcedureAddress(_MiniDumpWriteDump, ImageHlpLib, 'MiniDumpWriteDump');
asm
mov esp, ebp
pop ebp
jmp [_MiniDumpWriteDump]
end;
end;
{$ELSE}
function MiniDumpWriteDump; external ImageHlpLib name 'MiniDumpWriteDump';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
var
_MiniDumpReadDumpStream: Pointer;
function MiniDumpReadDumpStream;
begin
GetProcedureAddress(_MiniDumpReadDumpStream, ImageHlpLib, 'MiniDumpReadDumpStream');
asm
mov esp, ebp
pop ebp
jmp [_MiniDumpReadDumpStream]
end;
end;
{$ELSE}
function MiniDumpReadDumpStream; external ImageHlpLib name 'MiniDumpReadDumpStream';
{$ENDIF DYNAMIC_LINK}
end.