1
{******************************************************************************}
3
{ Image Help API interface Unit for Object Pascal }
5
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
6
{ Corporation. All Rights Reserved. }
8
{ The original file is: imagehlp.h, released August 2001. The original Pascal }
9
{ code is: ImageHelp.pas, released December 2000. The initial developer of the }
10
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
12
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
13
{ Marcel van Brakel. All Rights Reserved. }
15
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
17
{ You may retrieve the latest version of this file at the Project JEDI }
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
20
{ The contents of this file are used with permission, subject to the Mozilla }
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
22
{ in compliance with the License. You may obtain a copy of the License at }
23
{ http://www.mozilla.org/MPL/MPL-1.1.html }
25
{ Software distributed under the License is distributed on an "AS IS" basis, }
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27
{ the specific language governing rights and limitations under the License. }
29
{ Alternatively, the contents of this file may be used under the terms of the }
30
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
31
{ provisions of the LGPL License are applicable instead of those above. }
32
{ If you wish to allow use of your version of this file only under the terms }
33
{ of the LGPL License and not to allow others to use your version of this file }
34
{ under the MPL, indicate your decision by deleting the provisions above and }
35
{ replace them with the notice and other provisions required by the LGPL }
36
{ License. If you do not delete the provisions above, a recipient may use }
37
{ your version of this file under either the MPL or the LGPL License. }
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
41
{******************************************************************************}
43
// $Id: jwaimagehlp.pas,v 1.1 2005/04/04 07:56:10 marco Exp $
50
{$HPPEMIT '#include "ImageHlp.h"'}
58
Windows, JwaWinBase, JwaWinNT, JwaWinType;
61
IMAGE_SEPARATION = 64*1024;
62
{$EXTERNALSYM IMAGE_SEPARATION}
65
PLOADED_IMAGE = ^LOADED_IMAGE;
66
{$EXTERNALSYM PLOADED_IMAGE}
67
_LOADED_IMAGE = record
70
MappedAddress: PUCHAR;
71
FileHeader: PIMAGE_NT_HEADERS32;
72
LastRvaSection: PIMAGE_SECTION_HEADER;
73
NumberOfSections: ULONG;
74
Sections: PIMAGE_SECTION_HEADER;
75
Characteristics: ULONG;
76
fSystemImage: ByteBool;
81
{$EXTERNALSYM _LOADED_IMAGE}
82
LOADED_IMAGE = _LOADED_IMAGE;
83
{$EXTERNALSYM LOADED_IMAGE}
84
TLoadedImage = LOADED_IMAGE;
85
PLoadedImage = PLOADED_IMAGE;
89
{$EXTERNALSYM MAX_SYM_NAME}
91
function BindImage(ImageName, DllPath, SymbolPath: PSTR): BOOL; stdcall;
92
{$EXTERNALSYM BindImage}
95
_IMAGEHLP_STATUS_REASON = (
99
BindImportModuleFailed,
100
BindImportProcedureFailed,
106
BindExpandFileHeaders,
108
BindMismatchedSymbols,
109
BindSymbolsNotUpdated,
110
BindImportProcedure32,
111
BindImportProcedure64,
116
{$EXTERNALSYM _IMAGEHLP_STATUS_REASON}
117
IMAGEHLP_STATUS_REASON = _IMAGEHLP_STATUS_REASON;
118
{$EXTERNALSYM IMAGEHLP_STATUS_REASON}
119
TImageHlpStatusReason = IMAGEHLP_STATUS_REASON;
121
PIMAGEHLP_STATUS_ROUTINE = function(Reason: IMAGEHLP_STATUS_REASON;
122
ImageName, DllName: PSTR; Va, Parameter: ULONG_PTR): BOOL; stdcall;
123
{$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE}
124
PImageHlpStatusRoutine = PIMAGEHLP_STATUS_ROUTINE;
126
PIMAGEHLP_STATUS_ROUTINE32 = function(Reason: IMAGEHLP_STATUS_REASON; ImageName, DllName: PSTR;
127
Va: ULONG; Parameter: ULONG_PTR): BOOL; stdcall;
128
{$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE32}
129
PImageHlpStatusRoutine23 = PIMAGEHLP_STATUS_ROUTINE32;
131
PIMAGEHLP_STATUS_ROUTINE64 = function(Reason: IMAGEHLP_STATUS_REASON; ImageName, DllName: PSTR;
132
Va: ULONG64; Parameter: ULONG_PTR): BOOL; stdcall;
133
{$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE64}
134
PImageHlpStatusRoutine64 = PIMAGEHLP_STATUS_ROUTINE64;
136
function BindImageEx(Flags: DWORD; ImageName, DllPath, SymbolPath: PSTR;
137
StatusRoutine: PIMAGEHLP_STATUS_ROUTINE): BOOL; stdcall;
138
{$EXTERNALSYM BindImageEx}
141
BIND_NO_BOUND_IMPORTS = $00000001;
142
{$EXTERNALSYM BIND_NO_BOUND_IMPORTS}
143
BIND_NO_UPDATE = $00000002;
144
{$EXTERNALSYM BIND_NO_UPDATE}
145
BIND_ALL_IMAGES = $00000004;
146
{$EXTERNALSYM BIND_ALL_IMAGES}
147
BIND_CACHE_IMPORT_DLLS = $00000008; // Cache dll's across calls to BindImageEx (same as NT 3.1->NT 4.0)
148
{$EXTERNALSYM BIND_CACHE_IMPORT_DLLS}
150
BIND_REPORT_64BIT_VA = $00000010;
151
{$EXTERNALSYM BIND_REPORT_64BIT_VA}
153
function ReBaseImage(CurrentImageName: PSTR; SymbolPath: PSTR; fReBase: BOOL;
154
fRebaseSysfileOk: BOOL; fGoingDown: BOOL; CheckImageSize: ULONG;
155
var OldImageSize: ULONG; var OldImageBase: ULONG_PTR; var NewImageSize: ULONG;
156
var NewImageBase: ULONG_PTR; TimeStamp: ULONG): BOOL; stdcall;
157
{$EXTERNALSYM ReBaseImage}
159
function ReBaseImage64(CurrentImageName: PSTR; SymbolPath: PSTR; fReBase: BOOL;
160
fRebaseSysfileOk: BOOL; fGoingDown: BOOL; CheckImageSize: ULONG;
161
var OldImageSize: ULONG; var OldImageBase: ULONG64; var NewImageSize: ULONG;
162
var NewImageBase: ULONG64; TimeStamp: ULONG): BOOL; stdcall;
163
{$EXTERNALSYM ReBaseImage64}
166
// Define checksum return codes.
170
CHECKSUM_SUCCESS = 0;
171
{$EXTERNALSYM CHECKSUM_SUCCESS}
172
CHECKSUM_OPEN_FAILURE = 1;
173
{$EXTERNALSYM CHECKSUM_OPEN_FAILURE}
174
CHECKSUM_MAP_FAILURE = 2;
175
{$EXTERNALSYM CHECKSUM_MAP_FAILURE}
176
CHECKSUM_MAPVIEW_FAILURE = 3;
177
{$EXTERNALSYM CHECKSUM_MAPVIEW_FAILURE}
178
CHECKSUM_UNICODE_FAILURE = 4;
179
{$EXTERNALSYM CHECKSUM_UNICODE_FAILURE}
181
// Define Splitsym flags.
183
SPLITSYM_REMOVE_PRIVATE = $00000001; // Remove CV types/symbols and Fixup debug
184
{$EXTERNALSYM SPLITSYM_REMOVE_PRIVATE}
185
// Used for creating .dbg files that ship
186
// as part of the product.
188
SPLITSYM_EXTRACT_ALL = $00000002; // Extract all debug info from image.
189
{$EXTERNALSYM SPLITSYM_EXTRACT_ALL}
190
// Normally, FPO is left in the image
191
// to allow stack traces through the code.
192
// Using this switch is similar to linking
193
// with -debug:none except the .dbg file
196
SPLITSYM_SYMBOLPATH_IS_SRC = $00000004; // The SymbolFilePath contains an alternate
197
{$EXTERNALSYM SPLITSYM_SYMBOLPATH_IS_SRC}
198
// path to locate the pdb.
201
// Define checksum function prototypes.
204
function CheckSumMappedFile(BaseAddress: PVOID; FileLength: DWORD;
205
var HeaderSum, CheckSum: DWORD): PIMAGE_NT_HEADERS; stdcall;
206
{$EXTERNALSYM CheckSumMappedFile}
208
function MapFileAndCheckSumA(Filename: PSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
209
{$EXTERNALSYM MapFileAndCheckSumA}
210
function MapFileAndCheckSumW(Filename: PWSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
211
{$EXTERNALSYM MapFileAndCheckSumW}
212
function MapFileAndCheckSum(Filename: PTSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
213
{$EXTERNALSYM MapFileAndCheckSum}
215
function GetImageConfigInformation(const LoadedImage: LOADED_IMAGE;
216
var ImageConfigInformation: IMAGE_LOAD_CONFIG_DIRECTORY): BOOL; stdcall;
217
{$EXTERNALSYM GetImageConfigInformation}
219
function GetImageUnusedHeaderBytes(const LoadedImage: LOADED_IMAGE;
220
var SizeUnusedHeaderBytes: DWORD): DWORD; stdcall;
221
{$EXTERNALSYM GetImageUnusedHeaderBytes}
223
function SetImageConfigInformation(const LoadedImage: LOADED_IMAGE;
224
const ImageConfigInformation: IMAGE_LOAD_CONFIG_DIRECTORY): BOOL; stdcall;
225
{$EXTERNALSYM SetImageConfigInformation}
227
// Image Integrity API's
230
CERT_PE_IMAGE_DIGEST_DEBUG_INFO = $01;
231
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_DEBUG_INFO}
232
CERT_PE_IMAGE_DIGEST_RESOURCES = $02;
233
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_RESOURCES}
234
CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO = $04;
235
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO}
236
CERT_PE_IMAGE_DIGEST_NON_PE_INFO = $08; // include data outside the PE image
237
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_NON_PE_INFO}
239
CERT_SECTION_TYPE_ANY = $FF; // Any Certificate type
240
{$EXTERNALSYM CERT_SECTION_TYPE_ANY}
243
DIGEST_HANDLE = PVOID;
244
{$EXTERNALSYM DIGEST_HANDLE}
245
TDigestHandle = DIGEST_HANDLE;
247
DIGEST_FUNCTION = function(refdata: DIGEST_HANDLE; pData: PBYTE; dwLength: DWORD): BOOL; stdcall;
248
{$EXTERNALSYM DIGEST_FUNCTION}
249
TDigestFunction = DIGEST_FUNCTION;
251
function ImageGetDigestStream(FileHandle: HANDLE; DigestLevel: DWORD;
252
DigestFunction: DIGEST_FUNCTION; DigestHandle: DIGEST_HANDLE): BOOL; stdcall;
253
{$EXTERNALSYM ImageGetDigestStream}
255
function ImageAddCertificate(FileHandle: HANDLE; Certificate: PWinCertificate;
256
var Index: DWORD): BOOL; stdcall;
257
{$EXTERNALSYM ImageAddCertificate}
259
function ImageRemoveCertificate(FileHandle: HANDLE; Index: DWORD): BOOL; stdcall;
260
{$EXTERNALSYM ImageRemoveCertificate}
262
function ImageEnumerateCertificates(FileHandle: HANDLE; TypeFilter: WORD;
263
var CertificateCount: DWORD; Indices: PDWORD; IndexCount: DWORD): BOOL; stdcall;
264
{$EXTERNALSYM ImageEnumerateCertificates}
266
function ImageGetCertificateData(FileHandle: HANDLE; CertificateIndex: DWORD;
267
Certificate: PWinCertificate; var RequiredLength: DWORD): BOOL; stdcall;
268
{$EXTERNALSYM ImageGetCertificateData}
270
function ImageGetCertificateHeader(FileHandle: HANDLE; CertificateIndex: DWORD;
271
Certificateheader: PWinCertificate): BOOL; stdcall;
272
{$EXTERNALSYM ImageGetCertificateHeader}
274
function ImageLoad(DllName: PSTR; DllPath: PSTR): PLOADED_IMAGE; stdcall;
275
{$EXTERNALSYM ImageLoad}
277
function ImageUnload(const LoadedImage: LOADED_IMAGE): BOOL; stdcall;
278
{$EXTERNALSYM ImageUnload}
280
function MapAndLoad(ImageName, DllPath: PSTR; var LoadedImage: LOADED_IMAGE;
281
DotDll: BOOL; ReadOnly: BOOL): BOOL; stdcall;
282
{$EXTERNALSYM MapAndLoad}
284
function UnMapAndLoad(const LoadedImage: LOADED_IMAGE): BOOL; stdcall;
285
{$EXTERNALSYM UnMapAndLoad}
287
function TouchFileTimes(FileHandle: HANDLE; pSystemTime: PSYSTEMTIME): BOOL; stdcall;
288
{$EXTERNALSYM TouchFileTimes}
290
function SplitSymbols(ImageName, SymbolsPath, SymbolFilePath: PSTR; Flags: DWORD): BOOL; stdcall;
291
{$EXTERNALSYM SplitSymbols}
293
function UpdateDebugInfoFile(ImageFileName, SymbolPath, DebugFilePath: PSTR;
294
const NtHeaders: IMAGE_NT_HEADERS32): BOOL; stdcall;
295
{$EXTERNALSYM UpdateDebugInfoFile}
297
function UpdateDebugInfoFileEx(ImageFileName, SymbolPath, DebugFilePath: PSTR;
298
const NtHeaders: IMAGE_NT_HEADERS32; OldChecksum: DWORD): BOOL; stdcall;
299
{$EXTERNALSYM UpdateDebugInfoFileEx}
301
function FindDebugInfoFile(FileName, SymbolPath, DebugFilePath: PSTR): HANDLE; stdcall;
302
{$EXTERNALSYM FindDebugInfoFile}
305
PFIND_DEBUG_FILE_CALLBACK = function(FileHandle: HANDLE; FileName: PSTR;
306
CallerData: PVOID): BOOL; stdcall;
307
{$EXTERNALSYM PFIND_DEBUG_FILE_CALLBACK}
308
PFindDebugFileCallback = PFIND_DEBUG_FILE_CALLBACK;
310
function FindDebugInfoFileEx(FileName, SymbolPath, DebugFilePath: PSTR;
311
Callback: PFIND_DEBUG_FILE_CALLBACK; CallerData: PVOID): HANDLE; stdcall;
312
{$EXTERNALSYM FindDebugInfoFileEx}
315
PFINDFILEINPATHCALLBACK = function(filename: PSTR; context: PVOID): BOOL; stdcall;
316
{$EXTERNALSYM PFINDFILEINPATHCALLBACK}
318
function SymFindFileInPath(hprocess: HANDLE; SearchPath, FileName: LPSTR; id: PVOID; two, three, flags: DWORD;
319
FoundFile: LPSTR; callback: PFINDFILEINPATHCALLBACK; context: PVOID): BOOL; stdcall;
320
{$EXTERNALSYM SymFindFileInPath}
322
function FindExecutableImage(FileName, SymbolPath, ImageFilePath: PSTR): HANDLE; stdcall;
323
{$EXTERNALSYM FindExecutableImage}
326
PFIND_EXE_FILE_CALLBACK = function(FileHandle: HANDLE; FileName: PSTR;
327
CallerData: PVOID): BOOL; stdcall;
328
{$EXTERNALSYM PFIND_EXE_FILE_CALLBACK}
329
PFindExeFileCallback = PFIND_EXE_FILE_CALLBACK;
331
function FindExecutableImageEx(FileName, SymbolPath, ImageFilePath: PSTR;
332
Callback: PFIND_EXE_FILE_CALLBACK; CallerData: PVOID): HANDLE; stdcall;
333
{$EXTERNALSYM FindExecutableImageEx}
335
function ImageNtHeader(Base: PVOID): PIMAGE_NT_HEADERS; stdcall;
336
{$EXTERNALSYM ImageNtHeader}
338
function ImageDirectoryEntryToDataEx(Base: PVOID; MappedAsImage: ByteBool;
339
DirectoryEntry: USHORT; var Size: ULONG; var FoundHeader: PIMAGE_SECTION_HEADER): PVOID; stdcall;
340
{$EXTERNALSYM ImageDirectoryEntryToDataEx}
342
function ImageDirectoryEntryToData(Base: PVOID; MappedAsImage: ByteBool;
343
DirectoryEntry: USHORT; var Size: ULONG): PVOID; stdcall;
344
{$EXTERNALSYM ImageDirectoryEntryToData}
346
function ImageRvaToSection(NtHeaders: PIMAGE_NT_HEADERS; Base: PVOID; Rva: ULONG): PIMAGE_SECTION_HEADER; stdcall;
347
{$EXTERNALSYM ImageRvaToSection}
349
function ImageRvaToVa(NtHeaders: PIMAGE_NT_HEADERS; Base: PVOID; Rva: ULONG;
350
var LastRvaSection: PIMAGE_SECTION_HEADER): PVOID; stdcall;
351
{$EXTERNALSYM ImageRvaToVa}
353
// Symbol server exports
356
PSYMBOLSERVERPROC = function(a1, a2: LPCSTR; a3: PVOID; a4, a5: DWORD; a6: LPSTR): BOOL; stdcall;
357
{$EXTERNALSYM PSYMBOLSERVERPROC}
358
PSYMBOLSERVEROPENPROC = function: BOOL; stdcall;
359
{$EXTERNALSYM PSYMBOLSERVEROPENPROC}
360
PSYMBOLSERVERCLOSEPROC = function: BOOL; stdcall;
361
{$EXTERNALSYM PSYMBOLSERVERCLOSEPROC}
362
PSYMBOLSERVERSETOPTIONSPROC = function(a1: UINT_PTR; a2: ULONG64): BOOL; stdcall;
363
{$EXTERNALSYM PSYMBOLSERVERSETOPTIONSPROC}
364
PSYMBOLSERVERCALLBACKPROC = function(action: UINT_PTR; data: ULONG64; context: ULONG64): BOOL; stdcall;
365
{$EXTERNALSYM PSYMBOLSERVERCALLBACKPROC}
366
PSYMBOLSERVERGETOPTIONSPROC = function: UINT_PTR; stdcall;
367
{$EXTERNALSYM PSYMBOLSERVERGETOPTIONSPROC}
368
PSYMBOLSERVERPINGPROC = function(a1: LPCSTR): BOOL; stdcall;
369
{$EXTERNALSYM PSYMBOLSERVERPINGPROC}
372
SSRVOPT_CALLBACK = $01;
373
{$EXTERNALSYM SSRVOPT_CALLBACK}
375
{$EXTERNALSYM SSRVOPT_DWORD}
376
SSRVOPT_DWORDPTR = $04;
377
{$EXTERNALSYM SSRVOPT_DWORDPTR}
378
SSRVOPT_GUIDPTR = $08;
379
{$EXTERNALSYM SSRVOPT_GUIDPTR}
380
SSRVOPT_OLDGUIDPTR = $10;
381
{$EXTERNALSYM SSRVOPT_OLDGUIDPTR}
382
SSRVOPT_UNATTENDED = $20;
383
{$EXTERNALSYM SSRVOPT_UNATTENDED}
384
SSRVOPT_RESET = ULONG_PTR(-1);
385
{$EXTERNALSYM SSRVOPT_RESET}
387
SSRVACTION_TRACE = 1;
388
{$EXTERNALSYM SSRVACTION_TRACE}
390
// This api won't be ported to Win64 - Fix your code.
393
PIMAGE_DEBUG_INFORMATION = ^IMAGE_DEBUG_INFORMATION;
394
{$EXTERNALSYM PIMAGE_DEBUG_INFORMATION}
395
_IMAGE_DEBUG_INFORMATION = record
398
ReservedMappedBase: PVOID;
399
ReservedMachine: USHORT;
400
ReservedCharacteristics: USHORT;
401
ReservedCheckSum: DWORD;
404
ReservedNumberOfSections: DWORD;
405
ReservedSections: PIMAGE_SECTION_HEADER;
406
ReservedExportedNamesSize: DWORD;
407
ReservedExportedNames: PSTR;
408
ReservedNumberOfFunctionTableEntries: DWORD;
409
ReservedFunctionTableEntries: PIMAGE_FUNCTION_ENTRY;
410
ReservedLowestFunctionStartingAddress: DWORD;
411
ReservedHighestFunctionEndingAddress: DWORD;
412
ReservedNumberOfFpoTableEntries: DWORD;
413
ReservedFpoTableEntries: PFPO_DATA;
414
SizeOfCoffSymbols: DWORD;
415
CoffSymbols: PIMAGE_COFF_SYMBOLS_HEADER;
416
ReservedSizeOfCodeViewSymbols: DWORD;
417
ReservedCodeViewSymbols: PVOID;
420
ReservedDebugFilePath: PSTR;
421
ReservedTimeDateStamp: DWORD;
422
ReservedRomImage: BOOL;
423
ReservedDebugDirectory: PIMAGE_DEBUG_DIRECTORY;
424
ReservedNumberOfDebugDirectories: DWORD;
425
ReservedOriginalFunctionTableBaseAddress: DWORD;
426
Reserved: array [0..1] of DWORD;
428
{$EXTERNALSYM _IMAGE_DEBUG_INFORMATION}
429
IMAGE_DEBUG_INFORMATION = _IMAGE_DEBUG_INFORMATION;
430
{$EXTERNALSYM IMAGE_DEBUG_INFORMATION}
431
TImageDebugInformation = IMAGE_DEBUG_INFORMATION;
432
PImageDebugInformation = PIMAGE_DEBUG_INFORMATION;
434
function MapDebugInformation(FileHandle: HANDLE; FileName, SymbolPath: PSTR;
435
ImageBase: DWORD): PIMAGE_DEBUG_INFORMATION; stdcall;
436
{$EXTERNALSYM MapDebugInformation}
438
function UnmapDebugInformation(DebugInfo: PIMAGE_DEBUG_INFORMATION): BOOL; stdcall;
439
{$EXTERNALSYM UnmapDebugInformation}
441
function SearchTreeForFile(RootPath, InputPathName, OutputPathBuffer: PSTR): BOOL; stdcall;
442
{$EXTERNALSYM SearchTreeForFile}
445
PENUMDIRTREE_CALLBACK = function(FilePath: LPCSTR; CallerData: PVOID): BOOL; stdcall;
446
{$EXTERNALSYM PENUMDIRTREE_CALLBACK}
447
PEnumDirTreeCallback = PENUMDIRTREE_CALLBACK;
449
function EnumDirTree(hProcess: HANDLE; RootPath, InputPathName, OutputPathBuffer: PSTR;
450
Callback: PENUMDIRTREE_CALLBACK; CallbackData: PVOID): BOOL; stdcall;
451
{$EXTERNALSYM EnumDirTree}
453
function MakeSureDirectoryPathExists(DirPath: PCSTR): BOOL; stdcall;
454
{$EXTERNALSYM MakeSureDirectoryPathExists}
457
// UnDecorateSymbolName Flags
461
UNDNAME_COMPLETE = $0000; // Enable full undecoration
462
{$EXTERNALSYM UNDNAME_COMPLETE}
463
UNDNAME_NO_LEADING_UNDERSCORES = $0001; // Remove leading underscores from MS extended keywords
464
{$EXTERNALSYM UNDNAME_NO_LEADING_UNDERSCORES}
465
UNDNAME_NO_MS_KEYWORDS = $0002; // Disable expansion of MS extended keywords
466
{$EXTERNALSYM UNDNAME_NO_MS_KEYWORDS}
467
UNDNAME_NO_FUNCTION_RETURNS = $0004; // Disable expansion of return type for primary declaration
468
{$EXTERNALSYM UNDNAME_NO_FUNCTION_RETURNS}
469
UNDNAME_NO_ALLOCATION_MODEL = $0008; // Disable expansion of the declaration model
470
{$EXTERNALSYM UNDNAME_NO_ALLOCATION_MODEL}
471
UNDNAME_NO_ALLOCATION_LANGUAGE = $0010; // Disable expansion of the declaration language specifier
472
{$EXTERNALSYM UNDNAME_NO_ALLOCATION_LANGUAGE}
473
UNDNAME_NO_MS_THISTYPE = $0020; // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
474
{$EXTERNALSYM UNDNAME_NO_MS_THISTYPE}
475
UNDNAME_NO_CV_THISTYPE = $0040; // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
476
{$EXTERNALSYM UNDNAME_NO_CV_THISTYPE}
477
UNDNAME_NO_THISTYPE = $0060; // Disable all modifiers on the 'this' type
478
{$EXTERNALSYM UNDNAME_NO_THISTYPE}
479
UNDNAME_NO_ACCESS_SPECIFIERS = $0080; // Disable expansion of access specifiers for members
480
{$EXTERNALSYM UNDNAME_NO_ACCESS_SPECIFIERS}
481
UNDNAME_NO_THROW_SIGNATURES = $0100; // Disable expansion of 'throw-signatures' for functions and pointers to functions
482
{$EXTERNALSYM UNDNAME_NO_THROW_SIGNATURES}
483
UNDNAME_NO_MEMBER_TYPE = $0200; // Disable expansion of 'static' or 'virtual'ness of members
484
{$EXTERNALSYM UNDNAME_NO_MEMBER_TYPE}
485
UNDNAME_NO_RETURN_UDT_MODEL = $0400; // Disable expansion of MS model for UDT returns
486
{$EXTERNALSYM UNDNAME_NO_RETURN_UDT_MODEL}
487
UNDNAME_32_BIT_DECODE = $0800; // Undecorate 32-bit decorated names
488
{$EXTERNALSYM UNDNAME_32_BIT_DECODE}
489
UNDNAME_NAME_ONLY = $1000; // Crack only the name for primary declaration;
490
{$EXTERNALSYM UNDNAME_NAME_ONLY}
491
// return just [scope::]name. Does expand template params
492
UNDNAME_NO_ARGUMENTS = $2000; // Don't undecorate arguments to function
493
{$EXTERNALSYM UNDNAME_NO_ARGUMENTS}
494
UNDNAME_NO_SPECIAL_SYMS = $4000; // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
495
{$EXTERNALSYM UNDNAME_NO_SPECIAL_SYMS}
497
function UnDecorateSymbolName(DecoratedName: PCSTR; UnDecoratedName: PSTR;
498
UndecoratedLength: DWORD; Flags: DWORD): DWORD; stdcall;
499
{$EXTERNALSYM UnDecorateSymbolName}
502
// these values are used for synthesized file types
503
// that can be passed in as image headers instead of
504
// the standard ones from ntimage.h
508
DBHHEADER_DEBUGDIRS = $1;
509
{$EXTERNALSYM DBHHEADER_DEBUGDIRS}
512
_MODLOAD_DATA = record
513
ssize: DWORD; // size of this struct
514
ssig: DWORD; // signature identifying the passed data
515
data: PVOID; // pointer to passed data
516
size: DWORD; // size of passed data
517
flags: DWORD; // options
519
{$EXTERNALSYM _MODLOAD_DATA}
520
MODLOAD_DATA = _MODLOAD_DATA;
521
{$EXTERNALSYM MODLOAD_DATA}
522
PMODLOAD_DATA = ^MODLOAD_DATA;
523
{$EXTERNALSYM PMODLOAD_DATA}
524
TModLoadData = MODLOAD_DATA;
525
PModLoadData = PMODLOAD_DATA;
537
{$EXTERNALSYM ADDRESS_MODE}
538
TAddressMode = ADDRESS_MODE;
540
LPADDRESS64 = ^ADDRESS64;
541
{$EXTERNALSYM PADDRESS64}
542
_tagADDRESS64 = record
547
{$EXTERNALSYM _tagADDRESS64}
548
ADDRESS64 = _tagADDRESS64;
549
{$EXTERNALSYM ADDRESS64}
550
TAddress64 = ADDRESS64;
551
PAddress64 = LPADDRESS64;
553
LPADDRESS = ^ADDRESS;
554
{$EXTERNALSYM PADDRESS}
560
{$EXTERNALSYM _tagADDRESS}
561
ADDRESS = _tagADDRESS;
562
{$EXTERNALSYM ADDRESS}
564
PAddress = LPADDRESS;
566
procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
567
{$EXTERNALSYM Address32To64}
569
procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
570
{$EXTERNALSYM Address64To32}
573
// This structure is included in the STACKFRAME structure,
574
// and is used to trace through usermode callbacks in a thread's
575
// kernel stack. The values must be copied by the kernel debugger
576
// from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
580
// New KDHELP structure for 64 bit system support.
581
// This structure is preferred in new code.
585
PKDHELP64 = ^KDHELP64;
586
{$EXTERNALSYM PKDHELP64}
589
// address of kernel thread object, as provided in the
590
// WAIT_STATE_CHANGE packet.
594
// offset in thread object to pointer to the current callback frame
597
ThCallbackStack: DWORD;
599
// offset in thread object to pointer to the current callback backing
600
// store frame in kernel stack.
602
ThCallbackBStore: DWORD;
604
// offsets to values in frame:
606
// address of next callback frame
608
// address of saved frame pointer (if applicable)
611
// Address of the kernel function that calls out to user mode
613
KiCallUserMode: DWORD64;
615
// Address of the user mode dispatcher function
617
KeUserCallbackDispatcher: DWORD64;
619
// Lowest kernel mode address
621
SystemRangeStart: DWORD64;
622
Reserved: array [0..7] of DWORD64;
624
{$EXTERNALSYM _KDHELP64}
625
KDHELP64 = _KDHELP64;
626
{$EXTERNALSYM KDHELP64}
627
TKdHelp64 = KDHELP64;
628
//PKdHelp64 = PKDHELP64;
631
{$EXTERNALSYM PKDHELP}
634
// address of kernel thread object, as provided in the
635
// WAIT_STATE_CHANGE packet.
639
// offset in thread object to pointer to the current callback frame
642
ThCallbackStack: DWORD;
644
// offsets to values in frame:
646
// address of next callback frame
648
// address of saved frame pointer (if applicable)
651
// Address of the kernel function that calls out to user mode
653
KiCallUserMode: DWORD;
655
// Address of the user mode dispatcher function
657
KeUserCallbackDispatcher: DWORD;
659
// Lowest kernel mode address
661
SystemRangeStart: DWORD;
663
// offset in thread object to pointer to the current callback backing
664
// store frame in kernel stack.
666
ThCallbackBStore: DWORD;
667
Reserved: array [0..7] of DWORD;
669
{$EXTERNALSYM _KDHELP}
671
{$EXTERNALSYM KDHELP}
675
procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
676
{$EXTERNALSYM KdHelp32To64}
679
LPSTACKFRAME64 = ^STACKFRAME64;
680
{$EXTERNALSYM LPSTACKFRAME64}
681
_tagSTACKFRAME64 = record
682
AddrPC: ADDRESS64; // program counter
683
AddrReturn: ADDRESS64; // return address
684
AddrFrame: ADDRESS64; // frame pointer
685
AddrStack: ADDRESS64; // stack pointer
686
AddrBStore: ADDRESS64; // backing store pointer
687
FuncTableEntry: PVOID; // pointer to pdata/fpo or NULL
688
Params: array [0..3] of DWORD64; // possible arguments to the function
689
Far: BOOL; // WOW far call
690
Virtual: BOOL; // is this a virtual frame?
691
Reserved: array [0..2] of DWORD64;
694
{$EXTERNALSYM _tagSTACKFRAME64}
695
STACKFRAME64 = _tagSTACKFRAME64;
696
{$EXTERNALSYM STACKFRAME64}
697
TStackFrame64 = STACKFRAME64;
698
PStackFrame64 = LPSTACKFRAME64;
700
LPSTACKFRAME = ^STACKFRAME;
701
{$EXTERNALSYM LPSTACKFRAME}
702
_tagSTACKFRAME = record
703
AddrPC: ADDRESS; // program counter
704
AddrReturn: ADDRESS; // return address
705
AddrFrame: ADDRESS; // frame pointer
706
AddrStack: ADDRESS; // stack pointer
707
FuncTableEntry: PVOID; // pointer to pdata/fpo or NULL
708
Params: array [0..3] of DWORD; // possible arguments to the function
709
Far: BOOL; // WOW far call
710
Virtual: BOOL; // is this a virtual frame?
711
Reserved: array [0..2] of DWORD;
713
AddrBStore: ADDRESS; // backing store pointer
715
{$EXTERNALSYM _tagSTACKFRAME}
716
STACKFRAME = _tagSTACKFRAME;
717
{$EXTERNALSYM STACKFRAME}
718
TStackFrame = STACKFRAME;
719
PStackFrame = LPSTACKFRAME;
721
PREAD_PROCESS_MEMORY_ROUTINE64 = function(hProcess: HANDLE; qwBaseAddress: DWORD64;
722
lpBuffer: PVOID; nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
723
{$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE64}
724
PReadProcessMemoryRoutine64 = PREAD_PROCESS_MEMORY_ROUTINE64;
726
PFUNCTION_TABLE_ACCESS_ROUTINE64 = function(hProcess: HANDLE;
727
AddrBase: DWORD64): PVOID; stdcall;
728
{$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE64}
729
PFunctionTableAccessRoutine64 = PFUNCTION_TABLE_ACCESS_ROUTINE64;
731
PGET_MODULE_BASE_ROUTINE64 = function(hProcess: HANDLE;
732
Address: DWORD64): DWORD64; stdcall;
733
{$EXTERNALSYM PGET_MODULE_BASE_ROUTINE64}
734
PGetModuleBaseRoutine64 = PGET_MODULE_BASE_ROUTINE64;
736
PTRANSLATE_ADDRESS_ROUTINE64 = function(hProcess: HANDLE; hThread: HANDLE;
737
const lpaddr: ADDRESS64): DWORD64; stdcall;
738
{$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE64}
739
PTranslateAddressRoutine64 = PTRANSLATE_ADDRESS_ROUTINE64;
741
function StackWalk64(MachineType: DWORD; hProcess: HANDLE; hThread: HANDLE;
742
var StackFrame: STACKFRAME64; ContextRecord: PVOID;
743
ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64;
744
FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64;
745
GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64;
746
TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64): BOOL; stdcall;
747
{$EXTERNALSYM StackWalk64}
750
PREAD_PROCESS_MEMORY_ROUTINE = function(hProcess: HANDLE;
751
lpBaseAddress: DWORD; lpBuffer: PVOID; nSize: DWORD;
752
var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
753
{$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE}
754
PreadProcessMemoryRoutine = PREAD_PROCESS_MEMORY_ROUTINE;
756
PFUNCTION_TABLE_ACCESS_ROUTINE = function(hProcess: HANDLE; AddrBase: DWORD): PVOID; stdcall;
757
{$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE}
758
PFunctionTableAccessRoutine = PFUNCTION_TABLE_ACCESS_ROUTINE;
760
PGET_MODULE_BASE_ROUTINE = function(hProcess: HANDLE; Address: DWORD): DWORD; stdcall;
761
{$EXTERNALSYM PGET_MODULE_BASE_ROUTINE}
762
PGetModuleBaseRoutine = PGET_MODULE_BASE_ROUTINE;
764
PTRANSLATE_ADDRESS_ROUTINE = function(hProcess: HANDLE; hThread: HANDLE;
765
const lpaddr: ADDRESS): DWORD; stdcall;
766
{$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE}
767
PTranslateAddressRoutine = PTRANSLATE_ADDRESS_ROUTINE;
769
function StackWalk(MachineType: DWORD; hProcess: HANDLE; hThread: HANDLE;
770
var StackFrame: STACKFRAME; ContextRecord: PVOID;
771
ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE;
772
FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE;
773
GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE;
774
TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE): BOOL; stdcall;
775
{$EXTERNALSYM StackWalk}
778
API_VERSION_NUMBER = 9;
779
{$EXTERNALSYM API_VERSION_NUMBER}
782
LPAPI_VERSION = ^API_VERSION;
783
{$EXTERNALSYM LPAPI_VERSION}
785
MajorVersion: USHORT;
786
MinorVersion: USHORT;
790
{$EXTERNALSYM API_VERSION}
791
TApiVersion = API_VERSION;
792
PApiVersion = LPAPI_VERSION;
794
function ImagehlpApiVersion: LPAPI_VERSION; stdcall;
795
{$EXTERNALSYM ImagehlpApiVersion}
797
function ImagehlpApiVersionEx(const AppVersion: API_VERSION): LPAPI_VERSION; stdcall;
798
{$EXTERNALSYM ImagehlpApiVersionEx}
800
function GetTimestampForLoadedLibrary(Module: HMODULE): DWORD; stdcall;
801
{$EXTERNALSYM GetTimestampForLoadedLibrary}
804
// typedefs for function pointers
808
PSYM_ENUMMODULES_CALLBACK64 = function(ModuleName: PSTR; BaseOfDll: DWORD64;
809
UserContext: PVOID): BOOL; stdcall;
810
{$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK64}
811
PSymEnummodulesCallback64 = PSYM_ENUMMODULES_CALLBACK64;
813
PSYM_ENUMSYMBOLS_CALLBACK64 = function(SymbolName: PSTR; SymbolAddress: DWORD64;
814
SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
815
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK64}
816
PSymEnumsymbolsCallback64 = PSYM_ENUMSYMBOLS_CALLBACK64;
818
PSYM_ENUMSYMBOLS_CALLBACK64W = function(SymbolName: PWSTR;
819
SymbolAddress: DWORD64; SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
820
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK64W}
821
PSymEnumsymbolsCallback64w = PSYM_ENUMSYMBOLS_CALLBACK64W;
823
PENUMLOADED_MODULES_CALLBACK64 = function(ModuleName: PSTR;
824
ModuleBase: DWORD64; ModuleSize: ULONG; UserContext: PVOID): BOOL; stdcall;
825
{$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK64}
826
PSnumloadedModulesCallback64 = PENUMLOADED_MODULES_CALLBACK64;
828
PSYMBOL_REGISTERED_CALLBACK64 = function(hProcess: HANDLE; ActionCode: ULONG;
829
CallbackData: ULONG64; UserContext: ULONG64): BOOL; stdcall;
830
{$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK64}
831
PSymbolRegisteredCallback64 = PSYMBOL_REGISTERED_CALLBACK64;
833
PSYMBOL_FUNCENTRY_CALLBACK = function(hProcess: HANDLE; AddrBase: DWORD;
834
UserContext: PVOID): PVOID; stdcall;
835
{$EXTERNALSYM PSYMBOL_FUNCENTRY_CALLBACK}
836
PSymbolFuncentryCallback = PSYMBOL_FUNCENTRY_CALLBACK;
838
PSYMBOL_FUNCENTRY_CALLBACK64 = function(hProcess: HANDLE; AddrBase: ULONG64;
839
UserContext: ULONG64): PVOID; stdcall;
840
{$EXTERNALSYM PSYMBOL_FUNCENTRY_CALLBACK64}
841
PSymbolFuncentryCallback64 = PSYMBOL_FUNCENTRY_CALLBACK64;
843
PSYM_ENUMMODULES_CALLBACK = function(ModuleName: PSTR; BaseOfDll: ULONG;
844
UserContext: PVOID): BOOL; stdcall;
845
{$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK}
846
PSymEnummodulesCallback = PSYM_ENUMMODULES_CALLBACK;
848
PSYM_ENUMSYMBOLS_CALLBACK = function(SymbolName: PSTR; SymbolAddress: ULONG;
849
SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
850
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK}
851
PSymEnumsymbolsCallback = PSYM_ENUMSYMBOLS_CALLBACK;
853
PSYM_ENUMSYMBOLS_CALLBACKW = function(SymbolName: PWSTR; SymbolAddress: ULONG;
854
SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
855
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACKW}
856
PSymEnumsymbolsCallbackw = PSYM_ENUMSYMBOLS_CALLBACKW;
858
PENUMLOADED_MODULES_CALLBACK = function(ModuleName: PSTR; ModuleBase: ULONG;
859
ModuleSize: ULONG; UserContext: PVOID): BOOL; stdcall;
860
{$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK}
861
PEnumloadedModulesCallback = PENUMLOADED_MODULES_CALLBACK;
863
PSYMBOL_REGISTERED_CALLBACK = function(hProcess: HANDLE; ActionCode: ULONG;
864
CallbackData: PVOID; UserContext: PVOID): BOOL; stdcall;
865
{$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK}
866
PSymbolRegisteredCallback = PSYMBOL_REGISTERED_CALLBACK;
869
// flags found in SYMBOL_INFO.Flags
873
SYMFLAG_VALUEPRESENT = $00000001;
874
{$EXTERNALSYM SYMFLAG_VALUEPRESENT}
875
SYMFLAG_REGISTER = $00000008;
876
{$EXTERNALSYM SYMFLAG_REGISTER}
877
SYMFLAG_REGREL = $00000010;
878
{$EXTERNALSYM SYMFLAG_REGREL}
879
SYMFLAG_FRAMEREL = $00000020;
880
{$EXTERNALSYM SYMFLAG_FRAMEREL}
881
SYMFLAG_PARAMETER = $00000040;
882
{$EXTERNALSYM SYMFLAG_PARAMETER}
883
SYMFLAG_LOCAL = $00000080;
884
{$EXTERNALSYM SYMFLAG_LOCAL}
885
SYMFLAG_CONSTANT = $00000100;
886
{$EXTERNALSYM SYMFLAG_CONSTANT}
887
SYMFLAG_EXPORT = $00000200;
888
{$EXTERNALSYM SYMFLAG_EXPORT}
889
SYMFLAG_FORWARDER = $00000400;
890
{$EXTERNALSYM SYMFLAG_FORWARDER}
891
SYMFLAG_FUNCTION = $00000800;
892
{$EXTERNALSYM SYMFLAG_FUNCTION}
893
SYMFLAG_VIRTUAL = $00001000;
894
{$EXTERNALSYM SYMFLAG_VIRTUAL}
895
SYMFLAG_THUNK = $00002000;
896
{$EXTERNALSYM SYMFLAG_THUNK}
897
SYMFLAG_TLSREL = $00004000;
898
{$EXTERNALSYM SYMFLAG_TLSREL}
901
// symbol type enumeration
916
{$EXTERNALSYM SYM_TYPE}
920
// symbol data structure
923
PIMAGEHLP_SYMBOL64 = ^IMAGEHLP_SYMBOL64;
924
{$EXTERNALSYM PIMAGEHLP_SYMBOL64}
925
_IMAGEHLP_SYMBOL64 = record
926
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_SYMBOL64)
927
Address: DWORD64; // virtual address including dll base address
928
Size: DWORD; // estimated size of symbol, can be zero
929
Flags: DWORD; // info about the symbols, see the SYMF defines
930
MaxNameLength: DWORD; // maximum size of symbol name in 'Name'
931
Name: array [0..0] of CHAR; // symbol name (null terminated string)
933
{$EXTERNALSYM _IMAGEHLP_SYMBOL64}
934
IMAGEHLP_SYMBOL64 = _IMAGEHLP_SYMBOL64;
935
{$EXTERNALSYM IMAGEHLP_SYMBOL64}
936
TImageHlpSymbol64 = IMAGEHLP_SYMBOL64;
937
PImageHlpSymbol64 = PIMAGEHLP_SYMBOL64;
939
_IMAGEHLP_SYMBOL64_PACKAGE = record
940
sym: IMAGEHLP_SYMBOL64;
941
name: array [0..MAX_SYM_NAME] of CHAR;
943
{$EXTERNALSYM _IMAGEHLP_SYMBOL64_PACKAGE}
944
IMAGEHLP_SYMBOL64_PACKAGE = _IMAGEHLP_SYMBOL64_PACKAGE;
945
{$EXTERNALSYM IMAGEHLP_SYMBOL64_PACKAGE}
946
PIMAGEHLP_SYMBOL64_PACKAGE = ^IMAGEHLP_SYMBOL64_PACKAGE;
947
{$EXTERNALSYM PIMAGEHLP_SYMBOL64_PACKAGE}
948
TImageHlpSymbol64Package = IMAGEHLP_SYMBOL64_PACKAGE;
949
PImageHlpSymbol64Package = PIMAGEHLP_SYMBOL64_PACKAGE;
951
//#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
953
//#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
954
//#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
955
//#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
956
//#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
960
PIMAGEHLP_SYMBOL = ^IMAGEHLP_SYMBOL;
961
{$EXTERNALSYM PIMAGEHLP_SYMBOL}
962
_IMAGEHLP_SYMBOL = record
963
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_SYMBOL)
964
Address: DWORD; // virtual address including dll base address
965
Size: DWORD; // estimated size of symbol, can be zero
966
Flags: DWORD; // info about the symbols, see the SYMF defines
967
MaxNameLength: DWORD; // maximum size of symbol name in 'Name'
968
Name: array [0..0] of CHAR; // symbol name (null terminated string)
970
{$EXTERNALSYM _IMAGEHLP_SYMBOL}
971
IMAGEHLP_SYMBOL = _IMAGEHLP_SYMBOL;
972
{$EXTERNALSYM IMAGEHLP_SYMBOL}
973
TImageHlpSymbol = IMAGEHLP_SYMBOL;
974
PImageHlpSymbol = PIMAGEHLP_SYMBOL;
976
_IMAGEHLP_SYMBOL_PACKAGE = record
977
sym: IMAGEHLP_SYMBOL;
978
name: array [0..MAX_SYM_NAME] of CHAR;
980
{$EXTERNALSYM _IMAGEHLP_SYMBOL_PACKAGE}
981
IMAGEHLP_SYMBOL_PACKAGE = _IMAGEHLP_SYMBOL_PACKAGE;
982
{$EXTERNALSYM IMAGEHLP_SYMBOL_PACKAGE}
983
PIMAGEHLP_SYMBOL_PACKAGE = ^IMAGEHLP_SYMBOL_PACKAGE;
984
{$EXTERNALSYM PIMAGEHLP_SYMBOL_PACKAGE}
985
TImageHlpSymbolPackage = IMAGEHLP_SYMBOL_PACKAGE;
986
PImageHlpSymbolPackage = PIMAGEHLP_SYMBOL_PACKAGE;
991
// module data structure
994
PIMAGEHLP_MODULE64 = ^IMAGEHLP_MODULE64;
995
{$EXTERNALSYM PIMAGEHLP_MODULE64}
996
_IMAGEHLP_MODULE64 = record
997
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
998
BaseOfImage: DWORD64; // base load address of module
999
ImageSize: DWORD; // virtual size of the loaded module
1000
TimeDateStamp: DWORD; // date/time stamp from pe header
1001
CheckSum: DWORD; // checksum from the pe header
1002
NumSyms: DWORD; // number of symbols in the symbol table
1003
SymType: SYM_TYPE; // type of symbols loaded
1004
ModuleName: array [0..3] of CHAR; // module name
1005
ImageName: array [0..255] of CHAR; // image name
1006
LoadedImageName: array [0..255] of CHAR; // symbol file name
1008
{$EXTERNALSYM _IMAGEHLP_MODULE64}
1009
IMAGEHLP_MODULE64 = _IMAGEHLP_MODULE64;
1010
{$EXTERNALSYM IMAGEHLP_MODULE64}
1011
TImageHlpModule64 = IMAGEHLP_MODULE64;
1012
PImageHlpModule64 = PIMAGEHLP_MODULE64;
1014
PIMAGEHLP_MODULEW64 = ^IMAGEHLP_MODULEW64;
1015
{$EXTERNALSYM PIMAGEHLP_MODULEW64}
1016
_IMAGEHLP_MODULE64W = record
1017
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
1018
BaseOfImage: DWORD64; // base load address of module
1019
ImageSize: DWORD; // virtual size of the loaded module
1020
TimeDateStamp: DWORD; // date/time stamp from pe header
1021
CheckSum: DWORD; // checksum from the pe header
1022
NumSyms: DWORD; // number of symbols in the symbol table
1023
SymType: SYM_TYPE; // type of symbols loaded
1024
ModuleName: array [0..31] of WCHAR; // module name
1025
ImageName: array [0..255] of WCHAR; // image name
1026
LoadedImageName: array [0..255] of WCHAR; // symbol file name
1028
{$EXTERNALSYM _IMAGEHLP_MODULE64W}
1029
IMAGEHLP_MODULEW64 = _IMAGEHLP_MODULE64W;
1030
{$EXTERNALSYM IMAGEHLP_MODULEW64}
1031
TImageHlpModuleW64 = IMAGEHLP_MODULEW64;
1032
PImageHlpModuleW64 = PIMAGEHLP_MODULEW64;
1034
PIMAGEHLP_MODULE = ^IMAGEHLP_MODULE;
1035
{$EXTERNALSYM PIMAGEHLP_MODULE}
1036
_IMAGEHLP_MODULE = record
1037
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
1038
BaseOfImage: DWORD; // base load address of module
1039
ImageSize: DWORD; // virtual size of the loaded module
1040
TimeDateStamp: DWORD; // date/time stamp from pe header
1041
CheckSum: DWORD; // checksum from the pe header
1042
NumSyms: DWORD; // number of symbols in the symbol table
1043
SymType: SYM_TYPE; // type of symbols loaded
1044
ModuleName: array [0..31] of CHAR; // module name
1045
ImageName: array [0..255] of CHAR; // image name
1046
LoadedImageName: array [0..255] of CHAR; // symbol file name
1048
{$EXTERNALSYM _IMAGEHLP_MODULE}
1049
IMAGEHLP_MODULE = _IMAGEHLP_MODULE;
1050
{$EXTERNALSYM IMAGEHLP_MODULE}
1051
TImageHlpModule = IMAGEHLP_MODULE;
1052
PImageHlpModule = PIMAGEHLP_MODULE;
1054
PIMAGEHLP_MODULEW = ^IMAGEHLP_MODULEW;
1055
{$EXTERNALSYM PIMAGEHLP_MODULEW}
1056
_IMAGEHLP_MODULEW = record
1057
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
1058
BaseOfImage: DWORD; // base load address of module
1059
ImageSize: DWORD; // virtual size of the loaded module
1060
TimeDateStamp: DWORD; // date/time stamp from pe header
1061
CheckSum: DWORD; // checksum from the pe header
1062
NumSyms: DWORD; // number of symbols in the symbol table
1063
SymType: SYM_TYPE; // type of symbols loaded
1064
ModuleName: array [0..31] of WCHAR; // module name
1065
ImageName: array [0..255] of WCHAR; // image name
1066
LoadedImageName: array [0..255] of WCHAR; // symbol file name
1068
{$EXTERNALSYM _IMAGEHLP_MODULEW}
1069
IMAGEHLP_MODULEW = _IMAGEHLP_MODULEW;
1070
{$EXTERNALSYM IMAGEHLP_MODULEW}
1071
TImageHlpModuleW = IMAGEHLP_MODULEW;
1072
PImageHlpModuleW = PIMAGEHLP_MODULEW;
1075
// source file line data structure
1078
PIMAGEHLP_LINE64 = ^IMAGEHLP_LINE64;
1079
{$EXTERNALSYM PIMAGEHLP_LINE64}
1080
_IMAGEHLP_LINE64 = record
1081
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE64)
1082
Key: PVOID; // internal
1083
LineNumber: DWORD; // line number in file
1084
FileName: PCHAR; // full filename
1085
Address: DWORD64; // first instruction of line
1087
{$EXTERNALSYM _IMAGEHLP_LINE64}
1088
IMAGEHLP_LINE64 = _IMAGEHLP_LINE64;
1089
{$EXTERNALSYM IMAGEHLP_LINE64}
1090
TImageHlpLine64 = IMAGEHLP_LINE64;
1091
PImageHlpLine64 = PIMAGEHLP_LINE64;
1093
PIMAGEHLP_LINE = ^IMAGEHLP_LINE;
1094
{$EXTERNALSYM PIMAGEHLP_LINE}
1095
_IMAGEHLP_LINE = record
1096
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE)
1097
Key: PVOID; // internal
1098
LineNumber: DWORD; // line number in file
1099
FileName: PCHAR; // full filename
1100
Address: DWORD; // first instruction of line
1102
{$EXTERNALSYM _IMAGEHLP_LINE}
1103
IMAGEHLP_LINE = _IMAGEHLP_LINE;
1104
{$EXTERNALSYM IMAGEHLP_LINE}
1105
TImageHlpLine = IMAGEHLP_LINE;
1106
PImageHlpLine = PIMAGEHLP_LINE;
1109
// source file structure
1113
_SOURCEFILE = record
1114
ModBase: DWORD64; // base address of loaded module
1115
FileName: PCHAR; // full filename of source
1117
{$EXTERNALSYM _SOURCEFILE}
1118
SOURCEFILE = _SOURCEFILE;
1119
{$EXTERNALSYM SOURCEFILE}
1120
PSOURCEFILE = ^SOURCEFILE;
1121
{$EXTERNALSYM PSOURCEFILE}
1122
TSourceFile = SOURCEFILE;
1125
// data structures used for registered symbol callbacks
1129
CBA_DEFERRED_SYMBOL_LOAD_START = $00000001;
1130
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_START}
1131
CBA_DEFERRED_SYMBOL_LOAD_COMPLETE = $00000002;
1132
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_COMPLETE}
1133
CBA_DEFERRED_SYMBOL_LOAD_FAILURE = $00000003;
1134
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_FAILURE}
1135
CBA_SYMBOLS_UNLOADED = $00000004;
1136
{$EXTERNALSYM CBA_SYMBOLS_UNLOADED}
1137
CBA_DUPLICATE_SYMBOL = $00000005;
1138
{$EXTERNALSYM CBA_DUPLICATE_SYMBOL}
1139
CBA_READ_MEMORY = $00000006;
1140
{$EXTERNALSYM CBA_READ_MEMORY}
1141
CBA_DEFERRED_SYMBOL_LOAD_CANCEL = $00000007;
1142
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_CANCEL}
1143
CBA_SET_OPTIONS = $00000008;
1144
{$EXTERNALSYM CBA_SET_OPTIONS}
1145
CBA_EVENT = $00000010;
1146
{$EXTERNALSYM CBA_EVENT}
1147
CBA_DEFERRED_SYMBOL_LOAD_PARTIAL = $00000020;
1148
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_PARTIAL}
1149
CBA_DEBUG_INFO = $10000000;
1150
{$EXTERNALSYM CBA_DEBUG_INFO}
1153
PIMAGEHLP_CBA_READ_MEMORY = ^IMAGEHLP_CBA_READ_MEMORY;
1154
{$EXTERNALSYM PIMAGEHLP_CBA_READ_MEMORY}
1155
_IMAGEHLP_CBA_READ_MEMORY = record
1156
addr: DWORD64; // address to read from
1157
buf: PVOID; // buffer to read to
1158
bytes: DWORD; // amount of bytes to read
1159
bytesread: LPDWORD; // pointer to store amount of bytes read
1161
{$EXTERNALSYM _IMAGEHLP_CBA_READ_MEMORY}
1162
IMAGEHLP_CBA_READ_MEMORY = _IMAGEHLP_CBA_READ_MEMORY;
1163
{$EXTERNALSYM IMAGEHLP_CBA_READ_MEMORY}
1164
TImageHlpCbaReadMemory = IMAGEHLP_CBA_READ_MEMORY;
1165
PImageHlpCbaReadMemory = PIMAGEHLP_CBA_READ_MEMORY;
1169
{$EXTERNALSYM sevInfo}
1171
{$EXTERNALSYM sevProblem}
1173
{$EXTERNALSYM sevAttn}
1175
{$EXTERNALSYM sevFatal}
1176
sevMax = 4; // unused
1177
{$EXTERNALSYM sevMax}
1180
_IMAGEHLP_CBA_EVENT = record
1181
severity: DWORD; // values from sevInfo to sevFatal
1182
code: DWORD; // numerical code IDs the error
1183
desc: PCHAR; // may contain a text description of the error
1184
object_: PVOID; // value dependant upon the error code
1186
{$EXTERNALSYM _IMAGEHLP_CBA_EVENT}
1187
IMAGEHLP_CBA_EVENT = _IMAGEHLP_CBA_EVENT;
1188
{$EXTERNALSYM IMAGEHLP_CBA_EVENT}
1189
PIMAGEHLP_CBA_EVENT = ^IMAGEHLP_CBA_EVENT;
1190
{$EXTERNALSYM PIMAGEHLP_CBA_EVENT}
1191
TImageHlpCbaEvent = IMAGEHLP_CBA_EVENT;
1192
PImageHlpCbaEvent = PIMAGEHLP_CBA_EVENT;
1194
PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1195
{$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1196
_IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = record
1197
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
1198
BaseOfImage: DWORD64; // base load address of module
1199
CheckSum: DWORD; // checksum from the pe header
1200
TimeDateStamp: DWORD; // date/time stamp from pe header
1201
FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
1202
Reparse: ByteBool; // load failure reparse
1203
hFile: HANDLE; // file handle, if passed
1206
{$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1207
IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = _IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1208
{$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1209
TImageHlpDeferredSymbolLoad64 = IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1210
PImageHlpDeferredSymbolLoad64 = PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1213
DSLFLAG_MISMATCHED_PDB = $1;
1214
{$EXTERNALSYM DSLFLAG_MISMATCHED_PDB}
1215
DSLFLAG_MISMATCHED_DBG = $2;
1216
{$EXTERNALSYM DSLFLAG_MISMATCHED_DBG}
1219
PIMAGEHLP_DEFERRED_SYMBOL_LOAD = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1220
{$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD}
1221
_IMAGEHLP_DEFERRED_SYMBOL_LOAD = record
1222
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
1223
BaseOfImage: DWORD; // base load address of module
1224
CheckSum: DWORD; // checksum from the pe header
1225
TimeDateStamp: DWORD; // date/time stamp from pe header
1226
FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
1227
Reparse: ByteBool; // load failure reparse
1228
hFile: HANDLE; // file handle, if passed
1230
{$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD}
1231
IMAGEHLP_DEFERRED_SYMBOL_LOAD = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1232
{$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD}
1233
TImageHlpDeferredSymbolLoad = IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1234
PImageHlpDeferredSymbolLoad = PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
1236
PIMAGEHLP_DUPLICATE_SYMBOL64 = ^IMAGEHLP_DUPLICATE_SYMBOL64;
1237
{$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL64}
1238
_IMAGEHLP_DUPLICATE_SYMBOL64 = record
1239
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
1240
NumberOfDups: DWORD; // number of duplicates in the Symbol array
1241
Symbol: PIMAGEHLP_SYMBOL64; // array of duplicate symbols
1242
SelectedSymbol: DWORD; // symbol selected (-1 to start)
1244
{$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL64}
1245
IMAGEHLP_DUPLICATE_SYMBOL64 = _IMAGEHLP_DUPLICATE_SYMBOL64;
1246
{$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL64}
1247
TImageHlpDuplicateSymbol64 = IMAGEHLP_DUPLICATE_SYMBOL64;
1248
PImageHlpDuplicateSymbol64 = PIMAGEHLP_DUPLICATE_SYMBOL64;
1250
PIMAGEHLP_DUPLICATE_SYMBOL = ^IMAGEHLP_DUPLICATE_SYMBOL;
1251
{$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL}
1252
_IMAGEHLP_DUPLICATE_SYMBOL = record
1253
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
1254
NumberOfDups: DWORD; // number of duplicates in the Symbol array
1255
Symbol: PIMAGEHLP_SYMBOL; // array of duplicate symbols
1256
SelectedSymbol: DWORD; // symbol selected (-1 to start)
1258
{$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL}
1259
IMAGEHLP_DUPLICATE_SYMBOL = _IMAGEHLP_DUPLICATE_SYMBOL;
1260
{$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL}
1261
TImageHlpDuplicateSymbol = IMAGEHLP_DUPLICATE_SYMBOL;
1262
PImageHlpDuplicateSymbol = PIMAGEHLP_DUPLICATE_SYMBOL;
1264
// If dbghelp ever needs to display graphical UI, it will use this as the parent window.
1267
//SymSetParentWindow(
1272
// options that are set/returned by SymSetOptions() & SymGetOptions()
1273
// these are used as a mask
1277
SYMOPT_CASE_INSENSITIVE = $00000001;
1278
{$EXTERNALSYM SYMOPT_CASE_INSENSITIVE}
1279
SYMOPT_UNDNAME = $00000002;
1280
{$EXTERNALSYM SYMOPT_UNDNAME}
1281
SYMOPT_DEFERRED_LOADS = $00000004;
1282
{$EXTERNALSYM SYMOPT_DEFERRED_LOADS}
1283
SYMOPT_NO_CPP = $00000008;
1284
{$EXTERNALSYM SYMOPT_NO_CPP}
1285
SYMOPT_LOAD_LINES = $00000010;
1286
{$EXTERNALSYM SYMOPT_LOAD_LINES}
1287
SYMOPT_OMAP_FIND_NEAREST = $00000020;
1288
{$EXTERNALSYM SYMOPT_OMAP_FIND_NEAREST}
1289
SYMOPT_LOAD_ANYTHING = $00000040;
1290
{$EXTERNALSYM SYMOPT_LOAD_ANYTHING}
1291
SYMOPT_IGNORE_CVREC = $00000080;
1292
{$EXTERNALSYM SYMOPT_IGNORE_CVREC}
1293
SYMOPT_NO_UNQUALIFIED_LOADS = $00000100;
1294
{$EXTERNALSYM SYMOPT_NO_UNQUALIFIED_LOADS}
1295
SYMOPT_FAIL_CRITICAL_ERRORS = $00000200;
1296
{$EXTERNALSYM SYMOPT_FAIL_CRITICAL_ERRORS}
1297
SYMOPT_EXACT_SYMBOLS = $00000400;
1298
{$EXTERNALSYM SYMOPT_EXACT_SYMBOLS}
1299
SYMOPT_ALLOW_ABSOLUTE_SYMBOLS = $00000800;
1300
{$EXTERNALSYM SYMOPT_ALLOW_ABSOLUTE_SYMBOLS}
1301
SYMOPT_IGNORE_NT_SYMPATH = $00001000;
1302
{$EXTERNALSYM SYMOPT_IGNORE_NT_SYMPATH}
1303
SYMOPT_INCLUDE_32BIT_MODULES = $00002000;
1304
{$EXTERNALSYM SYMOPT_INCLUDE_32BIT_MODULES}
1305
SYMOPT_PUBLICS_ONLY = $00004000;
1306
{$EXTERNALSYM SYMOPT_PUBLICS_ONLY}
1307
SYMOPT_NO_PUBLICS = $00008000;
1308
{$EXTERNALSYM SYMOPT_NO_PUBLICS}
1309
SYMOPT_AUTO_PUBLICS = $00010000;
1310
{$EXTERNALSYM SYMOPT_AUTO_PUBLICS}
1311
SYMOPT_NO_IMAGE_SEARCH = $00020000;
1312
{$EXTERNALSYM SYMOPT_NO_IMAGE_SEARCH}
1313
SYMOPT_SECURE = $00040000;
1314
{$EXTERNALSYM SYMOPT_SECURE}
1316
SYMOPT_DEBUG = DWORD($80000000);
1317
{$EXTERNALSYM SYMOPT_DEBUG}
1319
function SymSetOptions(SymOptions: DWORD): DWORD; stdcall;
1320
{$EXTERNALSYM SymSetOptions}
1322
function SymGetOptions: DWORD; stdcall;
1323
{$EXTERNALSYM SymGetOptions}
1325
function SymCleanup(hProcess: HANDLE): BOOL; stdcall;
1326
{$EXTERNALSYM SymCleanup}
1328
function SymMatchString(string_, expression: LPSTR; fCase: BOOL): BOOL; stdcall;
1329
{$EXTERNALSYM SymMatchString}
1332
PSYM_ENUMSOURCFILES_CALLBACK = function(pSourceFile: PSOURCEFILE; UserContext: PVOID): BOOL; stdcall;
1333
{$EXTERNALSYM PSYM_ENUMSOURCFILES_CALLBACK}
1334
PSymEnumSourceFilesCallback = PSYM_ENUMSOURCFILES_CALLBACK;
1336
function SymEnumSourceFiles(hProcess: HANDLE; ModBase: ULONG64; Mask: LPSTR;
1337
cbSrcFiles: PSYM_ENUMSOURCFILES_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1338
{$EXTERNALSYM SymEnumSourceFiles}
1340
function SymEnumerateModules64(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK64;
1341
UserContext: PVOID): BOOL; stdcall;
1342
{$EXTERNALSYM SymEnumerateModules64}
1344
function SymEnumerateModules(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK;
1345
UserContext: PVOID): BOOL; stdcall;
1346
{$EXTERNALSYM SymEnumerateModules}
1348
function SymEnumerateSymbols64(hProcess: HANDLE; BaseOfDll: DWORD64;
1349
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64; UserContext: PVOID): BOOL; stdcall;
1350
{$EXTERNALSYM SymEnumerateSymbols64}
1352
function SymEnumerateSymbolsW64(hProcess: HANDLE; BaseOfDll: DWORD64;
1353
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64W; UserContext: PVOID): BOOL; stdcall;
1354
{$EXTERNALSYM SymEnumerateSymbolsW64}
1356
function SymEnumerateSymbols(hProcess: HANDLE; BaseOfDll: DWORD;
1357
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1358
{$EXTERNALSYM SymEnumerateSymbols}
1360
function SymEnumerateSymbolsW(hProcess: HANDLE; BaseOfDll: DWORD;
1361
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACKW; UserContext: PVOID): BOOL; stdcall;
1362
{$EXTERNALSYM SymEnumerateSymbolsW}
1364
function EnumerateLoadedModules64(hProcess: HANDLE; EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64;
1365
UserContext: PVOID): BOOL; stdcall;
1366
{$EXTERNALSYM EnumerateLoadedModules64}
1368
function EnumerateLoadedModules(hProcess: HANDLE; EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK;
1369
UserContext: PVOID): BOOL; stdcall;
1370
{$EXTERNALSYM EnumerateLoadedModules}
1372
function SymFunctionTableAccess64(hProcess: HANDLE; AddrBase: DWORD64): PVOID; stdcall;
1373
{$EXTERNALSYM SymFunctionTableAccess64}
1375
function SymFunctionTableAccess(hProcess: HANDLE; AddrBase: DWORD): PVOID; stdcall;
1376
{$EXTERNALSYM SymFunctionTableAccess}
1378
function SymGetModuleInfo64(hProcess: HANDLE; qwAddr: DWORD64;
1379
var ModuleInfo: IMAGEHLP_MODULE64): BOOL; stdcall;
1380
{$EXTERNALSYM SymGetModuleInfo64}
1382
function SymGetModuleInfoW64(hProcess: HANDLE; qwAddr: DWORD64;
1383
var ModuleInfo: IMAGEHLP_MODULEW64): BOOL; stdcall;
1384
{$EXTERNALSYM SymGetModuleInfoW64}
1386
function SymGetModuleInfo(hProcess: HANDLE; dwAddr: DWORD;
1387
var ModuleInfo: IMAGEHLP_MODULE): BOOL; stdcall;
1388
{$EXTERNALSYM SymGetModuleInfo}
1390
function SymGetModuleInfoW(hProcess: HANDLE; dwAddr: DWORD;
1391
var ModuleInfo: IMAGEHLP_MODULEW): BOOL; stdcall;
1392
{$EXTERNALSYM SymGetModuleInfoW}
1394
function SymGetModuleBase64(hProcess: HANDLE; qwAddr: DWORD64): DWORD64; stdcall;
1395
{$EXTERNALSYM SymGetModuleBase64}
1397
function SymGetModuleBase(hProcess: HANDLE; dwAddr: DWORD): DWORD; stdcall;
1398
{$EXTERNALSYM SymGetModuleBase}
1400
function SymGetSymNext64(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL64): BOOL; stdcall;
1401
{$EXTERNALSYM SymGetSymNext64}
1403
function SymGetSymNext(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL): BOOL; stdcall;
1404
{$EXTERNALSYM SymGetSymNext}
1406
function SymGetSymPrev64(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL64): BOOL; stdcall;
1407
{$EXTERNALSYM SymGetSymPrev64}
1409
function SymGetSymPrev(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL): BOOL; stdcall;
1410
{$EXTERNALSYM SymGetSymPrev}
1412
function SymGetLineFromAddr64(hProcess: HANDLE; qwAddr: DWORD64;
1413
var pdwDisplacement: DWORD; var Line64: IMAGEHLP_LINE64): BOOL; stdcall;
1414
{$EXTERNALSYM SymGetLineFromAddr64}
1416
function SymGetLineFromAddr(hProcess: HANDLE; dwAddr: DWORD;
1417
var pdwDisplacement: DWORD; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1418
{$EXTERNALSYM SymGetLineFromAddr}
1420
function SymGetLineFromName64(hProcess: HANDLE; ModuleName: PSTR; FileName: PSTR;
1421
dwLineNumber: DWORD; var plDisplacement: LONG; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1422
{$EXTERNALSYM SymGetLineFromName64}
1424
function SymGetLineFromName(hProcess: HANDLE; ModuleName: PSTR; FileName: PSTR;
1425
dwLineNumber: DWORD; var plDisplacement: LONG; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1426
{$EXTERNALSYM SymGetLineFromName}
1428
function SymGetLineNext64(hProcess: HANDLE; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1429
{$EXTERNALSYM SymGetLineNext64}
1431
function SymGetLineNext(hProcess: HANDLE; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1432
{$EXTERNALSYM SymGetLineNext}
1434
function SymGetLinePrev64(hProcess: HANDLE; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1435
{$EXTERNALSYM SymGetLinePrev64}
1437
function SymGetLinePrev(hProcess: HANDLE; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1438
{$EXTERNALSYM SymGetLinePrev}
1440
function SymMatchFileName(FileName, Match: PSTR; var FileNameStop, MatchStop: PSTR): BOOL; stdcall;
1441
{$EXTERNALSYM SymMatchFileName}
1443
function SymInitialize(hProcess: HANDLE; UserSearchPath: PSTR; fInvadeProcess: BOOL): BOOL; stdcall;
1444
{$EXTERNALSYM SymInitialize}
1446
function SymGetSearchPath(hProcess: HANDLE; SearchPath: PSTR; SearchPathLength: DWORD): BOOL; stdcall;
1447
{$EXTERNALSYM SymGetSearchPath}
1449
function SymSetSearchPath(hProcess: HANDLE; SearchPath: PSTR): BOOL; stdcall;
1450
{$EXTERNALSYM SymSetSearchPath}
1452
function SymLoadModule64(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR;
1453
BaseOfDll: DWORD64; SizeOfDll: DWORD): DWORD64; stdcall;
1454
{$EXTERNALSYM SymLoadModule64}
1457
SLMFLAG_VIRTUAL = $1;
1458
{$EXTERNALSYM SLMFLAG_VIRTUAL}
1460
function SymLoadModuleEx(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR; BaseOfDll: DWORD64;
1461
DllSize: DWORD; Data: PMODLOAD_DATA; Flag: DWORD): DWORD64; stdcall;
1462
{$EXTERNALSYM SymLoadModuleEx}
1464
function SymLoadModule(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR;
1465
BaseOfDll: DWORD; SizeOfDll: DWORD): DWORD; stdcall;
1466
{$EXTERNALSYM SymLoadModule}
1468
function SymUnloadModule64(hProcess: HANDLE; BaseOfDll: DWORD64): BOOL; stdcall;
1469
{$EXTERNALSYM SymUnloadModule64}
1471
function SymUnloadModule(hProcess: HANDLE; BaseOfDll: DWORD): BOOL; stdcall;
1472
{$EXTERNALSYM SymUnloadModule}
1474
function SymUnDName64(const sym: IMAGEHLP_SYMBOL64; UnDecName: PSTR;
1475
UnDecNameLength: DWORD): BOOL; stdcall;
1476
{$EXTERNALSYM SymUnDName64}
1478
function SymUnDName(const sym: IMAGEHLP_SYMBOL; UnDecName: PSTR;
1479
UnDecNameLength: DWORD): BOOL; stdcall;
1480
{$EXTERNALSYM SymUnDName}
1482
function SymRegisterCallback64(hProcess: HANDLE; CallbackFunction: PSYMBOL_REGISTERED_CALLBACK64;
1483
UserContext: ULONG64): BOOL; stdcall;
1484
{$EXTERNALSYM SymRegisterCallback64}
1486
function SymRegisterFunctionEntryCallback64(hProcess: HANDLE; CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK64;
1487
UserContext: ULONG64): BOOL; stdcall;
1488
{$EXTERNALSYM SymRegisterFunctionEntryCallback64}
1490
function SymRegisterCallback(hProcess: HANDLE; CallbackFunction: PSYMBOL_REGISTERED_CALLBACK;
1491
UserContext: PVOID): BOOL; stdcall;
1492
{$EXTERNALSYM SymRegisterCallback}
1494
function SymRegisterFunctionEntryCallback(hProcess: HANDLE; CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK;
1495
UserContext: PVOID): BOOL; stdcall;
1496
{$EXTERNALSYM SymRegisterFunctionEntryCallback}
1499
PIMAGEHLP_SYMBOL_SRC = ^IMAGEHLP_SYMBOL_SRC;
1500
{$EXTERNALSYM PIMAGEHLP_SYMBOL_SRC}
1501
_IMAGEHLP_SYMBOL_SRC = record
1502
sizeofstruct: DWORD;
1504
file_: array [0..MAX_PATH - 1] of Char;
1506
{$EXTERNALSYM _IMAGEHLP_SYMBOL_SRC}
1507
IMAGEHLP_SYMBOL_SRC = _IMAGEHLP_SYMBOL_SRC;
1508
{$EXTERNALSYM IMAGEHLP_SYMBOL_SRC}
1509
TImageHlpSymbolSrc = IMAGEHLP_SYMBOL_SRC;
1510
PImageHlpSymbolSrc = PIMAGEHLP_SYMBOL_SRC;
1512
PMODULE_TYPE_INFO = ^MODULE_TYPE_INFO;
1513
{$EXTERNALSYM PMODULE_TYPE_INFO}
1514
_MODULE_TYPE_INFO = record
1517
data: array [0..0] of BYTE;
1519
{$EXTERNALSYM _MODULE_TYPE_INFO}
1520
MODULE_TYPE_INFO = _MODULE_TYPE_INFO;
1521
{$EXTERNALSYM MODULE_TYPE_INFO}
1522
TModuleTypeInfo = MODULE_TYPE_INFO;
1523
PModuleTypeInfo = PMODULE_TYPE_INFO;
1526
PSYMBOL_INFO = ^SYMBOL_INFO;
1527
{$EXTERNALSYM PSYMBOL_INFO}
1528
_SYMBOL_INFO = record
1529
SizeOfStruct: ULONG;
1530
TypeIndex: ULONG; // Type Index of symbol
1531
Reserved: array [0..1] of ULONG64;
1534
ModBase: ULONG64; // Base Address of module comtaining this symbol
1536
Value: ULONG64; // Value of symbol, ValuePresent should be 1
1537
Address: ULONG64; // Address of symbol including base address of module
1538
Register_: ULONG; // register holding value or pointer to value
1539
Scope: ULONG; // scope of the symbol
1540
Tag: ULONG; // pdb classification
1541
NameLen: ULONG; // Actual length of name
1543
Name: array [0..0] of CHAR; // Name of symbol
1545
{$EXTERNALSYM _SYMBOL_INFO}
1546
SYMBOL_INFO = _SYMBOL_INFO;
1547
{$EXTERNALSYM SYMBOL_INFO}
1548
TSymbolInfo = SYMBOL_INFO;
1549
PSymbolInfo = PSYMBOL_INFO;
1551
_SYMBOL_INFO_PACKAGE = record
1553
name: array [0..MAX_SYM_NAME] of CHAR;
1555
{$EXTERNALSYM _SYMBOL_INFO_PACKAGE}
1556
SYMBOL_INFO_PACKAGE = _SYMBOL_INFO_PACKAGE;
1557
{$EXTERNALSYM SYMBOL_INFO_PACKAGE}
1558
PSYMBOL_INFO_PACKAGE = ^SYMBOL_INFO_PACKAGE;
1559
{$EXTERNALSYM PSYMBOL_INFO_PACKAGE}
1560
TSymbolInfoPackage = SYMBOL_INFO_PACKAGE;
1561
PSymbolInfoPackage = PSYMBOL_INFO_PACKAGE;
1563
PIMAGEHLP_STACK_FRAME = ^IMAGEHLP_STACK_FRAME;
1564
{$EXTERNALSYM PIMAGEHLP_STACK_FRAME}
1565
_IMAGEHLP_STACK_FRAME = record
1566
InstructionOffset: ULONG64;
1567
ReturnOffset: ULONG64;
1568
FrameOffset: ULONG64;
1569
StackOffset: ULONG64;
1570
BackingStoreOffset: ULONG64;
1571
FuncTableEntry: ULONG64;
1572
Params: array [0..3] of ULONG64;
1573
Reserved: array [0..4] of ULONG64;
1577
{$EXTERNALSYM _IMAGEHLP_STACK_FRAME}
1578
IMAGEHLP_STACK_FRAME = _IMAGEHLP_STACK_FRAME;
1579
{$EXTERNALSYM IMAGEHLP_STACK_FRAME}
1580
TImageHlpStackFrame = IMAGEHLP_STACK_FRAME;
1581
PImageHlpStackFrame = PIMAGEHLP_STACK_FRAME;
1583
IMAGEHLP_CONTEXT = LPVOID;
1584
{$EXTERNALSYM IMAGEHLP_CONTEXT}
1585
PIMAGEHLP_CONTEXT = ^IMAGEHLP_CONTEXT;
1586
{$EXTERNALSYM PIMAGEHLP_CONTEXT}
1587
TImageHlpContext = IMAGEHLP_CONTEXT;
1588
PImageHlpContext = PIMAGEHLP_CONTEXT;
1590
function SymSetContext(hProcess: HANDLE; StackFrame: PIMAGEHLP_STACK_FRAME; Context: PIMAGEHLP_CONTEXT): BOOL; stdcall;
1591
{$EXTERNALSYM SymSetContext}
1593
function SymFromAddr(hProcess: HANDLE; Address: DWORD64; Displacement: PDWORD64; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1594
{$EXTERNALSYM SymFromAddr}
1596
// While SymFromName will provide a symbol from a name,
1597
// SymEnumSymbols can provide the same matching information
1598
// for ALL symbols with a matching name, even regular
1599
// expressions. That way you can search across modules
1600
// and differentiate between identically named symbols.
1602
function SymFromName(hProcess: HANDLE; Name: LPSTR; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1603
{$EXTERNALSYM SymFromName}
1606
PSYM_ENUMERATESYMBOLS_CALLBACK = function(pSymInfo: PSYMBOL_INFO; SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
1607
{$EXTERNALSYM PSYM_ENUMERATESYMBOLS_CALLBACK}
1608
PSymEnumerateSymbolsCallback = PSYM_ENUMERATESYMBOLS_CALLBACK;
1610
function SymEnumSymbols(hProcess: HANDLE; BaseOfDll: ULONG64; Mask: PCSTR; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1611
{$EXTERNALSYM SymEnumSymbols}
1613
function SymEnumSymbolsForAddr(hProcess: HANDLE; Address: DWORD64;
1614
EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1615
{$EXTERNALSYM SymEnumSymbolsForAddr}
1618
_IMAGEHLP_SYMBOL_TYPE_INFO = (
1625
TI_GET_ARRAYINDEXTYPEID,
1628
TI_GET_ADDRESSOFFSET,
1632
TI_GET_CHILDRENCOUNT,
1634
TI_GET_VIRTUALBASECLASS,
1635
TI_GET_VIRTUALTABLESHAPEID,
1636
TI_GET_VIRTUALBASEPOINTEROFFSET,
1637
TI_GET_CLASSPARENTID,
1640
TI_GET_LEXICALPARENT,
1645
TI_GET_CALLING_CONVENTION);
1646
{$EXTERNALSYM _IMAGEHLP_SYMBOL_TYPE_INFO}
1647
IMAGEHLP_SYMBOL_TYPE_INFO = _IMAGEHLP_SYMBOL_TYPE_INFO;
1648
{$EXTERNALSYM IMAGEHLP_SYMBOL_TYPE_INFO}
1649
TImageHlpSymbolTypeInfo = IMAGEHLP_SYMBOL_TYPE_INFO;
1651
PTI_FINDCHILDREN_PARAMS = ^TI_FINDCHILDREN_PARAMS;
1652
{$EXTERNALSYM PTI_FINDCHILDREN_PARAMS}
1653
_TI_FINDCHILDREN_PARAMS = record
1656
ChildId: array [0..0] of ULONG;
1658
{$EXTERNALSYM _TI_FINDCHILDREN_PARAMS}
1659
TI_FINDCHILDREN_PARAMS = _TI_FINDCHILDREN_PARAMS;
1660
{$EXTERNALSYM TI_FINDCHILDREN_PARAMS}
1661
TTiFindChildrenParams = TI_FINDCHILDREN_PARAMS;
1662
PTiFindChildrenParams = PTI_FINDCHILDREN_PARAMS;
1664
function SymGetTypeInfo(hProcess: HANDLE; ModBase: DWORD64; TypeId: ULONG; GetType: IMAGEHLP_SYMBOL_TYPE_INFO; pInfo: PVOID): BOOL; stdcall;
1665
{$EXTERNALSYM SymGetTypeInfo}
1667
function SymEnumTypes(hProcess: HANDLE; BaseOfDll: ULONG64; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1668
{$EXTERNALSYM SymEnumTypes}
1670
function SymGetTypeFromName(hProcess: HANDLE; BaseOfDll: ULONG64; Name: LPSTR; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1671
{$EXTERNALSYM SymGetTypeFromName}
1673
function SymAddSymbol(hProcess: HANDLE; BaseOfDll: ULONG64; Name: PCSTR; Address: DWORD64; Size, Flags: DWORD): BOOL; stdcall;
1674
{$EXTERNALSYM SymAddSymbol}
1676
function SymDeleteSymbol(hProcess: HANDLE; BaseOfDll: ULONG64; Name: PCSTR; Address: DWORD64; Flags: DWORD): BOOL; stdcall;
1677
{$EXTERNALSYM SymDeleteSymbol}
1680
// Full user-mode dump creation.
1684
PDBGHELP_CREATE_USER_DUMP_CALLBACK = function(DataType: DWORD; var Data: PVOID; DataLength: LPDWORD; UserData: PVOID): BOOL; stdcall;
1685
{$EXTERNALSYM PDBGHELP_CREATE_USER_DUMP_CALLBACK}
1686
PDbgHelpCreateUserDumpCallback = PDBGHELP_CREATE_USER_DUMP_CALLBACK;
1688
function DbgHelpCreateUserDump(FileName: LPSTR; Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK; UserData: PVOID): BOOL; stdcall;
1689
{$EXTERNALSYM DbgHelpCreateUserDump}
1691
function DbgHelpCreateUserDumpW(FileName: LPWSTR; Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK; UserData: PVOID): BOOL; stdcall;
1692
{$EXTERNALSYM DbgHelpCreateUserDumpW}
1694
// -----------------------------------------------------------------
1695
// The following 4 legacy APIs are fully supported, but newer
1696
// ones are recommended. SymFromName and SymFromAddr provide
1697
// much more detailed info on the returned symbol.
1699
function SymGetSymFromAddr64(hProcess: HANDLE; qwAddr: DWORD64; pdwDisplacement: PDWORD64; Symbol: PIMAGEHLP_SYMBOL64): BOOL; stdcall;
1700
{$EXTERNALSYM SymGetSymFromAddr64}
1702
function SymGetSymFromAddr(hProcess: HANDLE; dwAddr: DWORD; pdwDisplacement: PDWORD; Symbol: PIMAGEHLP_SYMBOL): BOOL; stdcall;
1703
{$EXTERNALSYM SymGetSymFromAddr}
1705
// While following two APIs will provide a symbol from a name,
1706
// SymEnumSymbols can provide the same matching information
1707
// for ALL symbols with a matching name, even regular
1708
// expressions. That way you can search across modules
1709
// and differentiate between identically named symbols.
1711
function SymGetSymFromName64(hProcess: HANDLE; Name: PSTR; Symbol: PIMAGEHLP_SYMBOL64): BOOL; stdcall;
1712
{$EXTERNALSYM SymGetSymFromName64}
1714
function SymGetSymFromName(hProcess: HANDLE; Name: PSTR; Symbol: PIMAGEHLP_SYMBOL): BOOL; stdcall;
1715
{$EXTERNALSYM SymGetSymFromName}
1717
// -----------------------------------------------------------------
1718
// The following APIs exist only for backwards compatibility
1719
// with a pre-release version documented in an MSDN release.
1721
// You should use SymFindFileInPath if you want to maintain
1722
// future compatibility.
1724
function FindFileInPath(hprocess: HANDLE; SearchPath: LPSTR; FileName: LPSTR; id: PVOID; two: DWORD; three: DWORD; flags: DWORD; FilePath: LPSTR): BOOL; stdcall;
1725
{$EXTERNALSYM FindFileInPath}
1727
// You should use SymFindFileInPath if you want to maintain
1728
// future compatibility.
1730
function FindFileInSearchPath(hprocess: HANDLE; SearchPath: LPSTR; FileName: LPSTR; one: DWORD; two: DWORD; three: DWORD; FilePath: LPSTR): BOOL; stdcall;
1731
{$EXTERNALSYM FindFileInSearchPath}
1733
function SymEnumSym(hProcess: HANDLE; BaseOfDll: ULONG64; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1734
{$EXTERNALSYM SymEnumSym}
1736
// These values should not be used.
1737
// They have been replaced by SYMFLAG_ values.
1740
SYMF_OMAP_GENERATED = $00000001;
1741
SYMF_OMAP_MODIFIED = $00000002;
1742
SYMF_REGISTER = $00000008;
1743
SYMF_REGREL = $00000010;
1744
SYMF_FRAMEREL = $00000020;
1745
SYMF_PARAMETER = $00000040;
1746
SYMF_LOCAL = $00000080;
1747
SYMF_CONSTANT = $00000100;
1748
SYMF_EXPORT = $00000200;
1749
SYMF_FORWARDER = $00000400;
1750
SYMF_FUNCTION = $00000800;
1751
SYMF_VIRTUAL = $00001000;
1752
SYMF_THUNK = $00002000;
1753
SYMF_TLSREL = $00004000;
1755
// These values should also not be used.
1756
// They have been replaced by SYMFLAG_ values.
1758
IMAGEHLP_SYMBOL_INFO_VALUEPRESENT = 1;
1759
IMAGEHLP_SYMBOL_INFO_REGISTER = SYMF_REGISTER; // 0x0008
1760
IMAGEHLP_SYMBOL_INFO_REGRELATIVE = SYMF_REGREL; // 0x0010
1761
IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE = SYMF_FRAMEREL; // 0x0020
1762
IMAGEHLP_SYMBOL_INFO_PARAMETER = SYMF_PARAMETER; // 0x0040
1763
IMAGEHLP_SYMBOL_INFO_LOCAL = SYMF_LOCAL; // 0x0080
1764
IMAGEHLP_SYMBOL_INFO_CONSTANT = SYMF_CONSTANT; // 0x0100
1765
IMAGEHLP_SYMBOL_FUNCTION = SYMF_FUNCTION; // 0x0800
1766
IMAGEHLP_SYMBOL_VIRTUAL = SYMF_VIRTUAL; // 0x1000
1767
IMAGEHLP_SYMBOL_THUNK = SYMF_THUNK; // 0x2000
1768
IMAGEHLP_SYMBOL_INFO_TLSRELATIVE = SYMF_TLSREL; // 0x4000
1771
MINIDUMP_SIGNATURE = 'PMDM';
1772
{$EXTERNALSYM MINIDUMP_SIGNATURE}
1773
MINIDUMP_VERSION = 42899;
1774
{$EXTERNALSYM MINIDUMP_VERSION}
1780
{$EXTERNALSYM RVA64}
1782
_MINIDUMP_LOCATION_DESCRIPTOR = record
1786
{$EXTERNALSYM _MINIDUMP_LOCATION_DESCRIPTOR}
1787
MINIDUMP_LOCATION_DESCRIPTOR = _MINIDUMP_LOCATION_DESCRIPTOR;
1788
{$EXTERNALSYM MINIDUMP_LOCATION_DESCRIPTOR}
1789
TMinidumpLocationDescriptor = MINIDUMP_LOCATION_DESCRIPTOR;
1790
PMinidumpLocationDescriptor = ^MINIDUMP_LOCATION_DESCRIPTOR;
1792
_MINIDUMP_LOCATION_DESCRIPTOR64 = record
1796
{$EXTERNALSYM _MINIDUMP_LOCATION_DESCRIPTOR64}
1797
MINIDUMP_LOCATION_DESCRIPTOR64 = _MINIDUMP_LOCATION_DESCRIPTOR64;
1798
{$EXTERNALSYM MINIDUMP_LOCATION_DESCRIPTOR64}
1799
TMinidumpLocationDescriptor64 = MINIDUMP_LOCATION_DESCRIPTOR64;
1800
PMinidumpLocationDescriptor64 = ^MINIDUMP_LOCATION_DESCRIPTOR64;
1802
PMINIDUMP_MEMORY_DESCRIPTOR = ^MINIDUMP_MEMORY_DESCRIPTOR;
1803
{$EXTERNALSYM PMINIDUMP_MEMORY_DESCRIPTOR}
1804
_MINIDUMP_MEMORY_DESCRIPTOR = record
1805
StartOfMemoryRange: ULONG64;
1806
Memory: MINIDUMP_LOCATION_DESCRIPTOR;
1808
{$EXTERNALSYM _MINIDUMP_MEMORY_DESCRIPTOR}
1809
MINIDUMP_MEMORY_DESCRIPTOR = _MINIDUMP_MEMORY_DESCRIPTOR;
1810
{$EXTERNALSYM MINIDUMP_MEMORY_DESCRIPTOR}
1811
TMinidumpMemoryDescriptor = MINIDUMP_MEMORY_DESCRIPTOR;
1812
PMinidumpMemoryDescriptor = PMINIDUMP_MEMORY_DESCRIPTOR;
1814
// DESCRIPTOR64 is used for full-memory minidumps where
1815
// all of the raw memory is laid out sequentially at the
1816
// end of the dump. There is no need for individual RVAs
1817
// as the RVA is the base RVA plus the sum of the preceeding
1820
PMINIDUMP_MEMORY_DESCRIPTOR64 = ^MINIDUMP_MEMORY_DESCRIPTOR64;
1821
{$EXTERNALSYM PMINIDUMP_MEMORY_DESCRIPTOR64}
1822
_MINIDUMP_MEMORY_DESCRIPTOR64 = record
1823
StartOfMemoryRange: ULONG64;
1826
{$EXTERNALSYM _MINIDUMP_MEMORY_DESCRIPTOR64}
1827
MINIDUMP_MEMORY_DESCRIPTOR64 = _MINIDUMP_MEMORY_DESCRIPTOR64;
1828
{$EXTERNALSYM MINIDUMP_MEMORY_DESCRIPTOR64}
1829
TMinidumpMemoryDescriptor64 = MINIDUMP_MEMORY_DESCRIPTOR64;
1830
PMinidumpMemoryDescriptor64 = PMINIDUMP_MEMORY_DESCRIPTOR64;
1832
PMINIDUMP_HEADER = ^MINIDUMP_HEADER;
1833
{$EXTERNALSYM PMINIDUMP_HEADER}
1834
_MINIDUMP_HEADER = record
1837
NumberOfStreams: ULONG32;
1838
StreamDirectoryRva: RVA;
1842
0: (Reserved: ULONG32);
1843
1: (TimeDateStamp: ULONG32);
1847
{$EXTERNALSYM _MINIDUMP_HEADER}
1848
MINIDUMP_HEADER = _MINIDUMP_HEADER;
1849
{$EXTERNALSYM MINIDUMP_HEADER}
1850
TMinidumpHeader = MINIDUMP_HEADER;
1851
PMinidumpHeader = PMINIDUMP_HEADER;
1854
// The MINIDUMP_HEADER field StreamDirectoryRva points to
1855
// an array of MINIDUMP_DIRECTORY structures.
1858
PMINIDUMP_DIRECTORY = ^MINIDUMP_DIRECTORY;
1859
{$EXTERNALSYM PMINIDUMP_DIRECTORY}
1860
_MINIDUMP_DIRECTORY = record
1861
StreamType: ULONG32;
1862
Location: MINIDUMP_LOCATION_DESCRIPTOR;
1864
{$EXTERNALSYM _MINIDUMP_DIRECTORY}
1865
MINIDUMP_DIRECTORY = _MINIDUMP_DIRECTORY;
1866
{$EXTERNALSYM MINIDUMP_DIRECTORY}
1867
TMinidumpDirectory = MINIDUMP_DIRECTORY;
1868
PMinidumpDirectory = PMINIDUMP_DIRECTORY;
1870
PMINIDUMP_STRING = ^MINIDUMP_STRING;
1871
{$EXTERNALSYM PMINIDUMP_STRING}
1872
_MINIDUMP_STRING = record
1873
Length: ULONG32; // Length in bytes of the string
1874
Buffer: PWCHAR; // Variable size buffer
1876
{$EXTERNALSYM _MINIDUMP_STRING}
1877
MINIDUMP_STRING = _MINIDUMP_STRING;
1878
{$EXTERNALSYM MINIDUMP_STRING}
1879
TMinidumpString = MINIDUMP_STRING;
1880
PMinidumpString = PMINIDUMP_STRING;
1883
// The MINIDUMP_DIRECTORY field StreamType may be one of the following types.
1884
// Types will be added in the future, so if a program reading the minidump
1885
// header encounters a stream type it does not understand it should ignore
1886
// the data altogether. Any tag above LastReservedStream will not be used by
1887
// the system and is reserved for program-specific information.
1892
{$EXTERNALSYM UnusedStream}
1893
ReservedStream0 = 1;
1894
{$EXTERNALSYM ReservedStream0}
1895
ReservedStream1 = 2;
1896
{$EXTERNALSYM ReservedStream1}
1897
ThreadListStream = 3;
1898
{$EXTERNALSYM ThreadListStream}
1899
ModuleListStream = 4;
1900
{$EXTERNALSYM ModuleListStream}
1901
MemoryListStream = 5;
1902
{$EXTERNALSYM MemoryListStream}
1903
ExceptionStream = 6;
1904
{$EXTERNALSYM ExceptionStream}
1905
SystemInfoStream = 7;
1906
{$EXTERNALSYM SystemInfoStream}
1907
ThreadExListStream = 8;
1908
{$EXTERNALSYM ThreadExListStream}
1909
Memory64ListStream = 9;
1910
{$EXTERNALSYM Memory64ListStream}
1911
CommentStreamA = 10;
1912
{$EXTERNALSYM CommentStreamA}
1913
CommentStreamW = 11;
1914
{$EXTERNALSYM CommentStreamW}
1915
HandleDataStream = 12;
1916
{$EXTERNALSYM HandleDataStream}
1917
FunctionTableStream = 13;
1918
{$EXTERNALSYM FunctionTableStream}
1919
UnloadedModuleListStream = 14;
1920
{$EXTERNALSYM UnloadedModuleListStream}
1921
MiscInfoStream = 15;
1922
{$EXTERNALSYM MiscInfoStream}
1924
LastReservedStream = $ffff;
1925
{$EXTERNALSYM LastReservedStream}
1928
_MINIDUMP_STREAM_TYPE = DWORD;
1929
{$EXTERNALSYM MINIDUMP_STREAM_TYPE}
1930
MINIDUMP_STREAM_TYPE = _MINIDUMP_STREAM_TYPE;
1931
{$EXTERNALSYM _MINIDUMP_STREAM_TYPE}
1932
TMinidumpStreamType = MINIDUMP_STREAM_TYPE;
1935
// The minidump system information contains processor and
1936
// Operating System specific information.
1940
_CPU_INFORMATION = record
1944
// X86 platforms use CPUID function to obtain processor information.
1950
// CPUID Subfunction 0, register EAX (VendorId [0]),
1951
// EBX (VendorId [1]) and ECX (VendorId [2]).
1954
VendorId: array [0..2] of ULONG32;
1957
// CPUID Subfunction 1, register EAX
1960
VersionInformation: ULONG32;
1963
// CPUID Subfunction 1, register EDX
1966
FeatureInformation: ULONG32;
1969
// CPUID, Subfunction 80000001, register EBX. This will only
1970
// be obtained if the vendor id is "AuthenticAMD".
1973
AMDExtendedCpuFeatures: ULONG32);
1976
// Non-x86 platforms use processor feature flags.
1980
ProcessorFeatures: array [0..1] of ULONG64);
1983
_MINIDUMP_SYSTEM_INFO = record
1986
// ProcessorArchitecture, ProcessorLevel and ProcessorRevision are all
1987
// taken from the SYSTEM_INFO structure obtained by GetSystemInfo( ).
1990
ProcessorArchitecture: USHORT;
1991
ProcessorLevel: USHORT;
1992
ProcessorRevision: USHORT;
1996
0: (Reserved0: USHORT);
1998
NumberOfProcessors: UCHAR;
1999
ProductType: UCHAR);
2003
// MajorVersion, MinorVersion, BuildNumber, PlatformId and
2004
// CSDVersion are all taken from the OSVERSIONINFO structure
2005
// returned by GetVersionEx( ).
2008
MajorVersion: ULONG32;
2009
MinorVersion: ULONG32;
2010
BuildNumber: ULONG32;
2011
PlatformId: ULONG32;
2014
// RVA to a CSDVersion string in the string table.
2021
0: (Reserved1: ULONG32);
2028
// CPU information is obtained from one of two places.
2030
// 1) On x86 computers, CPU_INFORMATION is obtained from the CPUID
2031
// instruction. You must use the X86 portion of the union for X86
2034
// 2) On non-x86 architectures, CPU_INFORMATION is obtained by calling
2035
// IsProcessorFeatureSupported().
2038
Cpu: _CPU_INFORMATION;
2040
{$EXTERNALSYM _MINIDUMP_SYSTEM_INFO}
2041
MINIDUMP_SYSTEM_INFO = _MINIDUMP_SYSTEM_INFO;
2042
{$EXTERNALSYM MINIDUMP_SYSTEM_INFO}
2043
PMINIDUMP_SYSTEM_INFO = ^MINIDUMP_SYSTEM_INFO;
2044
{$EXTERNALSYM PMINIDUMP_SYSTEM_INFO}
2045
TMinidumpSystemInfo = MINIDUMP_SYSTEM_INFO;
2046
PMinidumpSystemInfo = PMINIDUMP_SYSTEM_INFO;
2048
CPU_INFORMATION = _CPU_INFORMATION;
2049
{$EXTERNALSYM CPU_INFORMATION}
2050
PCPU_INFORMATION = CPU_INFORMATION;
2051
{$EXTERNALSYM PCPU_INFORMATION}
2054
// The minidump thread contains standard thread
2055
// information plus an RVA to the memory for this
2056
// thread and an RVA to the CONTEXT structure for
2061
// ThreadId must be 4 bytes on all architectures.
2064
// C_ASSERT (sizeof ( ((PPROCESS_INFORMATION)0)->dwThreadId ) == 4);
2067
PMINIDUMP_THREAD = ^MINIDUMP_THREAD;
2068
{$EXTERNALSYM PMINIDUMP_THREAD}
2069
_MINIDUMP_THREAD = record
2071
SuspendCount: ULONG32;
2072
PriorityClass: ULONG32;
2075
Stack: MINIDUMP_MEMORY_DESCRIPTOR;
2076
ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2078
{$EXTERNALSYM _MINIDUMP_THREAD}
2079
MINIDUMP_THREAD = _MINIDUMP_THREAD;
2080
{$EXTERNALSYM MINIDUMP_THREAD}
2081
TMinidumpThread = MINIDUMP_THREAD;
2082
PMinidumpThread = PMINIDUMP_THREAD;
2085
// The thread list is a container of threads.
2088
PMINIDUMP_THREAD_LIST = ^MINIDUMP_THREAD_LIST;
2089
{$EXTERNALSYM PMINIDUMP_THREAD_LIST}
2090
_MINIDUMP_THREAD_LIST = record
2091
NumberOfThreads: ULONG32;
2092
Threads: array [0..0] of MINIDUMP_THREAD;
2094
{$EXTERNALSYM _MINIDUMP_THREAD_LIST}
2095
MINIDUMP_THREAD_LIST = _MINIDUMP_THREAD_LIST;
2096
{$EXTERNALSYM MINIDUMP_THREAD_LIST}
2097
TMinidumpThreadList = MINIDUMP_THREAD_LIST;
2098
PMinidumpThreadList = PMINIDUMP_THREAD_LIST;
2100
PMINIDUMP_THREAD_EX = ^MINIDUMP_THREAD_EX;
2101
{$EXTERNALSYM PMINIDUMP_THREAD_EX}
2102
_MINIDUMP_THREAD_EX = record
2104
SuspendCount: ULONG32;
2105
PriorityClass: ULONG32;
2108
Stack: MINIDUMP_MEMORY_DESCRIPTOR;
2109
ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2110
BackingStore: MINIDUMP_MEMORY_DESCRIPTOR;
2112
{$EXTERNALSYM _MINIDUMP_THREAD_EX}
2113
MINIDUMP_THREAD_EX = _MINIDUMP_THREAD_EX;
2114
{$EXTERNALSYM MINIDUMP_THREAD_EX}
2115
TMinidumpThreadEx = MINIDUMP_THREAD_EX;
2116
PMinidumpThreadEx = PMINIDUMP_THREAD_EX;
2119
// The thread list is a container of threads.
2122
PMINIDUMP_THREAD_EX_LIST = ^MINIDUMP_THREAD_EX_LIST;
2123
{$EXTERNALSYM PMINIDUMP_THREAD_EX_LIST}
2124
_MINIDUMP_THREAD_EX_LIST = record
2125
NumberOfThreads: ULONG32;
2126
Threads: array [0..0] of MINIDUMP_THREAD_EX;
2128
{$EXTERNALSYM _MINIDUMP_THREAD_EX_LIST}
2129
MINIDUMP_THREAD_EX_LIST = _MINIDUMP_THREAD_EX_LIST;
2130
{$EXTERNALSYM MINIDUMP_THREAD_EX_LIST}
2131
TMinidumpThreadExList = MINIDUMP_THREAD_EX_LIST;
2132
PMinidumpThreadExList = PMINIDUMP_THREAD_EX_LIST;
2135
// The MINIDUMP_EXCEPTION is the same as EXCEPTION on Win64.
2138
PMINIDUMP_EXCEPTION = ^MINIDUMP_EXCEPTION;
2139
{$EXTERNALSYM PMINIDUMP_EXCEPTION}
2140
_MINIDUMP_EXCEPTION = record
2141
ExceptionCode: ULONG32;
2142
ExceptionFlags: ULONG32;
2143
ExceptionRecord: ULONG64;
2144
ExceptionAddress: ULONG64;
2145
NumberParameters: ULONG32;
2146
__unusedAlignment: ULONG32;
2147
ExceptionInformation: array [0..EXCEPTION_MAXIMUM_PARAMETERS - 1] of ULONG64;
2149
{$EXTERNALSYM _MINIDUMP_EXCEPTION}
2150
MINIDUMP_EXCEPTION = _MINIDUMP_EXCEPTION;
2151
{$EXTERNALSYM MINIDUMP_EXCEPTION}
2152
TMinidumpException = MINIDUMP_EXCEPTION;
2153
PMinidumpException = PMINIDUMP_EXCEPTION;
2156
// The exception information stream contains the id of the thread that caused
2157
// the exception (ThreadId), the exception record for the exception
2158
// (ExceptionRecord) and an RVA to the thread context where the exception
2162
PMINIDUMP_EXCEPTION_STREAM = ^MINIDUMP_EXCEPTION_STREAM;
2163
{$EXTERNALSYM PMINIDUMP_EXCEPTION_STREAM}
2164
_MINIDUMP_EXCEPTION_STREAM = record
2166
__alignment: ULONG32;
2167
ExceptionRecord: MINIDUMP_EXCEPTION;
2168
ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2170
{$EXTERNALSYM _MINIDUMP_EXCEPTION_STREAM}
2171
MINIDUMP_EXCEPTION_STREAM = _MINIDUMP_EXCEPTION_STREAM;
2172
{$EXTERNALSYM MINIDUMP_EXCEPTION_STREAM}
2173
TMinidumpExceptionStream = MINIDUMP_EXCEPTION_STREAM;
2174
PMinidumpExceptionStream = PMINIDUMP_EXCEPTION_STREAM;
2177
// The MINIDUMP_MODULE contains information about a
2178
// a specific module. It includes the CheckSum and
2179
// the TimeDateStamp for the module so the module
2180
// can be reloaded during the analysis phase.
2183
PMINIDUMP_MODULE = ^MINIDUMP_MODULE;
2184
{$EXTERNALSYM PMINIDUMP_MODULE}
2185
_MINIDUMP_MODULE = record
2186
BaseOfImage: ULONG64;
2187
SizeOfImage: ULONG32;
2189
TimeDateStamp: ULONG32;
2191
VersionInfo: VS_FIXEDFILEINFO;
2192
CvRecord: MINIDUMP_LOCATION_DESCRIPTOR;
2193
MiscRecord: MINIDUMP_LOCATION_DESCRIPTOR;
2194
Reserved0: ULONG64; // Reserved for future use.
2195
Reserved1: ULONG64; // Reserved for future use.
2197
{$EXTERNALSYM _MINIDUMP_MODULE}
2198
MINIDUMP_MODULE = _MINIDUMP_MODULE;
2199
{$EXTERNALSYM MINIDUMP_MODULE}
2200
TMinidumpModule = MINIDUMP_MODULE;
2201
PMinidumpModule = PMINIDUMP_MODULE;
2204
// The minidump module list is a container for modules.
2207
PMINIDUMP_MODULE_LIST = ^MINIDUMP_MODULE_LIST;
2208
{$EXTERNALSYM PMINIDUMP_MODULE_LIST}
2209
_MINIDUMP_MODULE_LIST = record
2210
NumberOfModules: ULONG32;
2211
Modules: array [0..0] of MINIDUMP_MODULE;
2213
{$EXTERNALSYM _MINIDUMP_MODULE_LIST}
2214
MINIDUMP_MODULE_LIST = _MINIDUMP_MODULE_LIST;
2215
{$EXTERNALSYM MINIDUMP_MODULE_LIST}
2216
TMinidumpModuleList = MINIDUMP_MODULE_LIST;
2217
PMinidumpModuleList = PMINIDUMP_MODULE_LIST;
2223
PMINIDUMP_MEMORY_LIST = ^MINIDUMP_MEMORY_LIST;
2224
{$EXTERNALSYM PMINIDUMP_MEMORY_LIST}
2225
_MINIDUMP_MEMORY_LIST = record
2226
NumberOfMemoryRanges: ULONG32;
2227
MemoryRanges: array [0..0] of MINIDUMP_MEMORY_DESCRIPTOR;
2229
{$EXTERNALSYM _MINIDUMP_MEMORY_LIST}
2230
MINIDUMP_MEMORY_LIST = _MINIDUMP_MEMORY_LIST;
2231
{$EXTERNALSYM MINIDUMP_MEMORY_LIST}
2232
TMinidumpMemoryList = MINIDUMP_MEMORY_LIST;
2233
PMinidumpMemoryList = PMINIDUMP_MEMORY_LIST;
2235
PMINIDUMP_MEMORY64_LIST = ^MINIDUMP_MEMORY64_LIST;
2236
{$EXTERNALSYM PMINIDUMP_MEMORY64_LIST}
2237
_MINIDUMP_MEMORY64_LIST = record
2238
NumberOfMemoryRanges: ULONG64;
2240
MemoryRanges: array [0..0] of MINIDUMP_MEMORY_DESCRIPTOR64;
2242
{$EXTERNALSYM _MINIDUMP_MEMORY64_LIST}
2243
MINIDUMP_MEMORY64_LIST = _MINIDUMP_MEMORY64_LIST;
2244
{$EXTERNALSYM MINIDUMP_MEMORY64_LIST}
2245
TMinidumpMemory64List = MINIDUMP_MEMORY64_LIST;
2246
PMinidumpMemory64List = PMINIDUMP_MEMORY64_LIST;
2249
// Support for user supplied exception information.
2252
PMINIDUMP_EXCEPTION_INFORMATION = ^MINIDUMP_EXCEPTION_INFORMATION;
2253
{$EXTERNALSYM PMINIDUMP_EXCEPTION_INFORMATION}
2254
_MINIDUMP_EXCEPTION_INFORMATION = record
2256
ExceptionPointers: PEXCEPTION_POINTERS;
2257
ClientPointers: BOOL;
2259
{$EXTERNALSYM _MINIDUMP_EXCEPTION_INFORMATION}
2260
MINIDUMP_EXCEPTION_INFORMATION = _MINIDUMP_EXCEPTION_INFORMATION;
2261
{$EXTERNALSYM MINIDUMP_EXCEPTION_INFORMATION}
2262
TMinidumpExceptionInformation = MINIDUMP_EXCEPTION_INFORMATION;
2263
PMinidumpExceptionInformation = PMINIDUMP_EXCEPTION_INFORMATION;
2266
// Support for capturing system handle state at the time of the dump.
2269
PMINIDUMP_HANDLE_DESCRIPTOR = ^MINIDUMP_HANDLE_DESCRIPTOR;
2270
{$EXTERNALSYM PMINIDUMP_HANDLE_DESCRIPTOR}
2271
_MINIDUMP_HANDLE_DESCRIPTOR = record
2275
Attributes: ULONG32;
2276
GrantedAccess: ULONG32;
2277
HandleCount: ULONG32;
2278
PointerCount: ULONG32;
2280
{$EXTERNALSYM _MINIDUMP_HANDLE_DESCRIPTOR}
2281
MINIDUMP_HANDLE_DESCRIPTOR = _MINIDUMP_HANDLE_DESCRIPTOR;
2282
{$EXTERNALSYM MINIDUMP_HANDLE_DESCRIPTOR}
2283
TMinidumpHandleDescriptor = MINIDUMP_HANDLE_DESCRIPTOR;
2284
PMinidumpHandleDescriptor = PMINIDUMP_HANDLE_DESCRIPTOR;
2286
PMINIDUMP_HANDLE_DATA_STREAM = ^MINIDUMP_HANDLE_DATA_STREAM;
2287
{$EXTERNALSYM PMINIDUMP_HANDLE_DATA_STREAM}
2288
_MINIDUMP_HANDLE_DATA_STREAM = record
2289
SizeOfHeader: ULONG32;
2290
SizeOfDescriptor: ULONG32;
2291
NumberOfDescriptors: ULONG32;
2294
{$EXTERNALSYM _MINIDUMP_HANDLE_DATA_STREAM}
2295
MINIDUMP_HANDLE_DATA_STREAM = _MINIDUMP_HANDLE_DATA_STREAM;
2296
{$EXTERNALSYM MINIDUMP_HANDLE_DATA_STREAM}
2297
TMinidumpHandleDataStream = MINIDUMP_HANDLE_DATA_STREAM;
2298
PMinidumpHandleDataStream = PMINIDUMP_HANDLE_DATA_STREAM;
2301
// Support for capturing dynamic function table state at the time of the dump.
2304
PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR = ^MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2305
{$EXTERNALSYM PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2306
_MINIDUMP_FUNCTION_TABLE_DESCRIPTOR = record
2307
MinimumAddress: ULONG64;
2308
MaximumAddress: ULONG64;
2309
BaseAddress: ULONG64;
2310
EntryCount: ULONG32;
2311
SizeOfAlignPad: ULONG32;
2313
{$EXTERNALSYM _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2314
MINIDUMP_FUNCTION_TABLE_DESCRIPTOR = _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2315
{$EXTERNALSYM MINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2316
TMinidumpFunctionTableDescriptor = MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2317
PMinidumpFunctionTableDescriptor = PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2319
PMINIDUMP_FUNCTION_TABLE_STREAM = ^MINIDUMP_FUNCTION_TABLE_STREAM;
2320
{$EXTERNALSYM PMINIDUMP_FUNCTION_TABLE_STREAM}
2321
_MINIDUMP_FUNCTION_TABLE_STREAM = record
2322
SizeOfHeader: ULONG32;
2323
SizeOfDescriptor: ULONG32;
2324
SizeOfNativeDescriptor: ULONG32;
2325
SizeOfFunctionEntry: ULONG32;
2326
NumberOfDescriptors: ULONG32;
2327
SizeOfAlignPad: ULONG32;
2329
{$EXTERNALSYM _MINIDUMP_FUNCTION_TABLE_STREAM}
2330
MINIDUMP_FUNCTION_TABLE_STREAM = _MINIDUMP_FUNCTION_TABLE_STREAM;
2331
{$EXTERNALSYM MINIDUMP_FUNCTION_TABLE_STREAM}
2332
TMinidumpFunctionTableStream = MINIDUMP_FUNCTION_TABLE_STREAM;
2333
PMinidumpFunctionTableStream = PMINIDUMP_FUNCTION_TABLE_STREAM;
2336
// The MINIDUMP_UNLOADED_MODULE contains information about a
2337
// a specific module that was previously loaded but no
2338
// longer is. This can help with diagnosing problems where
2339
// callers attempt to call code that is no longer loaded.
2342
_MINIDUMP_UNLOADED_MODULE = record
2343
BaseOfImage: ULONG64;
2344
SizeOfImage: ULONG32;
2346
TimeDateStamp: ULONG32;
2349
{$EXTERNALSYM _MINIDUMP_UNLOADED_MODULE}
2350
MINIDUMP_UNLOADED_MODULE = _MINIDUMP_UNLOADED_MODULE;
2351
{$EXTERNALSYM MINIDUMP_UNLOADED_MODULE}
2352
PMINIDUMP_UNLOADED_MODULE = ^MINIDUMP_UNLOADED_MODULE;
2353
{$EXTERNALSYM PMINIDUMP_UNLOADED_MODULE}
2354
TMiniDumpUnloadedModule = MINIDUMP_UNLOADED_MODULE;
2355
PMiniDumpUnloadedModule = PMINIDUMP_UNLOADED_MODULE;
2358
// The minidump unloaded module list is a container for unloaded modules.
2361
_MINIDUMP_UNLOADED_MODULE_LIST = record
2362
SizeOfHeader: ULONG32;
2363
SizeOfEntry: ULONG32;
2364
NumberOfEntries: ULONG32;
2366
{$EXTERNALSYM _MINIDUMP_UNLOADED_MODULE_LIST}
2367
MINIDUMP_UNLOADED_MODULE_LIST = _MINIDUMP_UNLOADED_MODULE_LIST;
2368
{$EXTERNALSYM MINIDUMP_UNLOADED_MODULE_LIST}
2369
PMINIDUMP_UNLOADED_MODULE_LIST = ^MINIDUMP_UNLOADED_MODULE_LIST;
2370
{$EXTERNALSYM PMINIDUMP_UNLOADED_MODULE_LIST}
2371
TMiniDumpUnloadedModuleList = MINIDUMP_UNLOADED_MODULE_LIST;
2372
PMiniDumpUnloadedModuleList = PMINIDUMP_UNLOADED_MODULE_LIST;
2375
// The miscellaneous information stream contains a variety
2376
// of small pieces of information. A member is valid if
2377
// it's within the available size and its corresponding
2382
MINIDUMP_MISC1_PROCESS_ID = $00000001;
2383
{$EXTERNALSYM MINIDUMP_MISC1_PROCESS_ID}
2384
MINIDUMP_MISC1_PROCESS_TIMES = $00000002;
2385
{$EXTERNALSYM MINIDUMP_MISC1_PROCESS_TIMES}
2388
_MINIDUMP_MISC_INFO = record
2389
SizeOfInfo: ULONG32;
2392
ProcessCreateTime: ULONG32;
2393
ProcessUserTime: ULONG32;
2394
ProcessKernelTime: ULONG32;
2396
{$EXTERNALSYM _MINIDUMP_MISC_INFO}
2397
MINIDUMP_MISC_INFO = _MINIDUMP_MISC_INFO;
2398
{$EXTERNALSYM MINIDUMP_MISC_INFO}
2399
PMINIDUMP_MISC_INFO = ^MINIDUMP_MISC_INFO;
2400
{$EXTERNALSYM PMINIDUMP_MISC_INFO}
2401
TMiniDumpMiscInfo = MINIDUMP_MISC_INFO;
2402
PMiniDumpMiscInfo = PMINIDUMP_MISC_INFO;
2405
// Support for arbitrary user-defined information.
2408
PMINIDUMP_USER_RECORD = ^MINIDUMP_USER_RECORD;
2409
{$EXTERNALSYM PMINIDUMP_USER_RECORD}
2410
_MINIDUMP_USER_RECORD = record
2412
Memory: MINIDUMP_LOCATION_DESCRIPTOR;
2414
{$EXTERNALSYM _MINIDUMP_USER_RECORD}
2415
MINIDUMP_USER_RECORD = _MINIDUMP_USER_RECORD;
2416
{$EXTERNALSYM MINIDUMP_USER_RECORD}
2417
TMinidumpUserRecord = MINIDUMP_USER_RECORD;
2418
PMinidumpUserRecord = PMINIDUMP_USER_RECORD;
2420
PMINIDUMP_USER_STREAM = ^MINIDUMP_USER_STREAM;
2421
{$EXTERNALSYM PMINIDUMP_USER_STREAM}
2422
_MINIDUMP_USER_STREAM = record
2427
{$EXTERNALSYM _MINIDUMP_USER_STREAM}
2428
MINIDUMP_USER_STREAM = _MINIDUMP_USER_STREAM;
2429
{$EXTERNALSYM MINIDUMP_USER_STREAM}
2430
TMinidumpUserStream = MINIDUMP_USER_STREAM;
2431
PMinidumpUserStream = PMINIDUMP_USER_STREAM;
2433
PMINIDUMP_USER_STREAM_INFORMATION = ^MINIDUMP_USER_STREAM_INFORMATION;
2434
{$EXTERNALSYM PMINIDUMP_USER_STREAM_INFORMATION}
2435
_MINIDUMP_USER_STREAM_INFORMATION = record
2436
UserStreamCount: ULONG;
2437
UserStreamArray: PMINIDUMP_USER_STREAM;
2439
{$EXTERNALSYM _MINIDUMP_USER_STREAM_INFORMATION}
2440
MINIDUMP_USER_STREAM_INFORMATION = _MINIDUMP_USER_STREAM_INFORMATION;
2441
{$EXTERNALSYM MINIDUMP_USER_STREAM_INFORMATION}
2442
TMinidumpUserStreamInformation = MINIDUMP_USER_STREAM_INFORMATION;
2443
PMinidumpUserStreamInformation = PMINIDUMP_USER_STREAM_INFORMATION;
2446
// Callback support.
2449
_MINIDUMP_CALLBACK_TYPE = (
2453
IncludeThreadCallback,
2454
IncludeModuleCallback);
2455
{$EXTERNALSYM _MINIDUMP_CALLBACK_TYPE}
2456
MINIDUMP_CALLBACK_TYPE = _MINIDUMP_CALLBACK_TYPE;
2457
{$EXTERNALSYM MINIDUMP_CALLBACK_TYPE}
2458
TMinidumpCallbackType = MINIDUMP_CALLBACK_TYPE;
2460
PMINIDUMP_THREAD_CALLBACK = ^MINIDUMP_THREAD_CALLBACK;
2461
{$EXTERNALSYM PMINIDUMP_THREAD_CALLBACK}
2462
_MINIDUMP_THREAD_CALLBACK = record
2464
ThreadHandle: HANDLE;
2466
SizeOfContext: ULONG;
2470
{$EXTERNALSYM _MINIDUMP_THREAD_CALLBACK}
2471
MINIDUMP_THREAD_CALLBACK = _MINIDUMP_THREAD_CALLBACK;
2472
{$EXTERNALSYM MINIDUMP_THREAD_CALLBACK}
2473
TMinidumpThreadCallback = MINIDUMP_THREAD_CALLBACK;
2474
PMinidumpThreadCallback = PMINIDUMP_THREAD_CALLBACK;
2476
PMINIDUMP_THREAD_EX_CALLBACK = ^MINIDUMP_THREAD_EX_CALLBACK;
2477
{$EXTERNALSYM PMINIDUMP_THREAD_EX_CALLBACK}
2478
_MINIDUMP_THREAD_EX_CALLBACK = record
2480
ThreadHandle: HANDLE;
2482
SizeOfContext: ULONG;
2485
BackingStoreBase: ULONG64;
2486
BackingStoreEnd: ULONG64;
2488
{$EXTERNALSYM _MINIDUMP_THREAD_EX_CALLBACK}
2489
MINIDUMP_THREAD_EX_CALLBACK = _MINIDUMP_THREAD_EX_CALLBACK;
2490
{$EXTERNALSYM MINIDUMP_THREAD_EX_CALLBACK}
2491
TMinidumpThreadExCallback = MINIDUMP_THREAD_EX_CALLBACK;
2492
PMinidumpThreadExCallback = PMINIDUMP_THREAD_EX_CALLBACK;
2494
PMINIDUMP_INCLUDE_THREAD_CALLBACK = ^MINIDUMP_INCLUDE_THREAD_CALLBACK;
2495
{$EXTERNALSYM PMINIDUMP_INCLUDE_THREAD_CALLBACK}
2496
_MINIDUMP_INCLUDE_THREAD_CALLBACK = record
2499
{$EXTERNALSYM _MINIDUMP_INCLUDE_THREAD_CALLBACK}
2500
MINIDUMP_INCLUDE_THREAD_CALLBACK = _MINIDUMP_INCLUDE_THREAD_CALLBACK;
2501
{$EXTERNALSYM MINIDUMP_INCLUDE_THREAD_CALLBACK}
2502
TMinidumpIncludeThreadCallback = MINIDUMP_INCLUDE_THREAD_CALLBACK;
2503
PMinidumpIncludeThreadCallback = PMINIDUMP_INCLUDE_THREAD_CALLBACK;
2506
ThreadWriteThread = $0001;
2507
{$EXTERNALSYM ThreadWriteThread}
2508
ThreadWriteStack = $0002;
2509
{$EXTERNALSYM ThreadWriteStack}
2510
ThreadWriteContext = $0004;
2511
{$EXTERNALSYM ThreadWriteContext}
2512
ThreadWriteBackingStore = $0008;
2513
{$EXTERNALSYM ThreadWriteBackingStore}
2514
ThreadWriteInstructionWindow = $0010;
2515
{$EXTERNALSYM ThreadWriteInstructionWindow}
2516
ThreadWriteThreadData = $0020;
2517
{$EXTERNALSYM ThreadWriteThreadData}
2520
_THREAD_WRITE_FLAGS = DWORD;
2521
{$EXTERNALSYM _THREAD_WRITE_FLAGS}
2522
THREAD_WRITE_FLAGS = _THREAD_WRITE_FLAGS;
2523
{$EXTERNALSYM THREAD_WRITE_FLAGS}
2524
TThreadWriteFlags = THREAD_WRITE_FLAGS;
2527
PMINIDUMP_MODULE_CALLBACK = ^MINIDUMP_MODULE_CALLBACK;
2528
{$EXTERNALSYM PMINIDUMP_MODULE_CALLBACK}
2529
_MINIDUMP_MODULE_CALLBACK = record
2531
BaseOfImage: ULONG64;
2534
TimeDateStamp: ULONG;
2535
VersionInfo: VS_FIXEDFILEINFO;
2537
SizeOfCvRecord: ULONG;
2539
SizeOfMiscRecord: ULONG;
2541
{$EXTERNALSYM _MINIDUMP_MODULE_CALLBACK}
2542
MINIDUMP_MODULE_CALLBACK = _MINIDUMP_MODULE_CALLBACK;
2543
{$EXTERNALSYM MINIDUMP_MODULE_CALLBACK}
2544
TMinidumpModuleCallback = MINIDUMP_MODULE_CALLBACK;
2545
PMinidumpModuleCallback = PMINIDUMP_MODULE_CALLBACK;
2547
PMINIDUMP_INCLUDE_MODULE_CALLBACK = ^MINIDUMP_INCLUDE_MODULE_CALLBACK;
2548
{$EXTERNALSYM PMINIDUMP_INCLUDE_MODULE_CALLBACK}
2549
_MINIDUMP_INCLUDE_MODULE_CALLBACK = record
2550
BaseOfImage: ULONG64;
2552
{$EXTERNALSYM _MINIDUMP_INCLUDE_MODULE_CALLBACK}
2553
MINIDUMP_INCLUDE_MODULE_CALLBACK = _MINIDUMP_INCLUDE_MODULE_CALLBACK;
2554
{$EXTERNALSYM MINIDUMP_INCLUDE_MODULE_CALLBACK}
2555
TMinidumpIncludeModuleCallback = MINIDUMP_INCLUDE_MODULE_CALLBACK;
2556
PMinidumpIncludeModuleCallback = PMINIDUMP_INCLUDE_MODULE_CALLBACK;
2559
ModuleWriteModule = $0001;
2560
{$EXTERNALSYM ModuleWriteModule}
2561
ModuleWriteDataSeg = $0002;
2562
{$EXTERNALSYM ModuleWriteDataSeg}
2563
ModuleWriteMiscRecord = $0004;
2564
{$EXTERNALSYM ModuleWriteMiscRecord}
2565
ModuleWriteCvRecord = $0008;
2566
{$EXTERNALSYM ModuleWriteCvRecord}
2567
ModuleReferencedByMemory = $0010;
2568
{$EXTERNALSYM ModuleReferencedByMemory}
2571
_MODULE_WRITE_FLAGS = DWORD;
2572
{$EXTERNALSYM _MODULE_WRITE_FLAGS}
2573
MODULE_WRITE_FLAGS = _MODULE_WRITE_FLAGS;
2574
{$EXTERNALSYM MODULE_WRITE_FLAGS}
2575
TModuleWriteFlags = MODULE_WRITE_FLAGS;
2577
_MINIDUMP_CALLBACK_INPUT = record
2579
ProcessHandle: HANDLE;
2580
CallbackType: ULONG;
2582
0: (Thread: MINIDUMP_THREAD_CALLBACK);
2583
1: (ThreadEx: MINIDUMP_THREAD_EX_CALLBACK);
2584
2: (Module: MINIDUMP_MODULE_CALLBACK);
2585
3: (IncludeThread: MINIDUMP_INCLUDE_THREAD_CALLBACK);
2586
4: (IncludeModule: MINIDUMP_INCLUDE_MODULE_CALLBACK);
2588
{$EXTERNALSYM _MINIDUMP_CALLBACK_INPUT}
2589
MINIDUMP_CALLBACK_INPUT = _MINIDUMP_CALLBACK_INPUT;
2590
{$EXTERNALSYM MINIDUMP_CALLBACK_INPUT}
2591
PMINIDUMP_CALLBACK_INPUT = ^MINIDUMP_CALLBACK_INPUT;
2592
{$EXTERNALSYM PMINIDUMP_CALLBACK_INPUT}
2593
TminidumpCallbackInput = MINIDUMP_CALLBACK_INPUT;
2595
PMINIDUMP_CALLBACK_OUTPUT = ^MINIDUMP_CALLBACK_OUTPUT;
2596
{$EXTERNALSYM PMINIDUMP_CALLBACK_OUTPUT}
2597
_MINIDUMP_CALLBACK_OUTPUT = record
2599
0: (ModuleWriteFlags: ULONG);
2600
1: (ThreadWriteFlags: ULONG);
2602
{$EXTERNALSYM _MINIDUMP_CALLBACK_OUTPUT}
2603
MINIDUMP_CALLBACK_OUTPUT = _MINIDUMP_CALLBACK_OUTPUT;
2604
{$EXTERNALSYM MINIDUMP_CALLBACK_OUTPUT}
2605
TMinidumpCallbackOutput = MINIDUMP_CALLBACK_OUTPUT;
2606
PMinidumpCallbackOutput = PMINIDUMP_CALLBACK_OUTPUT;
2609
// A normal minidump contains just the information
2610
// necessary to capture stack traces for all of the
2611
// existing threads in a process.
2613
// A minidump with data segments includes all of the data
2614
// sections from loaded modules in order to capture
2615
// global variable contents. This can make the dump much
2616
// larger if many modules have global data.
2618
// A minidump with full memory includes all of the accessible
2619
// memory in the process and can be very large. A minidump
2620
// with full memory always has the raw memory data at the end
2621
// of the dump so that the initial structures in the dump can
2622
// be mapped directly without having to include the raw
2623
// memory information.
2625
// Stack and backing store memory can be filtered to remove
2626
// data unnecessary for stack walking. This can improve
2627
// compression of stacks and also deletes data that may
2628
// be private and should not be stored in a dump.
2629
// Memory can also be scanned to see what modules are
2630
// referenced by stack and backing store memory to allow
2631
// omission of other modules to reduce dump size.
2632
// In either of these modes the ModuleReferencedByMemory flag
2633
// is set for all modules referenced before the base
2634
// module callbacks occur.
2636
// On some operating systems a list of modules that were
2637
// recently unloaded is kept in addition to the currently
2638
// loaded module list. This information can be saved in
2639
// the dump if desired.
2641
// Stack and backing store memory can be scanned for referenced
2642
// pages in order to pick up data referenced by locals or other
2643
// stack memory. This can increase the size of a dump significantly.
2645
// Module paths may contain undesired information such as user names
2646
// or other important directory names so they can be stripped. This
2647
// option reduces the ability to locate the proper image later
2648
// and should only be used in certain situations.
2650
// Complete operating system per-process and per-thread information can
2651
// be gathered and stored in the dump.
2653
// The virtual address space can be scanned for various types
2654
// of memory to be included in the dump.
2658
MiniDumpNormal = $0000;
2659
{$EXTERNALSYM MiniDumpNormal}
2660
MiniDumpWithDataSegs = $0001;
2661
{$EXTERNALSYM MiniDumpWithDataSegs}
2662
MiniDumpWithFullMemory = $0002;
2663
{$EXTERNALSYM MiniDumpWithFullMemory}
2664
MiniDumpWithHandleData = $0004;
2665
{$EXTERNALSYM MiniDumpWithHandleData}
2666
MiniDumpFilterMemory = $0008;
2667
{$EXTERNALSYM MiniDumpFilterMemory}
2668
MiniDumpScanMemory = $0010;
2669
{$EXTERNALSYM MiniDumpScanMemory}
2670
MiniDumpWithUnloadedModules = $0020;
2671
{$EXTERNALSYM MiniDumpWithUnloadedModules}
2672
MiniDumpWithIndirectlyReferencedMemory = $0040;
2673
{$EXTERNALSYM MiniDumpWithIndirectlyReferencedMemory}
2674
MiniDumpFilterModulePaths = $0080;
2675
{$EXTERNALSYM MiniDumpFilterModulePaths}
2676
MiniDumpWithProcessThreadData = $0100;
2677
{$EXTERNALSYM MiniDumpWithProcessThreadData}
2678
MiniDumpWithPrivateReadWriteMemory = $0200;
2679
{$EXTERNALSYM MiniDumpWithPrivateReadWriteMemory}
2682
_MINIDUMP_TYPE = DWORD;
2683
{$EXTERNALSYM _MINIDUMP_TYPE}
2684
MINIDUMP_TYPE = _MINIDUMP_TYPE;
2685
{$EXTERNALSYM MINIDUMP_TYPE}
2686
TMinidumpType = MINIDUMP_TYPE;
2689
// The minidump callback should modify the FieldsToWrite parameter to reflect
2690
// what portions of the specified thread or module should be written to the
2694
MINIDUMP_CALLBACK_ROUTINE = function(CallbackParam: PVOID; CallbackInput: PMINIDUMP_CALLBACK_INPUT;
2695
CallbackOutput: PMINIDUMP_CALLBACK_OUTPUT): BOOL; stdcall;
2696
{$EXTERNALSYM MINIDUMP_CALLBACK_ROUTINE}
2697
TMinidumpCallbackRoutine = MINIDUMP_CALLBACK_ROUTINE;
2699
PMINIDUMP_CALLBACK_INFORMATION = ^MINIDUMP_CALLBACK_INFORMATION;
2700
{$EXTERNALSYM PMINIDUMP_CALLBACK_INFORMATION}
2701
_MINIDUMP_CALLBACK_INFORMATION = record
2702
CallbackRoutine: MINIDUMP_CALLBACK_ROUTINE;
2703
CallbackParam: PVOID;
2705
{$EXTERNALSYM _MINIDUMP_CALLBACK_INFORMATION}
2706
MINIDUMP_CALLBACK_INFORMATION = _MINIDUMP_CALLBACK_INFORMATION;
2707
{$EXTERNALSYM MINIDUMP_CALLBACK_INFORMATION}
2708
TMinidumpCallbackInformation = MINIDUMP_CALLBACK_INFORMATION;
2709
PMinidumpCallbackInformation = PMINIDUMP_CALLBACK_INFORMATION;
2719
// Routine Description:
2721
// Map an RVA that is contained within a mapped file to it's associated
2726
// Mapping - Base address of mapped file containing the RVA.
2728
// Rva - An Rva to fixup.
2732
// A pointer to the desired data.
2736
function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
2737
{$EXTERNALSYM RVA_TO_ADDR}
2739
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;
2740
{$EXTERNALSYM MiniDumpWriteDump}
2742
function MiniDumpReadDumpStream(BaseOfDump: PVOID; StreamNumber: ULONG; var Dir: PMINIDUMP_DIRECTORY; var StreamPointer: PVOID; var StreamSize: ULONG): BOOL; stdcall;
2743
{$EXTERNALSYM MiniDumpReadDumpStream}
2748
ImageHlpLib = 'imagehlp.dll';
2755
procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
2757
a64^.Offset := {ULONG64(LONG64(LONG(}a32^.Offset{)))};
2758
a64^.Segment := a32^.Segment;
2759
a64^.Mode := a32^.Mode;
2762
procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
2764
a32^.Offset := ULONG(a64^.Offset);
2765
a32^.Segment := a64^.Segment;
2766
a32^.Mode := a64^.Mode;
2769
procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
2771
p64^.Thread := p32^.Thread;
2772
p64^.ThCallbackStack := p32^.ThCallbackStack;
2773
p64^.NextCallback := p32^.NextCallback;
2774
p64^.FramePointer := p32^.FramePointer;
2775
p64^.KiCallUserMode := p32^.KiCallUserMode;
2776
p64^.KeUserCallbackDispatcher := p32^.KeUserCallbackDispatcher;
2777
p64^.SystemRangeStart := p32^.SystemRangeStart;
2780
function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
2782
Result := Pointer(Cardinal(Mapping) + Cardinal(Rva));
2785
{$IFDEF DYNAMIC_LINK}
2788
_BindImage: Pointer;
2792
GetProcedureAddress(_BindImage, ImageHlpLib, 'BindImage');
2801
_BindImageEx: Pointer;
2803
function BindImageEx;
2805
GetProcedureAddress(_BindImageEx, ImageHlpLib, 'BindImageEx');
2814
_ReBaseImage: Pointer;
2816
function ReBaseImage;
2818
GetProcedureAddress(_ReBaseImage, ImageHlpLib, 'ReBaseImage');
2827
_ReBaseImage64: Pointer;
2829
function ReBaseImage64;
2831
GetProcedureAddress(_ReBaseImage64, ImageHlpLib, 'ReBaseImage64');
2835
JMP [_ReBaseImage64]
2840
_CheckSumMappedFile: Pointer;
2842
function CheckSumMappedFile;
2844
GetProcedureAddress(_CheckSumMappedFile, ImageHlpLib, 'CheckSumMappedFile');
2848
JMP [_CheckSumMappedFile]
2853
_MapFileAndCheckSumA: Pointer;
2855
function MapFileAndCheckSumA;
2857
GetProcedureAddress(_MapFileAndCheckSumA, ImageHlpLib, 'MapFileAndCheckSumA');
2861
JMP [_MapFileAndCheckSumA]
2866
_MapFileAndCheckSumW: Pointer;
2868
function MapFileAndCheckSumW;
2870
GetProcedureAddress(_MapFileAndCheckSumW, ImageHlpLib, 'MapFileAndCheckSumW');
2874
JMP [_MapFileAndCheckSumW]
2879
_MapFileAndCheckSum: Pointer;
2881
function MapFileAndCheckSum;
2883
GetProcedureAddress(_MapFileAndCheckSum, ImageHlpLib, 'MapFileAndCheckSum' + AWSuffix);
2887
JMP [_MapFileAndCheckSum]
2892
_GetImageConfigInformation: Pointer;
2894
function GetImageConfigInformation;
2896
GetProcedureAddress(_GetImageConfigInformation, ImageHlpLib, 'GetImageConfigInformation');
2900
JMP [_GetImageConfigInformation]
2905
_GetImageUnusedHeaderBytes: Pointer;
2907
function GetImageUnusedHeaderBytes;
2909
GetProcedureAddress(_GetImageUnusedHeaderBytes, ImageHlpLib, 'GetImageUnusedHeaderBytes');
2913
JMP [_GetImageUnusedHeaderBytes]
2918
_SetImageConfigInformation: Pointer;
2920
function SetImageConfigInformation;
2922
GetProcedureAddress(_SetImageConfigInformation, ImageHlpLib, 'SetImageConfigInformation');
2926
JMP [_SetImageConfigInformation]
2931
_ImageGetDigestStream: Pointer;
2933
function ImageGetDigestStream;
2935
GetProcedureAddress(_ImageGetDigestStream, ImageHlpLib, 'ImageGetDigestStream');
2939
JMP [_ImageGetDigestStream]
2944
_ImageAddCertificate: Pointer;
2946
function ImageAddCertificate;
2948
GetProcedureAddress(_ImageAddCertificate, ImageHlpLib, 'ImageAddCertificate');
2952
JMP [_ImageAddCertificate]
2957
_ImageRemoveCertificate: Pointer;
2959
function ImageRemoveCertificate;
2961
GetProcedureAddress(_ImageRemoveCertificate, ImageHlpLib, 'ImageRemoveCertificate');
2965
JMP [_ImageRemoveCertificate]
2970
_ImageEnumerateCertificates: Pointer;
2972
function ImageEnumerateCertificates;
2974
GetProcedureAddress(_ImageEnumerateCertificates, ImageHlpLib, 'ImageEnumerateCertificates');
2978
JMP [_ImageEnumerateCertificates]
2983
_ImageGetCertificateData: Pointer;
2985
function ImageGetCertificateData;
2987
GetProcedureAddress(_ImageGetCertificateData, ImageHlpLib, 'ImageGetCertificateData');
2991
JMP [_ImageGetCertificateData]
2996
_ImageGetCertificateHeader: Pointer;
2998
function ImageGetCertificateHeader;
3000
GetProcedureAddress(_ImageGetCertificateHeader, ImageHlpLib, 'ImageGetCertificateHeader');
3004
JMP [_ImageGetCertificateHeader]
3009
_ImageLoad: Pointer;
3013
GetProcedureAddress(_ImageLoad, ImageHlpLib, 'ImageLoad');
3022
_ImageUnload: Pointer;
3024
function ImageUnload;
3026
GetProcedureAddress(_ImageUnload, ImageHlpLib, 'ImageUnload');
3035
_MapAndLoad: Pointer;
3037
function MapAndLoad;
3039
GetProcedureAddress(_MapAndLoad, ImageHlpLib, 'MapAndLoad');
3048
_UnMapAndLoad: Pointer;
3050
function UnMapAndLoad;
3052
GetProcedureAddress(_UnMapAndLoad, ImageHlpLib, 'UnMapAndLoad');
3061
_TouchFileTimes: Pointer;
3063
function TouchFileTimes;
3065
GetProcedureAddress(_TouchFileTimes, ImageHlpLib, 'TouchFileTimes');
3069
JMP [_TouchFileTimes]
3074
_SplitSymbols: Pointer;
3076
function SplitSymbols;
3078
GetProcedureAddress(_SplitSymbols, ImageHlpLib, 'SplitSymbols');
3087
_UpdateDebugInfoFile: Pointer;
3089
function UpdateDebugInfoFile;
3091
GetProcedureAddress(_UpdateDebugInfoFile, ImageHlpLib, 'UpdateDebugInfoFile');
3095
JMP [_UpdateDebugInfoFile]
3100
_UpdateDebugInfoFileEx: Pointer;
3102
function UpdateDebugInfoFileEx;
3104
GetProcedureAddress(_UpdateDebugInfoFileEx, ImageHlpLib, 'UpdateDebugInfoFileEx');
3108
JMP [_UpdateDebugInfoFileEx]
3113
_FindDebugInfoFile: Pointer;
3115
function FindDebugInfoFile;
3117
GetProcedureAddress(_FindDebugInfoFile, ImageHlpLib, 'FindDebugInfoFile');
3121
JMP [_FindDebugInfoFile]
3126
_FindDebugInfoFileEx: Pointer;
3128
function FindDebugInfoFileEx;
3130
GetProcedureAddress(_FindDebugInfoFileEx, ImageHlpLib, 'FindDebugInfoFileEx');
3134
JMP [_FindDebugInfoFileEx]
3139
_SymFindFileInPath: Pointer;
3141
function SymFindFileInPath;
3143
GetProcedureAddress(_SymFindFileInPath, ImageHlpLib, 'SymFindFileInPath');
3147
JMP [_SymFindFileInPath]
3152
_FindExecutableImage: Pointer;
3154
function FindExecutableImage;
3156
GetProcedureAddress(_FindExecutableImage, ImageHlpLib, 'FindExecutableImage');
3160
JMP [_FindExecutableImage]
3165
_FindExecutableImageEx: Pointer;
3167
function FindExecutableImageEx;
3169
GetProcedureAddress(_FindExecutableImageEx, ImageHlpLib, 'FindExecutableImageEx');
3173
JMP [_FindExecutableImageEx]
3178
_ImageNtHeader: Pointer;
3180
function ImageNtHeader;
3182
GetProcedureAddress(_ImageNtHeader, ImageHlpLib, 'ImageNtHeader');
3186
JMP [_ImageNtHeader]
3191
_ImageDirectoryEntryToDataEx: Pointer;
3193
function ImageDirectoryEntryToDataEx;
3195
GetProcedureAddress(_ImageDirectoryEntryToDataEx, ImageHlpLib, 'ImageDirectoryEntryToDataEx');
3199
JMP [_ImageDirectoryEntryToDataEx]
3204
_ImageDirectoryEntryToData: Pointer;
3206
function ImageDirectoryEntryToData;
3208
GetProcedureAddress(_ImageDirectoryEntryToData, ImageHlpLib, 'ImageDirectoryEntryToData');
3212
JMP [_ImageDirectoryEntryToData]
3217
_ImageRvaToSection: Pointer;
3219
function ImageRvaToSection;
3221
GetProcedureAddress(_ImageRvaToSection, ImageHlpLib, 'ImageRvaToSection');
3225
JMP [_ImageRvaToSection]
3230
_ImageRvaToVa: Pointer;
3232
function ImageRvaToVa;
3234
GetProcedureAddress(_ImageRvaToVa, ImageHlpLib, 'ImageRvaToVa');
3243
_MapDebugInformation: Pointer;
3245
function MapDebugInformation;
3247
GetProcedureAddress(_MapDebugInformation, ImageHlpLib, 'MapDebugInformation');
3251
JMP [_MapDebugInformation]
3256
_UnmapDebugInformation: Pointer;
3258
function UnmapDebugInformation;
3260
GetProcedureAddress(_UnmapDebugInformation, ImageHlpLib, 'UnmapDebugInformation');
3264
JMP [_UnmapDebugInformation]
3269
_SearchTreeForFile: Pointer;
3271
function SearchTreeForFile;
3273
GetProcedureAddress(_SearchTreeForFile, ImageHlpLib, 'SearchTreeForFile');
3277
JMP [_SearchTreeForFile]
3282
_EnumDirTree: Pointer;
3284
function EnumDirTree;
3286
GetProcedureAddress(_EnumDirTree, ImageHlpLib, 'EnumDirTree');
3295
_MakeSureDirectoryPathExists: Pointer;
3297
function MakeSureDirectoryPathExists;
3299
GetProcedureAddress(_MakeSureDirectoryPathExists, ImageHlpLib, 'MakeSureDirectoryPathExists');
3303
JMP [_MakeSureDirectoryPathExists]
3308
_UnDecorateSymbolName: Pointer;
3310
function UnDecorateSymbolName;
3312
GetProcedureAddress(_UnDecorateSymbolName, ImageHlpLib, 'UnDecorateSymbolName');
3316
JMP [_UnDecorateSymbolName]
3321
_StackWalk64: Pointer;
3323
function StackWalk64;
3325
GetProcedureAddress(_StackWalk64, ImageHlpLib, 'StackWalk64');
3334
_StackWalk: Pointer;
3338
GetProcedureAddress(_StackWalk, ImageHlpLib, 'StackWalk');
3347
_ImagehlpApiVersion: Pointer;
3349
function ImagehlpApiVersion;
3351
GetProcedureAddress(_ImagehlpApiVersion, ImageHlpLib, 'ImagehlpApiVersion');
3355
JMP [_ImagehlpApiVersion]
3360
_ImagehlpApiVersionEx: Pointer;
3362
function ImagehlpApiVersionEx;
3364
GetProcedureAddress(_ImagehlpApiVersionEx, ImageHlpLib, 'ImagehlpApiVersionEx');
3368
JMP [_ImagehlpApiVersionEx]
3373
_GetTimestampForLoadedLibrary: Pointer;
3375
function GetTimestampForLoadedLibrary;
3377
GetProcedureAddress(_GetTimestampForLoadedLibrary, ImageHlpLib, 'GetTimestampForLoadedLibrary');
3381
JMP [_GetTimestampForLoadedLibrary]
3386
_SymSetOptions: Pointer;
3388
function SymSetOptions;
3390
GetProcedureAddress(_SymSetOptions, ImageHlpLib, 'SymSetOptions');
3394
JMP [_SymSetOptions]
3399
_SymGetOptions: Pointer;
3401
function SymGetOptions;
3403
GetProcedureAddress(_SymGetOptions, ImageHlpLib, 'SymGetOptions');
3407
JMP [_SymGetOptions]
3412
_SymCleanup: Pointer;
3414
function SymCleanup;
3416
GetProcedureAddress(_SymCleanup, ImageHlpLib, 'SymCleanup');
3425
_SymMatchString: Pointer;
3427
function SymMatchString;
3429
GetProcedureAddress(_SymMatchString, ImageHlpLib, 'SymMatchString');
3433
JMP [_SymMatchString]
3438
_SymEnumSourceFiles: Pointer;
3440
function SymEnumSourceFiles;
3442
GetProcedureAddress(_SymEnumSourceFiles, ImageHlpLib, 'SymEnumSourceFiles');
3446
JMP [_SymEnumSourceFiles]
3451
_SymEnumerateModules64: Pointer;
3453
function SymEnumerateModules64;
3455
GetProcedureAddress(_SymEnumerateModules64, ImageHlpLib, 'SymEnumerateModules64');
3459
JMP [_SymEnumerateModules64]
3464
_SymEnumerateModules: Pointer;
3466
function SymEnumerateModules;
3468
GetProcedureAddress(_SymEnumerateModules, ImageHlpLib, 'SymEnumerateModules');
3472
JMP [_SymEnumerateModules]
3477
_SymEnumerateSymbols64: Pointer;
3479
function SymEnumerateSymbols64;
3481
GetProcedureAddress(_SymEnumerateSymbols64, ImageHlpLib, 'SymEnumerateSymbols64');
3485
JMP [_SymEnumerateSymbols64]
3490
_SymEnumerateSymbolsW64: Pointer;
3492
function SymEnumerateSymbolsW64;
3494
GetProcedureAddress(_SymEnumerateSymbolsW64, ImageHlpLib, 'SymEnumerateSymbolsW64');
3498
JMP [_SymEnumerateSymbolsW64]
3503
_SymEnumerateSymbols: Pointer;
3505
function SymEnumerateSymbols;
3507
GetProcedureAddress(_SymEnumerateSymbols, ImageHlpLib, 'SymEnumerateSymbols');
3511
JMP [_SymEnumerateSymbols]
3516
_SymEnumerateSymbolsW: Pointer;
3518
function SymEnumerateSymbolsW;
3520
GetProcedureAddress(_SymEnumerateSymbolsW, ImageHlpLib, 'SymEnumerateSymbolsW');
3524
JMP [_SymEnumerateSymbolsW]
3529
_EnumerateLoadedModules64: Pointer;
3531
function EnumerateLoadedModules64;
3533
GetProcedureAddress(_EnumerateLoadedModules64, ImageHlpLib, 'EnumerateLoadedModules64');
3537
JMP [_EnumerateLoadedModules64]
3542
_EnumerateLoadedModules: Pointer;
3544
function EnumerateLoadedModules;
3546
GetProcedureAddress(_EnumerateLoadedModules, ImageHlpLib, 'EnumerateLoadedModules');
3550
JMP [_EnumerateLoadedModules]
3555
_SymFunctionTableAccess64: Pointer;
3557
function SymFunctionTableAccess64;
3559
GetProcedureAddress(_SymFunctionTableAccess64, ImageHlpLib, 'SymFunctionTableAccess64');
3563
JMP [_SymFunctionTableAccess64]
3568
_SymFunctionTableAccess: Pointer;
3570
function SymFunctionTableAccess;
3572
GetProcedureAddress(_SymFunctionTableAccess, ImageHlpLib, 'SymFunctionTableAccess');
3576
JMP [_SymFunctionTableAccess]
3581
_SymGetModuleInfo64: Pointer;
3583
function SymGetModuleInfo64;
3585
GetProcedureAddress(_SymGetModuleInfo64, ImageHlpLib, 'SymGetModuleInfo64');
3589
JMP [_SymGetModuleInfo64]
3594
_SymGetModuleInfoW64: Pointer;
3596
function SymGetModuleInfoW64;
3598
GetProcedureAddress(_SymGetModuleInfoW64, ImageHlpLib, 'SymGetModuleInfoW64');
3602
JMP [_SymGetModuleInfoW64]
3607
_SymGetModuleInfo: Pointer;
3609
function SymGetModuleInfo;
3611
GetProcedureAddress(_SymGetModuleInfo, ImageHlpLib, 'SymGetModuleInfo');
3615
JMP [_SymGetModuleInfo]
3620
_SymGetModuleInfoW: Pointer;
3622
function SymGetModuleInfoW;
3624
GetProcedureAddress(_SymGetModuleInfoW, ImageHlpLib, 'SymGetModuleInfoW');
3628
JMP [_SymGetModuleInfoW]
3633
_SymGetModuleBase64: Pointer;
3635
function SymGetModuleBase64;
3637
GetProcedureAddress(_SymGetModuleBase64, ImageHlpLib, 'SymGetModuleBase64');
3641
JMP [_SymGetModuleBase64]
3646
_SymGetModuleBase: Pointer;
3648
function SymGetModuleBase;
3650
GetProcedureAddress(_SymGetModuleBase, ImageHlpLib, 'SymGetModuleBase');
3654
JMP [_SymGetModuleBase]
3659
_SymGetSymNext64: Pointer;
3661
function SymGetSymNext64;
3663
GetProcedureAddress(_SymGetSymNext64, ImageHlpLib, 'SymGetSymNext64');
3667
JMP [_SymGetSymNext64]
3672
_SymGetSymNext: Pointer;
3674
function SymGetSymNext;
3676
GetProcedureAddress(_SymGetSymNext, ImageHlpLib, 'SymGetSymNext');
3680
JMP [_SymGetSymNext]
3685
_SymGetSymPrev64: Pointer;
3687
function SymGetSymPrev64;
3689
GetProcedureAddress(_SymGetSymPrev64, ImageHlpLib, 'SymGetSymPrev64');
3693
JMP [_SymGetSymPrev64]
3698
_SymGetSymPrev: Pointer;
3700
function SymGetSymPrev;
3702
GetProcedureAddress(_SymGetSymPrev, ImageHlpLib, 'SymGetSymPrev');
3706
JMP [_SymGetSymPrev]
3711
_SymGetLineFromAddr64: Pointer;
3713
function SymGetLineFromAddr64;
3715
GetProcedureAddress(_SymGetLineFromAddr64, ImageHlpLib, 'SymGetLineFromAddr64');
3719
JMP [_SymGetLineFromAddr64]
3724
_SymGetLineFromAddr: Pointer;
3726
function SymGetLineFromAddr;
3728
GetProcedureAddress(_SymGetLineFromAddr, ImageHlpLib, 'SymGetLineFromAddr');
3732
JMP [_SymGetLineFromAddr]
3737
_SymGetLineFromName64: Pointer;
3739
function SymGetLineFromName64;
3741
GetProcedureAddress(_SymGetLineFromName64, ImageHlpLib, 'SymGetLineFromName64');
3745
JMP [_SymGetLineFromName64]
3750
_SymGetLineFromName: Pointer;
3752
function SymGetLineFromName;
3754
GetProcedureAddress(_SymGetLineFromName, ImageHlpLib, 'SymGetLineFromName');
3758
JMP [_SymGetLineFromName]
3763
_SymGetLineNext64: Pointer;
3765
function SymGetLineNext64;
3767
GetProcedureAddress(_SymGetLineNext64, ImageHlpLib, 'SymGetLineNext64');
3771
JMP [_SymGetLineNext64]
3776
_SymGetLineNext: Pointer;
3778
function SymGetLineNext;
3780
GetProcedureAddress(_SymGetLineNext, ImageHlpLib, 'SymGetLineNext');
3784
JMP [_SymGetLineNext]
3789
_SymGetLinePrev64: Pointer;
3791
function SymGetLinePrev64;
3793
GetProcedureAddress(_SymGetLinePrev64, ImageHlpLib, 'SymGetLinePrev64');
3797
JMP [_SymGetLinePrev64]
3802
_SymGetLinePrev: Pointer;
3804
function SymGetLinePrev;
3806
GetProcedureAddress(_SymGetLinePrev, ImageHlpLib, 'SymGetLinePrev');
3810
JMP [_SymGetLinePrev]
3815
_SymMatchFileName: Pointer;
3817
function SymMatchFileName;
3819
GetProcedureAddress(_SymMatchFileName, ImageHlpLib, 'SymMatchFileName');
3823
JMP [_SymMatchFileName]
3828
_SymInitialize: Pointer;
3830
function SymInitialize;
3832
GetProcedureAddress(_SymInitialize, ImageHlpLib, 'SymInitialize');
3836
JMP [_SymInitialize]
3841
_SymGetSearchPath: Pointer;
3843
function SymGetSearchPath;
3845
GetProcedureAddress(_SymGetSearchPath, ImageHlpLib, 'SymGetSearchPath');
3849
JMP [_SymGetSearchPath]
3854
_SymSetSearchPath: Pointer;
3856
function SymSetSearchPath;
3858
GetProcedureAddress(_SymSetSearchPath, ImageHlpLib, 'SymSetSearchPath');
3862
JMP [_SymSetSearchPath]
3867
_SymLoadModuleEx: Pointer;
3869
function SymLoadModuleEx;
3871
GetProcedureAddress(_SymLoadModuleEx, ImageHlpLib, 'SymLoadModuleEx');
3875
JMP [_SymLoadModuleEx]
3880
_SymLoadModule64: Pointer;
3882
function SymLoadModule64;
3884
GetProcedureAddress(_SymLoadModule64, ImageHlpLib, 'SymLoadModule64');
3888
JMP [_SymLoadModule64]
3893
_SymLoadModule: Pointer;
3895
function SymLoadModule;
3897
GetProcedureAddress(_SymLoadModule, ImageHlpLib, 'SymLoadModule');
3901
JMP [_SymLoadModule]
3906
_SymUnloadModule64: Pointer;
3908
function SymUnloadModule64;
3910
GetProcedureAddress(_SymUnloadModule64, ImageHlpLib, 'SymUnloadModule64');
3914
JMP [_SymUnloadModule64]
3919
_SymUnloadModule: Pointer;
3921
function SymUnloadModule;
3923
GetProcedureAddress(_SymUnloadModule, ImageHlpLib, 'SymUnloadModule');
3927
JMP [_SymUnloadModule]
3932
_SymUnDName64: Pointer;
3934
function SymUnDName64;
3936
GetProcedureAddress(_SymUnDName64, ImageHlpLib, 'SymUnDName64');
3945
_SymUnDName: Pointer;
3947
function SymUnDName;
3949
GetProcedureAddress(_SymUnDName, ImageHlpLib, 'SymUnDName');
3958
_SymRegisterCallback64: Pointer;
3960
function SymRegisterCallback64;
3962
GetProcedureAddress(_SymRegisterCallback64, ImageHlpLib, 'SymRegisterCallback64');
3966
JMP [_SymRegisterCallback64]
3971
_SymRegFuncEntryCallback64: Pointer;
3973
function SymRegisterFunctionEntryCallback64;
3975
GetProcedureAddress(_SymRegFuncEntryCallback64, ImageHlpLib, 'SymRegisterFunctionEntryCallback64');
3979
JMP [_SymRegFuncEntryCallback64]
3984
_SymRegisterCallback: Pointer;
3986
function SymRegisterCallback;
3988
GetProcedureAddress(_SymRegisterCallback, ImageHlpLib, 'SymRegisterCallback');
3992
JMP [_SymRegisterCallback]
3997
_SymRegisterFuncEntryCallback: Pointer;
3999
function SymRegisterFunctionEntryCallback;
4001
GetProcedureAddress(_SymRegisterFuncEntryCallback, ImageHlpLib, 'SymRegisterFunctionEntryCallback');
4005
JMP [_SymRegisterFuncEntryCallback]
4010
_SymSetContext: Pointer;
4012
function SymSetContext;
4014
GetProcedureAddress(_SymSetContext, ImageHlpLib, 'SymSetContext');
4018
JMP [_SymSetContext]
4023
_SymFromAddr: Pointer;
4025
function SymFromAddr;
4027
GetProcedureAddress(_SymFromAddr, ImageHlpLib, 'SymFromAddr');
4036
_SymFromName: Pointer;
4038
function SymFromName;
4040
GetProcedureAddress(_SymFromName, ImageHlpLib, 'SymFromName');
4049
_SymEnumSymbolsForAddr: Pointer;
4051
function SymEnumSymbolsForAddr;
4053
GetProcedureAddress(_SymEnumSymbolsForAddr, ImageHlpLib, 'SymEnumSymbolsForAddr');
4057
JMP [_SymEnumSymbolsForAddr]
4062
_SymEnumSymbols: Pointer;
4064
function SymEnumSymbols;
4066
GetProcedureAddress(_SymEnumSymbols, ImageHlpLib, 'SymEnumSymbols');
4070
JMP [_SymEnumSymbols]
4075
_SymGetTypeInfo: Pointer;
4077
function SymGetTypeInfo;
4079
GetProcedureAddress(_SymGetTypeInfo, ImageHlpLib, 'SymGetTypeInfo');
4083
JMP [_SymGetTypeInfo]
4088
_SymEnumTypes: Pointer;
4090
function SymEnumTypes;
4092
GetProcedureAddress(_SymEnumTypes, ImageHlpLib, 'SymEnumTypes');
4101
_SymGetTypeFromName: Pointer;
4103
function SymGetTypeFromName;
4105
GetProcedureAddress(_SymGetTypeFromName, ImageHlpLib, 'SymGetTypeFromName');
4109
JMP [_SymGetTypeFromName]
4114
_SymAddSymbol: Pointer;
4116
function SymAddSymbol;
4118
GetProcedureAddress(_SymAddSymbol, ImageHlpLib, 'SymAddSymbol');
4127
_SymDeleteSymbol: Pointer;
4129
function SymDeleteSymbol;
4131
GetProcedureAddress(_SymDeleteSymbol, ImageHlpLib, 'SymDeleteSymbol');
4135
JMP [_SymDeleteSymbol]
4140
_DbgHelpCreateUserDump: Pointer;
4142
function DbgHelpCreateUserDump;
4144
GetProcedureAddress(_DbgHelpCreateUserDump, ImageHlpLib, 'DbgHelpCreateUserDump');
4148
JMP [_DbgHelpCreateUserDump]
4153
_DbgHelpCreateUserDumpW: Pointer;
4155
function DbgHelpCreateUserDumpW;
4157
GetProcedureAddress(_DbgHelpCreateUserDumpW, ImageHlpLib, 'DbgHelpCreateUserDumpW');
4161
JMP [_DbgHelpCreateUserDumpW]
4166
_SymGetSymFromAddr64: Pointer;
4168
function SymGetSymFromAddr64;
4170
GetProcedureAddress(_SymGetSymFromAddr64, ImageHlpLib, 'SymGetSymFromAddr64');
4174
JMP [_SymGetSymFromAddr64]
4179
_SymGetSymFromAddr: Pointer;
4181
function SymGetSymFromAddr;
4183
GetProcedureAddress(_SymGetSymFromAddr, ImageHlpLib, 'SymGetSymFromAddr');
4187
JMP [_SymGetSymFromAddr]
4192
_SymGetSymFromName64: Pointer;
4194
function SymGetSymFromName64;
4196
GetProcedureAddress(_SymGetSymFromName64, ImageHlpLib, 'SymGetSymFromName64');
4200
JMP [_SymGetSymFromName64]
4205
_SymGetSymFromName: Pointer;
4207
function SymGetSymFromName;
4209
GetProcedureAddress(_SymGetSymFromName, ImageHlpLib, 'SymGetSymFromName');
4213
JMP [_SymGetSymFromName]
4218
_FindFileInPath: Pointer;
4220
function FindFileInPath;
4222
GetProcedureAddress(_FindFileInPath, ImageHlpLib, 'FindFileInPath');
4226
JMP [_FindFileInPath]
4231
_FindFileInSearchPath: Pointer;
4233
function FindFileInSearchPath;
4235
GetProcedureAddress(_FindFileInSearchPath, ImageHlpLib, 'FindFileInSearchPath');
4239
JMP [_FindFileInSearchPath]
4244
_SymEnumSym: Pointer;
4246
function SymEnumSym;
4248
GetProcedureAddress(_SymEnumSym, ImageHlpLib, 'SymEnumSym');
4257
_MiniDumpWriteDump: Pointer;
4259
function MiniDumpWriteDump;
4261
GetProcedureAddress(_MiniDumpWriteDump, ImageHlpLib, 'MiniDumpWriteDump');
4265
JMP [_MiniDumpWriteDump]
4270
_MiniDumpReadDumpStream: Pointer;
4272
function MiniDumpReadDumpStream;
4274
GetProcedureAddress(_MiniDumpReadDumpStream, ImageHlpLib, 'MiniDumpReadDumpStream');
4278
JMP [_MiniDumpReadDumpStream]
4284
function BindImage; external ImageHlpLib name 'BindImage';
4285
function BindImageEx; external ImageHlpLib name 'BindImageEx';
4286
function ReBaseImage; external ImageHlpLib name 'ReBaseImage';
4287
function ReBaseImage64; external ImageHlpLib name 'ReBaseImage64';
4288
function CheckSumMappedFile; external ImageHlpLib name 'CheckSumMappedFile';
4289
function MapFileAndCheckSumA; external ImageHlpLib name 'MapFileAndCheckSumA';
4290
function MapFileAndCheckSumW; external ImageHlpLib name 'MapFileAndCheckSumW';
4291
function MapFileAndCheckSum; external ImageHlpLib name 'MapFileAndCheckSum' + AWSuffix;
4292
function GetImageConfigInformation; external ImageHlpLib name 'GetImageConfigInformation';
4293
function GetImageUnusedHeaderBytes; external ImageHlpLib name 'GetImageUnusedHeaderBytes';
4294
function SetImageConfigInformation; external ImageHlpLib name 'SetImageConfigInformation';
4295
function ImageGetDigestStream; external ImageHlpLib name 'ImageGetDigestStream';
4296
function ImageAddCertificate; external ImageHlpLib name 'ImageAddCertificate';
4297
function ImageRemoveCertificate; external ImageHlpLib name 'ImageRemoveCertificate';
4298
function ImageEnumerateCertificates; external ImageHlpLib name 'ImageEnumerateCertificates';
4299
function ImageGetCertificateData; external ImageHlpLib name 'ImageGetCertificateData';
4300
function ImageGetCertificateHeader; external ImageHlpLib name 'ImageGetCertificateHeader';
4301
function ImageLoad; external ImageHlpLib name 'ImageLoad';
4302
function ImageUnload; external ImageHlpLib name 'ImageUnload';
4303
function MapAndLoad; external ImageHlpLib name 'MapAndLoad';
4304
function UnMapAndLoad; external ImageHlpLib name 'UnMapAndLoad';
4305
function TouchFileTimes; external ImageHlpLib name 'TouchFileTimes';
4306
function SplitSymbols; external ImageHlpLib name 'SplitSymbols';
4307
function UpdateDebugInfoFile; external ImageHlpLib name 'UpdateDebugInfoFile';
4308
function UpdateDebugInfoFileEx; external ImageHlpLib name 'UpdateDebugInfoFileEx';
4309
function FindDebugInfoFile; external ImageHlpLib name 'FindDebugInfoFile';
4310
function FindDebugInfoFileEx; external ImageHlpLib name 'FindDebugInfoFileEx';
4311
function SymFindFileInPath; external ImageHlpLib name 'SymFindFileInPath';
4312
function FindExecutableImage; external ImageHlpLib name 'FindExecutableImage';
4313
function FindExecutableImageEx; external ImageHlpLib name 'FindExecutableImageEx';
4314
function ImageNtHeader; external ImageHlpLib name 'ImageNtHeader';
4315
function ImageDirectoryEntryToDataEx; external ImageHlpLib name 'ImageDirectoryEntryToDataEx';
4316
function ImageDirectoryEntryToData; external ImageHlpLib name 'ImageDirectoryEntryToData';
4317
function ImageRvaToSection; external ImageHlpLib name 'ImageRvaToSection';
4318
function ImageRvaToVa; external ImageHlpLib name 'ImageRvaToVa';
4319
function MapDebugInformation; external ImageHlpLib name 'MapDebugInformation';
4320
function UnmapDebugInformation; external ImageHlpLib name 'UnmapDebugInformation';
4321
function SearchTreeForFile; external ImageHlpLib name 'SearchTreeForFile';
4322
function EnumDirTree; external ImageHlpLib name 'EnumDirTree';
4323
function MakeSureDirectoryPathExists; external ImageHlpLib name 'MakeSureDirectoryPathExists';
4324
function UnDecorateSymbolName; external ImageHlpLib name 'UnDecorateSymbolName';
4325
function StackWalk64; external ImageHlpLib name 'StackWalk64';
4326
function StackWalk; external ImageHlpLib name 'StackWalk';
4327
function ImagehlpApiVersion; external ImageHlpLib name 'ImagehlpApiVersion';
4328
function ImagehlpApiVersionEx; external ImageHlpLib name 'ImagehlpApiVersionEx';
4329
function GetTimestampForLoadedLibrary; external ImageHlpLib name 'GetTimestampForLoadedLibrary';
4330
function SymSetOptions; external ImageHlpLib name 'SymSetOptions';
4331
function SymGetOptions; external ImageHlpLib name 'SymGetOptions';
4332
function SymCleanup; external ImageHlpLib name 'SymCleanup';
4333
function SymMatchString; external ImageHlpLib name 'SymMatchString';
4334
function SymEnumSourceFiles; external ImageHlpLib name 'SymEnumSourceFiles';
4335
function SymEnumerateModules64; external ImageHlpLib name 'SymEnumerateModules64';
4336
function SymEnumerateModules; external ImageHlpLib name 'SymEnumerateModules';
4337
function SymEnumerateSymbols64; external ImageHlpLib name 'SymEnumerateSymbols64';
4338
function SymEnumerateSymbolsW64; external ImageHlpLib name 'SymEnumerateSymbolsW64';
4339
function SymEnumerateSymbols; external ImageHlpLib name 'SymEnumerateSymbols';
4340
function SymEnumerateSymbolsW; external ImageHlpLib name 'SymEnumerateSymbolsW';
4341
function EnumerateLoadedModules64; external ImageHlpLib name 'EnumerateLoadedModules64';
4342
function EnumerateLoadedModules; external ImageHlpLib name 'EnumerateLoadedModules';
4343
function SymFunctionTableAccess64; external ImageHlpLib name 'SymFunctionTableAccess64';
4344
function SymFunctionTableAccess; external ImageHlpLib name 'SymFunctionTableAccess';
4345
function SymGetModuleInfo64; external ImageHlpLib name 'SymGetModuleInfo64';
4346
function SymGetModuleInfoW64; external ImageHlpLib name 'SymGetModuleInfoW64';
4347
function SymGetModuleInfo; external ImageHlpLib name 'SymGetModuleInfo';
4348
function SymGetModuleInfoW; external ImageHlpLib name 'SymGetModuleInfoW';
4349
function SymGetModuleBase64; external ImageHlpLib name 'SymGetModuleBase64';
4350
function SymGetModuleBase; external ImageHlpLib name 'SymGetModuleBase';
4351
function SymGetSymNext64; external ImageHlpLib name 'SymGetSymNext64';
4352
function SymGetSymNext; external ImageHlpLib name 'SymGetSymNext';
4353
function SymGetSymPrev64; external ImageHlpLib name 'SymGetSymPrev64';
4354
function SymGetSymPrev; external ImageHlpLib name 'SymGetSymPrev';
4355
function SymGetLineFromAddr64; external ImageHlpLib name 'SymGetLineFromAddr64';
4356
function SymGetLineFromAddr; external ImageHlpLib name 'SymGetLineFromAddr';
4357
function SymGetLineFromName64; external ImageHlpLib name 'SymGetLineFromName64';
4358
function SymGetLineFromName; external ImageHlpLib name 'SymGetLineFromName';
4359
function SymGetLineNext64; external ImageHlpLib name 'SymGetLineNext64';
4360
function SymGetLineNext; external ImageHlpLib name 'SymGetLineNext';
4361
function SymGetLinePrev64; external ImageHlpLib name 'SymGetLinePrev64';
4362
function SymGetLinePrev; external ImageHlpLib name 'SymGetLinePrev';
4363
function SymMatchFileName; external ImageHlpLib name 'SymMatchFileName';
4364
function SymInitialize; external ImageHlpLib name 'SymInitialize';
4365
function SymGetSearchPath; external ImageHlpLib name 'SymGetSearchPath';
4366
function SymSetSearchPath; external ImageHlpLib name 'SymSetSearchPath';
4367
function SymLoadModuleEx; external ImageHlpLib name 'SymLoadModuleEx';
4368
function SymLoadModule64; external ImageHlpLib name 'SymLoadModule64';
4369
function SymLoadModule; external ImageHlpLib name 'SymLoadModule';
4370
function SymUnloadModule64; external ImageHlpLib name 'SymUnloadModule64';
4371
function SymUnloadModule; external ImageHlpLib name 'SymUnloadModule';
4372
function SymUnDName64; external ImageHlpLib name 'SymUnDName64';
4373
function SymUnDName; external ImageHlpLib name 'SymUnDName';
4374
function SymRegisterCallback64; external ImageHlpLib name 'SymRegisterCallback64';
4375
function SymRegisterFunctionEntryCallback64; external ImageHlpLib name 'SymRegisterFunctionEntryCallback64';
4376
function SymRegisterCallback; external ImageHlpLib name 'SymRegisterCallback';
4377
function SymRegisterFunctionEntryCallback; external ImageHlpLib name 'SymRegisterFunctionEntryCallback';
4378
function SymSetContext; external ImageHlpLib name 'SymSetContext';
4379
function SymFromAddr; external ImageHlpLib name 'SymFromAddr';
4380
function SymFromName; external ImageHlpLib name 'SymFromName';
4381
function SymEnumSymbolsForAddr; external ImageHlpLib name 'SymEnumSymbolsForAddr';
4382
function SymEnumSymbols; external ImageHlpLib name 'SymEnumSymbols';
4383
function SymGetTypeInfo; external ImageHlpLib name 'SymGetTypeInfo';
4384
function SymEnumTypes; external ImageHlpLib name 'SymEnumTypes';
4385
function SymGetTypeFromName; external ImageHlpLib name 'SymGetTypeFromName';
4386
function SymAddSymbol; external ImageHlpLib name 'SymAddSymbol';
4387
function SymDeleteSymbol; external ImageHlpLib name 'SymDeleteSymbol';
4388
function DbgHelpCreateUserDump; external ImageHlpLib name 'DbgHelpCreateUserDump';
4389
function DbgHelpCreateUserDumpW; external ImageHlpLib name 'DbgHelpCreateUserDumpW';
4390
function SymGetSymFromAddr64; external ImageHlpLib name 'SymGetSymFromAddr64';
4391
function SymGetSymFromAddr; external ImageHlpLib name 'SymGetSymFromAddr';
4392
function SymGetSymFromName64; external ImageHlpLib name 'SymGetSymFromName64';
4393
function SymGetSymFromName; external ImageHlpLib name 'SymGetSymFromName';
4394
function FindFileInPath; external ImageHlpLib name 'FindFileInPath';
4395
function FindFileInSearchPath; external ImageHlpLib name 'FindFileInSearchPath';
4396
function SymEnumSym; external ImageHlpLib name 'SymEnumSym';
4397
function MiniDumpWriteDump; external ImageHlpLib name 'MiniDumpWriteDump';
4398
function MiniDumpReadDumpStream; external ImageHlpLib name 'MiniDumpReadDumpStream';
4400
{$ENDIF DYNAMIC_LINK}
1
{******************************************************************************}
3
{ Image Help API interface Unit for Object Pascal }
5
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
6
{ Corporation. All Rights Reserved. }
8
{ The original file is: imagehlp.h, released August 2001. The original Pascal }
9
{ code is: ImageHelp.pas, released December 2000. The initial developer of the }
10
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
12
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
13
{ Marcel van Brakel. All Rights Reserved. }
15
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
17
{ You may retrieve the latest version of this file at the Project JEDI }
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
20
{ The contents of this file are used with permission, subject to the Mozilla }
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
22
{ in compliance with the License. You may obtain a copy of the License at }
23
{ http://www.mozilla.org/MPL/MPL-1.1.html }
25
{ Software distributed under the License is distributed on an "AS IS" basis, }
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27
{ the specific language governing rights and limitations under the License. }
29
{ Alternatively, the contents of this file may be used under the terms of the }
30
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
31
{ provisions of the LGPL License are applicable instead of those above. }
32
{ If you wish to allow use of your version of this file only under the terms }
33
{ of the LGPL License and not to allow others to use your version of this file }
34
{ under the MPL, indicate your decision by deleting the provisions above and }
35
{ replace them with the notice and other provisions required by the LGPL }
36
{ License. If you do not delete the provisions above, a recipient may use }
37
{ your version of this file under either the MPL or the LGPL License. }
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
41
{******************************************************************************}
49
{$HPPEMIT '#include "ImageHlp.h"'}
57
Windows, JwaWinBase, JwaWinNT, JwaWinType;
60
IMAGE_SEPARATION = 64*1024;
61
{$EXTERNALSYM IMAGE_SEPARATION}
64
PLOADED_IMAGE = ^LOADED_IMAGE;
65
{$EXTERNALSYM PLOADED_IMAGE}
66
_LOADED_IMAGE = record
69
MappedAddress: PUCHAR;
70
FileHeader: PIMAGE_NT_HEADERS32;
71
LastRvaSection: PIMAGE_SECTION_HEADER;
72
NumberOfSections: ULONG;
73
Sections: PIMAGE_SECTION_HEADER;
74
Characteristics: ULONG;
75
fSystemImage: ByteBool;
80
{$EXTERNALSYM _LOADED_IMAGE}
81
LOADED_IMAGE = _LOADED_IMAGE;
82
{$EXTERNALSYM LOADED_IMAGE}
83
TLoadedImage = LOADED_IMAGE;
84
PLoadedImage = PLOADED_IMAGE;
88
{$EXTERNALSYM MAX_SYM_NAME}
90
function BindImage(ImageName, DllPath, SymbolPath: PSTR): BOOL; stdcall;
91
{$EXTERNALSYM BindImage}
94
_IMAGEHLP_STATUS_REASON = (
98
BindImportModuleFailed,
99
BindImportProcedureFailed,
105
BindExpandFileHeaders,
107
BindMismatchedSymbols,
108
BindSymbolsNotUpdated,
109
BindImportProcedure32,
110
BindImportProcedure64,
115
{$EXTERNALSYM _IMAGEHLP_STATUS_REASON}
116
IMAGEHLP_STATUS_REASON = _IMAGEHLP_STATUS_REASON;
117
{$EXTERNALSYM IMAGEHLP_STATUS_REASON}
118
TImageHlpStatusReason = IMAGEHLP_STATUS_REASON;
120
PIMAGEHLP_STATUS_ROUTINE = function(Reason: IMAGEHLP_STATUS_REASON;
121
ImageName, DllName: PSTR; Va, Parameter: ULONG_PTR): BOOL; stdcall;
122
{$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE}
123
PImageHlpStatusRoutine = PIMAGEHLP_STATUS_ROUTINE;
125
PIMAGEHLP_STATUS_ROUTINE32 = function(Reason: IMAGEHLP_STATUS_REASON; ImageName, DllName: PSTR;
126
Va: ULONG; Parameter: ULONG_PTR): BOOL; stdcall;
127
{$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE32}
128
PImageHlpStatusRoutine23 = PIMAGEHLP_STATUS_ROUTINE32;
130
PIMAGEHLP_STATUS_ROUTINE64 = function(Reason: IMAGEHLP_STATUS_REASON; ImageName, DllName: PSTR;
131
Va: ULONG64; Parameter: ULONG_PTR): BOOL; stdcall;
132
{$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE64}
133
PImageHlpStatusRoutine64 = PIMAGEHLP_STATUS_ROUTINE64;
135
function BindImageEx(Flags: DWORD; ImageName, DllPath, SymbolPath: PSTR;
136
StatusRoutine: PIMAGEHLP_STATUS_ROUTINE): BOOL; stdcall;
137
{$EXTERNALSYM BindImageEx}
140
BIND_NO_BOUND_IMPORTS = $00000001;
141
{$EXTERNALSYM BIND_NO_BOUND_IMPORTS}
142
BIND_NO_UPDATE = $00000002;
143
{$EXTERNALSYM BIND_NO_UPDATE}
144
BIND_ALL_IMAGES = $00000004;
145
{$EXTERNALSYM BIND_ALL_IMAGES}
146
BIND_CACHE_IMPORT_DLLS = $00000008; // Cache dll's across calls to BindImageEx (same as NT 3.1->NT 4.0)
147
{$EXTERNALSYM BIND_CACHE_IMPORT_DLLS}
149
BIND_REPORT_64BIT_VA = $00000010;
150
{$EXTERNALSYM BIND_REPORT_64BIT_VA}
152
function ReBaseImage(CurrentImageName: PSTR; SymbolPath: PSTR; fReBase: BOOL;
153
fRebaseSysfileOk: BOOL; fGoingDown: BOOL; CheckImageSize: ULONG;
154
var OldImageSize: ULONG; var OldImageBase: ULONG_PTR; var NewImageSize: ULONG;
155
var NewImageBase: ULONG_PTR; TimeStamp: ULONG): BOOL; stdcall;
156
{$EXTERNALSYM ReBaseImage}
158
function ReBaseImage64(CurrentImageName: PSTR; SymbolPath: PSTR; fReBase: BOOL;
159
fRebaseSysfileOk: BOOL; fGoingDown: BOOL; CheckImageSize: ULONG;
160
var OldImageSize: ULONG; var OldImageBase: ULONG64; var NewImageSize: ULONG;
161
var NewImageBase: ULONG64; TimeStamp: ULONG): BOOL; stdcall;
162
{$EXTERNALSYM ReBaseImage64}
165
// Define checksum return codes.
169
CHECKSUM_SUCCESS = 0;
170
{$EXTERNALSYM CHECKSUM_SUCCESS}
171
CHECKSUM_OPEN_FAILURE = 1;
172
{$EXTERNALSYM CHECKSUM_OPEN_FAILURE}
173
CHECKSUM_MAP_FAILURE = 2;
174
{$EXTERNALSYM CHECKSUM_MAP_FAILURE}
175
CHECKSUM_MAPVIEW_FAILURE = 3;
176
{$EXTERNALSYM CHECKSUM_MAPVIEW_FAILURE}
177
CHECKSUM_UNICODE_FAILURE = 4;
178
{$EXTERNALSYM CHECKSUM_UNICODE_FAILURE}
180
// Define Splitsym flags.
182
SPLITSYM_REMOVE_PRIVATE = $00000001; // Remove CV types/symbols and Fixup debug
183
{$EXTERNALSYM SPLITSYM_REMOVE_PRIVATE}
184
// Used for creating .dbg files that ship
185
// as part of the product.
187
SPLITSYM_EXTRACT_ALL = $00000002; // Extract all debug info from image.
188
{$EXTERNALSYM SPLITSYM_EXTRACT_ALL}
189
// Normally, FPO is left in the image
190
// to allow stack traces through the code.
191
// Using this switch is similar to linking
192
// with -debug:none except the .dbg file
195
SPLITSYM_SYMBOLPATH_IS_SRC = $00000004; // The SymbolFilePath contains an alternate
196
{$EXTERNALSYM SPLITSYM_SYMBOLPATH_IS_SRC}
197
// path to locate the pdb.
200
// Define checksum function prototypes.
203
function CheckSumMappedFile(BaseAddress: PVOID; FileLength: DWORD;
204
var HeaderSum, CheckSum: DWORD): PIMAGE_NT_HEADERS; stdcall;
205
{$EXTERNALSYM CheckSumMappedFile}
207
function MapFileAndCheckSumA(Filename: PSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
208
{$EXTERNALSYM MapFileAndCheckSumA}
209
function MapFileAndCheckSumW(Filename: PWSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
210
{$EXTERNALSYM MapFileAndCheckSumW}
211
function MapFileAndCheckSum(Filename: PTSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
212
{$EXTERNALSYM MapFileAndCheckSum}
214
function GetImageConfigInformation(const LoadedImage: LOADED_IMAGE;
215
var ImageConfigInformation: IMAGE_LOAD_CONFIG_DIRECTORY): BOOL; stdcall;
216
{$EXTERNALSYM GetImageConfigInformation}
218
function GetImageUnusedHeaderBytes(const LoadedImage: LOADED_IMAGE;
219
var SizeUnusedHeaderBytes: DWORD): DWORD; stdcall;
220
{$EXTERNALSYM GetImageUnusedHeaderBytes}
222
function SetImageConfigInformation(const LoadedImage: LOADED_IMAGE;
223
const ImageConfigInformation: IMAGE_LOAD_CONFIG_DIRECTORY): BOOL; stdcall;
224
{$EXTERNALSYM SetImageConfigInformation}
226
// Image Integrity API's
229
CERT_PE_IMAGE_DIGEST_DEBUG_INFO = $01;
230
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_DEBUG_INFO}
231
CERT_PE_IMAGE_DIGEST_RESOURCES = $02;
232
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_RESOURCES}
233
CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO = $04;
234
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO}
235
CERT_PE_IMAGE_DIGEST_NON_PE_INFO = $08; // include data outside the PE image
236
{$EXTERNALSYM CERT_PE_IMAGE_DIGEST_NON_PE_INFO}
238
CERT_SECTION_TYPE_ANY = $FF; // Any Certificate type
239
{$EXTERNALSYM CERT_SECTION_TYPE_ANY}
242
DIGEST_HANDLE = PVOID;
243
{$EXTERNALSYM DIGEST_HANDLE}
244
TDigestHandle = DIGEST_HANDLE;
246
DIGEST_FUNCTION = function(refdata: DIGEST_HANDLE; pData: PBYTE; dwLength: DWORD): BOOL; stdcall;
247
{$EXTERNALSYM DIGEST_FUNCTION}
248
TDigestFunction = DIGEST_FUNCTION;
250
function ImageGetDigestStream(FileHandle: HANDLE; DigestLevel: DWORD;
251
DigestFunction: DIGEST_FUNCTION; DigestHandle: DIGEST_HANDLE): BOOL; stdcall;
252
{$EXTERNALSYM ImageGetDigestStream}
254
function ImageAddCertificate(FileHandle: HANDLE; Certificate: PWinCertificate;
255
var Index: DWORD): BOOL; stdcall;
256
{$EXTERNALSYM ImageAddCertificate}
258
function ImageRemoveCertificate(FileHandle: HANDLE; Index: DWORD): BOOL; stdcall;
259
{$EXTERNALSYM ImageRemoveCertificate}
261
function ImageEnumerateCertificates(FileHandle: HANDLE; TypeFilter: WORD;
262
var CertificateCount: DWORD; Indices: PDWORD; IndexCount: DWORD): BOOL; stdcall;
263
{$EXTERNALSYM ImageEnumerateCertificates}
265
function ImageGetCertificateData(FileHandle: HANDLE; CertificateIndex: DWORD;
266
Certificate: PWinCertificate; var RequiredLength: DWORD): BOOL; stdcall;
267
{$EXTERNALSYM ImageGetCertificateData}
269
function ImageGetCertificateHeader(FileHandle: HANDLE; CertificateIndex: DWORD;
270
Certificateheader: PWinCertificate): BOOL; stdcall;
271
{$EXTERNALSYM ImageGetCertificateHeader}
273
function ImageLoad(DllName: PSTR; DllPath: PSTR): PLOADED_IMAGE; stdcall;
274
{$EXTERNALSYM ImageLoad}
276
function ImageUnload(const LoadedImage: LOADED_IMAGE): BOOL; stdcall;
277
{$EXTERNALSYM ImageUnload}
279
function MapAndLoad(ImageName, DllPath: PSTR; var LoadedImage: LOADED_IMAGE;
280
DotDll: BOOL; ReadOnly: BOOL): BOOL; stdcall;
281
{$EXTERNALSYM MapAndLoad}
283
function UnMapAndLoad(const LoadedImage: LOADED_IMAGE): BOOL; stdcall;
284
{$EXTERNALSYM UnMapAndLoad}
286
function TouchFileTimes(FileHandle: HANDLE; pSystemTime: PSYSTEMTIME): BOOL; stdcall;
287
{$EXTERNALSYM TouchFileTimes}
289
function SplitSymbols(ImageName, SymbolsPath, SymbolFilePath: PSTR; Flags: DWORD): BOOL; stdcall;
290
{$EXTERNALSYM SplitSymbols}
292
function UpdateDebugInfoFile(ImageFileName, SymbolPath, DebugFilePath: PSTR;
293
const NtHeaders: IMAGE_NT_HEADERS32): BOOL; stdcall;
294
{$EXTERNALSYM UpdateDebugInfoFile}
296
function UpdateDebugInfoFileEx(ImageFileName, SymbolPath, DebugFilePath: PSTR;
297
const NtHeaders: IMAGE_NT_HEADERS32; OldChecksum: DWORD): BOOL; stdcall;
298
{$EXTERNALSYM UpdateDebugInfoFileEx}
300
function FindDebugInfoFile(FileName, SymbolPath, DebugFilePath: PSTR): HANDLE; stdcall;
301
{$EXTERNALSYM FindDebugInfoFile}
304
PFIND_DEBUG_FILE_CALLBACK = function(FileHandle: HANDLE; FileName: PSTR;
305
CallerData: PVOID): BOOL; stdcall;
306
{$EXTERNALSYM PFIND_DEBUG_FILE_CALLBACK}
307
PFindDebugFileCallback = PFIND_DEBUG_FILE_CALLBACK;
309
function FindDebugInfoFileEx(FileName, SymbolPath, DebugFilePath: PSTR;
310
Callback: PFIND_DEBUG_FILE_CALLBACK; CallerData: PVOID): HANDLE; stdcall;
311
{$EXTERNALSYM FindDebugInfoFileEx}
314
PFINDFILEINPATHCALLBACK = function(filename: PSTR; context: PVOID): BOOL; stdcall;
315
{$EXTERNALSYM PFINDFILEINPATHCALLBACK}
317
function SymFindFileInPath(hprocess: HANDLE; SearchPath, FileName: LPSTR; id: PVOID; two, three, flags: DWORD;
318
FoundFile: LPSTR; callback: PFINDFILEINPATHCALLBACK; context: PVOID): BOOL; stdcall;
319
{$EXTERNALSYM SymFindFileInPath}
321
function FindExecutableImage(FileName, SymbolPath, ImageFilePath: PSTR): HANDLE; stdcall;
322
{$EXTERNALSYM FindExecutableImage}
325
PFIND_EXE_FILE_CALLBACK = function(FileHandle: HANDLE; FileName: PSTR;
326
CallerData: PVOID): BOOL; stdcall;
327
{$EXTERNALSYM PFIND_EXE_FILE_CALLBACK}
328
PFindExeFileCallback = PFIND_EXE_FILE_CALLBACK;
330
function FindExecutableImageEx(FileName, SymbolPath, ImageFilePath: PSTR;
331
Callback: PFIND_EXE_FILE_CALLBACK; CallerData: PVOID): HANDLE; stdcall;
332
{$EXTERNALSYM FindExecutableImageEx}
334
function ImageNtHeader(Base: PVOID): PIMAGE_NT_HEADERS; stdcall;
335
{$EXTERNALSYM ImageNtHeader}
337
function ImageDirectoryEntryToDataEx(Base: PVOID; MappedAsImage: ByteBool;
338
DirectoryEntry: USHORT; var Size: ULONG; var FoundHeader: PIMAGE_SECTION_HEADER): PVOID; stdcall;
339
{$EXTERNALSYM ImageDirectoryEntryToDataEx}
341
function ImageDirectoryEntryToData(Base: PVOID; MappedAsImage: ByteBool;
342
DirectoryEntry: USHORT; var Size: ULONG): PVOID; stdcall;
343
{$EXTERNALSYM ImageDirectoryEntryToData}
345
function ImageRvaToSection(NtHeaders: PIMAGE_NT_HEADERS; Base: PVOID; Rva: ULONG): PIMAGE_SECTION_HEADER; stdcall;
346
{$EXTERNALSYM ImageRvaToSection}
348
function ImageRvaToVa(NtHeaders: PIMAGE_NT_HEADERS; Base: PVOID; Rva: ULONG;
349
var LastRvaSection: PIMAGE_SECTION_HEADER): PVOID; stdcall;
350
{$EXTERNALSYM ImageRvaToVa}
352
// Symbol server exports
355
PSYMBOLSERVERPROC = function(a1, a2: LPCSTR; a3: PVOID; a4, a5: DWORD; a6: LPSTR): BOOL; stdcall;
356
{$EXTERNALSYM PSYMBOLSERVERPROC}
357
PSYMBOLSERVEROPENPROC = function: BOOL; stdcall;
358
{$EXTERNALSYM PSYMBOLSERVEROPENPROC}
359
PSYMBOLSERVERCLOSEPROC = function: BOOL; stdcall;
360
{$EXTERNALSYM PSYMBOLSERVERCLOSEPROC}
361
PSYMBOLSERVERSETOPTIONSPROC = function(a1: UINT_PTR; a2: ULONG64): BOOL; stdcall;
362
{$EXTERNALSYM PSYMBOLSERVERSETOPTIONSPROC}
363
PSYMBOLSERVERCALLBACKPROC = function(action: UINT_PTR; data: ULONG64; context: ULONG64): BOOL; stdcall;
364
{$EXTERNALSYM PSYMBOLSERVERCALLBACKPROC}
365
PSYMBOLSERVERGETOPTIONSPROC = function: UINT_PTR; stdcall;
366
{$EXTERNALSYM PSYMBOLSERVERGETOPTIONSPROC}
367
PSYMBOLSERVERPINGPROC = function(a1: LPCSTR): BOOL; stdcall;
368
{$EXTERNALSYM PSYMBOLSERVERPINGPROC}
371
SSRVOPT_CALLBACK = $01;
372
{$EXTERNALSYM SSRVOPT_CALLBACK}
374
{$EXTERNALSYM SSRVOPT_DWORD}
375
SSRVOPT_DWORDPTR = $04;
376
{$EXTERNALSYM SSRVOPT_DWORDPTR}
377
SSRVOPT_GUIDPTR = $08;
378
{$EXTERNALSYM SSRVOPT_GUIDPTR}
379
SSRVOPT_OLDGUIDPTR = $10;
380
{$EXTERNALSYM SSRVOPT_OLDGUIDPTR}
381
SSRVOPT_UNATTENDED = $20;
382
{$EXTERNALSYM SSRVOPT_UNATTENDED}
383
SSRVOPT_RESET = ULONG_PTR(-1);
384
{$EXTERNALSYM SSRVOPT_RESET}
386
SSRVACTION_TRACE = 1;
387
{$EXTERNALSYM SSRVACTION_TRACE}
389
// This api won't be ported to Win64 - Fix your code.
392
PIMAGE_DEBUG_INFORMATION = ^IMAGE_DEBUG_INFORMATION;
393
{$EXTERNALSYM PIMAGE_DEBUG_INFORMATION}
394
_IMAGE_DEBUG_INFORMATION = record
397
ReservedMappedBase: PVOID;
398
ReservedMachine: USHORT;
399
ReservedCharacteristics: USHORT;
400
ReservedCheckSum: DWORD;
403
ReservedNumberOfSections: DWORD;
404
ReservedSections: PIMAGE_SECTION_HEADER;
405
ReservedExportedNamesSize: DWORD;
406
ReservedExportedNames: PSTR;
407
ReservedNumberOfFunctionTableEntries: DWORD;
408
ReservedFunctionTableEntries: PIMAGE_FUNCTION_ENTRY;
409
ReservedLowestFunctionStartingAddress: DWORD;
410
ReservedHighestFunctionEndingAddress: DWORD;
411
ReservedNumberOfFpoTableEntries: DWORD;
412
ReservedFpoTableEntries: PFPO_DATA;
413
SizeOfCoffSymbols: DWORD;
414
CoffSymbols: PIMAGE_COFF_SYMBOLS_HEADER;
415
ReservedSizeOfCodeViewSymbols: DWORD;
416
ReservedCodeViewSymbols: PVOID;
419
ReservedDebugFilePath: PSTR;
420
ReservedTimeDateStamp: DWORD;
421
ReservedRomImage: BOOL;
422
ReservedDebugDirectory: PIMAGE_DEBUG_DIRECTORY;
423
ReservedNumberOfDebugDirectories: DWORD;
424
ReservedOriginalFunctionTableBaseAddress: DWORD;
425
Reserved: array [0..1] of DWORD;
427
{$EXTERNALSYM _IMAGE_DEBUG_INFORMATION}
428
IMAGE_DEBUG_INFORMATION = _IMAGE_DEBUG_INFORMATION;
429
{$EXTERNALSYM IMAGE_DEBUG_INFORMATION}
430
TImageDebugInformation = IMAGE_DEBUG_INFORMATION;
431
PImageDebugInformation = PIMAGE_DEBUG_INFORMATION;
433
function MapDebugInformation(FileHandle: HANDLE; FileName, SymbolPath: PSTR;
434
ImageBase: DWORD): PIMAGE_DEBUG_INFORMATION; stdcall;
435
{$EXTERNALSYM MapDebugInformation}
437
function UnmapDebugInformation(DebugInfo: PIMAGE_DEBUG_INFORMATION): BOOL; stdcall;
438
{$EXTERNALSYM UnmapDebugInformation}
440
function SearchTreeForFile(RootPath, InputPathName, OutputPathBuffer: PSTR): BOOL; stdcall;
441
{$EXTERNALSYM SearchTreeForFile}
444
PENUMDIRTREE_CALLBACK = function(FilePath: LPCSTR; CallerData: PVOID): BOOL; stdcall;
445
{$EXTERNALSYM PENUMDIRTREE_CALLBACK}
446
PEnumDirTreeCallback = PENUMDIRTREE_CALLBACK;
448
function EnumDirTree(hProcess: HANDLE; RootPath, InputPathName, OutputPathBuffer: PSTR;
449
Callback: PENUMDIRTREE_CALLBACK; CallbackData: PVOID): BOOL; stdcall;
450
{$EXTERNALSYM EnumDirTree}
452
function MakeSureDirectoryPathExists(DirPath: PCSTR): BOOL; stdcall;
453
{$EXTERNALSYM MakeSureDirectoryPathExists}
456
// UnDecorateSymbolName Flags
460
UNDNAME_COMPLETE = $0000; // Enable full undecoration
461
{$EXTERNALSYM UNDNAME_COMPLETE}
462
UNDNAME_NO_LEADING_UNDERSCORES = $0001; // Remove leading underscores from MS extended keywords
463
{$EXTERNALSYM UNDNAME_NO_LEADING_UNDERSCORES}
464
UNDNAME_NO_MS_KEYWORDS = $0002; // Disable expansion of MS extended keywords
465
{$EXTERNALSYM UNDNAME_NO_MS_KEYWORDS}
466
UNDNAME_NO_FUNCTION_RETURNS = $0004; // Disable expansion of return type for primary declaration
467
{$EXTERNALSYM UNDNAME_NO_FUNCTION_RETURNS}
468
UNDNAME_NO_ALLOCATION_MODEL = $0008; // Disable expansion of the declaration model
469
{$EXTERNALSYM UNDNAME_NO_ALLOCATION_MODEL}
470
UNDNAME_NO_ALLOCATION_LANGUAGE = $0010; // Disable expansion of the declaration language specifier
471
{$EXTERNALSYM UNDNAME_NO_ALLOCATION_LANGUAGE}
472
UNDNAME_NO_MS_THISTYPE = $0020; // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
473
{$EXTERNALSYM UNDNAME_NO_MS_THISTYPE}
474
UNDNAME_NO_CV_THISTYPE = $0040; // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
475
{$EXTERNALSYM UNDNAME_NO_CV_THISTYPE}
476
UNDNAME_NO_THISTYPE = $0060; // Disable all modifiers on the 'this' type
477
{$EXTERNALSYM UNDNAME_NO_THISTYPE}
478
UNDNAME_NO_ACCESS_SPECIFIERS = $0080; // Disable expansion of access specifiers for members
479
{$EXTERNALSYM UNDNAME_NO_ACCESS_SPECIFIERS}
480
UNDNAME_NO_THROW_SIGNATURES = $0100; // Disable expansion of 'throw-signatures' for functions and pointers to functions
481
{$EXTERNALSYM UNDNAME_NO_THROW_SIGNATURES}
482
UNDNAME_NO_MEMBER_TYPE = $0200; // Disable expansion of 'static' or 'virtual'ness of members
483
{$EXTERNALSYM UNDNAME_NO_MEMBER_TYPE}
484
UNDNAME_NO_RETURN_UDT_MODEL = $0400; // Disable expansion of MS model for UDT returns
485
{$EXTERNALSYM UNDNAME_NO_RETURN_UDT_MODEL}
486
UNDNAME_32_BIT_DECODE = $0800; // Undecorate 32-bit decorated names
487
{$EXTERNALSYM UNDNAME_32_BIT_DECODE}
488
UNDNAME_NAME_ONLY = $1000; // Crack only the name for primary declaration;
489
{$EXTERNALSYM UNDNAME_NAME_ONLY}
490
// return just [scope::]name. Does expand template params
491
UNDNAME_NO_ARGUMENTS = $2000; // Don't undecorate arguments to function
492
{$EXTERNALSYM UNDNAME_NO_ARGUMENTS}
493
UNDNAME_NO_SPECIAL_SYMS = $4000; // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
494
{$EXTERNALSYM UNDNAME_NO_SPECIAL_SYMS}
496
function UnDecorateSymbolName(DecoratedName: PCSTR; UnDecoratedName: PSTR;
497
UndecoratedLength: DWORD; Flags: DWORD): DWORD; stdcall;
498
{$EXTERNALSYM UnDecorateSymbolName}
501
// these values are used for synthesized file types
502
// that can be passed in as image headers instead of
503
// the standard ones from ntimage.h
507
DBHHEADER_DEBUGDIRS = $1;
508
{$EXTERNALSYM DBHHEADER_DEBUGDIRS}
511
_MODLOAD_DATA = record
512
ssize: DWORD; // size of this struct
513
ssig: DWORD; // signature identifying the passed data
514
data: PVOID; // pointer to passed data
515
size: DWORD; // size of passed data
516
flags: DWORD; // options
518
{$EXTERNALSYM _MODLOAD_DATA}
519
MODLOAD_DATA = _MODLOAD_DATA;
520
{$EXTERNALSYM MODLOAD_DATA}
521
PMODLOAD_DATA = ^MODLOAD_DATA;
522
{$EXTERNALSYM PMODLOAD_DATA}
523
TModLoadData = MODLOAD_DATA;
524
PModLoadData = PMODLOAD_DATA;
536
{$EXTERNALSYM ADDRESS_MODE}
537
TAddressMode = ADDRESS_MODE;
539
LPADDRESS64 = ^ADDRESS64;
540
{$EXTERNALSYM PADDRESS64}
541
_tagADDRESS64 = record
546
{$EXTERNALSYM _tagADDRESS64}
547
ADDRESS64 = _tagADDRESS64;
548
{$EXTERNALSYM ADDRESS64}
549
TAddress64 = ADDRESS64;
550
PAddress64 = LPADDRESS64;
552
LPADDRESS = ^ADDRESS;
553
{$EXTERNALSYM PADDRESS}
559
{$EXTERNALSYM _tagADDRESS}
560
ADDRESS = _tagADDRESS;
561
{$EXTERNALSYM ADDRESS}
563
PAddress = LPADDRESS;
565
procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
566
{$EXTERNALSYM Address32To64}
568
procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
569
{$EXTERNALSYM Address64To32}
572
// This structure is included in the STACKFRAME structure,
573
// and is used to trace through usermode callbacks in a thread's
574
// kernel stack. The values must be copied by the kernel debugger
575
// from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
579
// New KDHELP structure for 64 bit system support.
580
// This structure is preferred in new code.
584
PKDHELP64 = ^KDHELP64;
585
{$EXTERNALSYM PKDHELP64}
588
// address of kernel thread object, as provided in the
589
// WAIT_STATE_CHANGE packet.
593
// offset in thread object to pointer to the current callback frame
596
ThCallbackStack: DWORD;
598
// offset in thread object to pointer to the current callback backing
599
// store frame in kernel stack.
601
ThCallbackBStore: DWORD;
603
// offsets to values in frame:
605
// address of next callback frame
607
// address of saved frame pointer (if applicable)
610
// Address of the kernel function that calls out to user mode
612
KiCallUserMode: DWORD64;
614
// Address of the user mode dispatcher function
616
KeUserCallbackDispatcher: DWORD64;
618
// Lowest kernel mode address
620
SystemRangeStart: DWORD64;
621
Reserved: array [0..7] of DWORD64;
623
{$EXTERNALSYM _KDHELP64}
624
KDHELP64 = _KDHELP64;
625
{$EXTERNALSYM KDHELP64}
626
TKdHelp64 = KDHELP64;
627
//PKdHelp64 = PKDHELP64;
630
{$EXTERNALSYM PKDHELP}
633
// address of kernel thread object, as provided in the
634
// WAIT_STATE_CHANGE packet.
638
// offset in thread object to pointer to the current callback frame
641
ThCallbackStack: DWORD;
643
// offsets to values in frame:
645
// address of next callback frame
647
// address of saved frame pointer (if applicable)
650
// Address of the kernel function that calls out to user mode
652
KiCallUserMode: DWORD;
654
// Address of the user mode dispatcher function
656
KeUserCallbackDispatcher: DWORD;
658
// Lowest kernel mode address
660
SystemRangeStart: DWORD;
662
// offset in thread object to pointer to the current callback backing
663
// store frame in kernel stack.
665
ThCallbackBStore: DWORD;
666
Reserved: array [0..7] of DWORD;
668
{$EXTERNALSYM _KDHELP}
670
{$EXTERNALSYM KDHELP}
674
procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
675
{$EXTERNALSYM KdHelp32To64}
678
LPSTACKFRAME64 = ^STACKFRAME64;
679
{$EXTERNALSYM LPSTACKFRAME64}
680
_tagSTACKFRAME64 = record
681
AddrPC: ADDRESS64; // program counter
682
AddrReturn: ADDRESS64; // return address
683
AddrFrame: ADDRESS64; // frame pointer
684
AddrStack: ADDRESS64; // stack pointer
685
AddrBStore: ADDRESS64; // backing store pointer
686
FuncTableEntry: PVOID; // pointer to pdata/fpo or NULL
687
Params: array [0..3] of DWORD64; // possible arguments to the function
688
Far: BOOL; // WOW far call
689
Virtual: BOOL; // is this a virtual frame?
690
Reserved: array [0..2] of DWORD64;
693
{$EXTERNALSYM _tagSTACKFRAME64}
694
STACKFRAME64 = _tagSTACKFRAME64;
695
{$EXTERNALSYM STACKFRAME64}
696
TStackFrame64 = STACKFRAME64;
697
PStackFrame64 = LPSTACKFRAME64;
699
LPSTACKFRAME = ^STACKFRAME;
700
{$EXTERNALSYM LPSTACKFRAME}
701
_tagSTACKFRAME = record
702
AddrPC: ADDRESS; // program counter
703
AddrReturn: ADDRESS; // return address
704
AddrFrame: ADDRESS; // frame pointer
705
AddrStack: ADDRESS; // stack pointer
706
FuncTableEntry: PVOID; // pointer to pdata/fpo or NULL
707
Params: array [0..3] of DWORD; // possible arguments to the function
708
Far: BOOL; // WOW far call
709
Virtual: BOOL; // is this a virtual frame?
710
Reserved: array [0..2] of DWORD;
712
AddrBStore: ADDRESS; // backing store pointer
714
{$EXTERNALSYM _tagSTACKFRAME}
715
STACKFRAME = _tagSTACKFRAME;
716
{$EXTERNALSYM STACKFRAME}
717
TStackFrame = STACKFRAME;
718
PStackFrame = LPSTACKFRAME;
720
PREAD_PROCESS_MEMORY_ROUTINE64 = function(hProcess: HANDLE; qwBaseAddress: DWORD64;
721
lpBuffer: PVOID; nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
722
{$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE64}
723
PReadProcessMemoryRoutine64 = PREAD_PROCESS_MEMORY_ROUTINE64;
725
PFUNCTION_TABLE_ACCESS_ROUTINE64 = function(hProcess: HANDLE;
726
AddrBase: DWORD64): PVOID; stdcall;
727
{$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE64}
728
PFunctionTableAccessRoutine64 = PFUNCTION_TABLE_ACCESS_ROUTINE64;
730
PGET_MODULE_BASE_ROUTINE64 = function(hProcess: HANDLE;
731
Address: DWORD64): DWORD64; stdcall;
732
{$EXTERNALSYM PGET_MODULE_BASE_ROUTINE64}
733
PGetModuleBaseRoutine64 = PGET_MODULE_BASE_ROUTINE64;
735
PTRANSLATE_ADDRESS_ROUTINE64 = function(hProcess: HANDLE; hThread: HANDLE;
736
const lpaddr: ADDRESS64): DWORD64; stdcall;
737
{$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE64}
738
PTranslateAddressRoutine64 = PTRANSLATE_ADDRESS_ROUTINE64;
740
function StackWalk64(MachineType: DWORD; hProcess: HANDLE; hThread: HANDLE;
741
var StackFrame: STACKFRAME64; ContextRecord: PVOID;
742
ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64;
743
FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64;
744
GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64;
745
TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64): BOOL; stdcall;
746
{$EXTERNALSYM StackWalk64}
749
PREAD_PROCESS_MEMORY_ROUTINE = function(hProcess: HANDLE;
750
lpBaseAddress: DWORD; lpBuffer: PVOID; nSize: DWORD;
751
var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
752
{$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE}
753
PreadProcessMemoryRoutine = PREAD_PROCESS_MEMORY_ROUTINE;
755
PFUNCTION_TABLE_ACCESS_ROUTINE = function(hProcess: HANDLE; AddrBase: DWORD): PVOID; stdcall;
756
{$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE}
757
PFunctionTableAccessRoutine = PFUNCTION_TABLE_ACCESS_ROUTINE;
759
PGET_MODULE_BASE_ROUTINE = function(hProcess: HANDLE; Address: DWORD): DWORD; stdcall;
760
{$EXTERNALSYM PGET_MODULE_BASE_ROUTINE}
761
PGetModuleBaseRoutine = PGET_MODULE_BASE_ROUTINE;
763
PTRANSLATE_ADDRESS_ROUTINE = function(hProcess: HANDLE; hThread: HANDLE;
764
const lpaddr: ADDRESS): DWORD; stdcall;
765
{$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE}
766
PTranslateAddressRoutine = PTRANSLATE_ADDRESS_ROUTINE;
768
function StackWalk(MachineType: DWORD; hProcess: HANDLE; hThread: HANDLE;
769
var StackFrame: STACKFRAME; ContextRecord: PVOID;
770
ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE;
771
FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE;
772
GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE;
773
TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE): BOOL; stdcall;
774
{$EXTERNALSYM StackWalk}
777
API_VERSION_NUMBER = 9;
778
{$EXTERNALSYM API_VERSION_NUMBER}
781
LPAPI_VERSION = ^API_VERSION;
782
{$EXTERNALSYM LPAPI_VERSION}
784
MajorVersion: USHORT;
785
MinorVersion: USHORT;
789
{$EXTERNALSYM API_VERSION}
790
TApiVersion = API_VERSION;
791
PApiVersion = LPAPI_VERSION;
793
function ImagehlpApiVersion: LPAPI_VERSION; stdcall;
794
{$EXTERNALSYM ImagehlpApiVersion}
796
function ImagehlpApiVersionEx(const AppVersion: API_VERSION): LPAPI_VERSION; stdcall;
797
{$EXTERNALSYM ImagehlpApiVersionEx}
799
function GetTimestampForLoadedLibrary(Module: HMODULE): DWORD; stdcall;
800
{$EXTERNALSYM GetTimestampForLoadedLibrary}
803
// typedefs for function pointers
807
PSYM_ENUMMODULES_CALLBACK64 = function(ModuleName: PSTR; BaseOfDll: DWORD64;
808
UserContext: PVOID): BOOL; stdcall;
809
{$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK64}
810
PSymEnummodulesCallback64 = PSYM_ENUMMODULES_CALLBACK64;
812
PSYM_ENUMSYMBOLS_CALLBACK64 = function(SymbolName: PSTR; SymbolAddress: DWORD64;
813
SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
814
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK64}
815
PSymEnumsymbolsCallback64 = PSYM_ENUMSYMBOLS_CALLBACK64;
817
PSYM_ENUMSYMBOLS_CALLBACK64W = function(SymbolName: PWSTR;
818
SymbolAddress: DWORD64; SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
819
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK64W}
820
PSymEnumsymbolsCallback64w = PSYM_ENUMSYMBOLS_CALLBACK64W;
822
PENUMLOADED_MODULES_CALLBACK64 = function(ModuleName: PSTR;
823
ModuleBase: DWORD64; ModuleSize: ULONG; UserContext: PVOID): BOOL; stdcall;
824
{$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK64}
825
PSnumloadedModulesCallback64 = PENUMLOADED_MODULES_CALLBACK64;
827
PSYMBOL_REGISTERED_CALLBACK64 = function(hProcess: HANDLE; ActionCode: ULONG;
828
CallbackData: ULONG64; UserContext: ULONG64): BOOL; stdcall;
829
{$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK64}
830
PSymbolRegisteredCallback64 = PSYMBOL_REGISTERED_CALLBACK64;
832
PSYMBOL_FUNCENTRY_CALLBACK = function(hProcess: HANDLE; AddrBase: DWORD;
833
UserContext: PVOID): PVOID; stdcall;
834
{$EXTERNALSYM PSYMBOL_FUNCENTRY_CALLBACK}
835
PSymbolFuncentryCallback = PSYMBOL_FUNCENTRY_CALLBACK;
837
PSYMBOL_FUNCENTRY_CALLBACK64 = function(hProcess: HANDLE; AddrBase: ULONG64;
838
UserContext: ULONG64): PVOID; stdcall;
839
{$EXTERNALSYM PSYMBOL_FUNCENTRY_CALLBACK64}
840
PSymbolFuncentryCallback64 = PSYMBOL_FUNCENTRY_CALLBACK64;
842
PSYM_ENUMMODULES_CALLBACK = function(ModuleName: PSTR; BaseOfDll: ULONG;
843
UserContext: PVOID): BOOL; stdcall;
844
{$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK}
845
PSymEnummodulesCallback = PSYM_ENUMMODULES_CALLBACK;
847
PSYM_ENUMSYMBOLS_CALLBACK = function(SymbolName: PSTR; SymbolAddress: ULONG;
848
SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
849
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK}
850
PSymEnumsymbolsCallback = PSYM_ENUMSYMBOLS_CALLBACK;
852
PSYM_ENUMSYMBOLS_CALLBACKW = function(SymbolName: PWSTR; SymbolAddress: ULONG;
853
SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
854
{$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACKW}
855
PSymEnumsymbolsCallbackw = PSYM_ENUMSYMBOLS_CALLBACKW;
857
PENUMLOADED_MODULES_CALLBACK = function(ModuleName: PSTR; ModuleBase: ULONG;
858
ModuleSize: ULONG; UserContext: PVOID): BOOL; stdcall;
859
{$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK}
860
PEnumloadedModulesCallback = PENUMLOADED_MODULES_CALLBACK;
862
PSYMBOL_REGISTERED_CALLBACK = function(hProcess: HANDLE; ActionCode: ULONG;
863
CallbackData: PVOID; UserContext: PVOID): BOOL; stdcall;
864
{$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK}
865
PSymbolRegisteredCallback = PSYMBOL_REGISTERED_CALLBACK;
868
// flags found in SYMBOL_INFO.Flags
872
SYMFLAG_VALUEPRESENT = $00000001;
873
{$EXTERNALSYM SYMFLAG_VALUEPRESENT}
874
SYMFLAG_REGISTER = $00000008;
875
{$EXTERNALSYM SYMFLAG_REGISTER}
876
SYMFLAG_REGREL = $00000010;
877
{$EXTERNALSYM SYMFLAG_REGREL}
878
SYMFLAG_FRAMEREL = $00000020;
879
{$EXTERNALSYM SYMFLAG_FRAMEREL}
880
SYMFLAG_PARAMETER = $00000040;
881
{$EXTERNALSYM SYMFLAG_PARAMETER}
882
SYMFLAG_LOCAL = $00000080;
883
{$EXTERNALSYM SYMFLAG_LOCAL}
884
SYMFLAG_CONSTANT = $00000100;
885
{$EXTERNALSYM SYMFLAG_CONSTANT}
886
SYMFLAG_EXPORT = $00000200;
887
{$EXTERNALSYM SYMFLAG_EXPORT}
888
SYMFLAG_FORWARDER = $00000400;
889
{$EXTERNALSYM SYMFLAG_FORWARDER}
890
SYMFLAG_FUNCTION = $00000800;
891
{$EXTERNALSYM SYMFLAG_FUNCTION}
892
SYMFLAG_VIRTUAL = $00001000;
893
{$EXTERNALSYM SYMFLAG_VIRTUAL}
894
SYMFLAG_THUNK = $00002000;
895
{$EXTERNALSYM SYMFLAG_THUNK}
896
SYMFLAG_TLSREL = $00004000;
897
{$EXTERNALSYM SYMFLAG_TLSREL}
900
// symbol type enumeration
915
{$EXTERNALSYM SYM_TYPE}
919
// symbol data structure
922
PIMAGEHLP_SYMBOL64 = ^IMAGEHLP_SYMBOL64;
923
{$EXTERNALSYM PIMAGEHLP_SYMBOL64}
924
_IMAGEHLP_SYMBOL64 = record
925
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_SYMBOL64)
926
Address: DWORD64; // virtual address including dll base address
927
Size: DWORD; // estimated size of symbol, can be zero
928
Flags: DWORD; // info about the symbols, see the SYMF defines
929
MaxNameLength: DWORD; // maximum size of symbol name in 'Name'
930
Name: array [0..0] of CHAR; // symbol name (null terminated string)
932
{$EXTERNALSYM _IMAGEHLP_SYMBOL64}
933
IMAGEHLP_SYMBOL64 = _IMAGEHLP_SYMBOL64;
934
{$EXTERNALSYM IMAGEHLP_SYMBOL64}
935
TImageHlpSymbol64 = IMAGEHLP_SYMBOL64;
936
PImageHlpSymbol64 = PIMAGEHLP_SYMBOL64;
938
_IMAGEHLP_SYMBOL64_PACKAGE = record
939
sym: IMAGEHLP_SYMBOL64;
940
name: array [0..MAX_SYM_NAME] of CHAR;
942
{$EXTERNALSYM _IMAGEHLP_SYMBOL64_PACKAGE}
943
IMAGEHLP_SYMBOL64_PACKAGE = _IMAGEHLP_SYMBOL64_PACKAGE;
944
{$EXTERNALSYM IMAGEHLP_SYMBOL64_PACKAGE}
945
PIMAGEHLP_SYMBOL64_PACKAGE = ^IMAGEHLP_SYMBOL64_PACKAGE;
946
{$EXTERNALSYM PIMAGEHLP_SYMBOL64_PACKAGE}
947
TImageHlpSymbol64Package = IMAGEHLP_SYMBOL64_PACKAGE;
948
PImageHlpSymbol64Package = PIMAGEHLP_SYMBOL64_PACKAGE;
950
//#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
952
//#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
953
//#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
954
//#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
955
//#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
959
PIMAGEHLP_SYMBOL = ^IMAGEHLP_SYMBOL;
960
{$EXTERNALSYM PIMAGEHLP_SYMBOL}
961
_IMAGEHLP_SYMBOL = record
962
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_SYMBOL)
963
Address: DWORD; // virtual address including dll base address
964
Size: DWORD; // estimated size of symbol, can be zero
965
Flags: DWORD; // info about the symbols, see the SYMF defines
966
MaxNameLength: DWORD; // maximum size of symbol name in 'Name'
967
Name: array [0..0] of CHAR; // symbol name (null terminated string)
969
{$EXTERNALSYM _IMAGEHLP_SYMBOL}
970
IMAGEHLP_SYMBOL = _IMAGEHLP_SYMBOL;
971
{$EXTERNALSYM IMAGEHLP_SYMBOL}
972
TImageHlpSymbol = IMAGEHLP_SYMBOL;
973
PImageHlpSymbol = PIMAGEHLP_SYMBOL;
975
_IMAGEHLP_SYMBOL_PACKAGE = record
976
sym: IMAGEHLP_SYMBOL;
977
name: array [0..MAX_SYM_NAME] of CHAR;
979
{$EXTERNALSYM _IMAGEHLP_SYMBOL_PACKAGE}
980
IMAGEHLP_SYMBOL_PACKAGE = _IMAGEHLP_SYMBOL_PACKAGE;
981
{$EXTERNALSYM IMAGEHLP_SYMBOL_PACKAGE}
982
PIMAGEHLP_SYMBOL_PACKAGE = ^IMAGEHLP_SYMBOL_PACKAGE;
983
{$EXTERNALSYM PIMAGEHLP_SYMBOL_PACKAGE}
984
TImageHlpSymbolPackage = IMAGEHLP_SYMBOL_PACKAGE;
985
PImageHlpSymbolPackage = PIMAGEHLP_SYMBOL_PACKAGE;
990
// module data structure
993
PIMAGEHLP_MODULE64 = ^IMAGEHLP_MODULE64;
994
{$EXTERNALSYM PIMAGEHLP_MODULE64}
995
_IMAGEHLP_MODULE64 = record
996
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
997
BaseOfImage: DWORD64; // base load address of module
998
ImageSize: DWORD; // virtual size of the loaded module
999
TimeDateStamp: DWORD; // date/time stamp from pe header
1000
CheckSum: DWORD; // checksum from the pe header
1001
NumSyms: DWORD; // number of symbols in the symbol table
1002
SymType: SYM_TYPE; // type of symbols loaded
1003
ModuleName: array [0..3] of CHAR; // module name
1004
ImageName: array [0..255] of CHAR; // image name
1005
LoadedImageName: array [0..255] of CHAR; // symbol file name
1007
{$EXTERNALSYM _IMAGEHLP_MODULE64}
1008
IMAGEHLP_MODULE64 = _IMAGEHLP_MODULE64;
1009
{$EXTERNALSYM IMAGEHLP_MODULE64}
1010
TImageHlpModule64 = IMAGEHLP_MODULE64;
1011
PImageHlpModule64 = PIMAGEHLP_MODULE64;
1013
PIMAGEHLP_MODULEW64 = ^IMAGEHLP_MODULEW64;
1014
{$EXTERNALSYM PIMAGEHLP_MODULEW64}
1015
_IMAGEHLP_MODULE64W = record
1016
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
1017
BaseOfImage: DWORD64; // base load address of module
1018
ImageSize: DWORD; // virtual size of the loaded module
1019
TimeDateStamp: DWORD; // date/time stamp from pe header
1020
CheckSum: DWORD; // checksum from the pe header
1021
NumSyms: DWORD; // number of symbols in the symbol table
1022
SymType: SYM_TYPE; // type of symbols loaded
1023
ModuleName: array [0..31] of WCHAR; // module name
1024
ImageName: array [0..255] of WCHAR; // image name
1025
LoadedImageName: array [0..255] of WCHAR; // symbol file name
1027
{$EXTERNALSYM _IMAGEHLP_MODULE64W}
1028
IMAGEHLP_MODULEW64 = _IMAGEHLP_MODULE64W;
1029
{$EXTERNALSYM IMAGEHLP_MODULEW64}
1030
TImageHlpModuleW64 = IMAGEHLP_MODULEW64;
1031
PImageHlpModuleW64 = PIMAGEHLP_MODULEW64;
1033
PIMAGEHLP_MODULE = ^IMAGEHLP_MODULE;
1034
{$EXTERNALSYM PIMAGEHLP_MODULE}
1035
_IMAGEHLP_MODULE = record
1036
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
1037
BaseOfImage: DWORD; // base load address of module
1038
ImageSize: DWORD; // virtual size of the loaded module
1039
TimeDateStamp: DWORD; // date/time stamp from pe header
1040
CheckSum: DWORD; // checksum from the pe header
1041
NumSyms: DWORD; // number of symbols in the symbol table
1042
SymType: SYM_TYPE; // type of symbols loaded
1043
ModuleName: array [0..31] of CHAR; // module name
1044
ImageName: array [0..255] of CHAR; // image name
1045
LoadedImageName: array [0..255] of CHAR; // symbol file name
1047
{$EXTERNALSYM _IMAGEHLP_MODULE}
1048
IMAGEHLP_MODULE = _IMAGEHLP_MODULE;
1049
{$EXTERNALSYM IMAGEHLP_MODULE}
1050
TImageHlpModule = IMAGEHLP_MODULE;
1051
PImageHlpModule = PIMAGEHLP_MODULE;
1053
PIMAGEHLP_MODULEW = ^IMAGEHLP_MODULEW;
1054
{$EXTERNALSYM PIMAGEHLP_MODULEW}
1055
_IMAGEHLP_MODULEW = record
1056
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
1057
BaseOfImage: DWORD; // base load address of module
1058
ImageSize: DWORD; // virtual size of the loaded module
1059
TimeDateStamp: DWORD; // date/time stamp from pe header
1060
CheckSum: DWORD; // checksum from the pe header
1061
NumSyms: DWORD; // number of symbols in the symbol table
1062
SymType: SYM_TYPE; // type of symbols loaded
1063
ModuleName: array [0..31] of WCHAR; // module name
1064
ImageName: array [0..255] of WCHAR; // image name
1065
LoadedImageName: array [0..255] of WCHAR; // symbol file name
1067
{$EXTERNALSYM _IMAGEHLP_MODULEW}
1068
IMAGEHLP_MODULEW = _IMAGEHLP_MODULEW;
1069
{$EXTERNALSYM IMAGEHLP_MODULEW}
1070
TImageHlpModuleW = IMAGEHLP_MODULEW;
1071
PImageHlpModuleW = PIMAGEHLP_MODULEW;
1074
// source file line data structure
1077
PIMAGEHLP_LINE64 = ^IMAGEHLP_LINE64;
1078
{$EXTERNALSYM PIMAGEHLP_LINE64}
1079
_IMAGEHLP_LINE64 = record
1080
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE64)
1081
Key: PVOID; // internal
1082
LineNumber: DWORD; // line number in file
1083
FileName: PCHAR; // full filename
1084
Address: DWORD64; // first instruction of line
1086
{$EXTERNALSYM _IMAGEHLP_LINE64}
1087
IMAGEHLP_LINE64 = _IMAGEHLP_LINE64;
1088
{$EXTERNALSYM IMAGEHLP_LINE64}
1089
TImageHlpLine64 = IMAGEHLP_LINE64;
1090
PImageHlpLine64 = PIMAGEHLP_LINE64;
1092
PIMAGEHLP_LINE = ^IMAGEHLP_LINE;
1093
{$EXTERNALSYM PIMAGEHLP_LINE}
1094
_IMAGEHLP_LINE = record
1095
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE)
1096
Key: PVOID; // internal
1097
LineNumber: DWORD; // line number in file
1098
FileName: PCHAR; // full filename
1099
Address: DWORD; // first instruction of line
1101
{$EXTERNALSYM _IMAGEHLP_LINE}
1102
IMAGEHLP_LINE = _IMAGEHLP_LINE;
1103
{$EXTERNALSYM IMAGEHLP_LINE}
1104
TImageHlpLine = IMAGEHLP_LINE;
1105
PImageHlpLine = PIMAGEHLP_LINE;
1108
// source file structure
1112
_SOURCEFILE = record
1113
ModBase: DWORD64; // base address of loaded module
1114
FileName: PCHAR; // full filename of source
1116
{$EXTERNALSYM _SOURCEFILE}
1117
SOURCEFILE = _SOURCEFILE;
1118
{$EXTERNALSYM SOURCEFILE}
1119
PSOURCEFILE = ^SOURCEFILE;
1120
{$EXTERNALSYM PSOURCEFILE}
1121
TSourceFile = SOURCEFILE;
1124
// data structures used for registered symbol callbacks
1128
CBA_DEFERRED_SYMBOL_LOAD_START = $00000001;
1129
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_START}
1130
CBA_DEFERRED_SYMBOL_LOAD_COMPLETE = $00000002;
1131
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_COMPLETE}
1132
CBA_DEFERRED_SYMBOL_LOAD_FAILURE = $00000003;
1133
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_FAILURE}
1134
CBA_SYMBOLS_UNLOADED = $00000004;
1135
{$EXTERNALSYM CBA_SYMBOLS_UNLOADED}
1136
CBA_DUPLICATE_SYMBOL = $00000005;
1137
{$EXTERNALSYM CBA_DUPLICATE_SYMBOL}
1138
CBA_READ_MEMORY = $00000006;
1139
{$EXTERNALSYM CBA_READ_MEMORY}
1140
CBA_DEFERRED_SYMBOL_LOAD_CANCEL = $00000007;
1141
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_CANCEL}
1142
CBA_SET_OPTIONS = $00000008;
1143
{$EXTERNALSYM CBA_SET_OPTIONS}
1144
CBA_EVENT = $00000010;
1145
{$EXTERNALSYM CBA_EVENT}
1146
CBA_DEFERRED_SYMBOL_LOAD_PARTIAL = $00000020;
1147
{$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_PARTIAL}
1148
CBA_DEBUG_INFO = $10000000;
1149
{$EXTERNALSYM CBA_DEBUG_INFO}
1152
PIMAGEHLP_CBA_READ_MEMORY = ^IMAGEHLP_CBA_READ_MEMORY;
1153
{$EXTERNALSYM PIMAGEHLP_CBA_READ_MEMORY}
1154
_IMAGEHLP_CBA_READ_MEMORY = record
1155
addr: DWORD64; // address to read from
1156
buf: PVOID; // buffer to read to
1157
bytes: DWORD; // amount of bytes to read
1158
bytesread: LPDWORD; // pointer to store amount of bytes read
1160
{$EXTERNALSYM _IMAGEHLP_CBA_READ_MEMORY}
1161
IMAGEHLP_CBA_READ_MEMORY = _IMAGEHLP_CBA_READ_MEMORY;
1162
{$EXTERNALSYM IMAGEHLP_CBA_READ_MEMORY}
1163
TImageHlpCbaReadMemory = IMAGEHLP_CBA_READ_MEMORY;
1164
PImageHlpCbaReadMemory = PIMAGEHLP_CBA_READ_MEMORY;
1168
{$EXTERNALSYM sevInfo}
1170
{$EXTERNALSYM sevProblem}
1172
{$EXTERNALSYM sevAttn}
1174
{$EXTERNALSYM sevFatal}
1175
sevMax = 4; // unused
1176
{$EXTERNALSYM sevMax}
1179
_IMAGEHLP_CBA_EVENT = record
1180
severity: DWORD; // values from sevInfo to sevFatal
1181
code: DWORD; // numerical code IDs the error
1182
desc: PCHAR; // may contain a text description of the error
1183
object_: PVOID; // value dependant upon the error code
1185
{$EXTERNALSYM _IMAGEHLP_CBA_EVENT}
1186
IMAGEHLP_CBA_EVENT = _IMAGEHLP_CBA_EVENT;
1187
{$EXTERNALSYM IMAGEHLP_CBA_EVENT}
1188
PIMAGEHLP_CBA_EVENT = ^IMAGEHLP_CBA_EVENT;
1189
{$EXTERNALSYM PIMAGEHLP_CBA_EVENT}
1190
TImageHlpCbaEvent = IMAGEHLP_CBA_EVENT;
1191
PImageHlpCbaEvent = PIMAGEHLP_CBA_EVENT;
1193
PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1194
{$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1195
_IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = record
1196
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
1197
BaseOfImage: DWORD64; // base load address of module
1198
CheckSum: DWORD; // checksum from the pe header
1199
TimeDateStamp: DWORD; // date/time stamp from pe header
1200
FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
1201
Reparse: ByteBool; // load failure reparse
1202
hFile: HANDLE; // file handle, if passed
1205
{$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1206
IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = _IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1207
{$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1208
TImageHlpDeferredSymbolLoad64 = IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1209
PImageHlpDeferredSymbolLoad64 = PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1212
DSLFLAG_MISMATCHED_PDB = $1;
1213
{$EXTERNALSYM DSLFLAG_MISMATCHED_PDB}
1214
DSLFLAG_MISMATCHED_DBG = $2;
1215
{$EXTERNALSYM DSLFLAG_MISMATCHED_DBG}
1218
PIMAGEHLP_DEFERRED_SYMBOL_LOAD = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1219
{$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD}
1220
_IMAGEHLP_DEFERRED_SYMBOL_LOAD = record
1221
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
1222
BaseOfImage: DWORD; // base load address of module
1223
CheckSum: DWORD; // checksum from the pe header
1224
TimeDateStamp: DWORD; // date/time stamp from pe header
1225
FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
1226
Reparse: ByteBool; // load failure reparse
1227
hFile: HANDLE; // file handle, if passed
1229
{$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD}
1230
IMAGEHLP_DEFERRED_SYMBOL_LOAD = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1231
{$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD}
1232
TImageHlpDeferredSymbolLoad = IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1233
PImageHlpDeferredSymbolLoad = PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
1235
PIMAGEHLP_DUPLICATE_SYMBOL64 = ^IMAGEHLP_DUPLICATE_SYMBOL64;
1236
{$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL64}
1237
_IMAGEHLP_DUPLICATE_SYMBOL64 = record
1238
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
1239
NumberOfDups: DWORD; // number of duplicates in the Symbol array
1240
Symbol: PIMAGEHLP_SYMBOL64; // array of duplicate symbols
1241
SelectedSymbol: DWORD; // symbol selected (-1 to start)
1243
{$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL64}
1244
IMAGEHLP_DUPLICATE_SYMBOL64 = _IMAGEHLP_DUPLICATE_SYMBOL64;
1245
{$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL64}
1246
TImageHlpDuplicateSymbol64 = IMAGEHLP_DUPLICATE_SYMBOL64;
1247
PImageHlpDuplicateSymbol64 = PIMAGEHLP_DUPLICATE_SYMBOL64;
1249
PIMAGEHLP_DUPLICATE_SYMBOL = ^IMAGEHLP_DUPLICATE_SYMBOL;
1250
{$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL}
1251
_IMAGEHLP_DUPLICATE_SYMBOL = record
1252
SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
1253
NumberOfDups: DWORD; // number of duplicates in the Symbol array
1254
Symbol: PIMAGEHLP_SYMBOL; // array of duplicate symbols
1255
SelectedSymbol: DWORD; // symbol selected (-1 to start)
1257
{$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL}
1258
IMAGEHLP_DUPLICATE_SYMBOL = _IMAGEHLP_DUPLICATE_SYMBOL;
1259
{$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL}
1260
TImageHlpDuplicateSymbol = IMAGEHLP_DUPLICATE_SYMBOL;
1261
PImageHlpDuplicateSymbol = PIMAGEHLP_DUPLICATE_SYMBOL;
1263
// If dbghelp ever needs to display graphical UI, it will use this as the parent window.
1266
//SymSetParentWindow(
1271
// options that are set/returned by SymSetOptions() & SymGetOptions()
1272
// these are used as a mask
1276
SYMOPT_CASE_INSENSITIVE = $00000001;
1277
{$EXTERNALSYM SYMOPT_CASE_INSENSITIVE}
1278
SYMOPT_UNDNAME = $00000002;
1279
{$EXTERNALSYM SYMOPT_UNDNAME}
1280
SYMOPT_DEFERRED_LOADS = $00000004;
1281
{$EXTERNALSYM SYMOPT_DEFERRED_LOADS}
1282
SYMOPT_NO_CPP = $00000008;
1283
{$EXTERNALSYM SYMOPT_NO_CPP}
1284
SYMOPT_LOAD_LINES = $00000010;
1285
{$EXTERNALSYM SYMOPT_LOAD_LINES}
1286
SYMOPT_OMAP_FIND_NEAREST = $00000020;
1287
{$EXTERNALSYM SYMOPT_OMAP_FIND_NEAREST}
1288
SYMOPT_LOAD_ANYTHING = $00000040;
1289
{$EXTERNALSYM SYMOPT_LOAD_ANYTHING}
1290
SYMOPT_IGNORE_CVREC = $00000080;
1291
{$EXTERNALSYM SYMOPT_IGNORE_CVREC}
1292
SYMOPT_NO_UNQUALIFIED_LOADS = $00000100;
1293
{$EXTERNALSYM SYMOPT_NO_UNQUALIFIED_LOADS}
1294
SYMOPT_FAIL_CRITICAL_ERRORS = $00000200;
1295
{$EXTERNALSYM SYMOPT_FAIL_CRITICAL_ERRORS}
1296
SYMOPT_EXACT_SYMBOLS = $00000400;
1297
{$EXTERNALSYM SYMOPT_EXACT_SYMBOLS}
1298
SYMOPT_ALLOW_ABSOLUTE_SYMBOLS = $00000800;
1299
{$EXTERNALSYM SYMOPT_ALLOW_ABSOLUTE_SYMBOLS}
1300
SYMOPT_IGNORE_NT_SYMPATH = $00001000;
1301
{$EXTERNALSYM SYMOPT_IGNORE_NT_SYMPATH}
1302
SYMOPT_INCLUDE_32BIT_MODULES = $00002000;
1303
{$EXTERNALSYM SYMOPT_INCLUDE_32BIT_MODULES}
1304
SYMOPT_PUBLICS_ONLY = $00004000;
1305
{$EXTERNALSYM SYMOPT_PUBLICS_ONLY}
1306
SYMOPT_NO_PUBLICS = $00008000;
1307
{$EXTERNALSYM SYMOPT_NO_PUBLICS}
1308
SYMOPT_AUTO_PUBLICS = $00010000;
1309
{$EXTERNALSYM SYMOPT_AUTO_PUBLICS}
1310
SYMOPT_NO_IMAGE_SEARCH = $00020000;
1311
{$EXTERNALSYM SYMOPT_NO_IMAGE_SEARCH}
1312
SYMOPT_SECURE = $00040000;
1313
{$EXTERNALSYM SYMOPT_SECURE}
1315
SYMOPT_DEBUG = DWORD($80000000);
1316
{$EXTERNALSYM SYMOPT_DEBUG}
1318
function SymSetOptions(SymOptions: DWORD): DWORD; stdcall;
1319
{$EXTERNALSYM SymSetOptions}
1321
function SymGetOptions: DWORD; stdcall;
1322
{$EXTERNALSYM SymGetOptions}
1324
function SymCleanup(hProcess: HANDLE): BOOL; stdcall;
1325
{$EXTERNALSYM SymCleanup}
1327
function SymMatchString(string_, expression: LPSTR; fCase: BOOL): BOOL; stdcall;
1328
{$EXTERNALSYM SymMatchString}
1331
PSYM_ENUMSOURCFILES_CALLBACK = function(pSourceFile: PSOURCEFILE; UserContext: PVOID): BOOL; stdcall;
1332
{$EXTERNALSYM PSYM_ENUMSOURCFILES_CALLBACK}
1333
PSymEnumSourceFilesCallback = PSYM_ENUMSOURCFILES_CALLBACK;
1335
function SymEnumSourceFiles(hProcess: HANDLE; ModBase: ULONG64; Mask: LPSTR;
1336
cbSrcFiles: PSYM_ENUMSOURCFILES_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1337
{$EXTERNALSYM SymEnumSourceFiles}
1339
function SymEnumerateModules64(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK64;
1340
UserContext: PVOID): BOOL; stdcall;
1341
{$EXTERNALSYM SymEnumerateModules64}
1343
function SymEnumerateModules(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK;
1344
UserContext: PVOID): BOOL; stdcall;
1345
{$EXTERNALSYM SymEnumerateModules}
1347
function SymEnumerateSymbols64(hProcess: HANDLE; BaseOfDll: DWORD64;
1348
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64; UserContext: PVOID): BOOL; stdcall;
1349
{$EXTERNALSYM SymEnumerateSymbols64}
1351
function SymEnumerateSymbolsW64(hProcess: HANDLE; BaseOfDll: DWORD64;
1352
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64W; UserContext: PVOID): BOOL; stdcall;
1353
{$EXTERNALSYM SymEnumerateSymbolsW64}
1355
function SymEnumerateSymbols(hProcess: HANDLE; BaseOfDll: DWORD;
1356
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1357
{$EXTERNALSYM SymEnumerateSymbols}
1359
function SymEnumerateSymbolsW(hProcess: HANDLE; BaseOfDll: DWORD;
1360
EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACKW; UserContext: PVOID): BOOL; stdcall;
1361
{$EXTERNALSYM SymEnumerateSymbolsW}
1363
function EnumerateLoadedModules64(hProcess: HANDLE; EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64;
1364
UserContext: PVOID): BOOL; stdcall;
1365
{$EXTERNALSYM EnumerateLoadedModules64}
1367
function EnumerateLoadedModules(hProcess: HANDLE; EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK;
1368
UserContext: PVOID): BOOL; stdcall;
1369
{$EXTERNALSYM EnumerateLoadedModules}
1371
function SymFunctionTableAccess64(hProcess: HANDLE; AddrBase: DWORD64): PVOID; stdcall;
1372
{$EXTERNALSYM SymFunctionTableAccess64}
1374
function SymFunctionTableAccess(hProcess: HANDLE; AddrBase: DWORD): PVOID; stdcall;
1375
{$EXTERNALSYM SymFunctionTableAccess}
1377
function SymGetModuleInfo64(hProcess: HANDLE; qwAddr: DWORD64;
1378
var ModuleInfo: IMAGEHLP_MODULE64): BOOL; stdcall;
1379
{$EXTERNALSYM SymGetModuleInfo64}
1381
function SymGetModuleInfoW64(hProcess: HANDLE; qwAddr: DWORD64;
1382
var ModuleInfo: IMAGEHLP_MODULEW64): BOOL; stdcall;
1383
{$EXTERNALSYM SymGetModuleInfoW64}
1385
function SymGetModuleInfo(hProcess: HANDLE; dwAddr: DWORD;
1386
var ModuleInfo: IMAGEHLP_MODULE): BOOL; stdcall;
1387
{$EXTERNALSYM SymGetModuleInfo}
1389
function SymGetModuleInfoW(hProcess: HANDLE; dwAddr: DWORD;
1390
var ModuleInfo: IMAGEHLP_MODULEW): BOOL; stdcall;
1391
{$EXTERNALSYM SymGetModuleInfoW}
1393
function SymGetModuleBase64(hProcess: HANDLE; qwAddr: DWORD64): DWORD64; stdcall;
1394
{$EXTERNALSYM SymGetModuleBase64}
1396
function SymGetModuleBase(hProcess: HANDLE; dwAddr: DWORD): DWORD; stdcall;
1397
{$EXTERNALSYM SymGetModuleBase}
1399
function SymGetSymNext64(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL64): BOOL; stdcall;
1400
{$EXTERNALSYM SymGetSymNext64}
1402
function SymGetSymNext(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL): BOOL; stdcall;
1403
{$EXTERNALSYM SymGetSymNext}
1405
function SymGetSymPrev64(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL64): BOOL; stdcall;
1406
{$EXTERNALSYM SymGetSymPrev64}
1408
function SymGetSymPrev(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL): BOOL; stdcall;
1409
{$EXTERNALSYM SymGetSymPrev}
1411
function SymGetLineFromAddr64(hProcess: HANDLE; qwAddr: DWORD64;
1412
var pdwDisplacement: DWORD; var Line64: IMAGEHLP_LINE64): BOOL; stdcall;
1413
{$EXTERNALSYM SymGetLineFromAddr64}
1415
function SymGetLineFromAddr(hProcess: HANDLE; dwAddr: DWORD;
1416
var pdwDisplacement: DWORD; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1417
{$EXTERNALSYM SymGetLineFromAddr}
1419
function SymGetLineFromName64(hProcess: HANDLE; ModuleName: PSTR; FileName: PSTR;
1420
dwLineNumber: DWORD; var plDisplacement: LONG; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1421
{$EXTERNALSYM SymGetLineFromName64}
1423
function SymGetLineFromName(hProcess: HANDLE; ModuleName: PSTR; FileName: PSTR;
1424
dwLineNumber: DWORD; var plDisplacement: LONG; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1425
{$EXTERNALSYM SymGetLineFromName}
1427
function SymGetLineNext64(hProcess: HANDLE; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1428
{$EXTERNALSYM SymGetLineNext64}
1430
function SymGetLineNext(hProcess: HANDLE; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1431
{$EXTERNALSYM SymGetLineNext}
1433
function SymGetLinePrev64(hProcess: HANDLE; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1434
{$EXTERNALSYM SymGetLinePrev64}
1436
function SymGetLinePrev(hProcess: HANDLE; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1437
{$EXTERNALSYM SymGetLinePrev}
1439
function SymMatchFileName(FileName, Match: PSTR; var FileNameStop, MatchStop: PSTR): BOOL; stdcall;
1440
{$EXTERNALSYM SymMatchFileName}
1442
function SymInitialize(hProcess: HANDLE; UserSearchPath: PSTR; fInvadeProcess: BOOL): BOOL; stdcall;
1443
{$EXTERNALSYM SymInitialize}
1445
function SymGetSearchPath(hProcess: HANDLE; SearchPath: PSTR; SearchPathLength: DWORD): BOOL; stdcall;
1446
{$EXTERNALSYM SymGetSearchPath}
1448
function SymSetSearchPath(hProcess: HANDLE; SearchPath: PSTR): BOOL; stdcall;
1449
{$EXTERNALSYM SymSetSearchPath}
1451
function SymLoadModule64(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR;
1452
BaseOfDll: DWORD64; SizeOfDll: DWORD): DWORD64; stdcall;
1453
{$EXTERNALSYM SymLoadModule64}
1456
SLMFLAG_VIRTUAL = $1;
1457
{$EXTERNALSYM SLMFLAG_VIRTUAL}
1459
function SymLoadModuleEx(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR; BaseOfDll: DWORD64;
1460
DllSize: DWORD; Data: PMODLOAD_DATA; Flag: DWORD): DWORD64; stdcall;
1461
{$EXTERNALSYM SymLoadModuleEx}
1463
function SymLoadModule(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR;
1464
BaseOfDll: DWORD; SizeOfDll: DWORD): DWORD; stdcall;
1465
{$EXTERNALSYM SymLoadModule}
1467
function SymUnloadModule64(hProcess: HANDLE; BaseOfDll: DWORD64): BOOL; stdcall;
1468
{$EXTERNALSYM SymUnloadModule64}
1470
function SymUnloadModule(hProcess: HANDLE; BaseOfDll: DWORD): BOOL; stdcall;
1471
{$EXTERNALSYM SymUnloadModule}
1473
function SymUnDName64(const sym: IMAGEHLP_SYMBOL64; UnDecName: PSTR;
1474
UnDecNameLength: DWORD): BOOL; stdcall;
1475
{$EXTERNALSYM SymUnDName64}
1477
function SymUnDName(const sym: IMAGEHLP_SYMBOL; UnDecName: PSTR;
1478
UnDecNameLength: DWORD): BOOL; stdcall;
1479
{$EXTERNALSYM SymUnDName}
1481
function SymRegisterCallback64(hProcess: HANDLE; CallbackFunction: PSYMBOL_REGISTERED_CALLBACK64;
1482
UserContext: ULONG64): BOOL; stdcall;
1483
{$EXTERNALSYM SymRegisterCallback64}
1485
function SymRegisterFunctionEntryCallback64(hProcess: HANDLE; CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK64;
1486
UserContext: ULONG64): BOOL; stdcall;
1487
{$EXTERNALSYM SymRegisterFunctionEntryCallback64}
1489
function SymRegisterCallback(hProcess: HANDLE; CallbackFunction: PSYMBOL_REGISTERED_CALLBACK;
1490
UserContext: PVOID): BOOL; stdcall;
1491
{$EXTERNALSYM SymRegisterCallback}
1493
function SymRegisterFunctionEntryCallback(hProcess: HANDLE; CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK;
1494
UserContext: PVOID): BOOL; stdcall;
1495
{$EXTERNALSYM SymRegisterFunctionEntryCallback}
1498
PIMAGEHLP_SYMBOL_SRC = ^IMAGEHLP_SYMBOL_SRC;
1499
{$EXTERNALSYM PIMAGEHLP_SYMBOL_SRC}
1500
_IMAGEHLP_SYMBOL_SRC = record
1501
sizeofstruct: DWORD;
1503
file_: array [0..MAX_PATH - 1] of Char;
1505
{$EXTERNALSYM _IMAGEHLP_SYMBOL_SRC}
1506
IMAGEHLP_SYMBOL_SRC = _IMAGEHLP_SYMBOL_SRC;
1507
{$EXTERNALSYM IMAGEHLP_SYMBOL_SRC}
1508
TImageHlpSymbolSrc = IMAGEHLP_SYMBOL_SRC;
1509
PImageHlpSymbolSrc = PIMAGEHLP_SYMBOL_SRC;
1511
PMODULE_TYPE_INFO = ^MODULE_TYPE_INFO;
1512
{$EXTERNALSYM PMODULE_TYPE_INFO}
1513
_MODULE_TYPE_INFO = record
1516
data: array [0..0] of BYTE;
1518
{$EXTERNALSYM _MODULE_TYPE_INFO}
1519
MODULE_TYPE_INFO = _MODULE_TYPE_INFO;
1520
{$EXTERNALSYM MODULE_TYPE_INFO}
1521
TModuleTypeInfo = MODULE_TYPE_INFO;
1522
PModuleTypeInfo = PMODULE_TYPE_INFO;
1525
PSYMBOL_INFO = ^SYMBOL_INFO;
1526
{$EXTERNALSYM PSYMBOL_INFO}
1527
_SYMBOL_INFO = record
1528
SizeOfStruct: ULONG;
1529
TypeIndex: ULONG; // Type Index of symbol
1530
Reserved: array [0..1] of ULONG64;
1533
ModBase: ULONG64; // Base Address of module comtaining this symbol
1535
Value: ULONG64; // Value of symbol, ValuePresent should be 1
1536
Address: ULONG64; // Address of symbol including base address of module
1537
Register_: ULONG; // register holding value or pointer to value
1538
Scope: ULONG; // scope of the symbol
1539
Tag: ULONG; // pdb classification
1540
NameLen: ULONG; // Actual length of name
1542
Name: array [0..0] of CHAR; // Name of symbol
1544
{$EXTERNALSYM _SYMBOL_INFO}
1545
SYMBOL_INFO = _SYMBOL_INFO;
1546
{$EXTERNALSYM SYMBOL_INFO}
1547
TSymbolInfo = SYMBOL_INFO;
1548
PSymbolInfo = PSYMBOL_INFO;
1550
_SYMBOL_INFO_PACKAGE = record
1552
name: array [0..MAX_SYM_NAME] of CHAR;
1554
{$EXTERNALSYM _SYMBOL_INFO_PACKAGE}
1555
SYMBOL_INFO_PACKAGE = _SYMBOL_INFO_PACKAGE;
1556
{$EXTERNALSYM SYMBOL_INFO_PACKAGE}
1557
PSYMBOL_INFO_PACKAGE = ^SYMBOL_INFO_PACKAGE;
1558
{$EXTERNALSYM PSYMBOL_INFO_PACKAGE}
1559
TSymbolInfoPackage = SYMBOL_INFO_PACKAGE;
1560
PSymbolInfoPackage = PSYMBOL_INFO_PACKAGE;
1562
PIMAGEHLP_STACK_FRAME = ^IMAGEHLP_STACK_FRAME;
1563
{$EXTERNALSYM PIMAGEHLP_STACK_FRAME}
1564
_IMAGEHLP_STACK_FRAME = record
1565
InstructionOffset: ULONG64;
1566
ReturnOffset: ULONG64;
1567
FrameOffset: ULONG64;
1568
StackOffset: ULONG64;
1569
BackingStoreOffset: ULONG64;
1570
FuncTableEntry: ULONG64;
1571
Params: array [0..3] of ULONG64;
1572
Reserved: array [0..4] of ULONG64;
1576
{$EXTERNALSYM _IMAGEHLP_STACK_FRAME}
1577
IMAGEHLP_STACK_FRAME = _IMAGEHLP_STACK_FRAME;
1578
{$EXTERNALSYM IMAGEHLP_STACK_FRAME}
1579
TImageHlpStackFrame = IMAGEHLP_STACK_FRAME;
1580
PImageHlpStackFrame = PIMAGEHLP_STACK_FRAME;
1582
IMAGEHLP_CONTEXT = LPVOID;
1583
{$EXTERNALSYM IMAGEHLP_CONTEXT}
1584
PIMAGEHLP_CONTEXT = ^IMAGEHLP_CONTEXT;
1585
{$EXTERNALSYM PIMAGEHLP_CONTEXT}
1586
TImageHlpContext = IMAGEHLP_CONTEXT;
1587
PImageHlpContext = PIMAGEHLP_CONTEXT;
1589
function SymSetContext(hProcess: HANDLE; StackFrame: PIMAGEHLP_STACK_FRAME; Context: PIMAGEHLP_CONTEXT): BOOL; stdcall;
1590
{$EXTERNALSYM SymSetContext}
1592
function SymFromAddr(hProcess: HANDLE; Address: DWORD64; Displacement: PDWORD64; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1593
{$EXTERNALSYM SymFromAddr}
1595
// While SymFromName will provide a symbol from a name,
1596
// SymEnumSymbols can provide the same matching information
1597
// for ALL symbols with a matching name, even regular
1598
// expressions. That way you can search across modules
1599
// and differentiate between identically named symbols.
1601
function SymFromName(hProcess: HANDLE; Name: LPSTR; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1602
{$EXTERNALSYM SymFromName}
1605
PSYM_ENUMERATESYMBOLS_CALLBACK = function(pSymInfo: PSYMBOL_INFO; SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
1606
{$EXTERNALSYM PSYM_ENUMERATESYMBOLS_CALLBACK}
1607
PSymEnumerateSymbolsCallback = PSYM_ENUMERATESYMBOLS_CALLBACK;
1609
function SymEnumSymbols(hProcess: HANDLE; BaseOfDll: ULONG64; Mask: PCSTR; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1610
{$EXTERNALSYM SymEnumSymbols}
1612
function SymEnumSymbolsForAddr(hProcess: HANDLE; Address: DWORD64;
1613
EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1614
{$EXTERNALSYM SymEnumSymbolsForAddr}
1617
_IMAGEHLP_SYMBOL_TYPE_INFO = (
1624
TI_GET_ARRAYINDEXTYPEID,
1627
TI_GET_ADDRESSOFFSET,
1631
TI_GET_CHILDRENCOUNT,
1633
TI_GET_VIRTUALBASECLASS,
1634
TI_GET_VIRTUALTABLESHAPEID,
1635
TI_GET_VIRTUALBASEPOINTEROFFSET,
1636
TI_GET_CLASSPARENTID,
1639
TI_GET_LEXICALPARENT,
1644
TI_GET_CALLING_CONVENTION);
1645
{$EXTERNALSYM _IMAGEHLP_SYMBOL_TYPE_INFO}
1646
IMAGEHLP_SYMBOL_TYPE_INFO = _IMAGEHLP_SYMBOL_TYPE_INFO;
1647
{$EXTERNALSYM IMAGEHLP_SYMBOL_TYPE_INFO}
1648
TImageHlpSymbolTypeInfo = IMAGEHLP_SYMBOL_TYPE_INFO;
1650
PTI_FINDCHILDREN_PARAMS = ^TI_FINDCHILDREN_PARAMS;
1651
{$EXTERNALSYM PTI_FINDCHILDREN_PARAMS}
1652
_TI_FINDCHILDREN_PARAMS = record
1655
ChildId: array [0..0] of ULONG;
1657
{$EXTERNALSYM _TI_FINDCHILDREN_PARAMS}
1658
TI_FINDCHILDREN_PARAMS = _TI_FINDCHILDREN_PARAMS;
1659
{$EXTERNALSYM TI_FINDCHILDREN_PARAMS}
1660
TTiFindChildrenParams = TI_FINDCHILDREN_PARAMS;
1661
PTiFindChildrenParams = PTI_FINDCHILDREN_PARAMS;
1663
function SymGetTypeInfo(hProcess: HANDLE; ModBase: DWORD64; TypeId: ULONG; GetType: IMAGEHLP_SYMBOL_TYPE_INFO; pInfo: PVOID): BOOL; stdcall;
1664
{$EXTERNALSYM SymGetTypeInfo}
1666
function SymEnumTypes(hProcess: HANDLE; BaseOfDll: ULONG64; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1667
{$EXTERNALSYM SymEnumTypes}
1669
function SymGetTypeFromName(hProcess: HANDLE; BaseOfDll: ULONG64; Name: LPSTR; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1670
{$EXTERNALSYM SymGetTypeFromName}
1672
function SymAddSymbol(hProcess: HANDLE; BaseOfDll: ULONG64; Name: PCSTR; Address: DWORD64; Size, Flags: DWORD): BOOL; stdcall;
1673
{$EXTERNALSYM SymAddSymbol}
1675
function SymDeleteSymbol(hProcess: HANDLE; BaseOfDll: ULONG64; Name: PCSTR; Address: DWORD64; Flags: DWORD): BOOL; stdcall;
1676
{$EXTERNALSYM SymDeleteSymbol}
1679
// Full user-mode dump creation.
1683
PDBGHELP_CREATE_USER_DUMP_CALLBACK = function(DataType: DWORD; var Data: PVOID; DataLength: LPDWORD; UserData: PVOID): BOOL; stdcall;
1684
{$EXTERNALSYM PDBGHELP_CREATE_USER_DUMP_CALLBACK}
1685
PDbgHelpCreateUserDumpCallback = PDBGHELP_CREATE_USER_DUMP_CALLBACK;
1687
function DbgHelpCreateUserDump(FileName: LPSTR; Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK; UserData: PVOID): BOOL; stdcall;
1688
{$EXTERNALSYM DbgHelpCreateUserDump}
1690
function DbgHelpCreateUserDumpW(FileName: LPWSTR; Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK; UserData: PVOID): BOOL; stdcall;
1691
{$EXTERNALSYM DbgHelpCreateUserDumpW}
1693
// -----------------------------------------------------------------
1694
// The following 4 legacy APIs are fully supported, but newer
1695
// ones are recommended. SymFromName and SymFromAddr provide
1696
// much more detailed info on the returned symbol.
1698
function SymGetSymFromAddr64(hProcess: HANDLE; qwAddr: DWORD64; pdwDisplacement: PDWORD64; Symbol: PIMAGEHLP_SYMBOL64): BOOL; stdcall;
1699
{$EXTERNALSYM SymGetSymFromAddr64}
1701
function SymGetSymFromAddr(hProcess: HANDLE; dwAddr: DWORD; pdwDisplacement: PDWORD; Symbol: PIMAGEHLP_SYMBOL): BOOL; stdcall;
1702
{$EXTERNALSYM SymGetSymFromAddr}
1704
// While following two APIs will provide a symbol from a name,
1705
// SymEnumSymbols can provide the same matching information
1706
// for ALL symbols with a matching name, even regular
1707
// expressions. That way you can search across modules
1708
// and differentiate between identically named symbols.
1710
function SymGetSymFromName64(hProcess: HANDLE; Name: PSTR; Symbol: PIMAGEHLP_SYMBOL64): BOOL; stdcall;
1711
{$EXTERNALSYM SymGetSymFromName64}
1713
function SymGetSymFromName(hProcess: HANDLE; Name: PSTR; Symbol: PIMAGEHLP_SYMBOL): BOOL; stdcall;
1714
{$EXTERNALSYM SymGetSymFromName}
1716
// -----------------------------------------------------------------
1717
// The following APIs exist only for backwards compatibility
1718
// with a pre-release version documented in an MSDN release.
1720
// You should use SymFindFileInPath if you want to maintain
1721
// future compatibility.
1723
function FindFileInPath(hprocess: HANDLE; SearchPath: LPSTR; FileName: LPSTR; id: PVOID; two: DWORD; three: DWORD; flags: DWORD; FilePath: LPSTR): BOOL; stdcall;
1724
{$EXTERNALSYM FindFileInPath}
1726
// You should use SymFindFileInPath if you want to maintain
1727
// future compatibility.
1729
function FindFileInSearchPath(hprocess: HANDLE; SearchPath: LPSTR; FileName: LPSTR; one: DWORD; two: DWORD; three: DWORD; FilePath: LPSTR): BOOL; stdcall;
1730
{$EXTERNALSYM FindFileInSearchPath}
1732
function SymEnumSym(hProcess: HANDLE; BaseOfDll: ULONG64; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1733
{$EXTERNALSYM SymEnumSym}
1735
// These values should not be used.
1736
// They have been replaced by SYMFLAG_ values.
1739
SYMF_OMAP_GENERATED = $00000001;
1740
SYMF_OMAP_MODIFIED = $00000002;
1741
SYMF_REGISTER = $00000008;
1742
SYMF_REGREL = $00000010;
1743
SYMF_FRAMEREL = $00000020;
1744
SYMF_PARAMETER = $00000040;
1745
SYMF_LOCAL = $00000080;
1746
SYMF_CONSTANT = $00000100;
1747
SYMF_EXPORT = $00000200;
1748
SYMF_FORWARDER = $00000400;
1749
SYMF_FUNCTION = $00000800;
1750
SYMF_VIRTUAL = $00001000;
1751
SYMF_THUNK = $00002000;
1752
SYMF_TLSREL = $00004000;
1754
// These values should also not be used.
1755
// They have been replaced by SYMFLAG_ values.
1757
IMAGEHLP_SYMBOL_INFO_VALUEPRESENT = 1;
1758
IMAGEHLP_SYMBOL_INFO_REGISTER = SYMF_REGISTER; // 0x0008
1759
IMAGEHLP_SYMBOL_INFO_REGRELATIVE = SYMF_REGREL; // 0x0010
1760
IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE = SYMF_FRAMEREL; // 0x0020
1761
IMAGEHLP_SYMBOL_INFO_PARAMETER = SYMF_PARAMETER; // 0x0040
1762
IMAGEHLP_SYMBOL_INFO_LOCAL = SYMF_LOCAL; // 0x0080
1763
IMAGEHLP_SYMBOL_INFO_CONSTANT = SYMF_CONSTANT; // 0x0100
1764
IMAGEHLP_SYMBOL_FUNCTION = SYMF_FUNCTION; // 0x0800
1765
IMAGEHLP_SYMBOL_VIRTUAL = SYMF_VIRTUAL; // 0x1000
1766
IMAGEHLP_SYMBOL_THUNK = SYMF_THUNK; // 0x2000
1767
IMAGEHLP_SYMBOL_INFO_TLSRELATIVE = SYMF_TLSREL; // 0x4000
1770
MINIDUMP_SIGNATURE = 'PMDM';
1771
{$EXTERNALSYM MINIDUMP_SIGNATURE}
1772
MINIDUMP_VERSION = 42899;
1773
{$EXTERNALSYM MINIDUMP_VERSION}
1779
{$EXTERNALSYM RVA64}
1781
_MINIDUMP_LOCATION_DESCRIPTOR = record
1785
{$EXTERNALSYM _MINIDUMP_LOCATION_DESCRIPTOR}
1786
MINIDUMP_LOCATION_DESCRIPTOR = _MINIDUMP_LOCATION_DESCRIPTOR;
1787
{$EXTERNALSYM MINIDUMP_LOCATION_DESCRIPTOR}
1788
TMinidumpLocationDescriptor = MINIDUMP_LOCATION_DESCRIPTOR;
1789
PMinidumpLocationDescriptor = ^MINIDUMP_LOCATION_DESCRIPTOR;
1791
_MINIDUMP_LOCATION_DESCRIPTOR64 = record
1795
{$EXTERNALSYM _MINIDUMP_LOCATION_DESCRIPTOR64}
1796
MINIDUMP_LOCATION_DESCRIPTOR64 = _MINIDUMP_LOCATION_DESCRIPTOR64;
1797
{$EXTERNALSYM MINIDUMP_LOCATION_DESCRIPTOR64}
1798
TMinidumpLocationDescriptor64 = MINIDUMP_LOCATION_DESCRIPTOR64;
1799
PMinidumpLocationDescriptor64 = ^MINIDUMP_LOCATION_DESCRIPTOR64;
1801
PMINIDUMP_MEMORY_DESCRIPTOR = ^MINIDUMP_MEMORY_DESCRIPTOR;
1802
{$EXTERNALSYM PMINIDUMP_MEMORY_DESCRIPTOR}
1803
_MINIDUMP_MEMORY_DESCRIPTOR = record
1804
StartOfMemoryRange: ULONG64;
1805
Memory: MINIDUMP_LOCATION_DESCRIPTOR;
1807
{$EXTERNALSYM _MINIDUMP_MEMORY_DESCRIPTOR}
1808
MINIDUMP_MEMORY_DESCRIPTOR = _MINIDUMP_MEMORY_DESCRIPTOR;
1809
{$EXTERNALSYM MINIDUMP_MEMORY_DESCRIPTOR}
1810
TMinidumpMemoryDescriptor = MINIDUMP_MEMORY_DESCRIPTOR;
1811
PMinidumpMemoryDescriptor = PMINIDUMP_MEMORY_DESCRIPTOR;
1813
// DESCRIPTOR64 is used for full-memory minidumps where
1814
// all of the raw memory is laid out sequentially at the
1815
// end of the dump. There is no need for individual RVAs
1816
// as the RVA is the base RVA plus the sum of the preceeding
1819
PMINIDUMP_MEMORY_DESCRIPTOR64 = ^MINIDUMP_MEMORY_DESCRIPTOR64;
1820
{$EXTERNALSYM PMINIDUMP_MEMORY_DESCRIPTOR64}
1821
_MINIDUMP_MEMORY_DESCRIPTOR64 = record
1822
StartOfMemoryRange: ULONG64;
1825
{$EXTERNALSYM _MINIDUMP_MEMORY_DESCRIPTOR64}
1826
MINIDUMP_MEMORY_DESCRIPTOR64 = _MINIDUMP_MEMORY_DESCRIPTOR64;
1827
{$EXTERNALSYM MINIDUMP_MEMORY_DESCRIPTOR64}
1828
TMinidumpMemoryDescriptor64 = MINIDUMP_MEMORY_DESCRIPTOR64;
1829
PMinidumpMemoryDescriptor64 = PMINIDUMP_MEMORY_DESCRIPTOR64;
1831
PMINIDUMP_HEADER = ^MINIDUMP_HEADER;
1832
{$EXTERNALSYM PMINIDUMP_HEADER}
1833
_MINIDUMP_HEADER = record
1836
NumberOfStreams: ULONG32;
1837
StreamDirectoryRva: RVA;
1841
0: (Reserved: ULONG32);
1842
1: (TimeDateStamp: ULONG32);
1846
{$EXTERNALSYM _MINIDUMP_HEADER}
1847
MINIDUMP_HEADER = _MINIDUMP_HEADER;
1848
{$EXTERNALSYM MINIDUMP_HEADER}
1849
TMinidumpHeader = MINIDUMP_HEADER;
1850
PMinidumpHeader = PMINIDUMP_HEADER;
1853
// The MINIDUMP_HEADER field StreamDirectoryRva points to
1854
// an array of MINIDUMP_DIRECTORY structures.
1857
PMINIDUMP_DIRECTORY = ^MINIDUMP_DIRECTORY;
1858
{$EXTERNALSYM PMINIDUMP_DIRECTORY}
1859
_MINIDUMP_DIRECTORY = record
1860
StreamType: ULONG32;
1861
Location: MINIDUMP_LOCATION_DESCRIPTOR;
1863
{$EXTERNALSYM _MINIDUMP_DIRECTORY}
1864
MINIDUMP_DIRECTORY = _MINIDUMP_DIRECTORY;
1865
{$EXTERNALSYM MINIDUMP_DIRECTORY}
1866
TMinidumpDirectory = MINIDUMP_DIRECTORY;
1867
PMinidumpDirectory = PMINIDUMP_DIRECTORY;
1869
PMINIDUMP_STRING = ^MINIDUMP_STRING;
1870
{$EXTERNALSYM PMINIDUMP_STRING}
1871
_MINIDUMP_STRING = record
1872
Length: ULONG32; // Length in bytes of the string
1873
Buffer: PWCHAR; // Variable size buffer
1875
{$EXTERNALSYM _MINIDUMP_STRING}
1876
MINIDUMP_STRING = _MINIDUMP_STRING;
1877
{$EXTERNALSYM MINIDUMP_STRING}
1878
TMinidumpString = MINIDUMP_STRING;
1879
PMinidumpString = PMINIDUMP_STRING;
1882
// The MINIDUMP_DIRECTORY field StreamType may be one of the following types.
1883
// Types will be added in the future, so if a program reading the minidump
1884
// header encounters a stream type it does not understand it should ignore
1885
// the data altogether. Any tag above LastReservedStream will not be used by
1886
// the system and is reserved for program-specific information.
1891
{$EXTERNALSYM UnusedStream}
1892
ReservedStream0 = 1;
1893
{$EXTERNALSYM ReservedStream0}
1894
ReservedStream1 = 2;
1895
{$EXTERNALSYM ReservedStream1}
1896
ThreadListStream = 3;
1897
{$EXTERNALSYM ThreadListStream}
1898
ModuleListStream = 4;
1899
{$EXTERNALSYM ModuleListStream}
1900
MemoryListStream = 5;
1901
{$EXTERNALSYM MemoryListStream}
1902
ExceptionStream = 6;
1903
{$EXTERNALSYM ExceptionStream}
1904
SystemInfoStream = 7;
1905
{$EXTERNALSYM SystemInfoStream}
1906
ThreadExListStream = 8;
1907
{$EXTERNALSYM ThreadExListStream}
1908
Memory64ListStream = 9;
1909
{$EXTERNALSYM Memory64ListStream}
1910
CommentStreamA = 10;
1911
{$EXTERNALSYM CommentStreamA}
1912
CommentStreamW = 11;
1913
{$EXTERNALSYM CommentStreamW}
1914
HandleDataStream = 12;
1915
{$EXTERNALSYM HandleDataStream}
1916
FunctionTableStream = 13;
1917
{$EXTERNALSYM FunctionTableStream}
1918
UnloadedModuleListStream = 14;
1919
{$EXTERNALSYM UnloadedModuleListStream}
1920
MiscInfoStream = 15;
1921
{$EXTERNALSYM MiscInfoStream}
1923
LastReservedStream = $ffff;
1924
{$EXTERNALSYM LastReservedStream}
1927
_MINIDUMP_STREAM_TYPE = DWORD;
1928
{$EXTERNALSYM MINIDUMP_STREAM_TYPE}
1929
MINIDUMP_STREAM_TYPE = _MINIDUMP_STREAM_TYPE;
1930
{$EXTERNALSYM _MINIDUMP_STREAM_TYPE}
1931
TMinidumpStreamType = MINIDUMP_STREAM_TYPE;
1934
// The minidump system information contains processor and
1935
// Operating System specific information.
1939
_CPU_INFORMATION = record
1943
// X86 platforms use CPUID function to obtain processor information.
1949
// CPUID Subfunction 0, register EAX (VendorId [0]),
1950
// EBX (VendorId [1]) and ECX (VendorId [2]).
1953
VendorId: array [0..2] of ULONG32;
1956
// CPUID Subfunction 1, register EAX
1959
VersionInformation: ULONG32;
1962
// CPUID Subfunction 1, register EDX
1965
FeatureInformation: ULONG32;
1968
// CPUID, Subfunction 80000001, register EBX. This will only
1969
// be obtained if the vendor id is "AuthenticAMD".
1972
AMDExtendedCpuFeatures: ULONG32);
1975
// Non-x86 platforms use processor feature flags.
1979
ProcessorFeatures: array [0..1] of ULONG64);
1982
_MINIDUMP_SYSTEM_INFO = record
1985
// ProcessorArchitecture, ProcessorLevel and ProcessorRevision are all
1986
// taken from the SYSTEM_INFO structure obtained by GetSystemInfo( ).
1989
ProcessorArchitecture: USHORT;
1990
ProcessorLevel: USHORT;
1991
ProcessorRevision: USHORT;
1995
0: (Reserved0: USHORT);
1997
NumberOfProcessors: UCHAR;
1998
ProductType: UCHAR);
2002
// MajorVersion, MinorVersion, BuildNumber, PlatformId and
2003
// CSDVersion are all taken from the OSVERSIONINFO structure
2004
// returned by GetVersionEx( ).
2007
MajorVersion: ULONG32;
2008
MinorVersion: ULONG32;
2009
BuildNumber: ULONG32;
2010
PlatformId: ULONG32;
2013
// RVA to a CSDVersion string in the string table.
2020
0: (Reserved1: ULONG32);
2027
// CPU information is obtained from one of two places.
2029
// 1) On x86 computers, CPU_INFORMATION is obtained from the CPUID
2030
// instruction. You must use the X86 portion of the union for X86
2033
// 2) On non-x86 architectures, CPU_INFORMATION is obtained by calling
2034
// IsProcessorFeatureSupported().
2037
Cpu: _CPU_INFORMATION;
2039
{$EXTERNALSYM _MINIDUMP_SYSTEM_INFO}
2040
MINIDUMP_SYSTEM_INFO = _MINIDUMP_SYSTEM_INFO;
2041
{$EXTERNALSYM MINIDUMP_SYSTEM_INFO}
2042
PMINIDUMP_SYSTEM_INFO = ^MINIDUMP_SYSTEM_INFO;
2043
{$EXTERNALSYM PMINIDUMP_SYSTEM_INFO}
2044
TMinidumpSystemInfo = MINIDUMP_SYSTEM_INFO;
2045
PMinidumpSystemInfo = PMINIDUMP_SYSTEM_INFO;
2047
CPU_INFORMATION = _CPU_INFORMATION;
2048
{$EXTERNALSYM CPU_INFORMATION}
2049
PCPU_INFORMATION = CPU_INFORMATION;
2050
{$EXTERNALSYM PCPU_INFORMATION}
2053
// The minidump thread contains standard thread
2054
// information plus an RVA to the memory for this
2055
// thread and an RVA to the CONTEXT structure for
2060
// ThreadId must be 4 bytes on all architectures.
2063
// C_ASSERT (sizeof ( ((PPROCESS_INFORMATION)0)->dwThreadId ) == 4);
2066
PMINIDUMP_THREAD = ^MINIDUMP_THREAD;
2067
{$EXTERNALSYM PMINIDUMP_THREAD}
2068
_MINIDUMP_THREAD = record
2070
SuspendCount: ULONG32;
2071
PriorityClass: ULONG32;
2074
Stack: MINIDUMP_MEMORY_DESCRIPTOR;
2075
ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2077
{$EXTERNALSYM _MINIDUMP_THREAD}
2078
MINIDUMP_THREAD = _MINIDUMP_THREAD;
2079
{$EXTERNALSYM MINIDUMP_THREAD}
2080
TMinidumpThread = MINIDUMP_THREAD;
2081
PMinidumpThread = PMINIDUMP_THREAD;
2084
// The thread list is a container of threads.
2087
PMINIDUMP_THREAD_LIST = ^MINIDUMP_THREAD_LIST;
2088
{$EXTERNALSYM PMINIDUMP_THREAD_LIST}
2089
_MINIDUMP_THREAD_LIST = record
2090
NumberOfThreads: ULONG32;
2091
Threads: array [0..0] of MINIDUMP_THREAD;
2093
{$EXTERNALSYM _MINIDUMP_THREAD_LIST}
2094
MINIDUMP_THREAD_LIST = _MINIDUMP_THREAD_LIST;
2095
{$EXTERNALSYM MINIDUMP_THREAD_LIST}
2096
TMinidumpThreadList = MINIDUMP_THREAD_LIST;
2097
PMinidumpThreadList = PMINIDUMP_THREAD_LIST;
2099
PMINIDUMP_THREAD_EX = ^MINIDUMP_THREAD_EX;
2100
{$EXTERNALSYM PMINIDUMP_THREAD_EX}
2101
_MINIDUMP_THREAD_EX = record
2103
SuspendCount: ULONG32;
2104
PriorityClass: ULONG32;
2107
Stack: MINIDUMP_MEMORY_DESCRIPTOR;
2108
ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2109
BackingStore: MINIDUMP_MEMORY_DESCRIPTOR;
2111
{$EXTERNALSYM _MINIDUMP_THREAD_EX}
2112
MINIDUMP_THREAD_EX = _MINIDUMP_THREAD_EX;
2113
{$EXTERNALSYM MINIDUMP_THREAD_EX}
2114
TMinidumpThreadEx = MINIDUMP_THREAD_EX;
2115
PMinidumpThreadEx = PMINIDUMP_THREAD_EX;
2118
// The thread list is a container of threads.
2121
PMINIDUMP_THREAD_EX_LIST = ^MINIDUMP_THREAD_EX_LIST;
2122
{$EXTERNALSYM PMINIDUMP_THREAD_EX_LIST}
2123
_MINIDUMP_THREAD_EX_LIST = record
2124
NumberOfThreads: ULONG32;
2125
Threads: array [0..0] of MINIDUMP_THREAD_EX;
2127
{$EXTERNALSYM _MINIDUMP_THREAD_EX_LIST}
2128
MINIDUMP_THREAD_EX_LIST = _MINIDUMP_THREAD_EX_LIST;
2129
{$EXTERNALSYM MINIDUMP_THREAD_EX_LIST}
2130
TMinidumpThreadExList = MINIDUMP_THREAD_EX_LIST;
2131
PMinidumpThreadExList = PMINIDUMP_THREAD_EX_LIST;
2134
// The MINIDUMP_EXCEPTION is the same as EXCEPTION on Win64.
2137
PMINIDUMP_EXCEPTION = ^MINIDUMP_EXCEPTION;
2138
{$EXTERNALSYM PMINIDUMP_EXCEPTION}
2139
_MINIDUMP_EXCEPTION = record
2140
ExceptionCode: ULONG32;
2141
ExceptionFlags: ULONG32;
2142
ExceptionRecord: ULONG64;
2143
ExceptionAddress: ULONG64;
2144
NumberParameters: ULONG32;
2145
__unusedAlignment: ULONG32;
2146
ExceptionInformation: array [0..EXCEPTION_MAXIMUM_PARAMETERS - 1] of ULONG64;
2148
{$EXTERNALSYM _MINIDUMP_EXCEPTION}
2149
MINIDUMP_EXCEPTION = _MINIDUMP_EXCEPTION;
2150
{$EXTERNALSYM MINIDUMP_EXCEPTION}
2151
TMinidumpException = MINIDUMP_EXCEPTION;
2152
PMinidumpException = PMINIDUMP_EXCEPTION;
2155
// The exception information stream contains the id of the thread that caused
2156
// the exception (ThreadId), the exception record for the exception
2157
// (ExceptionRecord) and an RVA to the thread context where the exception
2161
PMINIDUMP_EXCEPTION_STREAM = ^MINIDUMP_EXCEPTION_STREAM;
2162
{$EXTERNALSYM PMINIDUMP_EXCEPTION_STREAM}
2163
_MINIDUMP_EXCEPTION_STREAM = record
2165
__alignment: ULONG32;
2166
ExceptionRecord: MINIDUMP_EXCEPTION;
2167
ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2169
{$EXTERNALSYM _MINIDUMP_EXCEPTION_STREAM}
2170
MINIDUMP_EXCEPTION_STREAM = _MINIDUMP_EXCEPTION_STREAM;
2171
{$EXTERNALSYM MINIDUMP_EXCEPTION_STREAM}
2172
TMinidumpExceptionStream = MINIDUMP_EXCEPTION_STREAM;
2173
PMinidumpExceptionStream = PMINIDUMP_EXCEPTION_STREAM;
2176
// The MINIDUMP_MODULE contains information about a
2177
// a specific module. It includes the CheckSum and
2178
// the TimeDateStamp for the module so the module
2179
// can be reloaded during the analysis phase.
2182
PMINIDUMP_MODULE = ^MINIDUMP_MODULE;
2183
{$EXTERNALSYM PMINIDUMP_MODULE}
2184
_MINIDUMP_MODULE = record
2185
BaseOfImage: ULONG64;
2186
SizeOfImage: ULONG32;
2188
TimeDateStamp: ULONG32;
2190
VersionInfo: VS_FIXEDFILEINFO;
2191
CvRecord: MINIDUMP_LOCATION_DESCRIPTOR;
2192
MiscRecord: MINIDUMP_LOCATION_DESCRIPTOR;
2193
Reserved0: ULONG64; // Reserved for future use.
2194
Reserved1: ULONG64; // Reserved for future use.
2196
{$EXTERNALSYM _MINIDUMP_MODULE}
2197
MINIDUMP_MODULE = _MINIDUMP_MODULE;
2198
{$EXTERNALSYM MINIDUMP_MODULE}
2199
TMinidumpModule = MINIDUMP_MODULE;
2200
PMinidumpModule = PMINIDUMP_MODULE;
2203
// The minidump module list is a container for modules.
2206
PMINIDUMP_MODULE_LIST = ^MINIDUMP_MODULE_LIST;
2207
{$EXTERNALSYM PMINIDUMP_MODULE_LIST}
2208
_MINIDUMP_MODULE_LIST = record
2209
NumberOfModules: ULONG32;
2210
Modules: array [0..0] of MINIDUMP_MODULE;
2212
{$EXTERNALSYM _MINIDUMP_MODULE_LIST}
2213
MINIDUMP_MODULE_LIST = _MINIDUMP_MODULE_LIST;
2214
{$EXTERNALSYM MINIDUMP_MODULE_LIST}
2215
TMinidumpModuleList = MINIDUMP_MODULE_LIST;
2216
PMinidumpModuleList = PMINIDUMP_MODULE_LIST;
2222
PMINIDUMP_MEMORY_LIST = ^MINIDUMP_MEMORY_LIST;
2223
{$EXTERNALSYM PMINIDUMP_MEMORY_LIST}
2224
_MINIDUMP_MEMORY_LIST = record
2225
NumberOfMemoryRanges: ULONG32;
2226
MemoryRanges: array [0..0] of MINIDUMP_MEMORY_DESCRIPTOR;
2228
{$EXTERNALSYM _MINIDUMP_MEMORY_LIST}
2229
MINIDUMP_MEMORY_LIST = _MINIDUMP_MEMORY_LIST;
2230
{$EXTERNALSYM MINIDUMP_MEMORY_LIST}
2231
TMinidumpMemoryList = MINIDUMP_MEMORY_LIST;
2232
PMinidumpMemoryList = PMINIDUMP_MEMORY_LIST;
2234
PMINIDUMP_MEMORY64_LIST = ^MINIDUMP_MEMORY64_LIST;
2235
{$EXTERNALSYM PMINIDUMP_MEMORY64_LIST}
2236
_MINIDUMP_MEMORY64_LIST = record
2237
NumberOfMemoryRanges: ULONG64;
2239
MemoryRanges: array [0..0] of MINIDUMP_MEMORY_DESCRIPTOR64;
2241
{$EXTERNALSYM _MINIDUMP_MEMORY64_LIST}
2242
MINIDUMP_MEMORY64_LIST = _MINIDUMP_MEMORY64_LIST;
2243
{$EXTERNALSYM MINIDUMP_MEMORY64_LIST}
2244
TMinidumpMemory64List = MINIDUMP_MEMORY64_LIST;
2245
PMinidumpMemory64List = PMINIDUMP_MEMORY64_LIST;
2248
// Support for user supplied exception information.
2251
PMINIDUMP_EXCEPTION_INFORMATION = ^MINIDUMP_EXCEPTION_INFORMATION;
2252
{$EXTERNALSYM PMINIDUMP_EXCEPTION_INFORMATION}
2253
_MINIDUMP_EXCEPTION_INFORMATION = record
2255
ExceptionPointers: PEXCEPTION_POINTERS;
2256
ClientPointers: BOOL;
2258
{$EXTERNALSYM _MINIDUMP_EXCEPTION_INFORMATION}
2259
MINIDUMP_EXCEPTION_INFORMATION = _MINIDUMP_EXCEPTION_INFORMATION;
2260
{$EXTERNALSYM MINIDUMP_EXCEPTION_INFORMATION}
2261
TMinidumpExceptionInformation = MINIDUMP_EXCEPTION_INFORMATION;
2262
PMinidumpExceptionInformation = PMINIDUMP_EXCEPTION_INFORMATION;
2265
// Support for capturing system handle state at the time of the dump.
2268
PMINIDUMP_HANDLE_DESCRIPTOR = ^MINIDUMP_HANDLE_DESCRIPTOR;
2269
{$EXTERNALSYM PMINIDUMP_HANDLE_DESCRIPTOR}
2270
_MINIDUMP_HANDLE_DESCRIPTOR = record
2274
Attributes: ULONG32;
2275
GrantedAccess: ULONG32;
2276
HandleCount: ULONG32;
2277
PointerCount: ULONG32;
2279
{$EXTERNALSYM _MINIDUMP_HANDLE_DESCRIPTOR}
2280
MINIDUMP_HANDLE_DESCRIPTOR = _MINIDUMP_HANDLE_DESCRIPTOR;
2281
{$EXTERNALSYM MINIDUMP_HANDLE_DESCRIPTOR}
2282
TMinidumpHandleDescriptor = MINIDUMP_HANDLE_DESCRIPTOR;
2283
PMinidumpHandleDescriptor = PMINIDUMP_HANDLE_DESCRIPTOR;
2285
PMINIDUMP_HANDLE_DATA_STREAM = ^MINIDUMP_HANDLE_DATA_STREAM;
2286
{$EXTERNALSYM PMINIDUMP_HANDLE_DATA_STREAM}
2287
_MINIDUMP_HANDLE_DATA_STREAM = record
2288
SizeOfHeader: ULONG32;
2289
SizeOfDescriptor: ULONG32;
2290
NumberOfDescriptors: ULONG32;
2293
{$EXTERNALSYM _MINIDUMP_HANDLE_DATA_STREAM}
2294
MINIDUMP_HANDLE_DATA_STREAM = _MINIDUMP_HANDLE_DATA_STREAM;
2295
{$EXTERNALSYM MINIDUMP_HANDLE_DATA_STREAM}
2296
TMinidumpHandleDataStream = MINIDUMP_HANDLE_DATA_STREAM;
2297
PMinidumpHandleDataStream = PMINIDUMP_HANDLE_DATA_STREAM;
2300
// Support for capturing dynamic function table state at the time of the dump.
2303
PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR = ^MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2304
{$EXTERNALSYM PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2305
_MINIDUMP_FUNCTION_TABLE_DESCRIPTOR = record
2306
MinimumAddress: ULONG64;
2307
MaximumAddress: ULONG64;
2308
BaseAddress: ULONG64;
2309
EntryCount: ULONG32;
2310
SizeOfAlignPad: ULONG32;
2312
{$EXTERNALSYM _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2313
MINIDUMP_FUNCTION_TABLE_DESCRIPTOR = _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2314
{$EXTERNALSYM MINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2315
TMinidumpFunctionTableDescriptor = MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2316
PMinidumpFunctionTableDescriptor = PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2318
PMINIDUMP_FUNCTION_TABLE_STREAM = ^MINIDUMP_FUNCTION_TABLE_STREAM;
2319
{$EXTERNALSYM PMINIDUMP_FUNCTION_TABLE_STREAM}
2320
_MINIDUMP_FUNCTION_TABLE_STREAM = record
2321
SizeOfHeader: ULONG32;
2322
SizeOfDescriptor: ULONG32;
2323
SizeOfNativeDescriptor: ULONG32;
2324
SizeOfFunctionEntry: ULONG32;
2325
NumberOfDescriptors: ULONG32;
2326
SizeOfAlignPad: ULONG32;
2328
{$EXTERNALSYM _MINIDUMP_FUNCTION_TABLE_STREAM}
2329
MINIDUMP_FUNCTION_TABLE_STREAM = _MINIDUMP_FUNCTION_TABLE_STREAM;
2330
{$EXTERNALSYM MINIDUMP_FUNCTION_TABLE_STREAM}
2331
TMinidumpFunctionTableStream = MINIDUMP_FUNCTION_TABLE_STREAM;
2332
PMinidumpFunctionTableStream = PMINIDUMP_FUNCTION_TABLE_STREAM;
2335
// The MINIDUMP_UNLOADED_MODULE contains information about a
2336
// a specific module that was previously loaded but no
2337
// longer is. This can help with diagnosing problems where
2338
// callers attempt to call code that is no longer loaded.
2341
_MINIDUMP_UNLOADED_MODULE = record
2342
BaseOfImage: ULONG64;
2343
SizeOfImage: ULONG32;
2345
TimeDateStamp: ULONG32;
2348
{$EXTERNALSYM _MINIDUMP_UNLOADED_MODULE}
2349
MINIDUMP_UNLOADED_MODULE = _MINIDUMP_UNLOADED_MODULE;
2350
{$EXTERNALSYM MINIDUMP_UNLOADED_MODULE}
2351
PMINIDUMP_UNLOADED_MODULE = ^MINIDUMP_UNLOADED_MODULE;
2352
{$EXTERNALSYM PMINIDUMP_UNLOADED_MODULE}
2353
TMiniDumpUnloadedModule = MINIDUMP_UNLOADED_MODULE;
2354
PMiniDumpUnloadedModule = PMINIDUMP_UNLOADED_MODULE;
2357
// The minidump unloaded module list is a container for unloaded modules.
2360
_MINIDUMP_UNLOADED_MODULE_LIST = record
2361
SizeOfHeader: ULONG32;
2362
SizeOfEntry: ULONG32;
2363
NumberOfEntries: ULONG32;
2365
{$EXTERNALSYM _MINIDUMP_UNLOADED_MODULE_LIST}
2366
MINIDUMP_UNLOADED_MODULE_LIST = _MINIDUMP_UNLOADED_MODULE_LIST;
2367
{$EXTERNALSYM MINIDUMP_UNLOADED_MODULE_LIST}
2368
PMINIDUMP_UNLOADED_MODULE_LIST = ^MINIDUMP_UNLOADED_MODULE_LIST;
2369
{$EXTERNALSYM PMINIDUMP_UNLOADED_MODULE_LIST}
2370
TMiniDumpUnloadedModuleList = MINIDUMP_UNLOADED_MODULE_LIST;
2371
PMiniDumpUnloadedModuleList = PMINIDUMP_UNLOADED_MODULE_LIST;
2374
// The miscellaneous information stream contains a variety
2375
// of small pieces of information. A member is valid if
2376
// it's within the available size and its corresponding
2381
MINIDUMP_MISC1_PROCESS_ID = $00000001;
2382
{$EXTERNALSYM MINIDUMP_MISC1_PROCESS_ID}
2383
MINIDUMP_MISC1_PROCESS_TIMES = $00000002;
2384
{$EXTERNALSYM MINIDUMP_MISC1_PROCESS_TIMES}
2387
_MINIDUMP_MISC_INFO = record
2388
SizeOfInfo: ULONG32;
2391
ProcessCreateTime: ULONG32;
2392
ProcessUserTime: ULONG32;
2393
ProcessKernelTime: ULONG32;
2395
{$EXTERNALSYM _MINIDUMP_MISC_INFO}
2396
MINIDUMP_MISC_INFO = _MINIDUMP_MISC_INFO;
2397
{$EXTERNALSYM MINIDUMP_MISC_INFO}
2398
PMINIDUMP_MISC_INFO = ^MINIDUMP_MISC_INFO;
2399
{$EXTERNALSYM PMINIDUMP_MISC_INFO}
2400
TMiniDumpMiscInfo = MINIDUMP_MISC_INFO;
2401
PMiniDumpMiscInfo = PMINIDUMP_MISC_INFO;
2404
// Support for arbitrary user-defined information.
2407
PMINIDUMP_USER_RECORD = ^MINIDUMP_USER_RECORD;
2408
{$EXTERNALSYM PMINIDUMP_USER_RECORD}
2409
_MINIDUMP_USER_RECORD = record
2411
Memory: MINIDUMP_LOCATION_DESCRIPTOR;
2413
{$EXTERNALSYM _MINIDUMP_USER_RECORD}
2414
MINIDUMP_USER_RECORD = _MINIDUMP_USER_RECORD;
2415
{$EXTERNALSYM MINIDUMP_USER_RECORD}
2416
TMinidumpUserRecord = MINIDUMP_USER_RECORD;
2417
PMinidumpUserRecord = PMINIDUMP_USER_RECORD;
2419
PMINIDUMP_USER_STREAM = ^MINIDUMP_USER_STREAM;
2420
{$EXTERNALSYM PMINIDUMP_USER_STREAM}
2421
_MINIDUMP_USER_STREAM = record
2426
{$EXTERNALSYM _MINIDUMP_USER_STREAM}
2427
MINIDUMP_USER_STREAM = _MINIDUMP_USER_STREAM;
2428
{$EXTERNALSYM MINIDUMP_USER_STREAM}
2429
TMinidumpUserStream = MINIDUMP_USER_STREAM;
2430
PMinidumpUserStream = PMINIDUMP_USER_STREAM;
2432
PMINIDUMP_USER_STREAM_INFORMATION = ^MINIDUMP_USER_STREAM_INFORMATION;
2433
{$EXTERNALSYM PMINIDUMP_USER_STREAM_INFORMATION}
2434
_MINIDUMP_USER_STREAM_INFORMATION = record
2435
UserStreamCount: ULONG;
2436
UserStreamArray: PMINIDUMP_USER_STREAM;
2438
{$EXTERNALSYM _MINIDUMP_USER_STREAM_INFORMATION}
2439
MINIDUMP_USER_STREAM_INFORMATION = _MINIDUMP_USER_STREAM_INFORMATION;
2440
{$EXTERNALSYM MINIDUMP_USER_STREAM_INFORMATION}
2441
TMinidumpUserStreamInformation = MINIDUMP_USER_STREAM_INFORMATION;
2442
PMinidumpUserStreamInformation = PMINIDUMP_USER_STREAM_INFORMATION;
2445
// Callback support.
2448
_MINIDUMP_CALLBACK_TYPE = (
2452
IncludeThreadCallback,
2453
IncludeModuleCallback);
2454
{$EXTERNALSYM _MINIDUMP_CALLBACK_TYPE}
2455
MINIDUMP_CALLBACK_TYPE = _MINIDUMP_CALLBACK_TYPE;
2456
{$EXTERNALSYM MINIDUMP_CALLBACK_TYPE}
2457
TMinidumpCallbackType = MINIDUMP_CALLBACK_TYPE;
2459
PMINIDUMP_THREAD_CALLBACK = ^MINIDUMP_THREAD_CALLBACK;
2460
{$EXTERNALSYM PMINIDUMP_THREAD_CALLBACK}
2461
_MINIDUMP_THREAD_CALLBACK = record
2463
ThreadHandle: HANDLE;
2465
SizeOfContext: ULONG;
2469
{$EXTERNALSYM _MINIDUMP_THREAD_CALLBACK}
2470
MINIDUMP_THREAD_CALLBACK = _MINIDUMP_THREAD_CALLBACK;
2471
{$EXTERNALSYM MINIDUMP_THREAD_CALLBACK}
2472
TMinidumpThreadCallback = MINIDUMP_THREAD_CALLBACK;
2473
PMinidumpThreadCallback = PMINIDUMP_THREAD_CALLBACK;
2475
PMINIDUMP_THREAD_EX_CALLBACK = ^MINIDUMP_THREAD_EX_CALLBACK;
2476
{$EXTERNALSYM PMINIDUMP_THREAD_EX_CALLBACK}
2477
_MINIDUMP_THREAD_EX_CALLBACK = record
2479
ThreadHandle: HANDLE;
2481
SizeOfContext: ULONG;
2484
BackingStoreBase: ULONG64;
2485
BackingStoreEnd: ULONG64;
2487
{$EXTERNALSYM _MINIDUMP_THREAD_EX_CALLBACK}
2488
MINIDUMP_THREAD_EX_CALLBACK = _MINIDUMP_THREAD_EX_CALLBACK;
2489
{$EXTERNALSYM MINIDUMP_THREAD_EX_CALLBACK}
2490
TMinidumpThreadExCallback = MINIDUMP_THREAD_EX_CALLBACK;
2491
PMinidumpThreadExCallback = PMINIDUMP_THREAD_EX_CALLBACK;
2493
PMINIDUMP_INCLUDE_THREAD_CALLBACK = ^MINIDUMP_INCLUDE_THREAD_CALLBACK;
2494
{$EXTERNALSYM PMINIDUMP_INCLUDE_THREAD_CALLBACK}
2495
_MINIDUMP_INCLUDE_THREAD_CALLBACK = record
2498
{$EXTERNALSYM _MINIDUMP_INCLUDE_THREAD_CALLBACK}
2499
MINIDUMP_INCLUDE_THREAD_CALLBACK = _MINIDUMP_INCLUDE_THREAD_CALLBACK;
2500
{$EXTERNALSYM MINIDUMP_INCLUDE_THREAD_CALLBACK}
2501
TMinidumpIncludeThreadCallback = MINIDUMP_INCLUDE_THREAD_CALLBACK;
2502
PMinidumpIncludeThreadCallback = PMINIDUMP_INCLUDE_THREAD_CALLBACK;
2505
ThreadWriteThread = $0001;
2506
{$EXTERNALSYM ThreadWriteThread}
2507
ThreadWriteStack = $0002;
2508
{$EXTERNALSYM ThreadWriteStack}
2509
ThreadWriteContext = $0004;
2510
{$EXTERNALSYM ThreadWriteContext}
2511
ThreadWriteBackingStore = $0008;
2512
{$EXTERNALSYM ThreadWriteBackingStore}
2513
ThreadWriteInstructionWindow = $0010;
2514
{$EXTERNALSYM ThreadWriteInstructionWindow}
2515
ThreadWriteThreadData = $0020;
2516
{$EXTERNALSYM ThreadWriteThreadData}
2519
_THREAD_WRITE_FLAGS = DWORD;
2520
{$EXTERNALSYM _THREAD_WRITE_FLAGS}
2521
THREAD_WRITE_FLAGS = _THREAD_WRITE_FLAGS;
2522
{$EXTERNALSYM THREAD_WRITE_FLAGS}
2523
TThreadWriteFlags = THREAD_WRITE_FLAGS;
2526
PMINIDUMP_MODULE_CALLBACK = ^MINIDUMP_MODULE_CALLBACK;
2527
{$EXTERNALSYM PMINIDUMP_MODULE_CALLBACK}
2528
_MINIDUMP_MODULE_CALLBACK = record
2530
BaseOfImage: ULONG64;
2533
TimeDateStamp: ULONG;
2534
VersionInfo: VS_FIXEDFILEINFO;
2536
SizeOfCvRecord: ULONG;
2538
SizeOfMiscRecord: ULONG;
2540
{$EXTERNALSYM _MINIDUMP_MODULE_CALLBACK}
2541
MINIDUMP_MODULE_CALLBACK = _MINIDUMP_MODULE_CALLBACK;
2542
{$EXTERNALSYM MINIDUMP_MODULE_CALLBACK}
2543
TMinidumpModuleCallback = MINIDUMP_MODULE_CALLBACK;
2544
PMinidumpModuleCallback = PMINIDUMP_MODULE_CALLBACK;
2546
PMINIDUMP_INCLUDE_MODULE_CALLBACK = ^MINIDUMP_INCLUDE_MODULE_CALLBACK;
2547
{$EXTERNALSYM PMINIDUMP_INCLUDE_MODULE_CALLBACK}
2548
_MINIDUMP_INCLUDE_MODULE_CALLBACK = record
2549
BaseOfImage: ULONG64;
2551
{$EXTERNALSYM _MINIDUMP_INCLUDE_MODULE_CALLBACK}
2552
MINIDUMP_INCLUDE_MODULE_CALLBACK = _MINIDUMP_INCLUDE_MODULE_CALLBACK;
2553
{$EXTERNALSYM MINIDUMP_INCLUDE_MODULE_CALLBACK}
2554
TMinidumpIncludeModuleCallback = MINIDUMP_INCLUDE_MODULE_CALLBACK;
2555
PMinidumpIncludeModuleCallback = PMINIDUMP_INCLUDE_MODULE_CALLBACK;
2558
ModuleWriteModule = $0001;
2559
{$EXTERNALSYM ModuleWriteModule}
2560
ModuleWriteDataSeg = $0002;
2561
{$EXTERNALSYM ModuleWriteDataSeg}
2562
ModuleWriteMiscRecord = $0004;
2563
{$EXTERNALSYM ModuleWriteMiscRecord}
2564
ModuleWriteCvRecord = $0008;
2565
{$EXTERNALSYM ModuleWriteCvRecord}
2566
ModuleReferencedByMemory = $0010;
2567
{$EXTERNALSYM ModuleReferencedByMemory}
2570
_MODULE_WRITE_FLAGS = DWORD;
2571
{$EXTERNALSYM _MODULE_WRITE_FLAGS}
2572
MODULE_WRITE_FLAGS = _MODULE_WRITE_FLAGS;
2573
{$EXTERNALSYM MODULE_WRITE_FLAGS}
2574
TModuleWriteFlags = MODULE_WRITE_FLAGS;
2576
_MINIDUMP_CALLBACK_INPUT = record
2578
ProcessHandle: HANDLE;
2579
CallbackType: ULONG;
2581
0: (Thread: MINIDUMP_THREAD_CALLBACK);
2582
1: (ThreadEx: MINIDUMP_THREAD_EX_CALLBACK);
2583
2: (Module: MINIDUMP_MODULE_CALLBACK);
2584
3: (IncludeThread: MINIDUMP_INCLUDE_THREAD_CALLBACK);
2585
4: (IncludeModule: MINIDUMP_INCLUDE_MODULE_CALLBACK);
2587
{$EXTERNALSYM _MINIDUMP_CALLBACK_INPUT}
2588
MINIDUMP_CALLBACK_INPUT = _MINIDUMP_CALLBACK_INPUT;
2589
{$EXTERNALSYM MINIDUMP_CALLBACK_INPUT}
2590
PMINIDUMP_CALLBACK_INPUT = ^MINIDUMP_CALLBACK_INPUT;
2591
{$EXTERNALSYM PMINIDUMP_CALLBACK_INPUT}
2592
TminidumpCallbackInput = MINIDUMP_CALLBACK_INPUT;
2594
PMINIDUMP_CALLBACK_OUTPUT = ^MINIDUMP_CALLBACK_OUTPUT;
2595
{$EXTERNALSYM PMINIDUMP_CALLBACK_OUTPUT}
2596
_MINIDUMP_CALLBACK_OUTPUT = record
2598
0: (ModuleWriteFlags: ULONG);
2599
1: (ThreadWriteFlags: ULONG);
2601
{$EXTERNALSYM _MINIDUMP_CALLBACK_OUTPUT}
2602
MINIDUMP_CALLBACK_OUTPUT = _MINIDUMP_CALLBACK_OUTPUT;
2603
{$EXTERNALSYM MINIDUMP_CALLBACK_OUTPUT}
2604
TMinidumpCallbackOutput = MINIDUMP_CALLBACK_OUTPUT;
2605
PMinidumpCallbackOutput = PMINIDUMP_CALLBACK_OUTPUT;
2608
// A normal minidump contains just the information
2609
// necessary to capture stack traces for all of the
2610
// existing threads in a process.
2612
// A minidump with data segments includes all of the data
2613
// sections from loaded modules in order to capture
2614
// global variable contents. This can make the dump much
2615
// larger if many modules have global data.
2617
// A minidump with full memory includes all of the accessible
2618
// memory in the process and can be very large. A minidump
2619
// with full memory always has the raw memory data at the end
2620
// of the dump so that the initial structures in the dump can
2621
// be mapped directly without having to include the raw
2622
// memory information.
2624
// Stack and backing store memory can be filtered to remove
2625
// data unnecessary for stack walking. This can improve
2626
// compression of stacks and also deletes data that may
2627
// be private and should not be stored in a dump.
2628
// Memory can also be scanned to see what modules are
2629
// referenced by stack and backing store memory to allow
2630
// omission of other modules to reduce dump size.
2631
// In either of these modes the ModuleReferencedByMemory flag
2632
// is set for all modules referenced before the base
2633
// module callbacks occur.
2635
// On some operating systems a list of modules that were
2636
// recently unloaded is kept in addition to the currently
2637
// loaded module list. This information can be saved in
2638
// the dump if desired.
2640
// Stack and backing store memory can be scanned for referenced
2641
// pages in order to pick up data referenced by locals or other
2642
// stack memory. This can increase the size of a dump significantly.
2644
// Module paths may contain undesired information such as user names
2645
// or other important directory names so they can be stripped. This
2646
// option reduces the ability to locate the proper image later
2647
// and should only be used in certain situations.
2649
// Complete operating system per-process and per-thread information can
2650
// be gathered and stored in the dump.
2652
// The virtual address space can be scanned for various types
2653
// of memory to be included in the dump.
2657
MiniDumpNormal = $0000;
2658
{$EXTERNALSYM MiniDumpNormal}
2659
MiniDumpWithDataSegs = $0001;
2660
{$EXTERNALSYM MiniDumpWithDataSegs}
2661
MiniDumpWithFullMemory = $0002;
2662
{$EXTERNALSYM MiniDumpWithFullMemory}
2663
MiniDumpWithHandleData = $0004;
2664
{$EXTERNALSYM MiniDumpWithHandleData}
2665
MiniDumpFilterMemory = $0008;
2666
{$EXTERNALSYM MiniDumpFilterMemory}
2667
MiniDumpScanMemory = $0010;
2668
{$EXTERNALSYM MiniDumpScanMemory}
2669
MiniDumpWithUnloadedModules = $0020;
2670
{$EXTERNALSYM MiniDumpWithUnloadedModules}
2671
MiniDumpWithIndirectlyReferencedMemory = $0040;
2672
{$EXTERNALSYM MiniDumpWithIndirectlyReferencedMemory}
2673
MiniDumpFilterModulePaths = $0080;
2674
{$EXTERNALSYM MiniDumpFilterModulePaths}
2675
MiniDumpWithProcessThreadData = $0100;
2676
{$EXTERNALSYM MiniDumpWithProcessThreadData}
2677
MiniDumpWithPrivateReadWriteMemory = $0200;
2678
{$EXTERNALSYM MiniDumpWithPrivateReadWriteMemory}
2681
_MINIDUMP_TYPE = DWORD;
2682
{$EXTERNALSYM _MINIDUMP_TYPE}
2683
MINIDUMP_TYPE = _MINIDUMP_TYPE;
2684
{$EXTERNALSYM MINIDUMP_TYPE}
2685
TMinidumpType = MINIDUMP_TYPE;
2688
// The minidump callback should modify the FieldsToWrite parameter to reflect
2689
// what portions of the specified thread or module should be written to the
2693
MINIDUMP_CALLBACK_ROUTINE = function(CallbackParam: PVOID; CallbackInput: PMINIDUMP_CALLBACK_INPUT;
2694
CallbackOutput: PMINIDUMP_CALLBACK_OUTPUT): BOOL; stdcall;
2695
{$EXTERNALSYM MINIDUMP_CALLBACK_ROUTINE}
2696
TMinidumpCallbackRoutine = MINIDUMP_CALLBACK_ROUTINE;
2698
PMINIDUMP_CALLBACK_INFORMATION = ^MINIDUMP_CALLBACK_INFORMATION;
2699
{$EXTERNALSYM PMINIDUMP_CALLBACK_INFORMATION}
2700
_MINIDUMP_CALLBACK_INFORMATION = record
2701
CallbackRoutine: MINIDUMP_CALLBACK_ROUTINE;
2702
CallbackParam: PVOID;
2704
{$EXTERNALSYM _MINIDUMP_CALLBACK_INFORMATION}
2705
MINIDUMP_CALLBACK_INFORMATION = _MINIDUMP_CALLBACK_INFORMATION;
2706
{$EXTERNALSYM MINIDUMP_CALLBACK_INFORMATION}
2707
TMinidumpCallbackInformation = MINIDUMP_CALLBACK_INFORMATION;
2708
PMinidumpCallbackInformation = PMINIDUMP_CALLBACK_INFORMATION;
2718
// Routine Description:
2720
// Map an RVA that is contained within a mapped file to it's associated
2725
// Mapping - Base address of mapped file containing the RVA.
2727
// Rva - An Rva to fixup.
2731
// A pointer to the desired data.
2735
function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
2736
{$EXTERNALSYM RVA_TO_ADDR}
2738
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;
2739
{$EXTERNALSYM MiniDumpWriteDump}
2741
function MiniDumpReadDumpStream(BaseOfDump: PVOID; StreamNumber: ULONG; var Dir: PMINIDUMP_DIRECTORY; var StreamPointer: PVOID; var StreamSize: ULONG): BOOL; stdcall;
2742
{$EXTERNALSYM MiniDumpReadDumpStream}
2747
ImageHlpLib = 'imagehlp.dll';
2754
procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
2756
a64^.Offset := {ULONG64(LONG64(LONG(}a32^.Offset{)))};
2757
a64^.Segment := a32^.Segment;
2758
a64^.Mode := a32^.Mode;
2761
procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
2763
a32^.Offset := ULONG(a64^.Offset);
2764
a32^.Segment := a64^.Segment;
2765
a32^.Mode := a64^.Mode;
2768
procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
2770
p64^.Thread := p32^.Thread;
2771
p64^.ThCallbackStack := p32^.ThCallbackStack;
2772
p64^.NextCallback := p32^.NextCallback;
2773
p64^.FramePointer := p32^.FramePointer;
2774
p64^.KiCallUserMode := p32^.KiCallUserMode;
2775
p64^.KeUserCallbackDispatcher := p32^.KeUserCallbackDispatcher;
2776
p64^.SystemRangeStart := p32^.SystemRangeStart;
2779
function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
2781
Result := Pointer(Cardinal(Mapping) + Cardinal(Rva));
2784
{$IFDEF DYNAMIC_LINK}
2787
_BindImage: Pointer;
2791
GetProcedureAddress(_BindImage, ImageHlpLib, 'BindImage');
2800
_BindImageEx: Pointer;
2802
function BindImageEx;
2804
GetProcedureAddress(_BindImageEx, ImageHlpLib, 'BindImageEx');
2813
_ReBaseImage: Pointer;
2815
function ReBaseImage;
2817
GetProcedureAddress(_ReBaseImage, ImageHlpLib, 'ReBaseImage');
2826
_ReBaseImage64: Pointer;
2828
function ReBaseImage64;
2830
GetProcedureAddress(_ReBaseImage64, ImageHlpLib, 'ReBaseImage64');
2834
JMP [_ReBaseImage64]
2839
_CheckSumMappedFile: Pointer;
2841
function CheckSumMappedFile;
2843
GetProcedureAddress(_CheckSumMappedFile, ImageHlpLib, 'CheckSumMappedFile');
2847
JMP [_CheckSumMappedFile]
2852
_MapFileAndCheckSumA: Pointer;
2854
function MapFileAndCheckSumA;
2856
GetProcedureAddress(_MapFileAndCheckSumA, ImageHlpLib, 'MapFileAndCheckSumA');
2860
JMP [_MapFileAndCheckSumA]
2865
_MapFileAndCheckSumW: Pointer;
2867
function MapFileAndCheckSumW;
2869
GetProcedureAddress(_MapFileAndCheckSumW, ImageHlpLib, 'MapFileAndCheckSumW');
2873
JMP [_MapFileAndCheckSumW]
2878
_MapFileAndCheckSum: Pointer;
2880
function MapFileAndCheckSum;
2882
GetProcedureAddress(_MapFileAndCheckSum, ImageHlpLib, 'MapFileAndCheckSum' + AWSuffix);
2886
JMP [_MapFileAndCheckSum]
2891
_GetImageConfigInformation: Pointer;
2893
function GetImageConfigInformation;
2895
GetProcedureAddress(_GetImageConfigInformation, ImageHlpLib, 'GetImageConfigInformation');
2899
JMP [_GetImageConfigInformation]
2904
_GetImageUnusedHeaderBytes: Pointer;
2906
function GetImageUnusedHeaderBytes;
2908
GetProcedureAddress(_GetImageUnusedHeaderBytes, ImageHlpLib, 'GetImageUnusedHeaderBytes');
2912
JMP [_GetImageUnusedHeaderBytes]
2917
_SetImageConfigInformation: Pointer;
2919
function SetImageConfigInformation;
2921
GetProcedureAddress(_SetImageConfigInformation, ImageHlpLib, 'SetImageConfigInformation');
2925
JMP [_SetImageConfigInformation]
2930
_ImageGetDigestStream: Pointer;
2932
function ImageGetDigestStream;
2934
GetProcedureAddress(_ImageGetDigestStream, ImageHlpLib, 'ImageGetDigestStream');
2938
JMP [_ImageGetDigestStream]
2943
_ImageAddCertificate: Pointer;
2945
function ImageAddCertificate;
2947
GetProcedureAddress(_ImageAddCertificate, ImageHlpLib, 'ImageAddCertificate');
2951
JMP [_ImageAddCertificate]
2956
_ImageRemoveCertificate: Pointer;
2958
function ImageRemoveCertificate;
2960
GetProcedureAddress(_ImageRemoveCertificate, ImageHlpLib, 'ImageRemoveCertificate');
2964
JMP [_ImageRemoveCertificate]
2969
_ImageEnumerateCertificates: Pointer;
2971
function ImageEnumerateCertificates;
2973
GetProcedureAddress(_ImageEnumerateCertificates, ImageHlpLib, 'ImageEnumerateCertificates');
2977
JMP [_ImageEnumerateCertificates]
2982
_ImageGetCertificateData: Pointer;
2984
function ImageGetCertificateData;
2986
GetProcedureAddress(_ImageGetCertificateData, ImageHlpLib, 'ImageGetCertificateData');
2990
JMP [_ImageGetCertificateData]
2995
_ImageGetCertificateHeader: Pointer;
2997
function ImageGetCertificateHeader;
2999
GetProcedureAddress(_ImageGetCertificateHeader, ImageHlpLib, 'ImageGetCertificateHeader');
3003
JMP [_ImageGetCertificateHeader]
3008
_ImageLoad: Pointer;
3012
GetProcedureAddress(_ImageLoad, ImageHlpLib, 'ImageLoad');
3021
_ImageUnload: Pointer;
3023
function ImageUnload;
3025
GetProcedureAddress(_ImageUnload, ImageHlpLib, 'ImageUnload');
3034
_MapAndLoad: Pointer;
3036
function MapAndLoad;
3038
GetProcedureAddress(_MapAndLoad, ImageHlpLib, 'MapAndLoad');
3047
_UnMapAndLoad: Pointer;
3049
function UnMapAndLoad;
3051
GetProcedureAddress(_UnMapAndLoad, ImageHlpLib, 'UnMapAndLoad');
3060
_TouchFileTimes: Pointer;
3062
function TouchFileTimes;
3064
GetProcedureAddress(_TouchFileTimes, ImageHlpLib, 'TouchFileTimes');
3068
JMP [_TouchFileTimes]
3073
_SplitSymbols: Pointer;
3075
function SplitSymbols;
3077
GetProcedureAddress(_SplitSymbols, ImageHlpLib, 'SplitSymbols');
3086
_UpdateDebugInfoFile: Pointer;
3088
function UpdateDebugInfoFile;
3090
GetProcedureAddress(_UpdateDebugInfoFile, ImageHlpLib, 'UpdateDebugInfoFile');
3094
JMP [_UpdateDebugInfoFile]
3099
_UpdateDebugInfoFileEx: Pointer;
3101
function UpdateDebugInfoFileEx;
3103
GetProcedureAddress(_UpdateDebugInfoFileEx, ImageHlpLib, 'UpdateDebugInfoFileEx');
3107
JMP [_UpdateDebugInfoFileEx]
3112
_FindDebugInfoFile: Pointer;
3114
function FindDebugInfoFile;
3116
GetProcedureAddress(_FindDebugInfoFile, ImageHlpLib, 'FindDebugInfoFile');
3120
JMP [_FindDebugInfoFile]
3125
_FindDebugInfoFileEx: Pointer;
3127
function FindDebugInfoFileEx;
3129
GetProcedureAddress(_FindDebugInfoFileEx, ImageHlpLib, 'FindDebugInfoFileEx');
3133
JMP [_FindDebugInfoFileEx]
3138
_SymFindFileInPath: Pointer;
3140
function SymFindFileInPath;
3142
GetProcedureAddress(_SymFindFileInPath, ImageHlpLib, 'SymFindFileInPath');
3146
JMP [_SymFindFileInPath]
3151
_FindExecutableImage: Pointer;
3153
function FindExecutableImage;
3155
GetProcedureAddress(_FindExecutableImage, ImageHlpLib, 'FindExecutableImage');
3159
JMP [_FindExecutableImage]
3164
_FindExecutableImageEx: Pointer;
3166
function FindExecutableImageEx;
3168
GetProcedureAddress(_FindExecutableImageEx, ImageHlpLib, 'FindExecutableImageEx');
3172
JMP [_FindExecutableImageEx]
3177
_ImageNtHeader: Pointer;
3179
function ImageNtHeader;
3181
GetProcedureAddress(_ImageNtHeader, ImageHlpLib, 'ImageNtHeader');
3185
JMP [_ImageNtHeader]
3190
_ImageDirectoryEntryToDataEx: Pointer;
3192
function ImageDirectoryEntryToDataEx;
3194
GetProcedureAddress(_ImageDirectoryEntryToDataEx, ImageHlpLib, 'ImageDirectoryEntryToDataEx');
3198
JMP [_ImageDirectoryEntryToDataEx]
3203
_ImageDirectoryEntryToData: Pointer;
3205
function ImageDirectoryEntryToData;
3207
GetProcedureAddress(_ImageDirectoryEntryToData, ImageHlpLib, 'ImageDirectoryEntryToData');
3211
JMP [_ImageDirectoryEntryToData]
3216
_ImageRvaToSection: Pointer;
3218
function ImageRvaToSection;
3220
GetProcedureAddress(_ImageRvaToSection, ImageHlpLib, 'ImageRvaToSection');
3224
JMP [_ImageRvaToSection]
3229
_ImageRvaToVa: Pointer;
3231
function ImageRvaToVa;
3233
GetProcedureAddress(_ImageRvaToVa, ImageHlpLib, 'ImageRvaToVa');
3242
_MapDebugInformation: Pointer;
3244
function MapDebugInformation;
3246
GetProcedureAddress(_MapDebugInformation, ImageHlpLib, 'MapDebugInformation');
3250
JMP [_MapDebugInformation]
3255
_UnmapDebugInformation: Pointer;
3257
function UnmapDebugInformation;
3259
GetProcedureAddress(_UnmapDebugInformation, ImageHlpLib, 'UnmapDebugInformation');
3263
JMP [_UnmapDebugInformation]
3268
_SearchTreeForFile: Pointer;
3270
function SearchTreeForFile;
3272
GetProcedureAddress(_SearchTreeForFile, ImageHlpLib, 'SearchTreeForFile');
3276
JMP [_SearchTreeForFile]
3281
_EnumDirTree: Pointer;
3283
function EnumDirTree;
3285
GetProcedureAddress(_EnumDirTree, ImageHlpLib, 'EnumDirTree');
3294
_MakeSureDirectoryPathExists: Pointer;
3296
function MakeSureDirectoryPathExists;
3298
GetProcedureAddress(_MakeSureDirectoryPathExists, ImageHlpLib, 'MakeSureDirectoryPathExists');
3302
JMP [_MakeSureDirectoryPathExists]
3307
_UnDecorateSymbolName: Pointer;
3309
function UnDecorateSymbolName;
3311
GetProcedureAddress(_UnDecorateSymbolName, ImageHlpLib, 'UnDecorateSymbolName');
3315
JMP [_UnDecorateSymbolName]
3320
_StackWalk64: Pointer;
3322
function StackWalk64;
3324
GetProcedureAddress(_StackWalk64, ImageHlpLib, 'StackWalk64');
3333
_StackWalk: Pointer;
3337
GetProcedureAddress(_StackWalk, ImageHlpLib, 'StackWalk');
3346
_ImagehlpApiVersion: Pointer;
3348
function ImagehlpApiVersion;
3350
GetProcedureAddress(_ImagehlpApiVersion, ImageHlpLib, 'ImagehlpApiVersion');
3354
JMP [_ImagehlpApiVersion]
3359
_ImagehlpApiVersionEx: Pointer;
3361
function ImagehlpApiVersionEx;
3363
GetProcedureAddress(_ImagehlpApiVersionEx, ImageHlpLib, 'ImagehlpApiVersionEx');
3367
JMP [_ImagehlpApiVersionEx]
3372
_GetTimestampForLoadedLibrary: Pointer;
3374
function GetTimestampForLoadedLibrary;
3376
GetProcedureAddress(_GetTimestampForLoadedLibrary, ImageHlpLib, 'GetTimestampForLoadedLibrary');
3380
JMP [_GetTimestampForLoadedLibrary]
3385
_SymSetOptions: Pointer;
3387
function SymSetOptions;
3389
GetProcedureAddress(_SymSetOptions, ImageHlpLib, 'SymSetOptions');
3393
JMP [_SymSetOptions]
3398
_SymGetOptions: Pointer;
3400
function SymGetOptions;
3402
GetProcedureAddress(_SymGetOptions, ImageHlpLib, 'SymGetOptions');
3406
JMP [_SymGetOptions]
3411
_SymCleanup: Pointer;
3413
function SymCleanup;
3415
GetProcedureAddress(_SymCleanup, ImageHlpLib, 'SymCleanup');
3424
_SymMatchString: Pointer;
3426
function SymMatchString;
3428
GetProcedureAddress(_SymMatchString, ImageHlpLib, 'SymMatchString');
3432
JMP [_SymMatchString]
3437
_SymEnumSourceFiles: Pointer;
3439
function SymEnumSourceFiles;
3441
GetProcedureAddress(_SymEnumSourceFiles, ImageHlpLib, 'SymEnumSourceFiles');
3445
JMP [_SymEnumSourceFiles]
3450
_SymEnumerateModules64: Pointer;
3452
function SymEnumerateModules64;
3454
GetProcedureAddress(_SymEnumerateModules64, ImageHlpLib, 'SymEnumerateModules64');
3458
JMP [_SymEnumerateModules64]
3463
_SymEnumerateModules: Pointer;
3465
function SymEnumerateModules;
3467
GetProcedureAddress(_SymEnumerateModules, ImageHlpLib, 'SymEnumerateModules');
3471
JMP [_SymEnumerateModules]
3476
_SymEnumerateSymbols64: Pointer;
3478
function SymEnumerateSymbols64;
3480
GetProcedureAddress(_SymEnumerateSymbols64, ImageHlpLib, 'SymEnumerateSymbols64');
3484
JMP [_SymEnumerateSymbols64]
3489
_SymEnumerateSymbolsW64: Pointer;
3491
function SymEnumerateSymbolsW64;
3493
GetProcedureAddress(_SymEnumerateSymbolsW64, ImageHlpLib, 'SymEnumerateSymbolsW64');
3497
JMP [_SymEnumerateSymbolsW64]
3502
_SymEnumerateSymbols: Pointer;
3504
function SymEnumerateSymbols;
3506
GetProcedureAddress(_SymEnumerateSymbols, ImageHlpLib, 'SymEnumerateSymbols');
3510
JMP [_SymEnumerateSymbols]
3515
_SymEnumerateSymbolsW: Pointer;
3517
function SymEnumerateSymbolsW;
3519
GetProcedureAddress(_SymEnumerateSymbolsW, ImageHlpLib, 'SymEnumerateSymbolsW');
3523
JMP [_SymEnumerateSymbolsW]
3528
_EnumerateLoadedModules64: Pointer;
3530
function EnumerateLoadedModules64;
3532
GetProcedureAddress(_EnumerateLoadedModules64, ImageHlpLib, 'EnumerateLoadedModules64');
3536
JMP [_EnumerateLoadedModules64]
3541
_EnumerateLoadedModules: Pointer;
3543
function EnumerateLoadedModules;
3545
GetProcedureAddress(_EnumerateLoadedModules, ImageHlpLib, 'EnumerateLoadedModules');
3549
JMP [_EnumerateLoadedModules]
3554
_SymFunctionTableAccess64: Pointer;
3556
function SymFunctionTableAccess64;
3558
GetProcedureAddress(_SymFunctionTableAccess64, ImageHlpLib, 'SymFunctionTableAccess64');
3562
JMP [_SymFunctionTableAccess64]
3567
_SymFunctionTableAccess: Pointer;
3569
function SymFunctionTableAccess;
3571
GetProcedureAddress(_SymFunctionTableAccess, ImageHlpLib, 'SymFunctionTableAccess');
3575
JMP [_SymFunctionTableAccess]
3580
_SymGetModuleInfo64: Pointer;
3582
function SymGetModuleInfo64;
3584
GetProcedureAddress(_SymGetModuleInfo64, ImageHlpLib, 'SymGetModuleInfo64');
3588
JMP [_SymGetModuleInfo64]
3593
_SymGetModuleInfoW64: Pointer;
3595
function SymGetModuleInfoW64;
3597
GetProcedureAddress(_SymGetModuleInfoW64, ImageHlpLib, 'SymGetModuleInfoW64');
3601
JMP [_SymGetModuleInfoW64]
3606
_SymGetModuleInfo: Pointer;
3608
function SymGetModuleInfo;
3610
GetProcedureAddress(_SymGetModuleInfo, ImageHlpLib, 'SymGetModuleInfo');
3614
JMP [_SymGetModuleInfo]
3619
_SymGetModuleInfoW: Pointer;
3621
function SymGetModuleInfoW;
3623
GetProcedureAddress(_SymGetModuleInfoW, ImageHlpLib, 'SymGetModuleInfoW');
3627
JMP [_SymGetModuleInfoW]
3632
_SymGetModuleBase64: Pointer;
3634
function SymGetModuleBase64;
3636
GetProcedureAddress(_SymGetModuleBase64, ImageHlpLib, 'SymGetModuleBase64');
3640
JMP [_SymGetModuleBase64]
3645
_SymGetModuleBase: Pointer;
3647
function SymGetModuleBase;
3649
GetProcedureAddress(_SymGetModuleBase, ImageHlpLib, 'SymGetModuleBase');
3653
JMP [_SymGetModuleBase]
3658
_SymGetSymNext64: Pointer;
3660
function SymGetSymNext64;
3662
GetProcedureAddress(_SymGetSymNext64, ImageHlpLib, 'SymGetSymNext64');
3666
JMP [_SymGetSymNext64]
3671
_SymGetSymNext: Pointer;
3673
function SymGetSymNext;
3675
GetProcedureAddress(_SymGetSymNext, ImageHlpLib, 'SymGetSymNext');
3679
JMP [_SymGetSymNext]
3684
_SymGetSymPrev64: Pointer;
3686
function SymGetSymPrev64;
3688
GetProcedureAddress(_SymGetSymPrev64, ImageHlpLib, 'SymGetSymPrev64');
3692
JMP [_SymGetSymPrev64]
3697
_SymGetSymPrev: Pointer;
3699
function SymGetSymPrev;
3701
GetProcedureAddress(_SymGetSymPrev, ImageHlpLib, 'SymGetSymPrev');
3705
JMP [_SymGetSymPrev]
3710
_SymGetLineFromAddr64: Pointer;
3712
function SymGetLineFromAddr64;
3714
GetProcedureAddress(_SymGetLineFromAddr64, ImageHlpLib, 'SymGetLineFromAddr64');
3718
JMP [_SymGetLineFromAddr64]
3723
_SymGetLineFromAddr: Pointer;
3725
function SymGetLineFromAddr;
3727
GetProcedureAddress(_SymGetLineFromAddr, ImageHlpLib, 'SymGetLineFromAddr');
3731
JMP [_SymGetLineFromAddr]
3736
_SymGetLineFromName64: Pointer;
3738
function SymGetLineFromName64;
3740
GetProcedureAddress(_SymGetLineFromName64, ImageHlpLib, 'SymGetLineFromName64');
3744
JMP [_SymGetLineFromName64]
3749
_SymGetLineFromName: Pointer;
3751
function SymGetLineFromName;
3753
GetProcedureAddress(_SymGetLineFromName, ImageHlpLib, 'SymGetLineFromName');
3757
JMP [_SymGetLineFromName]
3762
_SymGetLineNext64: Pointer;
3764
function SymGetLineNext64;
3766
GetProcedureAddress(_SymGetLineNext64, ImageHlpLib, 'SymGetLineNext64');
3770
JMP [_SymGetLineNext64]
3775
_SymGetLineNext: Pointer;
3777
function SymGetLineNext;
3779
GetProcedureAddress(_SymGetLineNext, ImageHlpLib, 'SymGetLineNext');
3783
JMP [_SymGetLineNext]
3788
_SymGetLinePrev64: Pointer;
3790
function SymGetLinePrev64;
3792
GetProcedureAddress(_SymGetLinePrev64, ImageHlpLib, 'SymGetLinePrev64');
3796
JMP [_SymGetLinePrev64]
3801
_SymGetLinePrev: Pointer;
3803
function SymGetLinePrev;
3805
GetProcedureAddress(_SymGetLinePrev, ImageHlpLib, 'SymGetLinePrev');
3809
JMP [_SymGetLinePrev]
3814
_SymMatchFileName: Pointer;
3816
function SymMatchFileName;
3818
GetProcedureAddress(_SymMatchFileName, ImageHlpLib, 'SymMatchFileName');
3822
JMP [_SymMatchFileName]
3827
_SymInitialize: Pointer;
3829
function SymInitialize;
3831
GetProcedureAddress(_SymInitialize, ImageHlpLib, 'SymInitialize');
3835
JMP [_SymInitialize]
3840
_SymGetSearchPath: Pointer;
3842
function SymGetSearchPath;
3844
GetProcedureAddress(_SymGetSearchPath, ImageHlpLib, 'SymGetSearchPath');
3848
JMP [_SymGetSearchPath]
3853
_SymSetSearchPath: Pointer;
3855
function SymSetSearchPath;
3857
GetProcedureAddress(_SymSetSearchPath, ImageHlpLib, 'SymSetSearchPath');
3861
JMP [_SymSetSearchPath]
3866
_SymLoadModuleEx: Pointer;
3868
function SymLoadModuleEx;
3870
GetProcedureAddress(_SymLoadModuleEx, ImageHlpLib, 'SymLoadModuleEx');
3874
JMP [_SymLoadModuleEx]
3879
_SymLoadModule64: Pointer;
3881
function SymLoadModule64;
3883
GetProcedureAddress(_SymLoadModule64, ImageHlpLib, 'SymLoadModule64');
3887
JMP [_SymLoadModule64]
3892
_SymLoadModule: Pointer;
3894
function SymLoadModule;
3896
GetProcedureAddress(_SymLoadModule, ImageHlpLib, 'SymLoadModule');
3900
JMP [_SymLoadModule]
3905
_SymUnloadModule64: Pointer;
3907
function SymUnloadModule64;
3909
GetProcedureAddress(_SymUnloadModule64, ImageHlpLib, 'SymUnloadModule64');
3913
JMP [_SymUnloadModule64]
3918
_SymUnloadModule: Pointer;
3920
function SymUnloadModule;
3922
GetProcedureAddress(_SymUnloadModule, ImageHlpLib, 'SymUnloadModule');
3926
JMP [_SymUnloadModule]
3931
_SymUnDName64: Pointer;
3933
function SymUnDName64;
3935
GetProcedureAddress(_SymUnDName64, ImageHlpLib, 'SymUnDName64');
3944
_SymUnDName: Pointer;
3946
function SymUnDName;
3948
GetProcedureAddress(_SymUnDName, ImageHlpLib, 'SymUnDName');
3957
_SymRegisterCallback64: Pointer;
3959
function SymRegisterCallback64;
3961
GetProcedureAddress(_SymRegisterCallback64, ImageHlpLib, 'SymRegisterCallback64');
3965
JMP [_SymRegisterCallback64]
3970
_SymRegFuncEntryCallback64: Pointer;
3972
function SymRegisterFunctionEntryCallback64;
3974
GetProcedureAddress(_SymRegFuncEntryCallback64, ImageHlpLib, 'SymRegisterFunctionEntryCallback64');
3978
JMP [_SymRegFuncEntryCallback64]
3983
_SymRegisterCallback: Pointer;
3985
function SymRegisterCallback;
3987
GetProcedureAddress(_SymRegisterCallback, ImageHlpLib, 'SymRegisterCallback');
3991
JMP [_SymRegisterCallback]
3996
_SymRegisterFuncEntryCallback: Pointer;
3998
function SymRegisterFunctionEntryCallback;
4000
GetProcedureAddress(_SymRegisterFuncEntryCallback, ImageHlpLib, 'SymRegisterFunctionEntryCallback');
4004
JMP [_SymRegisterFuncEntryCallback]
4009
_SymSetContext: Pointer;
4011
function SymSetContext;
4013
GetProcedureAddress(_SymSetContext, ImageHlpLib, 'SymSetContext');
4017
JMP [_SymSetContext]
4022
_SymFromAddr: Pointer;
4024
function SymFromAddr;
4026
GetProcedureAddress(_SymFromAddr, ImageHlpLib, 'SymFromAddr');
4035
_SymFromName: Pointer;
4037
function SymFromName;
4039
GetProcedureAddress(_SymFromName, ImageHlpLib, 'SymFromName');
4048
_SymEnumSymbolsForAddr: Pointer;
4050
function SymEnumSymbolsForAddr;
4052
GetProcedureAddress(_SymEnumSymbolsForAddr, ImageHlpLib, 'SymEnumSymbolsForAddr');
4056
JMP [_SymEnumSymbolsForAddr]
4061
_SymEnumSymbols: Pointer;
4063
function SymEnumSymbols;
4065
GetProcedureAddress(_SymEnumSymbols, ImageHlpLib, 'SymEnumSymbols');
4069
JMP [_SymEnumSymbols]
4074
_SymGetTypeInfo: Pointer;
4076
function SymGetTypeInfo;
4078
GetProcedureAddress(_SymGetTypeInfo, ImageHlpLib, 'SymGetTypeInfo');
4082
JMP [_SymGetTypeInfo]
4087
_SymEnumTypes: Pointer;
4089
function SymEnumTypes;
4091
GetProcedureAddress(_SymEnumTypes, ImageHlpLib, 'SymEnumTypes');
4100
_SymGetTypeFromName: Pointer;
4102
function SymGetTypeFromName;
4104
GetProcedureAddress(_SymGetTypeFromName, ImageHlpLib, 'SymGetTypeFromName');
4108
JMP [_SymGetTypeFromName]
4113
_SymAddSymbol: Pointer;
4115
function SymAddSymbol;
4117
GetProcedureAddress(_SymAddSymbol, ImageHlpLib, 'SymAddSymbol');
4126
_SymDeleteSymbol: Pointer;
4128
function SymDeleteSymbol;
4130
GetProcedureAddress(_SymDeleteSymbol, ImageHlpLib, 'SymDeleteSymbol');
4134
JMP [_SymDeleteSymbol]
4139
_DbgHelpCreateUserDump: Pointer;
4141
function DbgHelpCreateUserDump;
4143
GetProcedureAddress(_DbgHelpCreateUserDump, ImageHlpLib, 'DbgHelpCreateUserDump');
4147
JMP [_DbgHelpCreateUserDump]
4152
_DbgHelpCreateUserDumpW: Pointer;
4154
function DbgHelpCreateUserDumpW;
4156
GetProcedureAddress(_DbgHelpCreateUserDumpW, ImageHlpLib, 'DbgHelpCreateUserDumpW');
4160
JMP [_DbgHelpCreateUserDumpW]
4165
_SymGetSymFromAddr64: Pointer;
4167
function SymGetSymFromAddr64;
4169
GetProcedureAddress(_SymGetSymFromAddr64, ImageHlpLib, 'SymGetSymFromAddr64');
4173
JMP [_SymGetSymFromAddr64]
4178
_SymGetSymFromAddr: Pointer;
4180
function SymGetSymFromAddr;
4182
GetProcedureAddress(_SymGetSymFromAddr, ImageHlpLib, 'SymGetSymFromAddr');
4186
JMP [_SymGetSymFromAddr]
4191
_SymGetSymFromName64: Pointer;
4193
function SymGetSymFromName64;
4195
GetProcedureAddress(_SymGetSymFromName64, ImageHlpLib, 'SymGetSymFromName64');
4199
JMP [_SymGetSymFromName64]
4204
_SymGetSymFromName: Pointer;
4206
function SymGetSymFromName;
4208
GetProcedureAddress(_SymGetSymFromName, ImageHlpLib, 'SymGetSymFromName');
4212
JMP [_SymGetSymFromName]
4217
_FindFileInPath: Pointer;
4219
function FindFileInPath;
4221
GetProcedureAddress(_FindFileInPath, ImageHlpLib, 'FindFileInPath');
4225
JMP [_FindFileInPath]
4230
_FindFileInSearchPath: Pointer;
4232
function FindFileInSearchPath;
4234
GetProcedureAddress(_FindFileInSearchPath, ImageHlpLib, 'FindFileInSearchPath');
4238
JMP [_FindFileInSearchPath]
4243
_SymEnumSym: Pointer;
4245
function SymEnumSym;
4247
GetProcedureAddress(_SymEnumSym, ImageHlpLib, 'SymEnumSym');
4256
_MiniDumpWriteDump: Pointer;
4258
function MiniDumpWriteDump;
4260
GetProcedureAddress(_MiniDumpWriteDump, ImageHlpLib, 'MiniDumpWriteDump');
4264
JMP [_MiniDumpWriteDump]
4269
_MiniDumpReadDumpStream: Pointer;
4271
function MiniDumpReadDumpStream;
4273
GetProcedureAddress(_MiniDumpReadDumpStream, ImageHlpLib, 'MiniDumpReadDumpStream');
4277
JMP [_MiniDumpReadDumpStream]
4283
function BindImage; external ImageHlpLib name 'BindImage';
4284
function BindImageEx; external ImageHlpLib name 'BindImageEx';
4285
function ReBaseImage; external ImageHlpLib name 'ReBaseImage';
4286
function ReBaseImage64; external ImageHlpLib name 'ReBaseImage64';
4287
function CheckSumMappedFile; external ImageHlpLib name 'CheckSumMappedFile';
4288
function MapFileAndCheckSumA; external ImageHlpLib name 'MapFileAndCheckSumA';
4289
function MapFileAndCheckSumW; external ImageHlpLib name 'MapFileAndCheckSumW';
4290
function MapFileAndCheckSum; external ImageHlpLib name 'MapFileAndCheckSum' + AWSuffix;
4291
function GetImageConfigInformation; external ImageHlpLib name 'GetImageConfigInformation';
4292
function GetImageUnusedHeaderBytes; external ImageHlpLib name 'GetImageUnusedHeaderBytes';
4293
function SetImageConfigInformation; external ImageHlpLib name 'SetImageConfigInformation';
4294
function ImageGetDigestStream; external ImageHlpLib name 'ImageGetDigestStream';
4295
function ImageAddCertificate; external ImageHlpLib name 'ImageAddCertificate';
4296
function ImageRemoveCertificate; external ImageHlpLib name 'ImageRemoveCertificate';
4297
function ImageEnumerateCertificates; external ImageHlpLib name 'ImageEnumerateCertificates';
4298
function ImageGetCertificateData; external ImageHlpLib name 'ImageGetCertificateData';
4299
function ImageGetCertificateHeader; external ImageHlpLib name 'ImageGetCertificateHeader';
4300
function ImageLoad; external ImageHlpLib name 'ImageLoad';
4301
function ImageUnload; external ImageHlpLib name 'ImageUnload';
4302
function MapAndLoad; external ImageHlpLib name 'MapAndLoad';
4303
function UnMapAndLoad; external ImageHlpLib name 'UnMapAndLoad';
4304
function TouchFileTimes; external ImageHlpLib name 'TouchFileTimes';
4305
function SplitSymbols; external ImageHlpLib name 'SplitSymbols';
4306
function UpdateDebugInfoFile; external ImageHlpLib name 'UpdateDebugInfoFile';
4307
function UpdateDebugInfoFileEx; external ImageHlpLib name 'UpdateDebugInfoFileEx';
4308
function FindDebugInfoFile; external ImageHlpLib name 'FindDebugInfoFile';
4309
function FindDebugInfoFileEx; external ImageHlpLib name 'FindDebugInfoFileEx';
4310
function SymFindFileInPath; external ImageHlpLib name 'SymFindFileInPath';
4311
function FindExecutableImage; external ImageHlpLib name 'FindExecutableImage';
4312
function FindExecutableImageEx; external ImageHlpLib name 'FindExecutableImageEx';
4313
function ImageNtHeader; external ImageHlpLib name 'ImageNtHeader';
4314
function ImageDirectoryEntryToDataEx; external ImageHlpLib name 'ImageDirectoryEntryToDataEx';
4315
function ImageDirectoryEntryToData; external ImageHlpLib name 'ImageDirectoryEntryToData';
4316
function ImageRvaToSection; external ImageHlpLib name 'ImageRvaToSection';
4317
function ImageRvaToVa; external ImageHlpLib name 'ImageRvaToVa';
4318
function MapDebugInformation; external ImageHlpLib name 'MapDebugInformation';
4319
function UnmapDebugInformation; external ImageHlpLib name 'UnmapDebugInformation';
4320
function SearchTreeForFile; external ImageHlpLib name 'SearchTreeForFile';
4321
function EnumDirTree; external ImageHlpLib name 'EnumDirTree';
4322
function MakeSureDirectoryPathExists; external ImageHlpLib name 'MakeSureDirectoryPathExists';
4323
function UnDecorateSymbolName; external ImageHlpLib name 'UnDecorateSymbolName';
4324
function StackWalk64; external ImageHlpLib name 'StackWalk64';
4325
function StackWalk; external ImageHlpLib name 'StackWalk';
4326
function ImagehlpApiVersion; external ImageHlpLib name 'ImagehlpApiVersion';
4327
function ImagehlpApiVersionEx; external ImageHlpLib name 'ImagehlpApiVersionEx';
4328
function GetTimestampForLoadedLibrary; external ImageHlpLib name 'GetTimestampForLoadedLibrary';
4329
function SymSetOptions; external ImageHlpLib name 'SymSetOptions';
4330
function SymGetOptions; external ImageHlpLib name 'SymGetOptions';
4331
function SymCleanup; external ImageHlpLib name 'SymCleanup';
4332
function SymMatchString; external ImageHlpLib name 'SymMatchString';
4333
function SymEnumSourceFiles; external ImageHlpLib name 'SymEnumSourceFiles';
4334
function SymEnumerateModules64; external ImageHlpLib name 'SymEnumerateModules64';
4335
function SymEnumerateModules; external ImageHlpLib name 'SymEnumerateModules';
4336
function SymEnumerateSymbols64; external ImageHlpLib name 'SymEnumerateSymbols64';
4337
function SymEnumerateSymbolsW64; external ImageHlpLib name 'SymEnumerateSymbolsW64';
4338
function SymEnumerateSymbols; external ImageHlpLib name 'SymEnumerateSymbols';
4339
function SymEnumerateSymbolsW; external ImageHlpLib name 'SymEnumerateSymbolsW';
4340
function EnumerateLoadedModules64; external ImageHlpLib name 'EnumerateLoadedModules64';
4341
function EnumerateLoadedModules; external ImageHlpLib name 'EnumerateLoadedModules';
4342
function SymFunctionTableAccess64; external ImageHlpLib name 'SymFunctionTableAccess64';
4343
function SymFunctionTableAccess; external ImageHlpLib name 'SymFunctionTableAccess';
4344
function SymGetModuleInfo64; external ImageHlpLib name 'SymGetModuleInfo64';
4345
function SymGetModuleInfoW64; external ImageHlpLib name 'SymGetModuleInfoW64';
4346
function SymGetModuleInfo; external ImageHlpLib name 'SymGetModuleInfo';
4347
function SymGetModuleInfoW; external ImageHlpLib name 'SymGetModuleInfoW';
4348
function SymGetModuleBase64; external ImageHlpLib name 'SymGetModuleBase64';
4349
function SymGetModuleBase; external ImageHlpLib name 'SymGetModuleBase';
4350
function SymGetSymNext64; external ImageHlpLib name 'SymGetSymNext64';
4351
function SymGetSymNext; external ImageHlpLib name 'SymGetSymNext';
4352
function SymGetSymPrev64; external ImageHlpLib name 'SymGetSymPrev64';
4353
function SymGetSymPrev; external ImageHlpLib name 'SymGetSymPrev';
4354
function SymGetLineFromAddr64; external ImageHlpLib name 'SymGetLineFromAddr64';
4355
function SymGetLineFromAddr; external ImageHlpLib name 'SymGetLineFromAddr';
4356
function SymGetLineFromName64; external ImageHlpLib name 'SymGetLineFromName64';
4357
function SymGetLineFromName; external ImageHlpLib name 'SymGetLineFromName';
4358
function SymGetLineNext64; external ImageHlpLib name 'SymGetLineNext64';
4359
function SymGetLineNext; external ImageHlpLib name 'SymGetLineNext';
4360
function SymGetLinePrev64; external ImageHlpLib name 'SymGetLinePrev64';
4361
function SymGetLinePrev; external ImageHlpLib name 'SymGetLinePrev';
4362
function SymMatchFileName; external ImageHlpLib name 'SymMatchFileName';
4363
function SymInitialize; external ImageHlpLib name 'SymInitialize';
4364
function SymGetSearchPath; external ImageHlpLib name 'SymGetSearchPath';
4365
function SymSetSearchPath; external ImageHlpLib name 'SymSetSearchPath';
4366
function SymLoadModuleEx; external ImageHlpLib name 'SymLoadModuleEx';
4367
function SymLoadModule64; external ImageHlpLib name 'SymLoadModule64';
4368
function SymLoadModule; external ImageHlpLib name 'SymLoadModule';
4369
function SymUnloadModule64; external ImageHlpLib name 'SymUnloadModule64';
4370
function SymUnloadModule; external ImageHlpLib name 'SymUnloadModule';
4371
function SymUnDName64; external ImageHlpLib name 'SymUnDName64';
4372
function SymUnDName; external ImageHlpLib name 'SymUnDName';
4373
function SymRegisterCallback64; external ImageHlpLib name 'SymRegisterCallback64';
4374
function SymRegisterFunctionEntryCallback64; external ImageHlpLib name 'SymRegisterFunctionEntryCallback64';
4375
function SymRegisterCallback; external ImageHlpLib name 'SymRegisterCallback';
4376
function SymRegisterFunctionEntryCallback; external ImageHlpLib name 'SymRegisterFunctionEntryCallback';
4377
function SymSetContext; external ImageHlpLib name 'SymSetContext';
4378
function SymFromAddr; external ImageHlpLib name 'SymFromAddr';
4379
function SymFromName; external ImageHlpLib name 'SymFromName';
4380
function SymEnumSymbolsForAddr; external ImageHlpLib name 'SymEnumSymbolsForAddr';
4381
function SymEnumSymbols; external ImageHlpLib name 'SymEnumSymbols';
4382
function SymGetTypeInfo; external ImageHlpLib name 'SymGetTypeInfo';
4383
function SymEnumTypes; external ImageHlpLib name 'SymEnumTypes';
4384
function SymGetTypeFromName; external ImageHlpLib name 'SymGetTypeFromName';
4385
function SymAddSymbol; external ImageHlpLib name 'SymAddSymbol';
4386
function SymDeleteSymbol; external ImageHlpLib name 'SymDeleteSymbol';
4387
function DbgHelpCreateUserDump; external ImageHlpLib name 'DbgHelpCreateUserDump';
4388
function DbgHelpCreateUserDumpW; external ImageHlpLib name 'DbgHelpCreateUserDumpW';
4389
function SymGetSymFromAddr64; external ImageHlpLib name 'SymGetSymFromAddr64';
4390
function SymGetSymFromAddr; external ImageHlpLib name 'SymGetSymFromAddr';
4391
function SymGetSymFromName64; external ImageHlpLib name 'SymGetSymFromName64';
4392
function SymGetSymFromName; external ImageHlpLib name 'SymGetSymFromName';
4393
function FindFileInPath; external ImageHlpLib name 'FindFileInPath';
4394
function FindFileInSearchPath; external ImageHlpLib name 'FindFileInSearchPath';
4395
function SymEnumSym; external ImageHlpLib name 'SymEnumSym';
4396
function MiniDumpWriteDump; external ImageHlpLib name 'MiniDumpWriteDump';
4397
function MiniDumpReadDumpStream; external ImageHlpLib name 'MiniDumpReadDumpStream';
4399
{$ENDIF DYNAMIC_LINK}
added
removed
packages/extra/winunits/jwaimagehlp.pas
