1 {******************************************************************************}
2 { }
3 { Image Help API interface Unit for Object Pascal }
4 { }
5 { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
6 { Corporation. All Rights Reserved. }
7 { }
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). }
11 { }
12 { Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
13 { Marcel van Brakel. All Rights Reserved. }
14 { }
15 { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
16 { }
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 }
19 { }
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 }
24 { }
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. }
28 { }
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. }
38 { }
39 { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
40 { }
41 {******************************************************************************}
42
43 // $Id: JwaImageHlp.pas,v 1.13 2007/09/14 06:48:45 marquardt Exp $
44
45 {$IFNDEF JWA_OMIT_SECTIONS}
46 unit JwaImageHlp;
47
48 {$WEAKPACKAGEUNIT}
49 {$ENDIF JWA_OMIT_SECTIONS}
50
51 {$HPPEMIT ''}
52 {$HPPEMIT '#include "ImageHlp.h"'}
53 {$HPPEMIT ''}
54
55 {$IFNDEF JWA_OMIT_SECTIONS}
56 {$I jediapilib.inc}
57
58 interface
59
60 uses
61 Windows, JwaWinBase, JwaWinNT, JwaWinType;
62 {$ENDIF JWA_OMIT_SECTIONS}
63
64 {$IFNDEF JWA_IMPLEMENTATIONSECTION}
65
66 const
67 IMAGE_SEPARATION = 64*1024;
68 {$EXTERNALSYM IMAGE_SEPARATION}
69
70 type
71 PLOADED_IMAGE = ^LOADED_IMAGE;
72 {$EXTERNALSYM PLOADED_IMAGE}
73 _LOADED_IMAGE = record
74 ModuleName: PSTR;
75 hFile: HANDLE;
76 MappedAddress: PUCHAR;
77 FileHeader: PIMAGE_NT_HEADERS32;
78 LastRvaSection: PIMAGE_SECTION_HEADER;
79 NumberOfSections: ULONG;
80 Sections: PIMAGE_SECTION_HEADER;
81 Characteristics: ULONG;
82 fSystemImage: ByteBool;
83 fDOSImage: ByteBool;
84 Links: LIST_ENTRY;
85 SizeOfImage: ULONG;
86 end;
87 {$EXTERNALSYM _LOADED_IMAGE}
88 LOADED_IMAGE = _LOADED_IMAGE;
89 {$EXTERNALSYM LOADED_IMAGE}
90 TLoadedImage = LOADED_IMAGE;
91 PLoadedImage = PLOADED_IMAGE;
92
93 const
94 MAX_SYM_NAME = 2000;
95 {$EXTERNALSYM MAX_SYM_NAME}
96
BindImagenull97 function BindImage(ImageName, DllPath, SymbolPath: PSTR): BOOL; stdcall;
98 {$EXTERNALSYM BindImage}
99
100 type
101 _IMAGEHLP_STATUS_REASON = (
102 BindOutOfMemory,
103 BindRvaToVaFailed,
104 BindNoRoomInImage,
105 BindImportModuleFailed,
106 BindImportProcedureFailed,
107 BindImportModule,
108 BindImportProcedure,
109 BindForwarder,
110 BindForwarderNOT,
111 BindImageModified,
112 BindExpandFileHeaders,
113 BindImageComplete,
114 BindMismatchedSymbols,
115 BindSymbolsNotUpdated,
116 BindImportProcedure32,
117 BindImportProcedure64,
118 BindForwarder32,
119 BindForwarder64,
120 BindForwarderNOT32,
121 BindForwarderNOT64);
122 {$EXTERNALSYM _IMAGEHLP_STATUS_REASON}
123 IMAGEHLP_STATUS_REASON = _IMAGEHLP_STATUS_REASON;
124 {$EXTERNALSYM IMAGEHLP_STATUS_REASON}
125 TImageHlpStatusReason = IMAGEHLP_STATUS_REASON;
126
easonnull127 PIMAGEHLP_STATUS_ROUTINE = function(Reason: IMAGEHLP_STATUS_REASON;
128 ImageName, DllName: PSTR; Va, Parameter: ULONG_PTR): BOOL; stdcall;
129 {$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE}
130 PImageHlpStatusRoutine = PIMAGEHLP_STATUS_ROUTINE;
131
easonnull132 PIMAGEHLP_STATUS_ROUTINE32 = function(Reason: IMAGEHLP_STATUS_REASON; ImageName, DllName: PSTR;
133 Va: ULONG; Parameter: ULONG_PTR): BOOL; stdcall;
134 {$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE32}
135 PImageHlpStatusRoutine23 = PIMAGEHLP_STATUS_ROUTINE32;
136
easonnull137 PIMAGEHLP_STATUS_ROUTINE64 = function(Reason: IMAGEHLP_STATUS_REASON; ImageName, DllName: PSTR;
138 Va: ULONG64; Parameter: ULONG_PTR): BOOL; stdcall;
139 {$EXTERNALSYM PIMAGEHLP_STATUS_ROUTINE64}
140 PImageHlpStatusRoutine64 = PIMAGEHLP_STATUS_ROUTINE64;
141
BindImageExnull142 function BindImageEx(Flags: DWORD; ImageName, DllPath, SymbolPath: PSTR;
143 StatusRoutine: PIMAGEHLP_STATUS_ROUTINE): BOOL; stdcall;
144 {$EXTERNALSYM BindImageEx}
145
146 const
147 BIND_NO_BOUND_IMPORTS = $00000001;
148 {$EXTERNALSYM BIND_NO_BOUND_IMPORTS}
149 BIND_NO_UPDATE = $00000002;
150 {$EXTERNALSYM BIND_NO_UPDATE}
151 BIND_ALL_IMAGES = $00000004;
152 {$EXTERNALSYM BIND_ALL_IMAGES}
153 BIND_CACHE_IMPORT_DLLS = $00000008; // Cache dll's across calls to BindImageEx (same as NT 3.1->NT 4.0)
154 {$EXTERNALSYM BIND_CACHE_IMPORT_DLLS}
155
156 BIND_REPORT_64BIT_VA = $00000010;
157 {$EXTERNALSYM BIND_REPORT_64BIT_VA}
158
159 function ReBaseImage(CurrentImageName: PSTR; SymbolPath: PSTR; fReBase: BOOL;
160 fRebaseSysfileOk: BOOL; fGoingDown: BOOL; CheckImageSize: ULONG;
161 var OldImageSize: ULONG; var OldImageBase: ULONG_PTR; var NewImageSize: ULONG;
162 var NewImageBase: ULONG_PTR; TimeStamp: ULONG): BOOL; stdcall;
163 {$EXTERNALSYM ReBaseImage}
164
165 function ReBaseImage64(CurrentImageName: PSTR; SymbolPath: PSTR; fReBase: BOOL;
166 fRebaseSysfileOk: BOOL; fGoingDown: BOOL; CheckImageSize: ULONG;
167 var OldImageSize: ULONG; var OldImageBase: ULONG64; var NewImageSize: ULONG;
168 var NewImageBase: ULONG64; TimeStamp: ULONG): BOOL; stdcall;
169 {$EXTERNALSYM ReBaseImage64}
170
171 //
172 // Define checksum return codes.
173 //
174
175 const
176 CHECKSUM_SUCCESS = 0;
177 {$EXTERNALSYM CHECKSUM_SUCCESS}
178 CHECKSUM_OPEN_FAILURE = 1;
179 {$EXTERNALSYM CHECKSUM_OPEN_FAILURE}
180 CHECKSUM_MAP_FAILURE = 2;
181 {$EXTERNALSYM CHECKSUM_MAP_FAILURE}
182 CHECKSUM_MAPVIEW_FAILURE = 3;
183 {$EXTERNALSYM CHECKSUM_MAPVIEW_FAILURE}
184 CHECKSUM_UNICODE_FAILURE = 4;
185 {$EXTERNALSYM CHECKSUM_UNICODE_FAILURE}
186
187 // Define Splitsym flags.
188
189 SPLITSYM_REMOVE_PRIVATE = $00000001; // Remove CV types/symbols and Fixup debug
190 {$EXTERNALSYM SPLITSYM_REMOVE_PRIVATE}
191 // Used for creating .dbg files that ship
192 // as part of the product.
193
194 SPLITSYM_EXTRACT_ALL = $00000002; // Extract all debug info from image.
195 {$EXTERNALSYM SPLITSYM_EXTRACT_ALL}
196 // Normally, FPO is left in the image
197 // to allow stack traces through the code.
198 // Using this switch is similar to linking
199 // with -debug:none except the .dbg file
200 // exists...
201
202 SPLITSYM_SYMBOLPATH_IS_SRC = $00000004; // The SymbolFilePath contains an alternate
203 {$EXTERNALSYM SPLITSYM_SYMBOLPATH_IS_SRC}
204 // path to locate the pdb.
205
206 //
207 // Define checksum function prototypes.
208 //
209
210 function CheckSumMappedFile(BaseAddress: PVOID; FileLength: DWORD;
211 var HeaderSum, CheckSum: DWORD): PIMAGE_NT_HEADERS; stdcall;
212 {$EXTERNALSYM CheckSumMappedFile}
213
214 function MapFileAndCheckSumA(Filename: PSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
215 {$EXTERNALSYM MapFileAndCheckSumA}
216 function MapFileAndCheckSumW(Filename: PWSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
217 {$EXTERNALSYM MapFileAndCheckSumW}
218 function MapFileAndCheckSum(Filename: PTSTR; var HeaderSum, CheckSum: DWORD): DWORD; stdcall;
219 {$EXTERNALSYM MapFileAndCheckSum}
220
221 function GetImageConfigInformation(const LoadedImage: LOADED_IMAGE;
222 var ImageConfigInformation: IMAGE_LOAD_CONFIG_DIRECTORY): BOOL; stdcall;
223 {$EXTERNALSYM GetImageConfigInformation}
224
225 function GetImageUnusedHeaderBytes(const LoadedImage: LOADED_IMAGE;
226 var SizeUnusedHeaderBytes: DWORD): DWORD; stdcall;
227 {$EXTERNALSYM GetImageUnusedHeaderBytes}
228
229 function SetImageConfigInformation(const LoadedImage: LOADED_IMAGE;
230 const ImageConfigInformation: IMAGE_LOAD_CONFIG_DIRECTORY): BOOL; stdcall;
231 {$EXTERNALSYM SetImageConfigInformation}
232
233 // Image Integrity API's
234
235 const
236 CERT_PE_IMAGE_DIGEST_DEBUG_INFO = $01;
237 {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_DEBUG_INFO}
238 CERT_PE_IMAGE_DIGEST_RESOURCES = $02;
239 {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_RESOURCES}
240 CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO = $04;
241 {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO}
242 CERT_PE_IMAGE_DIGEST_NON_PE_INFO = $08; // include data outside the PE image
243 {$EXTERNALSYM CERT_PE_IMAGE_DIGEST_NON_PE_INFO}
244
245 CERT_SECTION_TYPE_ANY = $FF; // Any Certificate type
246 {$EXTERNALSYM CERT_SECTION_TYPE_ANY}
247
248 type
249 DIGEST_HANDLE = PVOID;
250 {$EXTERNALSYM DIGEST_HANDLE}
251 TDigestHandle = DIGEST_HANDLE;
252
253 DIGEST_FUNCTION = function(refdata: DIGEST_HANDLE; pData: PBYTE; dwLength: DWORD): BOOL; stdcall;
254 {$EXTERNALSYM DIGEST_FUNCTION}
255 TDigestFunction = DIGEST_FUNCTION;
256
ImageGetDigestStreamnull257 function ImageGetDigestStream(FileHandle: HANDLE; DigestLevel: DWORD;
258 DigestFunction: DIGEST_FUNCTION; DigestHandle: DIGEST_HANDLE): BOOL; stdcall;
259 {$EXTERNALSYM ImageGetDigestStream}
260
ImageAddCertificatenull261 function ImageAddCertificate(FileHandle: HANDLE; Certificate: PWinCertificate;
262 var Index: DWORD): BOOL; stdcall;
263 {$EXTERNALSYM ImageAddCertificate}
264
ImageRemoveCertificatenull265 function ImageRemoveCertificate(FileHandle: HANDLE; Index: DWORD): BOOL; stdcall;
266 {$EXTERNALSYM ImageRemoveCertificate}
267
ImageEnumerateCertificatesnull268 function ImageEnumerateCertificates(FileHandle: HANDLE; TypeFilter: WORD;
269 var CertificateCount: DWORD; Indices: PDWORD; IndexCount: DWORD): BOOL; stdcall;
270 {$EXTERNALSYM ImageEnumerateCertificates}
271
ImageGetCertificateDatanull272 function ImageGetCertificateData(FileHandle: HANDLE; CertificateIndex: DWORD;
273 Certificate: PWinCertificate; var RequiredLength: DWORD): BOOL; stdcall;
274 {$EXTERNALSYM ImageGetCertificateData}
275
ImageGetCertificateHeadernull276 function ImageGetCertificateHeader(FileHandle: HANDLE; CertificateIndex: DWORD;
277 Certificateheader: PWinCertificate): BOOL; stdcall;
278 {$EXTERNALSYM ImageGetCertificateHeader}
279
ImageLoadnull280 function ImageLoad(DllName: PSTR; DllPath: PSTR): PLOADED_IMAGE; stdcall;
281 {$EXTERNALSYM ImageLoad}
282
ImageUnloadnull283 function ImageUnload(const LoadedImage: LOADED_IMAGE): BOOL; stdcall;
284 {$EXTERNALSYM ImageUnload}
285
MapAndLoadnull286 function MapAndLoad(ImageName, DllPath: PSTR; var LoadedImage: LOADED_IMAGE;
287 DotDll: BOOL; ReadOnly: BOOL): BOOL; stdcall;
288 {$EXTERNALSYM MapAndLoad}
289
UnMapAndLoadnull290 function UnMapAndLoad(const LoadedImage: LOADED_IMAGE): BOOL; stdcall;
291 {$EXTERNALSYM UnMapAndLoad}
292
TouchFileTimesnull293 function TouchFileTimes(FileHandle: HANDLE; pSystemTime: PSYSTEMTIME): BOOL; stdcall;
294 {$EXTERNALSYM TouchFileTimes}
295
SplitSymbolsnull296 function SplitSymbols(ImageName, SymbolsPath, SymbolFilePath: PSTR; Flags: DWORD): BOOL; stdcall;
297 {$EXTERNALSYM SplitSymbols}
298
UpdateDebugInfoFilenull299 function UpdateDebugInfoFile(ImageFileName, SymbolPath, DebugFilePath: PSTR;
300 const NtHeaders: IMAGE_NT_HEADERS32): BOOL; stdcall;
301 {$EXTERNALSYM UpdateDebugInfoFile}
302
UpdateDebugInfoFileExnull303 function UpdateDebugInfoFileEx(ImageFileName, SymbolPath, DebugFilePath: PSTR;
304 const NtHeaders: IMAGE_NT_HEADERS32; OldChecksum: DWORD): BOOL; stdcall;
305 {$EXTERNALSYM UpdateDebugInfoFileEx}
306
FindDebugInfoFilenull307 function FindDebugInfoFile(FileName, SymbolPath, DebugFilePath: PSTR): HANDLE; stdcall;
308 {$EXTERNALSYM FindDebugInfoFile}
309
310 type
ileHandlenull311 PFIND_DEBUG_FILE_CALLBACK = function(FileHandle: HANDLE; FileName: PSTR;
312 CallerData: PVOID): BOOL; stdcall;
313 {$EXTERNALSYM PFIND_DEBUG_FILE_CALLBACK}
314 PFindDebugFileCallback = PFIND_DEBUG_FILE_CALLBACK;
315
FindDebugInfoFileExnull316 function FindDebugInfoFileEx(FileName, SymbolPath, DebugFilePath: PSTR;
317 Callback: PFIND_DEBUG_FILE_CALLBACK; CallerData: PVOID): HANDLE; stdcall;
318 {$EXTERNALSYM FindDebugInfoFileEx}
319
320 type
ilenamenull321 PFINDFILEINPATHCALLBACK = function(filename: PSTR; context: PVOID): BOOL; stdcall;
322 {$EXTERNALSYM PFINDFILEINPATHCALLBACK}
323
SymFindFileInPathnull324 function SymFindFileInPath(hprocess: HANDLE; SearchPath, FileName: LPSTR; id: PVOID; two, three, flags: DWORD;
325 FoundFile: LPSTR; callback: PFINDFILEINPATHCALLBACK; context: PVOID): BOOL; stdcall;
326 {$EXTERNALSYM SymFindFileInPath}
327
FindExecutableImagenull328 function FindExecutableImage(FileName, SymbolPath, ImageFilePath: PSTR): HANDLE; stdcall;
329 {$EXTERNALSYM FindExecutableImage}
330
331 type
ileHandlenull332 PFIND_EXE_FILE_CALLBACK = function(FileHandle: HANDLE; FileName: PSTR;
333 CallerData: PVOID): BOOL; stdcall;
334 {$EXTERNALSYM PFIND_EXE_FILE_CALLBACK}
335 PFindExeFileCallback = PFIND_EXE_FILE_CALLBACK;
336
FindExecutableImageExnull337 function FindExecutableImageEx(FileName, SymbolPath, ImageFilePath: PSTR;
338 Callback: PFIND_EXE_FILE_CALLBACK; CallerData: PVOID): HANDLE; stdcall;
339 {$EXTERNALSYM FindExecutableImageEx}
340
ImageNtHeadernull341 function ImageNtHeader(Base: PVOID): PIMAGE_NT_HEADERS; stdcall;
342 {$EXTERNALSYM ImageNtHeader}
343
ImageDirectoryEntryToDataExnull344 function ImageDirectoryEntryToDataEx(Base: PVOID; MappedAsImage: ByteBool;
345 DirectoryEntry: USHORT; var Size: ULONG; var FoundHeader: PIMAGE_SECTION_HEADER): PVOID; stdcall;
346 {$EXTERNALSYM ImageDirectoryEntryToDataEx}
347
ImageDirectoryEntryToDatanull348 function ImageDirectoryEntryToData(Base: PVOID; MappedAsImage: ByteBool;
349 DirectoryEntry: USHORT; var Size: ULONG): PVOID; stdcall;
350 {$EXTERNALSYM ImageDirectoryEntryToData}
351
ImageRvaToSectionnull352 function ImageRvaToSection(NtHeaders: PIMAGE_NT_HEADERS; Base: PVOID; Rva: ULONG): PIMAGE_SECTION_HEADER; stdcall;
353 {$EXTERNALSYM ImageRvaToSection}
354
ImageRvaToVanull355 function ImageRvaToVa(NtHeaders: PIMAGE_NT_HEADERS; Base: PVOID; Rva: ULONG;
356 var LastRvaSection: PIMAGE_SECTION_HEADER): PVOID; stdcall;
357 {$EXTERNALSYM ImageRvaToVa}
358
359 // Symbol server exports
360
361 type
1null362 PSYMBOLSERVERPROC = function(a1, a2: LPCSTR; a3: PVOID; a4, a5: DWORD; a6: LPSTR): BOOL; stdcall;
363 {$EXTERNALSYM PSYMBOLSERVERPROC}
BOOLnull364 PSYMBOLSERVEROPENPROC = function: BOOL; stdcall;
365 {$EXTERNALSYM PSYMBOLSERVEROPENPROC}
BOOLnull366 PSYMBOLSERVERCLOSEPROC = function: BOOL; stdcall;
367 {$EXTERNALSYM PSYMBOLSERVERCLOSEPROC}
1null368 PSYMBOLSERVERSETOPTIONSPROC = function(a1: UINT_PTR; a2: ULONG64): BOOL; stdcall;
369 {$EXTERNALSYM PSYMBOLSERVERSETOPTIONSPROC}
ctionnull370 PSYMBOLSERVERCALLBACKPROC = function(action: UINT_PTR; data: ULONG64; context: ULONG64): BOOL; stdcall;
371 {$EXTERNALSYM PSYMBOLSERVERCALLBACKPROC}
UINT_PTRnull372 PSYMBOLSERVERGETOPTIONSPROC = function: UINT_PTR; stdcall;
373 {$EXTERNALSYM PSYMBOLSERVERGETOPTIONSPROC}
1null374 PSYMBOLSERVERPINGPROC = function(a1: LPCSTR): BOOL; stdcall;
375 {$EXTERNALSYM PSYMBOLSERVERPINGPROC}
376
377 const
378 SSRVOPT_CALLBACK = $01;
379 {$EXTERNALSYM SSRVOPT_CALLBACK}
380 SSRVOPT_DWORD = $02;
381 {$EXTERNALSYM SSRVOPT_DWORD}
382 SSRVOPT_DWORDPTR = $04;
383 {$EXTERNALSYM SSRVOPT_DWORDPTR}
384 SSRVOPT_GUIDPTR = $08;
385 {$EXTERNALSYM SSRVOPT_GUIDPTR}
386 SSRVOPT_OLDGUIDPTR = $10;
387 {$EXTERNALSYM SSRVOPT_OLDGUIDPTR}
388 SSRVOPT_UNATTENDED = $20;
389 {$EXTERNALSYM SSRVOPT_UNATTENDED}
390 SSRVOPT_RESET = ULONG_PTR(-1);
391 {$EXTERNALSYM SSRVOPT_RESET}
392
393 SSRVACTION_TRACE = 1;
394 {$EXTERNALSYM SSRVACTION_TRACE}
395
396 // This api won't be ported to Win64 - Fix your code.
397
398 type
399 PIMAGE_DEBUG_INFORMATION = ^IMAGE_DEBUG_INFORMATION;
400 {$EXTERNALSYM PIMAGE_DEBUG_INFORMATION}
401 _IMAGE_DEBUG_INFORMATION = record
402 List: LIST_ENTRY;
403 ReservedSize: DWORD;
404 ReservedMappedBase: PVOID;
405 ReservedMachine: USHORT;
406 ReservedCharacteristics: USHORT;
407 ReservedCheckSum: DWORD;
408 ImageBase: DWORD;
409 SizeOfImage: DWORD;
410 ReservedNumberOfSections: DWORD;
411 ReservedSections: PIMAGE_SECTION_HEADER;
412 ReservedExportedNamesSize: DWORD;
413 ReservedExportedNames: PSTR;
414 ReservedNumberOfFunctionTableEntries: DWORD;
415 ReservedFunctionTableEntries: PIMAGE_FUNCTION_ENTRY;
416 ReservedLowestFunctionStartingAddress: DWORD;
417 ReservedHighestFunctionEndingAddress: DWORD;
418 ReservedNumberOfFpoTableEntries: DWORD;
419 ReservedFpoTableEntries: PFPO_DATA;
420 SizeOfCoffSymbols: DWORD;
421 CoffSymbols: PIMAGE_COFF_SYMBOLS_HEADER;
422 ReservedSizeOfCodeViewSymbols: DWORD;
423 ReservedCodeViewSymbols: PVOID;
424 ImageFilePath: PSTR;
425 ImageFileName: PSTR;
426 ReservedDebugFilePath: PSTR;
427 ReservedTimeDateStamp: DWORD;
428 ReservedRomImage: BOOL;
429 ReservedDebugDirectory: PIMAGE_DEBUG_DIRECTORY;
430 ReservedNumberOfDebugDirectories: DWORD;
431 ReservedOriginalFunctionTableBaseAddress: DWORD;
432 Reserved: array [0..1] of DWORD;
433 end;
434 {$EXTERNALSYM _IMAGE_DEBUG_INFORMATION}
435 IMAGE_DEBUG_INFORMATION = _IMAGE_DEBUG_INFORMATION;
436 {$EXTERNALSYM IMAGE_DEBUG_INFORMATION}
437 TImageDebugInformation = IMAGE_DEBUG_INFORMATION;
438 PImageDebugInformation = PIMAGE_DEBUG_INFORMATION;
439
440 function MapDebugInformation(FileHandle: HANDLE; FileName, SymbolPath: PSTR;
441 ImageBase: DWORD): PIMAGE_DEBUG_INFORMATION; stdcall;
442 {$EXTERNALSYM MapDebugInformation}
443
444 function UnmapDebugInformation(DebugInfo: PIMAGE_DEBUG_INFORMATION): BOOL; stdcall;
445 {$EXTERNALSYM UnmapDebugInformation}
446
447 function SearchTreeForFile(RootPath, InputPathName, OutputPathBuffer: PSTR): BOOL; stdcall;
448 {$EXTERNALSYM SearchTreeForFile}
449
450 type
451 PENUMDIRTREE_CALLBACK = function(FilePath: LPCSTR; CallerData: PVOID): BOOL; stdcall;
452 {$EXTERNALSYM PENUMDIRTREE_CALLBACK}
453 PEnumDirTreeCallback = PENUMDIRTREE_CALLBACK;
454
455 function EnumDirTree(hProcess: HANDLE; RootPath, InputPathName, OutputPathBuffer: PSTR;
456 Callback: PENUMDIRTREE_CALLBACK; CallbackData: PVOID): BOOL; stdcall;
457 {$EXTERNALSYM EnumDirTree}
458
459 function MakeSureDirectoryPathExists(DirPath: PCSTR): BOOL; stdcall;
460 {$EXTERNALSYM MakeSureDirectoryPathExists}
461
462 //
463 // UnDecorateSymbolName Flags
464 //
465
466 const
467 UNDNAME_COMPLETE = $0000; // Enable full undecoration
468 {$EXTERNALSYM UNDNAME_COMPLETE}
469 UNDNAME_NO_LEADING_UNDERSCORES = $0001; // Remove leading underscores from MS extended keywords
470 {$EXTERNALSYM UNDNAME_NO_LEADING_UNDERSCORES}
471 UNDNAME_NO_MS_KEYWORDS = $0002; // Disable expansion of MS extended keywords
472 {$EXTERNALSYM UNDNAME_NO_MS_KEYWORDS}
473 UNDNAME_NO_FUNCTION_RETURNS = $0004; // Disable expansion of return type for primary declaration
474 {$EXTERNALSYM UNDNAME_NO_FUNCTION_RETURNS}
475 UNDNAME_NO_ALLOCATION_MODEL = $0008; // Disable expansion of the declaration model
476 {$EXTERNALSYM UNDNAME_NO_ALLOCATION_MODEL}
477 UNDNAME_NO_ALLOCATION_LANGUAGE = $0010; // Disable expansion of the declaration language specifier
478 {$EXTERNALSYM UNDNAME_NO_ALLOCATION_LANGUAGE}
479 UNDNAME_NO_MS_THISTYPE = $0020; // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
480 {$EXTERNALSYM UNDNAME_NO_MS_THISTYPE}
481 UNDNAME_NO_CV_THISTYPE = $0040; // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
482 {$EXTERNALSYM UNDNAME_NO_CV_THISTYPE}
483 UNDNAME_NO_THISTYPE = $0060; // Disable all modifiers on the 'this' type
484 {$EXTERNALSYM UNDNAME_NO_THISTYPE}
485 UNDNAME_NO_ACCESS_SPECIFIERS = $0080; // Disable expansion of access specifiers for members
486 {$EXTERNALSYM UNDNAME_NO_ACCESS_SPECIFIERS}
487 UNDNAME_NO_THROW_SIGNATURES = $0100; // Disable expansion of 'throw-signatures' for functions and pointers to functions
488 {$EXTERNALSYM UNDNAME_NO_THROW_SIGNATURES}
489 UNDNAME_NO_MEMBER_TYPE = $0200; // Disable expansion of 'static' or 'virtual'ness of members
490 {$EXTERNALSYM UNDNAME_NO_MEMBER_TYPE}
491 UNDNAME_NO_RETURN_UDT_MODEL = $0400; // Disable expansion of MS model for UDT returns
492 {$EXTERNALSYM UNDNAME_NO_RETURN_UDT_MODEL}
493 UNDNAME_32_BIT_DECODE = $0800; // Undecorate 32-bit decorated names
494 {$EXTERNALSYM UNDNAME_32_BIT_DECODE}
495 UNDNAME_NAME_ONLY = $1000; // Crack only the name for primary declaration;
496 {$EXTERNALSYM UNDNAME_NAME_ONLY}
497 // return just [scope::]name. Does expand template params
498 UNDNAME_NO_ARGUMENTS = $2000; // Don't undecorate arguments to function
499 {$EXTERNALSYM UNDNAME_NO_ARGUMENTS}
500 UNDNAME_NO_SPECIAL_SYMS = $4000; // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
501 {$EXTERNALSYM UNDNAME_NO_SPECIAL_SYMS}
502
503 function UnDecorateSymbolName(DecoratedName: PCSTR; UnDecoratedName: PSTR;
504 UndecoratedLength: DWORD; Flags: DWORD): DWORD; stdcall;
505 {$EXTERNALSYM UnDecorateSymbolName}
506
507 //
508 // these values are used for synthesized file types
509 // that can be passed in as image headers instead of
510 // the standard ones from ntimage.h
511 //
512
513 const
514 DBHHEADER_DEBUGDIRS = $1;
515 {$EXTERNALSYM DBHHEADER_DEBUGDIRS}
516
517 type
518 _MODLOAD_DATA = record
519 ssize: DWORD; // size of this struct
520 ssig: DWORD; // signature identifying the passed data
521 data: PVOID; // pointer to passed data
522 size: DWORD; // size of passed data
523 flags: DWORD; // options
524 end;
525 {$EXTERNALSYM _MODLOAD_DATA}
526 MODLOAD_DATA = _MODLOAD_DATA;
527 {$EXTERNALSYM MODLOAD_DATA}
528 PMODLOAD_DATA = ^MODLOAD_DATA;
529 {$EXTERNALSYM PMODLOAD_DATA}
530 TModLoadData = MODLOAD_DATA;
531 PModLoadData = PMODLOAD_DATA;
532
533 //
534 // StackWalking API
535 //
536
537 type
538 ADDRESS_MODE = (
539 AddrMode1616,
540 AddrMode1632,
541 AddrModeReal,
542 AddrModeFlat);
543 {$EXTERNALSYM ADDRESS_MODE}
544 TAddressMode = ADDRESS_MODE;
545
546 LPADDRESS64 = ^ADDRESS64;
547 {$EXTERNALSYM PADDRESS64}
548 _tagADDRESS64 = record
549 Offset: DWORD64;
550 Segment: WORD;
551 Mode: ADDRESS_MODE;
552 end;
553 {$EXTERNALSYM _tagADDRESS64}
554 ADDRESS64 = _tagADDRESS64;
555 {$EXTERNALSYM ADDRESS64}
556 TAddress64 = ADDRESS64;
557 PAddress64 = LPADDRESS64;
558
559 LPADDRESS = ^ADDRESS;
560 {$EXTERNALSYM PADDRESS}
561 _tagADDRESS = record
562 Offset: DWORD;
563 Segment: WORD;
564 Mode: ADDRESS_MODE;
565 end;
566 {$EXTERNALSYM _tagADDRESS}
567 ADDRESS = _tagADDRESS;
568 {$EXTERNALSYM ADDRESS}
569 TAddress = ADDRESS;
570 PAddress = LPADDRESS;
571
572 procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
573 {$EXTERNALSYM Address32To64}
574
575 procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
576 {$EXTERNALSYM Address64To32}
577
578 //
579 // This structure is included in the STACKFRAME structure,
580 // and is used to trace through usermode callbacks in a thread's
581 // kernel stack. The values must be copied by the kernel debugger
582 // from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
583 //
584
585 //
586 // New KDHELP structure for 64 bit system support.
587 // This structure is preferred in new code.
588 //
589
590 type
591 PKDHELP64 = ^KDHELP64;
592 {$EXTERNALSYM PKDHELP64}
593 _KDHELP64 = record
594 //
595 // address of kernel thread object, as provided in the
596 // WAIT_STATE_CHANGE packet.
597 //
598 Thread: DWORD64;
599 //
600 // offset in thread object to pointer to the current callback frame
601 // in kernel stack.
602 //
603 ThCallbackStack: DWORD;
604 //
605 // offset in thread object to pointer to the current callback backing
606 // store frame in kernel stack.
607 //
608 ThCallbackBStore: DWORD;
609 //
610 // offsets to values in frame:
611 //
612 // address of next callback frame
613 NextCallback: DWORD;
614 // address of saved frame pointer (if applicable)
615 FramePointer: DWORD;
616 //
thatnull617 // Address of the kernel function that calls out to user mode
618 //
619 KiCallUserMode: DWORD64;
620 //
621 // Address of the user mode dispatcher function
622 //
623 KeUserCallbackDispatcher: DWORD64;
624 //
625 // Lowest kernel mode address
626 //
627 SystemRangeStart: DWORD64;
628 Reserved: array [0..7] of DWORD64;
629 end;
630 {$EXTERNALSYM _KDHELP64}
631 KDHELP64 = _KDHELP64;
632 {$EXTERNALSYM KDHELP64}
633 TKdHelp64 = KDHELP64;
634 //PKdHelp64 = PKDHELP64;
635
636 PKDHELP = ^KDHELP;
637 {$EXTERNALSYM PKDHELP}
638 _KDHELP = record
639 //
640 // address of kernel thread object, as provided in the
641 // WAIT_STATE_CHANGE packet.
642 //
643 Thread: DWORD;
644 //
645 // offset in thread object to pointer to the current callback frame
646 // in kernel stack.
647 //
648 ThCallbackStack: DWORD;
649 //
650 // offsets to values in frame:
651 //
652 // address of next callback frame
653 NextCallback: DWORD;
654 // address of saved frame pointer (if applicable)
655 FramePointer: DWORD;
656 //
thatnull657 // Address of the kernel function that calls out to user mode
658 //
659 KiCallUserMode: DWORD;
660 //
661 // Address of the user mode dispatcher function
662 //
663 KeUserCallbackDispatcher: DWORD;
664 //
665 // Lowest kernel mode address
666 //
667 SystemRangeStart: DWORD;
668 //
669 // offset in thread object to pointer to the current callback backing
670 // store frame in kernel stack.
671 //
672 ThCallbackBStore: DWORD;
673 Reserved: array [0..7] of DWORD;
674 end;
675 {$EXTERNALSYM _KDHELP}
676 KDHELP = _KDHELP;
677 {$EXTERNALSYM KDHELP}
678 TKdHelp = KDHELP;
679 //PKdHelp = PKDHELP;
680
681 procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
682 {$EXTERNALSYM KdHelp32To64}
683
684 type
685 LPSTACKFRAME64 = ^STACKFRAME64;
686 {$EXTERNALSYM LPSTACKFRAME64}
687 _tagSTACKFRAME64 = record
688 AddrPC: ADDRESS64; // program counter
689 AddrReturn: ADDRESS64; // return address
690 AddrFrame: ADDRESS64; // frame pointer
691 AddrStack: ADDRESS64; // stack pointer
692 AddrBStore: ADDRESS64; // backing store pointer
693 FuncTableEntry: PVOID; // pointer to pdata/fpo or NULL
694 Params: array [0..3] of DWORD64; // possible arguments to the function
Farnull695 Far: BOOL; // WOW far call
696 Virtual: BOOL; // is this a virtual frame?
697 Reserved: array [0..2] of DWORD64;
698 KdHelp: KDHELP64;
699 end;
700 {$EXTERNALSYM _tagSTACKFRAME64}
701 STACKFRAME64 = _tagSTACKFRAME64;
702 {$EXTERNALSYM STACKFRAME64}
703 TStackFrame64 = STACKFRAME64;
704 PStackFrame64 = LPSTACKFRAME64;
705
706 LPSTACKFRAME = ^STACKFRAME;
707 {$EXTERNALSYM LPSTACKFRAME}
708 _tagSTACKFRAME = record
709 AddrPC: ADDRESS; // program counter
710 AddrReturn: ADDRESS; // return address
711 AddrFrame: ADDRESS; // frame pointer
712 AddrStack: ADDRESS; // stack pointer
713 FuncTableEntry: PVOID; // pointer to pdata/fpo or NULL
714 Params: array [0..3] of DWORD; // possible arguments to the function
Farnull715 Far: BOOL; // WOW far call
716 Virtual: BOOL; // is this a virtual frame?
717 Reserved: array [0..2] of DWORD;
718 KdHelp: KDHELP;
719 AddrBStore: ADDRESS; // backing store pointer
720 end;
721 {$EXTERNALSYM _tagSTACKFRAME}
722 STACKFRAME = _tagSTACKFRAME;
723 {$EXTERNALSYM STACKFRAME}
724 TStackFrame = STACKFRAME;
725 PStackFrame = LPSTACKFRAME;
726
Processnull727 PREAD_PROCESS_MEMORY_ROUTINE64 = function(hProcess: HANDLE; qwBaseAddress: DWORD64;
728 lpBuffer: PVOID; nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
729 {$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE64}
730 PReadProcessMemoryRoutine64 = PREAD_PROCESS_MEMORY_ROUTINE64;
731
Processnull732 PFUNCTION_TABLE_ACCESS_ROUTINE64 = function(hProcess: HANDLE;
733 AddrBase: DWORD64): PVOID; stdcall;
734 {$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE64}
735 PFunctionTableAccessRoutine64 = PFUNCTION_TABLE_ACCESS_ROUTINE64;
736
Processnull737 PGET_MODULE_BASE_ROUTINE64 = function(hProcess: HANDLE;
738 Address: DWORD64): DWORD64; stdcall;
739 {$EXTERNALSYM PGET_MODULE_BASE_ROUTINE64}
740 PGetModuleBaseRoutine64 = PGET_MODULE_BASE_ROUTINE64;
741
Processnull742 PTRANSLATE_ADDRESS_ROUTINE64 = function(hProcess: HANDLE; hThread: HANDLE;
743 const lpaddr: ADDRESS64): DWORD64; stdcall;
744 {$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE64}
745 PTranslateAddressRoutine64 = PTRANSLATE_ADDRESS_ROUTINE64;
746
StackWalk64null747 function StackWalk64(MachineType: DWORD; hProcess: HANDLE; hThread: HANDLE;
748 var StackFrame: STACKFRAME64; ContextRecord: PVOID;
749 ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64;
750 FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64;
751 GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64;
752 TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64): BOOL; stdcall;
753 {$EXTERNALSYM StackWalk64}
754
755 type
Processnull756 PREAD_PROCESS_MEMORY_ROUTINE = function(hProcess: HANDLE;
757 lpBaseAddress: DWORD; lpBuffer: PVOID; nSize: DWORD;
758 var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
759 {$EXTERNALSYM PREAD_PROCESS_MEMORY_ROUTINE}
760 PreadProcessMemoryRoutine = PREAD_PROCESS_MEMORY_ROUTINE;
761
Processnull762 PFUNCTION_TABLE_ACCESS_ROUTINE = function(hProcess: HANDLE; AddrBase: DWORD): PVOID; stdcall;
763 {$EXTERNALSYM PFUNCTION_TABLE_ACCESS_ROUTINE}
764 PFunctionTableAccessRoutine = PFUNCTION_TABLE_ACCESS_ROUTINE;
765
Processnull766 PGET_MODULE_BASE_ROUTINE = function(hProcess: HANDLE; Address: DWORD): DWORD; stdcall;
767 {$EXTERNALSYM PGET_MODULE_BASE_ROUTINE}
768 PGetModuleBaseRoutine = PGET_MODULE_BASE_ROUTINE;
769
Processnull770 PTRANSLATE_ADDRESS_ROUTINE = function(hProcess: HANDLE; hThread: HANDLE;
771 const lpaddr: ADDRESS): DWORD; stdcall;
772 {$EXTERNALSYM PTRANSLATE_ADDRESS_ROUTINE}
773 PTranslateAddressRoutine = PTRANSLATE_ADDRESS_ROUTINE;
774
StackWalknull775 function StackWalk(MachineType: DWORD; hProcess: HANDLE; hThread: HANDLE;
776 var StackFrame: STACKFRAME; ContextRecord: PVOID;
777 ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE;
778 FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE;
779 GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE;
780 TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE): BOOL; stdcall;
781 {$EXTERNALSYM StackWalk}
782
783 const
784 API_VERSION_NUMBER = 9;
785 {$EXTERNALSYM API_VERSION_NUMBER}
786
787 type
788 LPAPI_VERSION = ^API_VERSION;
789 {$EXTERNALSYM LPAPI_VERSION}
790 API_VERSION = record
791 MajorVersion: USHORT;
792 MinorVersion: USHORT;
793 Revision: USHORT;
794 Reserved: USHORT;
795 end;
796 {$EXTERNALSYM API_VERSION}
797 TApiVersion = API_VERSION;
798 PApiVersion = LPAPI_VERSION;
799
ImagehlpApiVersionnull800 function ImagehlpApiVersion: LPAPI_VERSION; stdcall;
801 {$EXTERNALSYM ImagehlpApiVersion}
802
ImagehlpApiVersionExnull803 function ImagehlpApiVersionEx(const AppVersion: API_VERSION): LPAPI_VERSION; stdcall;
804 {$EXTERNALSYM ImagehlpApiVersionEx}
805
GetTimestampForLoadedLibrarynull806 function GetTimestampForLoadedLibrary(Module: HMODULE): DWORD; stdcall;
807 {$EXTERNALSYM GetTimestampForLoadedLibrary}
808
809 //
pointersnull810 // typedefs for function pointers
811 //
812
813 type
814 PSYM_ENUMMODULES_CALLBACK64 = function(ModuleName: PSTR; BaseOfDll: DWORD64;
815 UserContext: PVOID): BOOL; stdcall;
816 {$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK64}
817 PSymEnummodulesCallback64 = PSYM_ENUMMODULES_CALLBACK64;
818
ymbolNamenull819 PSYM_ENUMSYMBOLS_CALLBACK64 = function(SymbolName: PSTR; SymbolAddress: DWORD64;
820 SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
821 {$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK64}
822 PSymEnumsymbolsCallback64 = PSYM_ENUMSYMBOLS_CALLBACK64;
823
ymbolNamenull824 PSYM_ENUMSYMBOLS_CALLBACK64W = function(SymbolName: PWSTR;
825 SymbolAddress: DWORD64; SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
826 {$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK64W}
827 PSymEnumsymbolsCallback64w = PSYM_ENUMSYMBOLS_CALLBACK64W;
828
oduleNamenull829 PENUMLOADED_MODULES_CALLBACK64 = function(ModuleName: PSTR;
830 ModuleBase: DWORD64; ModuleSize: ULONG; UserContext: PVOID): BOOL; stdcall;
831 {$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK64}
832 PSnumloadedModulesCallback64 = PENUMLOADED_MODULES_CALLBACK64;
833
Processnull834 PSYMBOL_REGISTERED_CALLBACK64 = function(hProcess: HANDLE; ActionCode: ULONG;
835 CallbackData: ULONG64; UserContext: ULONG64): BOOL; stdcall;
836 {$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK64}
837 PSymbolRegisteredCallback64 = PSYMBOL_REGISTERED_CALLBACK64;
838
Processnull839 PSYMBOL_FUNCENTRY_CALLBACK = function(hProcess: HANDLE; AddrBase: DWORD;
840 UserContext: PVOID): PVOID; stdcall;
841 {$EXTERNALSYM PSYMBOL_FUNCENTRY_CALLBACK}
842 PSymbolFuncentryCallback = PSYMBOL_FUNCENTRY_CALLBACK;
843
Processnull844 PSYMBOL_FUNCENTRY_CALLBACK64 = function(hProcess: HANDLE; AddrBase: ULONG64;
845 UserContext: ULONG64): PVOID; stdcall;
846 {$EXTERNALSYM PSYMBOL_FUNCENTRY_CALLBACK64}
847 PSymbolFuncentryCallback64 = PSYMBOL_FUNCENTRY_CALLBACK64;
848
oduleNamenull849 PSYM_ENUMMODULES_CALLBACK = function(ModuleName: PSTR; BaseOfDll: ULONG;
850 UserContext: PVOID): BOOL; stdcall;
851 {$EXTERNALSYM PSYM_ENUMMODULES_CALLBACK}
852 PSymEnummodulesCallback = PSYM_ENUMMODULES_CALLBACK;
853
ymbolNamenull854 PSYM_ENUMSYMBOLS_CALLBACK = function(SymbolName: PSTR; SymbolAddress: ULONG;
855 SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
856 {$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACK}
857 PSymEnumsymbolsCallback = PSYM_ENUMSYMBOLS_CALLBACK;
858
ymbolNamenull859 PSYM_ENUMSYMBOLS_CALLBACKW = function(SymbolName: PWSTR; SymbolAddress: ULONG;
860 SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
861 {$EXTERNALSYM PSYM_ENUMSYMBOLS_CALLBACKW}
862 PSymEnumsymbolsCallbackw = PSYM_ENUMSYMBOLS_CALLBACKW;
863
oduleNamenull864 PENUMLOADED_MODULES_CALLBACK = function(ModuleName: PSTR; ModuleBase: ULONG;
865 ModuleSize: ULONG; UserContext: PVOID): BOOL; stdcall;
866 {$EXTERNALSYM PENUMLOADED_MODULES_CALLBACK}
867 PEnumloadedModulesCallback = PENUMLOADED_MODULES_CALLBACK;
868
Processnull869 PSYMBOL_REGISTERED_CALLBACK = function(hProcess: HANDLE; ActionCode: ULONG;
870 CallbackData: PVOID; UserContext: PVOID): BOOL; stdcall;
871 {$EXTERNALSYM PSYMBOL_REGISTERED_CALLBACK}
872 PSymbolRegisteredCallback = PSYMBOL_REGISTERED_CALLBACK;
873
874 //
875 // flags found in SYMBOL_INFO.Flags
876 //
877
878 const
879 SYMFLAG_VALUEPRESENT = $00000001;
880 {$EXTERNALSYM SYMFLAG_VALUEPRESENT}
881 SYMFLAG_REGISTER = $00000008;
882 {$EXTERNALSYM SYMFLAG_REGISTER}
883 SYMFLAG_REGREL = $00000010;
884 {$EXTERNALSYM SYMFLAG_REGREL}
885 SYMFLAG_FRAMEREL = $00000020;
886 {$EXTERNALSYM SYMFLAG_FRAMEREL}
887 SYMFLAG_PARAMETER = $00000040;
888 {$EXTERNALSYM SYMFLAG_PARAMETER}
889 SYMFLAG_LOCAL = $00000080;
890 {$EXTERNALSYM SYMFLAG_LOCAL}
891 SYMFLAG_CONSTANT = $00000100;
892 {$EXTERNALSYM SYMFLAG_CONSTANT}
893 SYMFLAG_EXPORT = $00000200;
894 {$EXTERNALSYM SYMFLAG_EXPORT}
895 SYMFLAG_FORWARDER = $00000400;
896 {$EXTERNALSYM SYMFLAG_FORWARDER}
897 SYMFLAG_FUNCTION = $00000800;
898 {$EXTERNALSYM SYMFLAG_FUNCTION}
899 SYMFLAG_VIRTUAL = $00001000;
900 {$EXTERNALSYM SYMFLAG_VIRTUAL}
901 SYMFLAG_THUNK = $00002000;
902 {$EXTERNALSYM SYMFLAG_THUNK}
903 SYMFLAG_TLSREL = $00004000;
904 {$EXTERNALSYM SYMFLAG_TLSREL}
905
906 //
907 // symbol type enumeration
908 //
909
910 type
911 SYM_TYPE = (
912 SymNone,
913 SymCoff,
914 SymCv,
915 SymPdb,
916 SymExport,
917 SymDeferred,
918 SymSym, // .sym file
919 SymDia,
920 SymVirtual,
921 NumSymTypes);
922 {$EXTERNALSYM SYM_TYPE}
923 TSymType = SYM_TYPE;
924
925 //
926 // symbol data structure
927 //
928
929 PIMAGEHLP_SYMBOL64 = ^IMAGEHLP_SYMBOL64;
930 {$EXTERNALSYM PIMAGEHLP_SYMBOL64}
931 _IMAGEHLP_SYMBOL64 = record
932 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_SYMBOL64)
933 Address: DWORD64; // virtual address including dll base address
934 Size: DWORD; // estimated size of symbol, can be zero
935 Flags: DWORD; // info about the symbols, see the SYMF defines
936 MaxNameLength: DWORD; // maximum size of symbol name in 'Name'
937 Name: array [0..0] of CHAR; // symbol name (null terminated string)
938 end;
939 {$EXTERNALSYM _IMAGEHLP_SYMBOL64}
940 IMAGEHLP_SYMBOL64 = _IMAGEHLP_SYMBOL64;
941 {$EXTERNALSYM IMAGEHLP_SYMBOL64}
942 TImageHlpSymbol64 = IMAGEHLP_SYMBOL64;
943 PImageHlpSymbol64 = PIMAGEHLP_SYMBOL64;
944
945 _IMAGEHLP_SYMBOL64_PACKAGE = record
946 sym: IMAGEHLP_SYMBOL64;
947 name: array [0..MAX_SYM_NAME] of CHAR;
948 end;
949 {$EXTERNALSYM _IMAGEHLP_SYMBOL64_PACKAGE}
950 IMAGEHLP_SYMBOL64_PACKAGE = _IMAGEHLP_SYMBOL64_PACKAGE;
951 {$EXTERNALSYM IMAGEHLP_SYMBOL64_PACKAGE}
952 PIMAGEHLP_SYMBOL64_PACKAGE = ^IMAGEHLP_SYMBOL64_PACKAGE;
953 {$EXTERNALSYM PIMAGEHLP_SYMBOL64_PACKAGE}
954 TImageHlpSymbol64Package = IMAGEHLP_SYMBOL64_PACKAGE;
955 PImageHlpSymbol64Package = PIMAGEHLP_SYMBOL64_PACKAGE;
956
957 //#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
958 //
959 //#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
960 //#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
961 //#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
962 //#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
963 //
964 //#else
965
966 PIMAGEHLP_SYMBOL = ^IMAGEHLP_SYMBOL;
967 {$EXTERNALSYM PIMAGEHLP_SYMBOL}
968 _IMAGEHLP_SYMBOL = record
969 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_SYMBOL)
970 Address: DWORD; // virtual address including dll base address
971 Size: DWORD; // estimated size of symbol, can be zero
972 Flags: DWORD; // info about the symbols, see the SYMF defines
973 MaxNameLength: DWORD; // maximum size of symbol name in 'Name'
974 Name: array [0..0] of CHAR; // symbol name (null terminated string)
975 end;
976 {$EXTERNALSYM _IMAGEHLP_SYMBOL}
977 IMAGEHLP_SYMBOL = _IMAGEHLP_SYMBOL;
978 {$EXTERNALSYM IMAGEHLP_SYMBOL}
979 TImageHlpSymbol = IMAGEHLP_SYMBOL;
980 PImageHlpSymbol = PIMAGEHLP_SYMBOL;
981
982 _IMAGEHLP_SYMBOL_PACKAGE = record
983 sym: IMAGEHLP_SYMBOL;
984 name: array [0..MAX_SYM_NAME] of CHAR;
985 end;
986 {$EXTERNALSYM _IMAGEHLP_SYMBOL_PACKAGE}
987 IMAGEHLP_SYMBOL_PACKAGE = _IMAGEHLP_SYMBOL_PACKAGE;
988 {$EXTERNALSYM IMAGEHLP_SYMBOL_PACKAGE}
989 PIMAGEHLP_SYMBOL_PACKAGE = ^IMAGEHLP_SYMBOL_PACKAGE;
990 {$EXTERNALSYM PIMAGEHLP_SYMBOL_PACKAGE}
991 TImageHlpSymbolPackage = IMAGEHLP_SYMBOL_PACKAGE;
992 PImageHlpSymbolPackage = PIMAGEHLP_SYMBOL_PACKAGE;
993
994 //#endif
995
996 //
997 // module data structure
998 //
999
1000 PIMAGEHLP_MODULE64 = ^IMAGEHLP_MODULE64;
1001 {$EXTERNALSYM PIMAGEHLP_MODULE64}
1002 _IMAGEHLP_MODULE64 = record
1003 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
1004 BaseOfImage: DWORD64; // base load address of module
1005 ImageSize: DWORD; // virtual size of the loaded module
1006 TimeDateStamp: DWORD; // date/time stamp from pe header
1007 CheckSum: DWORD; // checksum from the pe header
1008 NumSyms: DWORD; // number of symbols in the symbol table
1009 SymType: SYM_TYPE; // type of symbols loaded
1010 ModuleName: array [0..3] of CHAR; // module name
1011 ImageName: array [0..255] of CHAR; // image name
1012 LoadedImageName: array [0..255] of CHAR; // symbol file name
1013 end;
1014 {$EXTERNALSYM _IMAGEHLP_MODULE64}
1015 IMAGEHLP_MODULE64 = _IMAGEHLP_MODULE64;
1016 {$EXTERNALSYM IMAGEHLP_MODULE64}
1017 TImageHlpModule64 = IMAGEHLP_MODULE64;
1018 PImageHlpModule64 = PIMAGEHLP_MODULE64;
1019
1020 PIMAGEHLP_MODULEW64 = ^IMAGEHLP_MODULEW64;
1021 {$EXTERNALSYM PIMAGEHLP_MODULEW64}
1022 _IMAGEHLP_MODULE64W = record
1023 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE64)
1024 BaseOfImage: DWORD64; // base load address of module
1025 ImageSize: DWORD; // virtual size of the loaded module
1026 TimeDateStamp: DWORD; // date/time stamp from pe header
1027 CheckSum: DWORD; // checksum from the pe header
1028 NumSyms: DWORD; // number of symbols in the symbol table
1029 SymType: SYM_TYPE; // type of symbols loaded
1030 ModuleName: array [0..31] of WCHAR; // module name
1031 ImageName: array [0..255] of WCHAR; // image name
1032 LoadedImageName: array [0..255] of WCHAR; // symbol file name
1033 end;
1034 {$EXTERNALSYM _IMAGEHLP_MODULE64W}
1035 IMAGEHLP_MODULEW64 = _IMAGEHLP_MODULE64W;
1036 {$EXTERNALSYM IMAGEHLP_MODULEW64}
1037 TImageHlpModuleW64 = IMAGEHLP_MODULEW64;
1038 PImageHlpModuleW64 = PIMAGEHLP_MODULEW64;
1039
1040 PIMAGEHLP_MODULE = ^IMAGEHLP_MODULE;
1041 {$EXTERNALSYM PIMAGEHLP_MODULE}
1042 _IMAGEHLP_MODULE = record
1043 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
1044 BaseOfImage: DWORD; // base load address of module
1045 ImageSize: DWORD; // virtual size of the loaded module
1046 TimeDateStamp: DWORD; // date/time stamp from pe header
1047 CheckSum: DWORD; // checksum from the pe header
1048 NumSyms: DWORD; // number of symbols in the symbol table
1049 SymType: SYM_TYPE; // type of symbols loaded
1050 ModuleName: array [0..31] of CHAR; // module name
1051 ImageName: array [0..255] of CHAR; // image name
1052 LoadedImageName: array [0..255] of CHAR; // symbol file name
1053 end;
1054 {$EXTERNALSYM _IMAGEHLP_MODULE}
1055 IMAGEHLP_MODULE = _IMAGEHLP_MODULE;
1056 {$EXTERNALSYM IMAGEHLP_MODULE}
1057 TImageHlpModule = IMAGEHLP_MODULE;
1058 PImageHlpModule = PIMAGEHLP_MODULE;
1059
1060 PIMAGEHLP_MODULEW = ^IMAGEHLP_MODULEW;
1061 {$EXTERNALSYM PIMAGEHLP_MODULEW}
1062 _IMAGEHLP_MODULEW = record
1063 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_MODULE)
1064 BaseOfImage: DWORD; // base load address of module
1065 ImageSize: DWORD; // virtual size of the loaded module
1066 TimeDateStamp: DWORD; // date/time stamp from pe header
1067 CheckSum: DWORD; // checksum from the pe header
1068 NumSyms: DWORD; // number of symbols in the symbol table
1069 SymType: SYM_TYPE; // type of symbols loaded
1070 ModuleName: array [0..31] of WCHAR; // module name
1071 ImageName: array [0..255] of WCHAR; // image name
1072 LoadedImageName: array [0..255] of WCHAR; // symbol file name
1073 end;
1074 {$EXTERNALSYM _IMAGEHLP_MODULEW}
1075 IMAGEHLP_MODULEW = _IMAGEHLP_MODULEW;
1076 {$EXTERNALSYM IMAGEHLP_MODULEW}
1077 TImageHlpModuleW = IMAGEHLP_MODULEW;
1078 PImageHlpModuleW = PIMAGEHLP_MODULEW;
1079
1080 //
1081 // source file line data structure
1082 //
1083
1084 PIMAGEHLP_LINE64 = ^IMAGEHLP_LINE64;
1085 {$EXTERNALSYM PIMAGEHLP_LINE64}
1086 _IMAGEHLP_LINE64 = record
1087 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE64)
1088 Key: PVOID; // internal
1089 LineNumber: DWORD; // line number in file
1090 FileName: PCHAR; // full filename
1091 Address: DWORD64; // first instruction of line
1092 end;
1093 {$EXTERNALSYM _IMAGEHLP_LINE64}
1094 IMAGEHLP_LINE64 = _IMAGEHLP_LINE64;
1095 {$EXTERNALSYM IMAGEHLP_LINE64}
1096 TImageHlpLine64 = IMAGEHLP_LINE64;
1097 PImageHlpLine64 = PIMAGEHLP_LINE64;
1098
1099 PIMAGEHLP_LINE = ^IMAGEHLP_LINE;
1100 {$EXTERNALSYM PIMAGEHLP_LINE}
1101 _IMAGEHLP_LINE = record
1102 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_LINE)
1103 Key: PVOID; // internal
1104 LineNumber: DWORD; // line number in file
1105 FileName: PCHAR; // full filename
1106 Address: DWORD; // first instruction of line
1107 end;
1108 {$EXTERNALSYM _IMAGEHLP_LINE}
1109 IMAGEHLP_LINE = _IMAGEHLP_LINE;
1110 {$EXTERNALSYM IMAGEHLP_LINE}
1111 TImageHlpLine = IMAGEHLP_LINE;
1112 PImageHlpLine = PIMAGEHLP_LINE;
1113
1114 //
1115 // source file structure
1116 //
1117
1118 type
1119 _SOURCEFILE = record
1120 ModBase: DWORD64; // base address of loaded module
1121 FileName: PCHAR; // full filename of source
1122 end;
1123 {$EXTERNALSYM _SOURCEFILE}
1124 SOURCEFILE = _SOURCEFILE;
1125 {$EXTERNALSYM SOURCEFILE}
1126 PSOURCEFILE = ^SOURCEFILE;
1127 {$EXTERNALSYM PSOURCEFILE}
1128 TSourceFile = SOURCEFILE;
1129
1130 //
1131 // data structures used for registered symbol callbacks
1132 //
1133
1134 const
1135 CBA_DEFERRED_SYMBOL_LOAD_START = $00000001;
1136 {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_START}
1137 CBA_DEFERRED_SYMBOL_LOAD_COMPLETE = $00000002;
1138 {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_COMPLETE}
1139 CBA_DEFERRED_SYMBOL_LOAD_FAILURE = $00000003;
1140 {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_FAILURE}
1141 CBA_SYMBOLS_UNLOADED = $00000004;
1142 {$EXTERNALSYM CBA_SYMBOLS_UNLOADED}
1143 CBA_DUPLICATE_SYMBOL = $00000005;
1144 {$EXTERNALSYM CBA_DUPLICATE_SYMBOL}
1145 CBA_READ_MEMORY = $00000006;
1146 {$EXTERNALSYM CBA_READ_MEMORY}
1147 CBA_DEFERRED_SYMBOL_LOAD_CANCEL = $00000007;
1148 {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_CANCEL}
1149 CBA_SET_OPTIONS = $00000008;
1150 {$EXTERNALSYM CBA_SET_OPTIONS}
1151 CBA_EVENT = $00000010;
1152 {$EXTERNALSYM CBA_EVENT}
1153 CBA_DEFERRED_SYMBOL_LOAD_PARTIAL = $00000020;
1154 {$EXTERNALSYM CBA_DEFERRED_SYMBOL_LOAD_PARTIAL}
1155 CBA_DEBUG_INFO = $10000000;
1156 {$EXTERNALSYM CBA_DEBUG_INFO}
1157
1158 type
1159 PIMAGEHLP_CBA_READ_MEMORY = ^IMAGEHLP_CBA_READ_MEMORY;
1160 {$EXTERNALSYM PIMAGEHLP_CBA_READ_MEMORY}
1161 _IMAGEHLP_CBA_READ_MEMORY = record
1162 addr: DWORD64; // address to read from
1163 buf: PVOID; // buffer to read to
1164 bytes: DWORD; // amount of bytes to read
1165 bytesread: LPDWORD; // pointer to store amount of bytes read
1166 end;
1167 {$EXTERNALSYM _IMAGEHLP_CBA_READ_MEMORY}
1168 IMAGEHLP_CBA_READ_MEMORY = _IMAGEHLP_CBA_READ_MEMORY;
1169 {$EXTERNALSYM IMAGEHLP_CBA_READ_MEMORY}
1170 TImageHlpCbaReadMemory = IMAGEHLP_CBA_READ_MEMORY;
1171 PImageHlpCbaReadMemory = PIMAGEHLP_CBA_READ_MEMORY;
1172
1173 const
1174 sevInfo = 0;
1175 {$EXTERNALSYM sevInfo}
1176 sevProblem = 1;
1177 {$EXTERNALSYM sevProblem}
1178 sevAttn = 2;
1179 {$EXTERNALSYM sevAttn}
1180 sevFatal = 3;
1181 {$EXTERNALSYM sevFatal}
1182 sevMax = 4; // unused
1183 {$EXTERNALSYM sevMax}
1184
1185 type
1186 _IMAGEHLP_CBA_EVENT = record
1187 severity: DWORD; // values from sevInfo to sevFatal
1188 code: DWORD; // numerical code IDs the error
1189 desc: PCHAR; // may contain a text description of the error
1190 object_: PVOID; // value dependant upon the error code
1191 end;
1192 {$EXTERNALSYM _IMAGEHLP_CBA_EVENT}
1193 IMAGEHLP_CBA_EVENT = _IMAGEHLP_CBA_EVENT;
1194 {$EXTERNALSYM IMAGEHLP_CBA_EVENT}
1195 PIMAGEHLP_CBA_EVENT = ^IMAGEHLP_CBA_EVENT;
1196 {$EXTERNALSYM PIMAGEHLP_CBA_EVENT}
1197 TImageHlpCbaEvent = IMAGEHLP_CBA_EVENT;
1198 PImageHlpCbaEvent = PIMAGEHLP_CBA_EVENT;
1199
1200 PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1201 {$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1202 _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = record
1203 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
1204 BaseOfImage: DWORD64; // base load address of module
1205 CheckSum: DWORD; // checksum from the pe header
1206 TimeDateStamp: DWORD; // date/time stamp from pe header
1207 FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
1208 Reparse: ByteBool; // load failure reparse
1209 hFile: HANDLE; // file handle, if passed
1210 Flags: DWORD; //
1211 end;
1212 {$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1213 IMAGEHLP_DEFERRED_SYMBOL_LOAD64 = _IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1214 {$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD64}
1215 TImageHlpDeferredSymbolLoad64 = IMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1216 PImageHlpDeferredSymbolLoad64 = PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
1217
1218 const
1219 DSLFLAG_MISMATCHED_PDB = $1;
1220 {$EXTERNALSYM DSLFLAG_MISMATCHED_PDB}
1221 DSLFLAG_MISMATCHED_DBG = $2;
1222 {$EXTERNALSYM DSLFLAG_MISMATCHED_DBG}
1223
1224 type
1225 PIMAGEHLP_DEFERRED_SYMBOL_LOAD = ^IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1226 {$EXTERNALSYM PIMAGEHLP_DEFERRED_SYMBOL_LOAD}
1227 _IMAGEHLP_DEFERRED_SYMBOL_LOAD = record
1228 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
1229 BaseOfImage: DWORD; // base load address of module
1230 CheckSum: DWORD; // checksum from the pe header
1231 TimeDateStamp: DWORD; // date/time stamp from pe header
1232 FileName: array [0..MAX_PATH - 1] of CHAR; // symbols file or image name
1233 Reparse: ByteBool; // load failure reparse
1234 hFile: HANDLE; // file handle, if passed
1235 end;
1236 {$EXTERNALSYM _IMAGEHLP_DEFERRED_SYMBOL_LOAD}
1237 IMAGEHLP_DEFERRED_SYMBOL_LOAD = _IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1238 {$EXTERNALSYM IMAGEHLP_DEFERRED_SYMBOL_LOAD}
1239 TImageHlpDeferredSymbolLoad = IMAGEHLP_DEFERRED_SYMBOL_LOAD;
1240 PImageHlpDeferredSymbolLoad = PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
1241
1242 PIMAGEHLP_DUPLICATE_SYMBOL64 = ^IMAGEHLP_DUPLICATE_SYMBOL64;
1243 {$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL64}
1244 _IMAGEHLP_DUPLICATE_SYMBOL64 = record
1245 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
1246 NumberOfDups: DWORD; // number of duplicates in the Symbol array
1247 Symbol: PIMAGEHLP_SYMBOL64; // array of duplicate symbols
1248 SelectedSymbol: DWORD; // symbol selected (-1 to start)
1249 end;
1250 {$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL64}
1251 IMAGEHLP_DUPLICATE_SYMBOL64 = _IMAGEHLP_DUPLICATE_SYMBOL64;
1252 {$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL64}
1253 TImageHlpDuplicateSymbol64 = IMAGEHLP_DUPLICATE_SYMBOL64;
1254 PImageHlpDuplicateSymbol64 = PIMAGEHLP_DUPLICATE_SYMBOL64;
1255
1256 PIMAGEHLP_DUPLICATE_SYMBOL = ^IMAGEHLP_DUPLICATE_SYMBOL;
1257 {$EXTERNALSYM PIMAGEHLP_DUPLICATE_SYMBOL}
1258 _IMAGEHLP_DUPLICATE_SYMBOL = record
1259 SizeOfStruct: DWORD; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
1260 NumberOfDups: DWORD; // number of duplicates in the Symbol array
1261 Symbol: PIMAGEHLP_SYMBOL; // array of duplicate symbols
1262 SelectedSymbol: DWORD; // symbol selected (-1 to start)
1263 end;
1264 {$EXTERNALSYM _IMAGEHLP_DUPLICATE_SYMBOL}
1265 IMAGEHLP_DUPLICATE_SYMBOL = _IMAGEHLP_DUPLICATE_SYMBOL;
1266 {$EXTERNALSYM IMAGEHLP_DUPLICATE_SYMBOL}
1267 TImageHlpDuplicateSymbol = IMAGEHLP_DUPLICATE_SYMBOL;
1268 PImageHlpDuplicateSymbol = PIMAGEHLP_DUPLICATE_SYMBOL;
1269
1270 // If dbghelp ever needs to display graphical UI, it will use this as the parent window.
1271
1272 //BOOL
1273 //SymSetParentWindow(
1274 // HWND hwnd
1275 // );
1276
1277 //
1278 // options that are set/returned by SymSetOptions() & SymGetOptions()
1279 // these are used as a mask
1280 //
1281
1282 const
1283 SYMOPT_CASE_INSENSITIVE = $00000001;
1284 {$EXTERNALSYM SYMOPT_CASE_INSENSITIVE}
1285 SYMOPT_UNDNAME = $00000002;
1286 {$EXTERNALSYM SYMOPT_UNDNAME}
1287 SYMOPT_DEFERRED_LOADS = $00000004;
1288 {$EXTERNALSYM SYMOPT_DEFERRED_LOADS}
1289 SYMOPT_NO_CPP = $00000008;
1290 {$EXTERNALSYM SYMOPT_NO_CPP}
1291 SYMOPT_LOAD_LINES = $00000010;
1292 {$EXTERNALSYM SYMOPT_LOAD_LINES}
1293 SYMOPT_OMAP_FIND_NEAREST = $00000020;
1294 {$EXTERNALSYM SYMOPT_OMAP_FIND_NEAREST}
1295 SYMOPT_LOAD_ANYTHING = $00000040;
1296 {$EXTERNALSYM SYMOPT_LOAD_ANYTHING}
1297 SYMOPT_IGNORE_CVREC = $00000080;
1298 {$EXTERNALSYM SYMOPT_IGNORE_CVREC}
1299 SYMOPT_NO_UNQUALIFIED_LOADS = $00000100;
1300 {$EXTERNALSYM SYMOPT_NO_UNQUALIFIED_LOADS}
1301 SYMOPT_FAIL_CRITICAL_ERRORS = $00000200;
1302 {$EXTERNALSYM SYMOPT_FAIL_CRITICAL_ERRORS}
1303 SYMOPT_EXACT_SYMBOLS = $00000400;
1304 {$EXTERNALSYM SYMOPT_EXACT_SYMBOLS}
1305 SYMOPT_ALLOW_ABSOLUTE_SYMBOLS = $00000800;
1306 {$EXTERNALSYM SYMOPT_ALLOW_ABSOLUTE_SYMBOLS}
1307 SYMOPT_IGNORE_NT_SYMPATH = $00001000;
1308 {$EXTERNALSYM SYMOPT_IGNORE_NT_SYMPATH}
1309 SYMOPT_INCLUDE_32BIT_MODULES = $00002000;
1310 {$EXTERNALSYM SYMOPT_INCLUDE_32BIT_MODULES}
1311 SYMOPT_PUBLICS_ONLY = $00004000;
1312 {$EXTERNALSYM SYMOPT_PUBLICS_ONLY}
1313 SYMOPT_NO_PUBLICS = $00008000;
1314 {$EXTERNALSYM SYMOPT_NO_PUBLICS}
1315 SYMOPT_AUTO_PUBLICS = $00010000;
1316 {$EXTERNALSYM SYMOPT_AUTO_PUBLICS}
1317 SYMOPT_NO_IMAGE_SEARCH = $00020000;
1318 {$EXTERNALSYM SYMOPT_NO_IMAGE_SEARCH}
1319 SYMOPT_SECURE = $00040000;
1320 {$EXTERNALSYM SYMOPT_SECURE}
1321
1322 SYMOPT_DEBUG = DWORD($80000000);
1323 {$EXTERNALSYM SYMOPT_DEBUG}
1324
SymSetOptionsnull1325 function SymSetOptions(SymOptions: DWORD): DWORD; stdcall;
1326 {$EXTERNALSYM SymSetOptions}
1327
SymGetOptionsnull1328 function SymGetOptions: DWORD; stdcall;
1329 {$EXTERNALSYM SymGetOptions}
1330
SymCleanupnull1331 function SymCleanup(hProcess: HANDLE): BOOL; stdcall;
1332 {$EXTERNALSYM SymCleanup}
1333
SymMatchStringnull1334 function SymMatchString(string_, expression: LPSTR; fCase: BOOL): BOOL; stdcall;
1335 {$EXTERNALSYM SymMatchString}
1336
1337 type
SourceFilenull1338 PSYM_ENUMSOURCFILES_CALLBACK = function(pSourceFile: PSOURCEFILE; UserContext: PVOID): BOOL; stdcall;
1339 {$EXTERNALSYM PSYM_ENUMSOURCFILES_CALLBACK}
1340 PSymEnumSourceFilesCallback = PSYM_ENUMSOURCFILES_CALLBACK;
1341
SymEnumSourceFilesnull1342 function SymEnumSourceFiles(hProcess: HANDLE; ModBase: ULONG64; Mask: LPSTR;
1343 cbSrcFiles: PSYM_ENUMSOURCFILES_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1344 {$EXTERNALSYM SymEnumSourceFiles}
1345
SymEnumerateModules64null1346 function SymEnumerateModules64(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK64;
1347 UserContext: PVOID): BOOL; stdcall;
1348 {$EXTERNALSYM SymEnumerateModules64}
1349
SymEnumerateModulesnull1350 function SymEnumerateModules(hProcess: HANDLE; EnumModulesCallback: PSYM_ENUMMODULES_CALLBACK;
1351 UserContext: PVOID): BOOL; stdcall;
1352 {$EXTERNALSYM SymEnumerateModules}
1353
SymEnumerateSymbols64null1354 function SymEnumerateSymbols64(hProcess: HANDLE; BaseOfDll: DWORD64;
1355 EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64; UserContext: PVOID): BOOL; stdcall;
1356 {$EXTERNALSYM SymEnumerateSymbols64}
1357
SymEnumerateSymbolsW64null1358 function SymEnumerateSymbolsW64(hProcess: HANDLE; BaseOfDll: DWORD64;
1359 EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK64W; UserContext: PVOID): BOOL; stdcall;
1360 {$EXTERNALSYM SymEnumerateSymbolsW64}
1361
SymEnumerateSymbolsnull1362 function SymEnumerateSymbols(hProcess: HANDLE; BaseOfDll: DWORD;
1363 EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1364 {$EXTERNALSYM SymEnumerateSymbols}
1365
SymEnumerateSymbolsWnull1366 function SymEnumerateSymbolsW(hProcess: HANDLE; BaseOfDll: DWORD;
1367 EnumSymbolsCallback: PSYM_ENUMSYMBOLS_CALLBACKW; UserContext: PVOID): BOOL; stdcall;
1368 {$EXTERNALSYM SymEnumerateSymbolsW}
1369
EnumerateLoadedModules64null1370 function EnumerateLoadedModules64(hProcess: HANDLE; EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK64;
1371 UserContext: PVOID): BOOL; stdcall;
1372 {$EXTERNALSYM EnumerateLoadedModules64}
1373
EnumerateLoadedModulesnull1374 function EnumerateLoadedModules(hProcess: HANDLE; EnumLoadedModulesCallback: PENUMLOADED_MODULES_CALLBACK;
1375 UserContext: PVOID): BOOL; stdcall;
1376 {$EXTERNALSYM EnumerateLoadedModules}
1377
SymFunctionTableAccess64null1378 function SymFunctionTableAccess64(hProcess: HANDLE; AddrBase: DWORD64): PVOID; stdcall;
1379 {$EXTERNALSYM SymFunctionTableAccess64}
1380
SymFunctionTableAccessnull1381 function SymFunctionTableAccess(hProcess: HANDLE; AddrBase: DWORD): PVOID; stdcall;
1382 {$EXTERNALSYM SymFunctionTableAccess}
1383
SymGetModuleInfo64null1384 function SymGetModuleInfo64(hProcess: HANDLE; qwAddr: DWORD64;
1385 var ModuleInfo: IMAGEHLP_MODULE64): BOOL; stdcall;
1386 {$EXTERNALSYM SymGetModuleInfo64}
1387
SymGetModuleInfoW64null1388 function SymGetModuleInfoW64(hProcess: HANDLE; qwAddr: DWORD64;
1389 var ModuleInfo: IMAGEHLP_MODULEW64): BOOL; stdcall;
1390 {$EXTERNALSYM SymGetModuleInfoW64}
1391
SymGetModuleInfonull1392 function SymGetModuleInfo(hProcess: HANDLE; dwAddr: DWORD;
1393 var ModuleInfo: IMAGEHLP_MODULE): BOOL; stdcall;
1394 {$EXTERNALSYM SymGetModuleInfo}
1395
SymGetModuleInfoWnull1396 function SymGetModuleInfoW(hProcess: HANDLE; dwAddr: DWORD;
1397 var ModuleInfo: IMAGEHLP_MODULEW): BOOL; stdcall;
1398 {$EXTERNALSYM SymGetModuleInfoW}
1399
SymGetModuleBase64null1400 function SymGetModuleBase64(hProcess: HANDLE; qwAddr: DWORD64): DWORD64; stdcall;
1401 {$EXTERNALSYM SymGetModuleBase64}
1402
SymGetModuleBasenull1403 function SymGetModuleBase(hProcess: HANDLE; dwAddr: DWORD): DWORD; stdcall;
1404 {$EXTERNALSYM SymGetModuleBase}
1405
SymGetSymNext64null1406 function SymGetSymNext64(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL64): BOOL; stdcall;
1407 {$EXTERNALSYM SymGetSymNext64}
1408
SymGetSymNextnull1409 function SymGetSymNext(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL): BOOL; stdcall;
1410 {$EXTERNALSYM SymGetSymNext}
1411
SymGetSymPrev64null1412 function SymGetSymPrev64(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL64): BOOL; stdcall;
1413 {$EXTERNALSYM SymGetSymPrev64}
1414
SymGetSymPrevnull1415 function SymGetSymPrev(hProcess: HANDLE; var Symbol: IMAGEHLP_SYMBOL): BOOL; stdcall;
1416 {$EXTERNALSYM SymGetSymPrev}
1417
SymGetLineFromAddr64null1418 function SymGetLineFromAddr64(hProcess: HANDLE; qwAddr: DWORD64;
1419 var pdwDisplacement: DWORD; var Line64: IMAGEHLP_LINE64): BOOL; stdcall;
1420 {$EXTERNALSYM SymGetLineFromAddr64}
1421
SymGetLineFromAddrnull1422 function SymGetLineFromAddr(hProcess: HANDLE; dwAddr: DWORD;
1423 var pdwDisplacement: DWORD; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1424 {$EXTERNALSYM SymGetLineFromAddr}
1425
SymGetLineFromName64null1426 function SymGetLineFromName64(hProcess: HANDLE; ModuleName: PSTR; FileName: PSTR;
1427 dwLineNumber: DWORD; var plDisplacement: LONG; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1428 {$EXTERNALSYM SymGetLineFromName64}
1429
SymGetLineFromNamenull1430 function SymGetLineFromName(hProcess: HANDLE; ModuleName: PSTR; FileName: PSTR;
1431 dwLineNumber: DWORD; var plDisplacement: LONG; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1432 {$EXTERNALSYM SymGetLineFromName}
1433
SymGetLineNext64null1434 function SymGetLineNext64(hProcess: HANDLE; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1435 {$EXTERNALSYM SymGetLineNext64}
1436
SymGetLineNextnull1437 function SymGetLineNext(hProcess: HANDLE; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1438 {$EXTERNALSYM SymGetLineNext}
1439
SymGetLinePrev64null1440 function SymGetLinePrev64(hProcess: HANDLE; var Line: IMAGEHLP_LINE64): BOOL; stdcall;
1441 {$EXTERNALSYM SymGetLinePrev64}
1442
SymGetLinePrevnull1443 function SymGetLinePrev(hProcess: HANDLE; var Line: IMAGEHLP_LINE): BOOL; stdcall;
1444 {$EXTERNALSYM SymGetLinePrev}
1445
SymMatchFileNamenull1446 function SymMatchFileName(FileName, Match: PSTR; var FileNameStop, MatchStop: PSTR): BOOL; stdcall;
1447 {$EXTERNALSYM SymMatchFileName}
1448
SymInitializenull1449 function SymInitialize(hProcess: HANDLE; UserSearchPath: PSTR; fInvadeProcess: BOOL): BOOL; stdcall;
1450 {$EXTERNALSYM SymInitialize}
1451
SymGetSearchPathnull1452 function SymGetSearchPath(hProcess: HANDLE; SearchPath: PSTR; SearchPathLength: DWORD): BOOL; stdcall;
1453 {$EXTERNALSYM SymGetSearchPath}
1454
SymSetSearchPathnull1455 function SymSetSearchPath(hProcess: HANDLE; SearchPath: PSTR): BOOL; stdcall;
1456 {$EXTERNALSYM SymSetSearchPath}
1457
SymLoadModule64null1458 function SymLoadModule64(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR;
1459 BaseOfDll: DWORD64; SizeOfDll: DWORD): DWORD64; stdcall;
1460 {$EXTERNALSYM SymLoadModule64}
1461
1462 const
1463 SLMFLAG_VIRTUAL = $1;
1464 {$EXTERNALSYM SLMFLAG_VIRTUAL}
1465
SymLoadModuleExnull1466 function SymLoadModuleEx(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR; BaseOfDll: DWORD64;
1467 DllSize: DWORD; Data: PMODLOAD_DATA; Flag: DWORD): DWORD64; stdcall;
1468 {$EXTERNALSYM SymLoadModuleEx}
1469
SymLoadModulenull1470 function SymLoadModule(hProcess, hFile: HANDLE; ImageName, ModuleName: PSTR;
1471 BaseOfDll: DWORD; SizeOfDll: DWORD): DWORD; stdcall;
1472 {$EXTERNALSYM SymLoadModule}
1473
SymUnloadModule64null1474 function SymUnloadModule64(hProcess: HANDLE; BaseOfDll: DWORD64): BOOL; stdcall;
1475 {$EXTERNALSYM SymUnloadModule64}
1476
SymUnloadModulenull1477 function SymUnloadModule(hProcess: HANDLE; BaseOfDll: DWORD): BOOL; stdcall;
1478 {$EXTERNALSYM SymUnloadModule}
1479
SymUnDName64null1480 function SymUnDName64(const sym: IMAGEHLP_SYMBOL64; UnDecName: PSTR;
1481 UnDecNameLength: DWORD): BOOL; stdcall;
1482 {$EXTERNALSYM SymUnDName64}
1483
SymUnDNamenull1484 function SymUnDName(const sym: IMAGEHLP_SYMBOL; UnDecName: PSTR;
1485 UnDecNameLength: DWORD): BOOL; stdcall;
1486 {$EXTERNALSYM SymUnDName}
1487
SymRegisterCallback64null1488 function SymRegisterCallback64(hProcess: HANDLE; CallbackFunction: PSYMBOL_REGISTERED_CALLBACK64;
1489 UserContext: ULONG64): BOOL; stdcall;
1490 {$EXTERNALSYM SymRegisterCallback64}
1491
SymRegisterFunctionEntryCallback64null1492 function SymRegisterFunctionEntryCallback64(hProcess: HANDLE; CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK64;
1493 UserContext: ULONG64): BOOL; stdcall;
1494 {$EXTERNALSYM SymRegisterFunctionEntryCallback64}
1495
SymRegisterCallbacknull1496 function SymRegisterCallback(hProcess: HANDLE; CallbackFunction: PSYMBOL_REGISTERED_CALLBACK;
1497 UserContext: PVOID): BOOL; stdcall;
1498 {$EXTERNALSYM SymRegisterCallback}
1499
SymRegisterFunctionEntryCallbacknull1500 function SymRegisterFunctionEntryCallback(hProcess: HANDLE; CallbackFunction: PSYMBOL_FUNCENTRY_CALLBACK;
1501 UserContext: PVOID): BOOL; stdcall;
1502 {$EXTERNALSYM SymRegisterFunctionEntryCallback}
1503
1504 type
1505 PIMAGEHLP_SYMBOL_SRC = ^IMAGEHLP_SYMBOL_SRC;
1506 {$EXTERNALSYM PIMAGEHLP_SYMBOL_SRC}
1507 _IMAGEHLP_SYMBOL_SRC = record
1508 sizeofstruct: DWORD;
1509 type_: DWORD;
1510 file_: array [0..MAX_PATH - 1] of Char;
1511 end;
1512 {$EXTERNALSYM _IMAGEHLP_SYMBOL_SRC}
1513 IMAGEHLP_SYMBOL_SRC = _IMAGEHLP_SYMBOL_SRC;
1514 {$EXTERNALSYM IMAGEHLP_SYMBOL_SRC}
1515 TImageHlpSymbolSrc = IMAGEHLP_SYMBOL_SRC;
1516 PImageHlpSymbolSrc = PIMAGEHLP_SYMBOL_SRC;
1517
1518 PMODULE_TYPE_INFO = ^MODULE_TYPE_INFO;
1519 {$EXTERNALSYM PMODULE_TYPE_INFO}
1520 _MODULE_TYPE_INFO = record
1521 dataLength: USHORT;
1522 leaf: USHORT;
1523 data: array [0..0] of BYTE;
1524 end;
1525 {$EXTERNALSYM _MODULE_TYPE_INFO}
1526 MODULE_TYPE_INFO = _MODULE_TYPE_INFO;
1527 {$EXTERNALSYM MODULE_TYPE_INFO}
1528 TModuleTypeInfo = MODULE_TYPE_INFO;
1529 PModuleTypeInfo = PMODULE_TYPE_INFO;
1530
1531 type
1532 PSYMBOL_INFO = ^SYMBOL_INFO;
1533 {$EXTERNALSYM PSYMBOL_INFO}
1534 _SYMBOL_INFO = record
1535 SizeOfStruct: ULONG;
1536 TypeIndex: ULONG; // Type Index of symbol
1537 Reserved: array [0..1] of ULONG64;
1538 Info: ULONG;
1539 Size: ULONG;
1540 ModBase: ULONG64; // Base Address of module comtaining this symbol
1541 Flags: ULONG;
1542 Value: ULONG64; // Value of symbol, ValuePresent should be 1
1543 Address: ULONG64; // Address of symbol including base address of module
1544 Register_: ULONG; // register holding value or pointer to value
1545 Scope: ULONG; // scope of the symbol
1546 Tag: ULONG; // pdb classification
1547 NameLen: ULONG; // Actual length of name
1548 MaxNameLen: ULONG;
1549 Name: array [0..0] of CHAR; // Name of symbol
1550 end;
1551 {$EXTERNALSYM _SYMBOL_INFO}
1552 SYMBOL_INFO = _SYMBOL_INFO;
1553 {$EXTERNALSYM SYMBOL_INFO}
1554 TSymbolInfo = SYMBOL_INFO;
1555 PSymbolInfo = PSYMBOL_INFO;
1556
1557 _SYMBOL_INFO_PACKAGE = record
1558 si: SYMBOL_INFO;
1559 name: array [0..MAX_SYM_NAME] of CHAR;
1560 end;
1561 {$EXTERNALSYM _SYMBOL_INFO_PACKAGE}
1562 SYMBOL_INFO_PACKAGE = _SYMBOL_INFO_PACKAGE;
1563 {$EXTERNALSYM SYMBOL_INFO_PACKAGE}
1564 PSYMBOL_INFO_PACKAGE = ^SYMBOL_INFO_PACKAGE;
1565 {$EXTERNALSYM PSYMBOL_INFO_PACKAGE}
1566 TSymbolInfoPackage = SYMBOL_INFO_PACKAGE;
1567 PSymbolInfoPackage = PSYMBOL_INFO_PACKAGE;
1568
1569 PIMAGEHLP_STACK_FRAME = ^IMAGEHLP_STACK_FRAME;
1570 {$EXTERNALSYM PIMAGEHLP_STACK_FRAME}
1571 _IMAGEHLP_STACK_FRAME = record
1572 InstructionOffset: ULONG64;
1573 ReturnOffset: ULONG64;
1574 FrameOffset: ULONG64;
1575 StackOffset: ULONG64;
1576 BackingStoreOffset: ULONG64;
1577 FuncTableEntry: ULONG64;
1578 Params: array [0..3] of ULONG64;
1579 Reserved: array [0..4] of ULONG64;
1580 Virtual_: BOOL;
1581 Reserved2: ULONG;
1582 end;
1583 {$EXTERNALSYM _IMAGEHLP_STACK_FRAME}
1584 IMAGEHLP_STACK_FRAME = _IMAGEHLP_STACK_FRAME;
1585 {$EXTERNALSYM IMAGEHLP_STACK_FRAME}
1586 TImageHlpStackFrame = IMAGEHLP_STACK_FRAME;
1587 PImageHlpStackFrame = PIMAGEHLP_STACK_FRAME;
1588
1589 IMAGEHLP_CONTEXT = LPVOID;
1590 {$EXTERNALSYM IMAGEHLP_CONTEXT}
1591 PIMAGEHLP_CONTEXT = ^IMAGEHLP_CONTEXT;
1592 {$EXTERNALSYM PIMAGEHLP_CONTEXT}
1593 TImageHlpContext = IMAGEHLP_CONTEXT;
1594 PImageHlpContext = PIMAGEHLP_CONTEXT;
1595
SymSetContextnull1596 function SymSetContext(hProcess: HANDLE; StackFrame: PIMAGEHLP_STACK_FRAME; Context: PIMAGEHLP_CONTEXT): BOOL; stdcall;
1597 {$EXTERNALSYM SymSetContext}
1598
SymFromAddrnull1599 function SymFromAddr(hProcess: HANDLE; Address: DWORD64; Displacement: PDWORD64; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1600 {$EXTERNALSYM SymFromAddr}
1601
1602 // While SymFromName will provide a symbol from a name,
1603 // SymEnumSymbols can provide the same matching information
1604 // for ALL symbols with a matching name, even regular
1605 // expressions. That way you can search across modules
1606 // and differentiate between identically named symbols.
1607
SymFromNamenull1608 function SymFromName(hProcess: HANDLE; Name: LPSTR; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1609 {$EXTERNALSYM SymFromName}
1610
1611 type
SymInfonull1612 PSYM_ENUMERATESYMBOLS_CALLBACK = function(pSymInfo: PSYMBOL_INFO; SymbolSize: ULONG; UserContext: PVOID): BOOL; stdcall;
1613 {$EXTERNALSYM PSYM_ENUMERATESYMBOLS_CALLBACK}
1614 PSymEnumerateSymbolsCallback = PSYM_ENUMERATESYMBOLS_CALLBACK;
1615
SymEnumSymbolsnull1616 function SymEnumSymbols(hProcess: HANDLE; BaseOfDll: ULONG64; Mask: PCSTR; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1617 {$EXTERNALSYM SymEnumSymbols}
1618
SymEnumSymbolsForAddrnull1619 function SymEnumSymbolsForAddr(hProcess: HANDLE; Address: DWORD64;
1620 EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1621 {$EXTERNALSYM SymEnumSymbolsForAddr}
1622
1623 type
1624 _IMAGEHLP_SYMBOL_TYPE_INFO = (
1625 TI_GET_SYMTAG,
1626 TI_GET_SYMNAME,
1627 TI_GET_LENGTH,
1628 TI_GET_TYPE,
1629 TI_GET_TYPEID,
1630 TI_GET_BASETYPE,
1631 TI_GET_ARRAYINDEXTYPEID,
1632 TI_FINDCHILDREN,
1633 TI_GET_DATAKIND,
1634 TI_GET_ADDRESSOFFSET,
1635 TI_GET_OFFSET,
1636 TI_GET_VALUE,
1637 TI_GET_COUNT,
1638 TI_GET_CHILDRENCOUNT,
1639 TI_GET_BITPOSITION,
1640 TI_GET_VIRTUALBASECLASS,
1641 TI_GET_VIRTUALTABLESHAPEID,
1642 TI_GET_VIRTUALBASEPOINTEROFFSET,
1643 TI_GET_CLASSPARENTID,
1644 TI_GET_NESTED,
1645 TI_GET_SYMINDEX,
1646 TI_GET_LEXICALPARENT,
1647 TI_GET_ADDRESS,
1648 TI_GET_THISADJUST,
1649 TI_GET_UDTKIND,
1650 TI_IS_EQUIV_TO,
1651 TI_GET_CALLING_CONVENTION);
1652 {$EXTERNALSYM _IMAGEHLP_SYMBOL_TYPE_INFO}
1653 IMAGEHLP_SYMBOL_TYPE_INFO = _IMAGEHLP_SYMBOL_TYPE_INFO;
1654 {$EXTERNALSYM IMAGEHLP_SYMBOL_TYPE_INFO}
1655 TImageHlpSymbolTypeInfo = IMAGEHLP_SYMBOL_TYPE_INFO;
1656
1657 PTI_FINDCHILDREN_PARAMS = ^TI_FINDCHILDREN_PARAMS;
1658 {$EXTERNALSYM PTI_FINDCHILDREN_PARAMS}
1659 _TI_FINDCHILDREN_PARAMS = record
1660 Count: ULONG;
1661 Start: ULONG;
1662 ChildId: array [0..0] of ULONG;
1663 end;
1664 {$EXTERNALSYM _TI_FINDCHILDREN_PARAMS}
1665 TI_FINDCHILDREN_PARAMS = _TI_FINDCHILDREN_PARAMS;
1666 {$EXTERNALSYM TI_FINDCHILDREN_PARAMS}
1667 TTiFindChildrenParams = TI_FINDCHILDREN_PARAMS;
1668 PTiFindChildrenParams = PTI_FINDCHILDREN_PARAMS;
1669
SymGetTypeInfonull1670 function SymGetTypeInfo(hProcess: HANDLE; ModBase: DWORD64; TypeId: ULONG; GetType: IMAGEHLP_SYMBOL_TYPE_INFO; pInfo: PVOID): BOOL; stdcall;
1671 {$EXTERNALSYM SymGetTypeInfo}
1672
SymEnumTypesnull1673 function SymEnumTypes(hProcess: HANDLE; BaseOfDll: ULONG64; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1674 {$EXTERNALSYM SymEnumTypes}
1675
SymGetTypeFromNamenull1676 function SymGetTypeFromName(hProcess: HANDLE; BaseOfDll: ULONG64; Name: LPSTR; Symbol: PSYMBOL_INFO): BOOL; stdcall;
1677 {$EXTERNALSYM SymGetTypeFromName}
1678
SymAddSymbolnull1679 function SymAddSymbol(hProcess: HANDLE; BaseOfDll: ULONG64; Name: PCSTR; Address: DWORD64; Size, Flags: DWORD): BOOL; stdcall;
1680 {$EXTERNALSYM SymAddSymbol}
1681
SymDeleteSymbolnull1682 function SymDeleteSymbol(hProcess: HANDLE; BaseOfDll: ULONG64; Name: PCSTR; Address: DWORD64; Flags: DWORD): BOOL; stdcall;
1683 {$EXTERNALSYM SymDeleteSymbol}
1684
1685 //
1686 // Full user-mode dump creation.
1687 //
1688
1689 type
ataTypenull1690 PDBGHELP_CREATE_USER_DUMP_CALLBACK = function(DataType: DWORD; var Data: PVOID; DataLength: LPDWORD; UserData: PVOID): BOOL; stdcall;
1691 {$EXTERNALSYM PDBGHELP_CREATE_USER_DUMP_CALLBACK}
1692 PDbgHelpCreateUserDumpCallback = PDBGHELP_CREATE_USER_DUMP_CALLBACK;
1693
DbgHelpCreateUserDumpnull1694 function DbgHelpCreateUserDump(FileName: LPSTR; Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK; UserData: PVOID): BOOL; stdcall;
1695 {$EXTERNALSYM DbgHelpCreateUserDump}
1696
DbgHelpCreateUserDumpWnull1697 function DbgHelpCreateUserDumpW(FileName: LPWSTR; Callback: PDBGHELP_CREATE_USER_DUMP_CALLBACK; UserData: PVOID): BOOL; stdcall;
1698 {$EXTERNALSYM DbgHelpCreateUserDumpW}
1699
1700 // -----------------------------------------------------------------
1701 // The following 4 legacy APIs are fully supported, but newer
1702 // ones are recommended. SymFromName and SymFromAddr provide
1703 // much more detailed info on the returned symbol.
1704
SymGetSymFromAddr64null1705 function SymGetSymFromAddr64(hProcess: HANDLE; qwAddr: DWORD64; pdwDisplacement: PDWORD64; Symbol: PIMAGEHLP_SYMBOL64): BOOL; stdcall;
1706 {$EXTERNALSYM SymGetSymFromAddr64}
1707
SymGetSymFromAddrnull1708 function SymGetSymFromAddr(hProcess: HANDLE; dwAddr: DWORD; pdwDisplacement: PDWORD; Symbol: PIMAGEHLP_SYMBOL): BOOL; stdcall;
1709 {$EXTERNALSYM SymGetSymFromAddr}
1710
1711 // While following two APIs will provide a symbol from a name,
1712 // SymEnumSymbols can provide the same matching information
1713 // for ALL symbols with a matching name, even regular
1714 // expressions. That way you can search across modules
1715 // and differentiate between identically named symbols.
1716
SymGetSymFromName64null1717 function SymGetSymFromName64(hProcess: HANDLE; Name: PSTR; Symbol: PIMAGEHLP_SYMBOL64): BOOL; stdcall;
1718 {$EXTERNALSYM SymGetSymFromName64}
1719
SymGetSymFromNamenull1720 function SymGetSymFromName(hProcess: HANDLE; Name: PSTR; Symbol: PIMAGEHLP_SYMBOL): BOOL; stdcall;
1721 {$EXTERNALSYM SymGetSymFromName}
1722
1723 // -----------------------------------------------------------------
1724 // The following APIs exist only for backwards compatibility
1725 // with a pre-release version documented in an MSDN release.
1726
1727 // You should use SymFindFileInPath if you want to maintain
1728 // future compatibility.
1729
FindFileInPathnull1730 function FindFileInPath(hprocess: HANDLE; SearchPath: LPSTR; FileName: LPSTR; id: PVOID; two: DWORD; three: DWORD; flags: DWORD; FilePath: LPSTR): BOOL; stdcall;
1731 {$EXTERNALSYM FindFileInPath}
1732
1733 // You should use SymFindFileInPath if you want to maintain
1734 // future compatibility.
1735
FindFileInSearchPathnull1736 function FindFileInSearchPath(hprocess: HANDLE; SearchPath: LPSTR; FileName: LPSTR; one: DWORD; two: DWORD; three: DWORD; FilePath: LPSTR): BOOL; stdcall;
1737 {$EXTERNALSYM FindFileInSearchPath}
1738
SymEnumSymnull1739 function SymEnumSym(hProcess: HANDLE; BaseOfDll: ULONG64; EnumSymbolsCallback: PSYM_ENUMERATESYMBOLS_CALLBACK; UserContext: PVOID): BOOL; stdcall;
1740 {$EXTERNALSYM SymEnumSym}
1741
1742 // These values should not be used.
1743 // They have been replaced by SYMFLAG_ values.
1744
1745 const
1746 SYMF_OMAP_GENERATED = $00000001;
1747 SYMF_OMAP_MODIFIED = $00000002;
1748 SYMF_REGISTER = $00000008;
1749 SYMF_REGREL = $00000010;
1750 SYMF_FRAMEREL = $00000020;
1751 SYMF_PARAMETER = $00000040;
1752 SYMF_LOCAL = $00000080;
1753 SYMF_CONSTANT = $00000100;
1754 SYMF_EXPORT = $00000200;
1755 SYMF_FORWARDER = $00000400;
1756 SYMF_FUNCTION = $00000800;
1757 SYMF_VIRTUAL = $00001000;
1758 SYMF_THUNK = $00002000;
1759 SYMF_TLSREL = $00004000;
1760
1761 // These values should also not be used.
1762 // They have been replaced by SYMFLAG_ values.
1763
1764 IMAGEHLP_SYMBOL_INFO_VALUEPRESENT = 1;
1765 IMAGEHLP_SYMBOL_INFO_REGISTER = SYMF_REGISTER; // 0x0008
1766 IMAGEHLP_SYMBOL_INFO_REGRELATIVE = SYMF_REGREL; // 0x0010
1767 IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE = SYMF_FRAMEREL; // 0x0020
1768 IMAGEHLP_SYMBOL_INFO_PARAMETER = SYMF_PARAMETER; // 0x0040
1769 IMAGEHLP_SYMBOL_INFO_LOCAL = SYMF_LOCAL; // 0x0080
1770 IMAGEHLP_SYMBOL_INFO_CONSTANT = SYMF_CONSTANT; // 0x0100
1771 IMAGEHLP_SYMBOL_FUNCTION = SYMF_FUNCTION; // 0x0800
1772 IMAGEHLP_SYMBOL_VIRTUAL = SYMF_VIRTUAL; // 0x1000
1773 IMAGEHLP_SYMBOL_THUNK = SYMF_THUNK; // 0x2000
1774 IMAGEHLP_SYMBOL_INFO_TLSRELATIVE = SYMF_TLSREL; // 0x4000
1775
1776 const
1777 MINIDUMP_SIGNATURE = 'PMDM';
1778 {$EXTERNALSYM MINIDUMP_SIGNATURE}
1779 MINIDUMP_VERSION = 42899;
1780 {$EXTERNALSYM MINIDUMP_VERSION}
1781
1782 type
1783 RVA = DWORD;
1784 {$EXTERNALSYM RVA}
1785 RVA64 = ULONG64;
1786 {$EXTERNALSYM RVA64}
1787
1788 _MINIDUMP_LOCATION_DESCRIPTOR = record
1789 DataSize: ULONG32;
1790 Rva: RVA;
1791 end;
1792 {$EXTERNALSYM _MINIDUMP_LOCATION_DESCRIPTOR}
1793 MINIDUMP_LOCATION_DESCRIPTOR = _MINIDUMP_LOCATION_DESCRIPTOR;
1794 {$EXTERNALSYM MINIDUMP_LOCATION_DESCRIPTOR}
1795 TMinidumpLocationDescriptor = MINIDUMP_LOCATION_DESCRIPTOR;
1796 PMinidumpLocationDescriptor = ^MINIDUMP_LOCATION_DESCRIPTOR;
1797
1798 _MINIDUMP_LOCATION_DESCRIPTOR64 = record
1799 DataSize: ULONG64;
1800 Rva: RVA64;
1801 end;
1802 {$EXTERNALSYM _MINIDUMP_LOCATION_DESCRIPTOR64}
1803 MINIDUMP_LOCATION_DESCRIPTOR64 = _MINIDUMP_LOCATION_DESCRIPTOR64;
1804 {$EXTERNALSYM MINIDUMP_LOCATION_DESCRIPTOR64}
1805 TMinidumpLocationDescriptor64 = MINIDUMP_LOCATION_DESCRIPTOR64;
1806 PMinidumpLocationDescriptor64 = ^MINIDUMP_LOCATION_DESCRIPTOR64;
1807
1808 PMINIDUMP_MEMORY_DESCRIPTOR = ^MINIDUMP_MEMORY_DESCRIPTOR;
1809 {$EXTERNALSYM PMINIDUMP_MEMORY_DESCRIPTOR}
1810 _MINIDUMP_MEMORY_DESCRIPTOR = record
1811 StartOfMemoryRange: ULONG64;
1812 Memory: MINIDUMP_LOCATION_DESCRIPTOR;
1813 end;
1814 {$EXTERNALSYM _MINIDUMP_MEMORY_DESCRIPTOR}
1815 MINIDUMP_MEMORY_DESCRIPTOR = _MINIDUMP_MEMORY_DESCRIPTOR;
1816 {$EXTERNALSYM MINIDUMP_MEMORY_DESCRIPTOR}
1817 TMinidumpMemoryDescriptor = MINIDUMP_MEMORY_DESCRIPTOR;
1818 PMinidumpMemoryDescriptor = PMINIDUMP_MEMORY_DESCRIPTOR;
1819
1820 // DESCRIPTOR64 is used for full-memory minidumps where
1821 // all of the raw memory is laid out sequentially at the
1822 // end of the dump. There is no need for individual RVAs
1823 // as the RVA is the base RVA plus the sum of the preceeding
1824 // data blocks.
1825
1826 PMINIDUMP_MEMORY_DESCRIPTOR64 = ^MINIDUMP_MEMORY_DESCRIPTOR64;
1827 {$EXTERNALSYM PMINIDUMP_MEMORY_DESCRIPTOR64}
1828 _MINIDUMP_MEMORY_DESCRIPTOR64 = record
1829 StartOfMemoryRange: ULONG64;
1830 DataSize: ULONG64;
1831 end;
1832 {$EXTERNALSYM _MINIDUMP_MEMORY_DESCRIPTOR64}
1833 MINIDUMP_MEMORY_DESCRIPTOR64 = _MINIDUMP_MEMORY_DESCRIPTOR64;
1834 {$EXTERNALSYM MINIDUMP_MEMORY_DESCRIPTOR64}
1835 TMinidumpMemoryDescriptor64 = MINIDUMP_MEMORY_DESCRIPTOR64;
1836 PMinidumpMemoryDescriptor64 = PMINIDUMP_MEMORY_DESCRIPTOR64;
1837
1838 PMINIDUMP_HEADER = ^MINIDUMP_HEADER;
1839 {$EXTERNALSYM PMINIDUMP_HEADER}
1840 _MINIDUMP_HEADER = record
1841 Signature: ULONG32;
1842 Version: ULONG32;
1843 NumberOfStreams: ULONG32;
1844 StreamDirectoryRva: RVA;
1845 CheckSum: ULONG32;
1846 U: record
1847 case Integer of
1848 0: (Reserved: ULONG32);
1849 1: (TimeDateStamp: ULONG32);
1850 end;
1851 Flags: ULONG64;
1852 end;
1853 {$EXTERNALSYM _MINIDUMP_HEADER}
1854 MINIDUMP_HEADER = _MINIDUMP_HEADER;
1855 {$EXTERNALSYM MINIDUMP_HEADER}
1856 TMinidumpHeader = MINIDUMP_HEADER;
1857 PMinidumpHeader = PMINIDUMP_HEADER;
1858
1859 //
1860 // The MINIDUMP_HEADER field StreamDirectoryRva points to
1861 // an array of MINIDUMP_DIRECTORY structures.
1862 //
1863
1864 PMINIDUMP_DIRECTORY = ^MINIDUMP_DIRECTORY;
1865 {$EXTERNALSYM PMINIDUMP_DIRECTORY}
1866 _MINIDUMP_DIRECTORY = record
1867 StreamType: ULONG32;
1868 Location: MINIDUMP_LOCATION_DESCRIPTOR;
1869 end;
1870 {$EXTERNALSYM _MINIDUMP_DIRECTORY}
1871 MINIDUMP_DIRECTORY = _MINIDUMP_DIRECTORY;
1872 {$EXTERNALSYM MINIDUMP_DIRECTORY}
1873 TMinidumpDirectory = MINIDUMP_DIRECTORY;
1874 PMinidumpDirectory = PMINIDUMP_DIRECTORY;
1875
1876 PMINIDUMP_STRING = ^MINIDUMP_STRING;
1877 {$EXTERNALSYM PMINIDUMP_STRING}
1878 _MINIDUMP_STRING = record
1879 Length: ULONG32; // Length in bytes of the string
1880 Buffer: PWCHAR; // Variable size buffer
1881 end;
1882 {$EXTERNALSYM _MINIDUMP_STRING}
1883 MINIDUMP_STRING = _MINIDUMP_STRING;
1884 {$EXTERNALSYM MINIDUMP_STRING}
1885 TMinidumpString = MINIDUMP_STRING;
1886 PMinidumpString = PMINIDUMP_STRING;
1887
1888 //
1889 // The MINIDUMP_DIRECTORY field StreamType may be one of the following types.
1890 // Types will be added in the future, so if a program reading the minidump
1891 // header encounters a stream type it does not understand it should ignore
1892 // the data altogether. Any tag above LastReservedStream will not be used by
1893 // the system and is reserved for program-specific information.
1894 //
1895
1896 const
1897 UnusedStream = 0;
1898 {$EXTERNALSYM UnusedStream}
1899 ReservedStream0 = 1;
1900 {$EXTERNALSYM ReservedStream0}
1901 ReservedStream1 = 2;
1902 {$EXTERNALSYM ReservedStream1}
1903 ThreadListStream = 3;
1904 {$EXTERNALSYM ThreadListStream}
1905 ModuleListStream = 4;
1906 {$EXTERNALSYM ModuleListStream}
1907 MemoryListStream = 5;
1908 {$EXTERNALSYM MemoryListStream}
1909 ExceptionStream = 6;
1910 {$EXTERNALSYM ExceptionStream}
1911 SystemInfoStream = 7;
1912 {$EXTERNALSYM SystemInfoStream}
1913 ThreadExListStream = 8;
1914 {$EXTERNALSYM ThreadExListStream}
1915 Memory64ListStream = 9;
1916 {$EXTERNALSYM Memory64ListStream}
1917 CommentStreamA = 10;
1918 {$EXTERNALSYM CommentStreamA}
1919 CommentStreamW = 11;
1920 {$EXTERNALSYM CommentStreamW}
1921 HandleDataStream = 12;
1922 {$EXTERNALSYM HandleDataStream}
1923 FunctionTableStream = 13;
1924 {$EXTERNALSYM FunctionTableStream}
1925 UnloadedModuleListStream = 14;
1926 {$EXTERNALSYM UnloadedModuleListStream}
1927 MiscInfoStream = 15;
1928 {$EXTERNALSYM MiscInfoStream}
1929
1930 LastReservedStream = $ffff;
1931 {$EXTERNALSYM LastReservedStream}
1932
1933 type
1934 _MINIDUMP_STREAM_TYPE = DWORD;
1935 {$EXTERNALSYM MINIDUMP_STREAM_TYPE}
1936 MINIDUMP_STREAM_TYPE = _MINIDUMP_STREAM_TYPE;
1937 {$EXTERNALSYM _MINIDUMP_STREAM_TYPE}
1938 TMinidumpStreamType = MINIDUMP_STREAM_TYPE;
1939
1940 //
1941 // The minidump system information contains processor and
1942 // Operating System specific information.
1943 //
1944
1945 type
1946 _CPU_INFORMATION = record
1947 case Integer of
1948
1949 //
tonull1950 // X86 platforms use CPUID function to obtain processor information.
1951 //
1952
1953 0: (
1954
1955 //
1956 // CPUID Subfunction 0, register EAX (VendorId [0]),
1957 // EBX (VendorId [1]) and ECX (VendorId [2]).
1958 //
1959
1960 VendorId: array [0..2] of ULONG32;
1961
1962 //
1null1963 // CPUID Subfunction 1, register EAX
1964 //
1965
1966 VersionInformation: ULONG32;
1967
1968 //
1null1969 // CPUID Subfunction 1, register EDX
1970 //
1971
1972 FeatureInformation: ULONG32;
1973
1974 //
80000001null1975 // CPUID, Subfunction 80000001, register EBX. This will only
1976 // be obtained if the vendor id is "AuthenticAMD".
1977 //
1978
1979 AMDExtendedCpuFeatures: ULONG32);
1980
1981 //
1982 // Non-x86 platforms use processor feature flags.
1983 //
1984
1985 1: (
1986 ProcessorFeatures: array [0..1] of ULONG64);
1987 end;
1988
1989 _MINIDUMP_SYSTEM_INFO = record
1990
1991 //
1992 // ProcessorArchitecture, ProcessorLevel and ProcessorRevision are all
1993 // taken from the SYSTEM_INFO structure obtained by GetSystemInfo( ).
1994 //
1995
1996 ProcessorArchitecture: USHORT;
1997 ProcessorLevel: USHORT;
1998 ProcessorRevision: USHORT;
1999
2000 U: record
2001 case Integer of
2002 0: (Reserved0: USHORT);
2003 1: (
2004 NumberOfProcessors: UCHAR;
2005 ProductType: UCHAR);
2006 end;
2007
2008 //
2009 // MajorVersion, MinorVersion, BuildNumber, PlatformId and
2010 // CSDVersion are all taken from the OSVERSIONINFO structure
2011 // returned by GetVersionEx( ).
2012 //
2013
2014 MajorVersion: ULONG32;
2015 MinorVersion: ULONG32;
2016 BuildNumber: ULONG32;
2017 PlatformId: ULONG32;
2018
2019 //
2020 // RVA to a CSDVersion string in the string table.
2021 //
2022
2023 CSDVersionRva: RVA;
2024
2025 U2: record
2026 case Integer of
2027 0: (Reserved1: ULONG32);
2028 1: (
2029 SuiteMask: USHORT;
2030 Reserved2: USHORT);
2031 end;
2032
2033 //
2034 // CPU information is obtained from one of two places.
2035 //
2036 // 1) On x86 computers, CPU_INFORMATION is obtained from the CPUID
2037 // instruction. You must use the X86 portion of the union for X86
2038 // computers.
2039 //
2040 // 2) On non-x86 architectures, CPU_INFORMATION is obtained by calling
2041 // IsProcessorFeatureSupported().
2042 //
2043
2044 Cpu: _CPU_INFORMATION;
2045 end;
2046 {$EXTERNALSYM _MINIDUMP_SYSTEM_INFO}
2047 MINIDUMP_SYSTEM_INFO = _MINIDUMP_SYSTEM_INFO;
2048 {$EXTERNALSYM MINIDUMP_SYSTEM_INFO}
2049 PMINIDUMP_SYSTEM_INFO = ^MINIDUMP_SYSTEM_INFO;
2050 {$EXTERNALSYM PMINIDUMP_SYSTEM_INFO}
2051 TMinidumpSystemInfo = MINIDUMP_SYSTEM_INFO;
2052 PMinidumpSystemInfo = PMINIDUMP_SYSTEM_INFO;
2053
2054 CPU_INFORMATION = _CPU_INFORMATION;
2055 {$EXTERNALSYM CPU_INFORMATION}
2056 PCPU_INFORMATION = CPU_INFORMATION;
2057 {$EXTERNALSYM PCPU_INFORMATION}
2058
2059 //
2060 // The minidump thread contains standard thread
2061 // information plus an RVA to the memory for this
2062 // thread and an RVA to the CONTEXT structure for
2063 // this thread.
2064 //
2065
2066 //
2067 // ThreadId must be 4 bytes on all architectures.
2068 //
2069
2070 // C_ASSERT (sizeof ( ((PPROCESS_INFORMATION)0)->dwThreadId ) == 4);
2071
2072 type
2073 PMINIDUMP_THREAD = ^MINIDUMP_THREAD;
2074 {$EXTERNALSYM PMINIDUMP_THREAD}
2075 _MINIDUMP_THREAD = record
2076 ThreadId: ULONG32;
2077 SuspendCount: ULONG32;
2078 PriorityClass: ULONG32;
2079 Priority: ULONG32;
2080 Teb: ULONG64;
2081 Stack: MINIDUMP_MEMORY_DESCRIPTOR;
2082 ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2083 end;
2084 {$EXTERNALSYM _MINIDUMP_THREAD}
2085 MINIDUMP_THREAD = _MINIDUMP_THREAD;
2086 {$EXTERNALSYM MINIDUMP_THREAD}
2087 TMinidumpThread = MINIDUMP_THREAD;
2088 PMinidumpThread = PMINIDUMP_THREAD;
2089
2090 //
2091 // The thread list is a container of threads.
2092 //
2093
2094 PMINIDUMP_THREAD_LIST = ^MINIDUMP_THREAD_LIST;
2095 {$EXTERNALSYM PMINIDUMP_THREAD_LIST}
2096 _MINIDUMP_THREAD_LIST = record
2097 NumberOfThreads: ULONG32;
2098 Threads: array [0..0] of MINIDUMP_THREAD;
2099 end;
2100 {$EXTERNALSYM _MINIDUMP_THREAD_LIST}
2101 MINIDUMP_THREAD_LIST = _MINIDUMP_THREAD_LIST;
2102 {$EXTERNALSYM MINIDUMP_THREAD_LIST}
2103 TMinidumpThreadList = MINIDUMP_THREAD_LIST;
2104 PMinidumpThreadList = PMINIDUMP_THREAD_LIST;
2105
2106 PMINIDUMP_THREAD_EX = ^MINIDUMP_THREAD_EX;
2107 {$EXTERNALSYM PMINIDUMP_THREAD_EX}
2108 _MINIDUMP_THREAD_EX = record
2109 ThreadId: ULONG32;
2110 SuspendCount: ULONG32;
2111 PriorityClass: ULONG32;
2112 Priority: ULONG32;
2113 Teb: ULONG64;
2114 Stack: MINIDUMP_MEMORY_DESCRIPTOR;
2115 ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2116 BackingStore: MINIDUMP_MEMORY_DESCRIPTOR;
2117 end;
2118 {$EXTERNALSYM _MINIDUMP_THREAD_EX}
2119 MINIDUMP_THREAD_EX = _MINIDUMP_THREAD_EX;
2120 {$EXTERNALSYM MINIDUMP_THREAD_EX}
2121 TMinidumpThreadEx = MINIDUMP_THREAD_EX;
2122 PMinidumpThreadEx = PMINIDUMP_THREAD_EX;
2123
2124 //
2125 // The thread list is a container of threads.
2126 //
2127
2128 PMINIDUMP_THREAD_EX_LIST = ^MINIDUMP_THREAD_EX_LIST;
2129 {$EXTERNALSYM PMINIDUMP_THREAD_EX_LIST}
2130 _MINIDUMP_THREAD_EX_LIST = record
2131 NumberOfThreads: ULONG32;
2132 Threads: array [0..0] of MINIDUMP_THREAD_EX;
2133 end;
2134 {$EXTERNALSYM _MINIDUMP_THREAD_EX_LIST}
2135 MINIDUMP_THREAD_EX_LIST = _MINIDUMP_THREAD_EX_LIST;
2136 {$EXTERNALSYM MINIDUMP_THREAD_EX_LIST}
2137 TMinidumpThreadExList = MINIDUMP_THREAD_EX_LIST;
2138 PMinidumpThreadExList = PMINIDUMP_THREAD_EX_LIST;
2139
2140 //
2141 // The MINIDUMP_EXCEPTION is the same as EXCEPTION on Win64.
2142 //
2143
2144 PMINIDUMP_EXCEPTION = ^MINIDUMP_EXCEPTION;
2145 {$EXTERNALSYM PMINIDUMP_EXCEPTION}
2146 _MINIDUMP_EXCEPTION = record
2147 ExceptionCode: ULONG32;
2148 ExceptionFlags: ULONG32;
2149 ExceptionRecord: ULONG64;
2150 ExceptionAddress: ULONG64;
2151 NumberParameters: ULONG32;
2152 __unusedAlignment: ULONG32;
2153 ExceptionInformation: array [0..EXCEPTION_MAXIMUM_PARAMETERS - 1] of ULONG64;
2154 end;
2155 {$EXTERNALSYM _MINIDUMP_EXCEPTION}
2156 MINIDUMP_EXCEPTION = _MINIDUMP_EXCEPTION;
2157 {$EXTERNALSYM MINIDUMP_EXCEPTION}
2158 TMinidumpException = MINIDUMP_EXCEPTION;
2159 PMinidumpException = PMINIDUMP_EXCEPTION;
2160
2161 //
2162 // The exception information stream contains the id of the thread that caused
2163 // the exception (ThreadId), the exception record for the exception
2164 // (ExceptionRecord) and an RVA to the thread context where the exception
2165 // occurred.
2166 //
2167
2168 PMINIDUMP_EXCEPTION_STREAM = ^MINIDUMP_EXCEPTION_STREAM;
2169 {$EXTERNALSYM PMINIDUMP_EXCEPTION_STREAM}
2170 _MINIDUMP_EXCEPTION_STREAM = record
2171 ThreadId: ULONG32;
2172 __alignment: ULONG32;
2173 ExceptionRecord: MINIDUMP_EXCEPTION;
2174 ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR;
2175 end;
2176 {$EXTERNALSYM _MINIDUMP_EXCEPTION_STREAM}
2177 MINIDUMP_EXCEPTION_STREAM = _MINIDUMP_EXCEPTION_STREAM;
2178 {$EXTERNALSYM MINIDUMP_EXCEPTION_STREAM}
2179 TMinidumpExceptionStream = MINIDUMP_EXCEPTION_STREAM;
2180 PMinidumpExceptionStream = PMINIDUMP_EXCEPTION_STREAM;
2181
2182 //
2183 // The MINIDUMP_MODULE contains information about a
2184 // a specific module. It includes the CheckSum and
2185 // the TimeDateStamp for the module so the module
2186 // can be reloaded during the analysis phase.
2187 //
2188
2189 PMINIDUMP_MODULE = ^MINIDUMP_MODULE;
2190 {$EXTERNALSYM PMINIDUMP_MODULE}
2191 _MINIDUMP_MODULE = record
2192 BaseOfImage: ULONG64;
2193 SizeOfImage: ULONG32;
2194 CheckSum: ULONG32;
2195 TimeDateStamp: ULONG32;
2196 ModuleNameRva: RVA;
2197 VersionInfo: VS_FIXEDFILEINFO;
2198 CvRecord: MINIDUMP_LOCATION_DESCRIPTOR;
2199 MiscRecord: MINIDUMP_LOCATION_DESCRIPTOR;
2200 Reserved0: ULONG64; // Reserved for future use.
2201 Reserved1: ULONG64; // Reserved for future use.
2202 end;
2203 {$EXTERNALSYM _MINIDUMP_MODULE}
2204 MINIDUMP_MODULE = _MINIDUMP_MODULE;
2205 {$EXTERNALSYM MINIDUMP_MODULE}
2206 TMinidumpModule = MINIDUMP_MODULE;
2207 PMinidumpModule = PMINIDUMP_MODULE;
2208
2209 //
2210 // The minidump module list is a container for modules.
2211 //
2212
2213 PMINIDUMP_MODULE_LIST = ^MINIDUMP_MODULE_LIST;
2214 {$EXTERNALSYM PMINIDUMP_MODULE_LIST}
2215 _MINIDUMP_MODULE_LIST = record
2216 NumberOfModules: ULONG32;
2217 Modules: array [0..0] of MINIDUMP_MODULE;
2218 end;
2219 {$EXTERNALSYM _MINIDUMP_MODULE_LIST}
2220 MINIDUMP_MODULE_LIST = _MINIDUMP_MODULE_LIST;
2221 {$EXTERNALSYM MINIDUMP_MODULE_LIST}
2222 TMinidumpModuleList = MINIDUMP_MODULE_LIST;
2223 PMinidumpModuleList = PMINIDUMP_MODULE_LIST;
2224
2225 //
2226 // Memory Ranges
2227 //
2228
2229 PMINIDUMP_MEMORY_LIST = ^MINIDUMP_MEMORY_LIST;
2230 {$EXTERNALSYM PMINIDUMP_MEMORY_LIST}
2231 _MINIDUMP_MEMORY_LIST = record
2232 NumberOfMemoryRanges: ULONG32;
2233 MemoryRanges: array [0..0] of MINIDUMP_MEMORY_DESCRIPTOR;
2234 end;
2235 {$EXTERNALSYM _MINIDUMP_MEMORY_LIST}
2236 MINIDUMP_MEMORY_LIST = _MINIDUMP_MEMORY_LIST;
2237 {$EXTERNALSYM MINIDUMP_MEMORY_LIST}
2238 TMinidumpMemoryList = MINIDUMP_MEMORY_LIST;
2239 PMinidumpMemoryList = PMINIDUMP_MEMORY_LIST;
2240
2241 PMINIDUMP_MEMORY64_LIST = ^MINIDUMP_MEMORY64_LIST;
2242 {$EXTERNALSYM PMINIDUMP_MEMORY64_LIST}
2243 _MINIDUMP_MEMORY64_LIST = record
2244 NumberOfMemoryRanges: ULONG64;
2245 BaseRva: RVA64;
2246 MemoryRanges: array [0..0] of MINIDUMP_MEMORY_DESCRIPTOR64;
2247 end;
2248 {$EXTERNALSYM _MINIDUMP_MEMORY64_LIST}
2249 MINIDUMP_MEMORY64_LIST = _MINIDUMP_MEMORY64_LIST;
2250 {$EXTERNALSYM MINIDUMP_MEMORY64_LIST}
2251 TMinidumpMemory64List = MINIDUMP_MEMORY64_LIST;
2252 PMinidumpMemory64List = PMINIDUMP_MEMORY64_LIST;
2253
2254 //
2255 // Support for user supplied exception information.
2256 //
2257
2258 PMINIDUMP_EXCEPTION_INFORMATION = ^MINIDUMP_EXCEPTION_INFORMATION;
2259 {$EXTERNALSYM PMINIDUMP_EXCEPTION_INFORMATION}
2260 _MINIDUMP_EXCEPTION_INFORMATION = record
2261 ThreadId: DWORD;
2262 ExceptionPointers: PEXCEPTION_POINTERS;
2263 ClientPointers: BOOL;
2264 end;
2265 {$EXTERNALSYM _MINIDUMP_EXCEPTION_INFORMATION}
2266 MINIDUMP_EXCEPTION_INFORMATION = _MINIDUMP_EXCEPTION_INFORMATION;
2267 {$EXTERNALSYM MINIDUMP_EXCEPTION_INFORMATION}
2268 TMinidumpExceptionInformation = MINIDUMP_EXCEPTION_INFORMATION;
2269 PMinidumpExceptionInformation = PMINIDUMP_EXCEPTION_INFORMATION;
2270
2271 //
2272 // Support for capturing system handle state at the time of the dump.
2273 //
2274
2275 PMINIDUMP_HANDLE_DESCRIPTOR = ^MINIDUMP_HANDLE_DESCRIPTOR;
2276 {$EXTERNALSYM PMINIDUMP_HANDLE_DESCRIPTOR}
2277 _MINIDUMP_HANDLE_DESCRIPTOR = record
2278 Handle: ULONG64;
2279 TypeNameRva: RVA;
2280 ObjectNameRva: RVA;
2281 Attributes: ULONG32;
2282 GrantedAccess: ULONG32;
2283 HandleCount: ULONG32;
2284 PointerCount: ULONG32;
2285 end;
2286 {$EXTERNALSYM _MINIDUMP_HANDLE_DESCRIPTOR}
2287 MINIDUMP_HANDLE_DESCRIPTOR = _MINIDUMP_HANDLE_DESCRIPTOR;
2288 {$EXTERNALSYM MINIDUMP_HANDLE_DESCRIPTOR}
2289 TMinidumpHandleDescriptor = MINIDUMP_HANDLE_DESCRIPTOR;
2290 PMinidumpHandleDescriptor = PMINIDUMP_HANDLE_DESCRIPTOR;
2291
2292 PMINIDUMP_HANDLE_DATA_STREAM = ^MINIDUMP_HANDLE_DATA_STREAM;
2293 {$EXTERNALSYM PMINIDUMP_HANDLE_DATA_STREAM}
2294 _MINIDUMP_HANDLE_DATA_STREAM = record
2295 SizeOfHeader: ULONG32;
2296 SizeOfDescriptor: ULONG32;
2297 NumberOfDescriptors: ULONG32;
2298 Reserved: ULONG32;
2299 end;
2300 {$EXTERNALSYM _MINIDUMP_HANDLE_DATA_STREAM}
2301 MINIDUMP_HANDLE_DATA_STREAM = _MINIDUMP_HANDLE_DATA_STREAM;
2302 {$EXTERNALSYM MINIDUMP_HANDLE_DATA_STREAM}
2303 TMinidumpHandleDataStream = MINIDUMP_HANDLE_DATA_STREAM;
2304 PMinidumpHandleDataStream = PMINIDUMP_HANDLE_DATA_STREAM;
2305
2306 //
tablenull2307 // Support for capturing dynamic function table state at the time of the dump.
2308 //
2309
2310 PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR = ^MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2311 {$EXTERNALSYM PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2312 _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR = record
2313 MinimumAddress: ULONG64;
2314 MaximumAddress: ULONG64;
2315 BaseAddress: ULONG64;
2316 EntryCount: ULONG32;
2317 SizeOfAlignPad: ULONG32;
2318 end;
2319 {$EXTERNALSYM _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2320 MINIDUMP_FUNCTION_TABLE_DESCRIPTOR = _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2321 {$EXTERNALSYM MINIDUMP_FUNCTION_TABLE_DESCRIPTOR}
2322 TMinidumpFunctionTableDescriptor = MINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2323 PMinidumpFunctionTableDescriptor = PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2324
2325 PMINIDUMP_FUNCTION_TABLE_STREAM = ^MINIDUMP_FUNCTION_TABLE_STREAM;
2326 {$EXTERNALSYM PMINIDUMP_FUNCTION_TABLE_STREAM}
2327 _MINIDUMP_FUNCTION_TABLE_STREAM = record
2328 SizeOfHeader: ULONG32;
2329 SizeOfDescriptor: ULONG32;
2330 SizeOfNativeDescriptor: ULONG32;
2331 SizeOfFunctionEntry: ULONG32;
2332 NumberOfDescriptors: ULONG32;
2333 SizeOfAlignPad: ULONG32;
2334 end;
2335 {$EXTERNALSYM _MINIDUMP_FUNCTION_TABLE_STREAM}
2336 MINIDUMP_FUNCTION_TABLE_STREAM = _MINIDUMP_FUNCTION_TABLE_STREAM;
2337 {$EXTERNALSYM MINIDUMP_FUNCTION_TABLE_STREAM}
2338 TMinidumpFunctionTableStream = MINIDUMP_FUNCTION_TABLE_STREAM;
2339 PMinidumpFunctionTableStream = PMINIDUMP_FUNCTION_TABLE_STREAM;
2340
2341 //
2342 // The MINIDUMP_UNLOADED_MODULE contains information about a
2343 // a specific module that was previously loaded but no
2344 // longer is. This can help with diagnosing problems where
2345 // callers attempt to call code that is no longer loaded.
2346 //
2347
2348 _MINIDUMP_UNLOADED_MODULE = record
2349 BaseOfImage: ULONG64;
2350 SizeOfImage: ULONG32;
2351 CheckSum: ULONG32;
2352 TimeDateStamp: ULONG32;
2353 ModuleNameRva: RVA;
2354 end;
2355 {$EXTERNALSYM _MINIDUMP_UNLOADED_MODULE}
2356 MINIDUMP_UNLOADED_MODULE = _MINIDUMP_UNLOADED_MODULE;
2357 {$EXTERNALSYM MINIDUMP_UNLOADED_MODULE}
2358 PMINIDUMP_UNLOADED_MODULE = ^MINIDUMP_UNLOADED_MODULE;
2359 {$EXTERNALSYM PMINIDUMP_UNLOADED_MODULE}
2360 TMiniDumpUnloadedModule = MINIDUMP_UNLOADED_MODULE;
2361 PMiniDumpUnloadedModule = PMINIDUMP_UNLOADED_MODULE;
2362
2363 //
2364 // The minidump unloaded module list is a container for unloaded modules.
2365 //
2366
2367 _MINIDUMP_UNLOADED_MODULE_LIST = record
2368 SizeOfHeader: ULONG32;
2369 SizeOfEntry: ULONG32;
2370 NumberOfEntries: ULONG32;
2371 end;
2372 {$EXTERNALSYM _MINIDUMP_UNLOADED_MODULE_LIST}
2373 MINIDUMP_UNLOADED_MODULE_LIST = _MINIDUMP_UNLOADED_MODULE_LIST;
2374 {$EXTERNALSYM MINIDUMP_UNLOADED_MODULE_LIST}
2375 PMINIDUMP_UNLOADED_MODULE_LIST = ^MINIDUMP_UNLOADED_MODULE_LIST;
2376 {$EXTERNALSYM PMINIDUMP_UNLOADED_MODULE_LIST}
2377 TMiniDumpUnloadedModuleList = MINIDUMP_UNLOADED_MODULE_LIST;
2378 PMiniDumpUnloadedModuleList = PMINIDUMP_UNLOADED_MODULE_LIST;
2379
2380 //
2381 // The miscellaneous information stream contains a variety
2382 // of small pieces of information. A member is valid if
2383 // it's within the available size and its corresponding
2384 // bit is set.
2385 //
2386
2387 const
2388 MINIDUMP_MISC1_PROCESS_ID = $00000001;
2389 {$EXTERNALSYM MINIDUMP_MISC1_PROCESS_ID}
2390 MINIDUMP_MISC1_PROCESS_TIMES = $00000002;
2391 {$EXTERNALSYM MINIDUMP_MISC1_PROCESS_TIMES}
2392
2393 type
2394 _MINIDUMP_MISC_INFO = record
2395 SizeOfInfo: ULONG32;
2396 Flags1: ULONG32;
2397 ProcessId: ULONG32;
2398 ProcessCreateTime: ULONG32;
2399 ProcessUserTime: ULONG32;
2400 ProcessKernelTime: ULONG32;
2401 end;
2402 {$EXTERNALSYM _MINIDUMP_MISC_INFO}
2403 MINIDUMP_MISC_INFO = _MINIDUMP_MISC_INFO;
2404 {$EXTERNALSYM MINIDUMP_MISC_INFO}
2405 PMINIDUMP_MISC_INFO = ^MINIDUMP_MISC_INFO;
2406 {$EXTERNALSYM PMINIDUMP_MISC_INFO}
2407 TMiniDumpMiscInfo = MINIDUMP_MISC_INFO;
2408 PMiniDumpMiscInfo = PMINIDUMP_MISC_INFO;
2409
2410 //
2411 // Support for arbitrary user-defined information.
2412 //
2413
2414 PMINIDUMP_USER_RECORD = ^MINIDUMP_USER_RECORD;
2415 {$EXTERNALSYM PMINIDUMP_USER_RECORD}
2416 _MINIDUMP_USER_RECORD = record
2417 Type_: ULONG32;
2418 Memory: MINIDUMP_LOCATION_DESCRIPTOR;
2419 end;
2420 {$EXTERNALSYM _MINIDUMP_USER_RECORD}
2421 MINIDUMP_USER_RECORD = _MINIDUMP_USER_RECORD;
2422 {$EXTERNALSYM MINIDUMP_USER_RECORD}
2423 TMinidumpUserRecord = MINIDUMP_USER_RECORD;
2424 PMinidumpUserRecord = PMINIDUMP_USER_RECORD;
2425
2426 PMINIDUMP_USER_STREAM = ^MINIDUMP_USER_STREAM;
2427 {$EXTERNALSYM PMINIDUMP_USER_STREAM}
2428 _MINIDUMP_USER_STREAM = record
2429 Type_: ULONG32;
2430 BufferSize: ULONG;
2431 Buffer: PVOID;
2432 end;
2433 {$EXTERNALSYM _MINIDUMP_USER_STREAM}
2434 MINIDUMP_USER_STREAM = _MINIDUMP_USER_STREAM;
2435 {$EXTERNALSYM MINIDUMP_USER_STREAM}
2436 TMinidumpUserStream = MINIDUMP_USER_STREAM;
2437 PMinidumpUserStream = PMINIDUMP_USER_STREAM;
2438
2439 PMINIDUMP_USER_STREAM_INFORMATION = ^MINIDUMP_USER_STREAM_INFORMATION;
2440 {$EXTERNALSYM PMINIDUMP_USER_STREAM_INFORMATION}
2441 _MINIDUMP_USER_STREAM_INFORMATION = record
2442 UserStreamCount: ULONG;
2443 UserStreamArray: PMINIDUMP_USER_STREAM;
2444 end;
2445 {$EXTERNALSYM _MINIDUMP_USER_STREAM_INFORMATION}
2446 MINIDUMP_USER_STREAM_INFORMATION = _MINIDUMP_USER_STREAM_INFORMATION;
2447 {$EXTERNALSYM MINIDUMP_USER_STREAM_INFORMATION}
2448 TMinidumpUserStreamInformation = MINIDUMP_USER_STREAM_INFORMATION;
2449 PMinidumpUserStreamInformation = PMINIDUMP_USER_STREAM_INFORMATION;
2450
2451 //
2452 // Callback support.
2453 //
2454
2455 _MINIDUMP_CALLBACK_TYPE = (
2456 ModuleCallback,
2457 ThreadCallback,
2458 ThreadExCallback,
2459 IncludeThreadCallback,
2460 IncludeModuleCallback);
2461 {$EXTERNALSYM _MINIDUMP_CALLBACK_TYPE}
2462 MINIDUMP_CALLBACK_TYPE = _MINIDUMP_CALLBACK_TYPE;
2463 {$EXTERNALSYM MINIDUMP_CALLBACK_TYPE}
2464 TMinidumpCallbackType = MINIDUMP_CALLBACK_TYPE;
2465
2466 PMINIDUMP_THREAD_CALLBACK = ^MINIDUMP_THREAD_CALLBACK;
2467 {$EXTERNALSYM PMINIDUMP_THREAD_CALLBACK}
2468 _MINIDUMP_THREAD_CALLBACK = record
2469 ThreadId: ULONG;
2470 ThreadHandle: HANDLE;
2471 Context: CONTEXT;
2472 SizeOfContext: ULONG;
2473 StackBase: ULONG64;
2474 StackEnd: ULONG64;
2475 end;
2476 {$EXTERNALSYM _MINIDUMP_THREAD_CALLBACK}
2477 MINIDUMP_THREAD_CALLBACK = _MINIDUMP_THREAD_CALLBACK;
2478 {$EXTERNALSYM MINIDUMP_THREAD_CALLBACK}
2479 TMinidumpThreadCallback = MINIDUMP_THREAD_CALLBACK;
2480 PMinidumpThreadCallback = PMINIDUMP_THREAD_CALLBACK;
2481
2482 PMINIDUMP_THREAD_EX_CALLBACK = ^MINIDUMP_THREAD_EX_CALLBACK;
2483 {$EXTERNALSYM PMINIDUMP_THREAD_EX_CALLBACK}
2484 _MINIDUMP_THREAD_EX_CALLBACK = record
2485 ThreadId: ULONG;
2486 ThreadHandle: HANDLE;
2487 Context: CONTEXT;
2488 SizeOfContext: ULONG;
2489 StackBase: ULONG64;
2490 StackEnd: ULONG64;
2491 BackingStoreBase: ULONG64;
2492 BackingStoreEnd: ULONG64;
2493 end;
2494 {$EXTERNALSYM _MINIDUMP_THREAD_EX_CALLBACK}
2495 MINIDUMP_THREAD_EX_CALLBACK = _MINIDUMP_THREAD_EX_CALLBACK;
2496 {$EXTERNALSYM MINIDUMP_THREAD_EX_CALLBACK}
2497 TMinidumpThreadExCallback = MINIDUMP_THREAD_EX_CALLBACK;
2498 PMinidumpThreadExCallback = PMINIDUMP_THREAD_EX_CALLBACK;
2499
2500 PMINIDUMP_INCLUDE_THREAD_CALLBACK = ^MINIDUMP_INCLUDE_THREAD_CALLBACK;
2501 {$EXTERNALSYM PMINIDUMP_INCLUDE_THREAD_CALLBACK}
2502 _MINIDUMP_INCLUDE_THREAD_CALLBACK = record
2503 ThreadId: ULONG;
2504 end;
2505 {$EXTERNALSYM _MINIDUMP_INCLUDE_THREAD_CALLBACK}
2506 MINIDUMP_INCLUDE_THREAD_CALLBACK = _MINIDUMP_INCLUDE_THREAD_CALLBACK;
2507 {$EXTERNALSYM MINIDUMP_INCLUDE_THREAD_CALLBACK}
2508 TMinidumpIncludeThreadCallback = MINIDUMP_INCLUDE_THREAD_CALLBACK;
2509 PMinidumpIncludeThreadCallback = PMINIDUMP_INCLUDE_THREAD_CALLBACK;
2510
2511 const
2512 ThreadWriteThread = $0001;
2513 {$EXTERNALSYM ThreadWriteThread}
2514 ThreadWriteStack = $0002;
2515 {$EXTERNALSYM ThreadWriteStack}
2516 ThreadWriteContext = $0004;
2517 {$EXTERNALSYM ThreadWriteContext}
2518 ThreadWriteBackingStore = $0008;
2519 {$EXTERNALSYM ThreadWriteBackingStore}
2520 ThreadWriteInstructionWindow = $0010;
2521 {$EXTERNALSYM ThreadWriteInstructionWindow}
2522 ThreadWriteThreadData = $0020;
2523 {$EXTERNALSYM ThreadWriteThreadData}
2524
2525 type
2526 _THREAD_WRITE_FLAGS = DWORD;
2527 {$EXTERNALSYM _THREAD_WRITE_FLAGS}
2528 THREAD_WRITE_FLAGS = _THREAD_WRITE_FLAGS;
2529 {$EXTERNALSYM THREAD_WRITE_FLAGS}
2530 TThreadWriteFlags = THREAD_WRITE_FLAGS;
2531
2532 type
2533 PMINIDUMP_MODULE_CALLBACK = ^MINIDUMP_MODULE_CALLBACK;
2534 {$EXTERNALSYM PMINIDUMP_MODULE_CALLBACK}
2535 _MINIDUMP_MODULE_CALLBACK = record
2536 FullPath: PWCHAR;
2537 BaseOfImage: ULONG64;
2538 SizeOfImage: ULONG;
2539 CheckSum: ULONG;
2540 TimeDateStamp: ULONG;
2541 VersionInfo: VS_FIXEDFILEINFO;
2542 CvRecord: PVOID;
2543 SizeOfCvRecord: ULONG;
2544 MiscRecord: PVOID;
2545 SizeOfMiscRecord: ULONG;
2546 end;
2547 {$EXTERNALSYM _MINIDUMP_MODULE_CALLBACK}
2548 MINIDUMP_MODULE_CALLBACK = _MINIDUMP_MODULE_CALLBACK;
2549 {$EXTERNALSYM MINIDUMP_MODULE_CALLBACK}
2550 TMinidumpModuleCallback = MINIDUMP_MODULE_CALLBACK;
2551 PMinidumpModuleCallback = PMINIDUMP_MODULE_CALLBACK;
2552
2553 PMINIDUMP_INCLUDE_MODULE_CALLBACK = ^MINIDUMP_INCLUDE_MODULE_CALLBACK;
2554 {$EXTERNALSYM PMINIDUMP_INCLUDE_MODULE_CALLBACK}
2555 _MINIDUMP_INCLUDE_MODULE_CALLBACK = record
2556 BaseOfImage: ULONG64;
2557 end;
2558 {$EXTERNALSYM _MINIDUMP_INCLUDE_MODULE_CALLBACK}
2559 MINIDUMP_INCLUDE_MODULE_CALLBACK = _MINIDUMP_INCLUDE_MODULE_CALLBACK;
2560 {$EXTERNALSYM MINIDUMP_INCLUDE_MODULE_CALLBACK}
2561 TMinidumpIncludeModuleCallback = MINIDUMP_INCLUDE_MODULE_CALLBACK;
2562 PMinidumpIncludeModuleCallback = PMINIDUMP_INCLUDE_MODULE_CALLBACK;
2563
2564 const
2565 ModuleWriteModule = $0001;
2566 {$EXTERNALSYM ModuleWriteModule}
2567 ModuleWriteDataSeg = $0002;
2568 {$EXTERNALSYM ModuleWriteDataSeg}
2569 ModuleWriteMiscRecord = $0004;
2570 {$EXTERNALSYM ModuleWriteMiscRecord}
2571 ModuleWriteCvRecord = $0008;
2572 {$EXTERNALSYM ModuleWriteCvRecord}
2573 ModuleReferencedByMemory = $0010;
2574 {$EXTERNALSYM ModuleReferencedByMemory}
2575
2576 type
2577 _MODULE_WRITE_FLAGS = DWORD;
2578 {$EXTERNALSYM _MODULE_WRITE_FLAGS}
2579 MODULE_WRITE_FLAGS = _MODULE_WRITE_FLAGS;
2580 {$EXTERNALSYM MODULE_WRITE_FLAGS}
2581 TModuleWriteFlags = MODULE_WRITE_FLAGS;
2582
2583 _MINIDUMP_CALLBACK_INPUT = record
2584 ProcessId: ULONG;
2585 ProcessHandle: HANDLE;
2586 CallbackType: ULONG;
2587 case Integer of
2588 0: (Thread: MINIDUMP_THREAD_CALLBACK);
2589 1: (ThreadEx: MINIDUMP_THREAD_EX_CALLBACK);
2590 2: (Module: MINIDUMP_MODULE_CALLBACK);
2591 3: (IncludeThread: MINIDUMP_INCLUDE_THREAD_CALLBACK);
2592 4: (IncludeModule: MINIDUMP_INCLUDE_MODULE_CALLBACK);
2593 end;
2594 {$EXTERNALSYM _MINIDUMP_CALLBACK_INPUT}
2595 MINIDUMP_CALLBACK_INPUT = _MINIDUMP_CALLBACK_INPUT;
2596 {$EXTERNALSYM MINIDUMP_CALLBACK_INPUT}
2597 PMINIDUMP_CALLBACK_INPUT = ^MINIDUMP_CALLBACK_INPUT;
2598 {$EXTERNALSYM PMINIDUMP_CALLBACK_INPUT}
2599 TminidumpCallbackInput = MINIDUMP_CALLBACK_INPUT;
2600
2601 PMINIDUMP_CALLBACK_OUTPUT = ^MINIDUMP_CALLBACK_OUTPUT;
2602 {$EXTERNALSYM PMINIDUMP_CALLBACK_OUTPUT}
2603 _MINIDUMP_CALLBACK_OUTPUT = record
2604 case Integer of
2605 0: (ModuleWriteFlags: ULONG);
2606 1: (ThreadWriteFlags: ULONG);
2607 end;
2608 {$EXTERNALSYM _MINIDUMP_CALLBACK_OUTPUT}
2609 MINIDUMP_CALLBACK_OUTPUT = _MINIDUMP_CALLBACK_OUTPUT;
2610 {$EXTERNALSYM MINIDUMP_CALLBACK_OUTPUT}
2611 TMinidumpCallbackOutput = MINIDUMP_CALLBACK_OUTPUT;
2612 PMinidumpCallbackOutput = PMINIDUMP_CALLBACK_OUTPUT;
2613
2614 //
2615 // A normal minidump contains just the information
2616 // necessary to capture stack traces for all of the
2617 // existing threads in a process.
2618 //
2619 // A minidump with data segments includes all of the data
2620 // sections from loaded modules in order to capture
2621 // global variable contents. This can make the dump much
2622 // larger if many modules have global data.
2623 //
2624 // A minidump with full memory includes all of the accessible
2625 // memory in the process and can be very large. A minidump
2626 // with full memory always has the raw memory data at the end
2627 // of the dump so that the initial structures in the dump can
2628 // be mapped directly without having to include the raw
2629 // memory information.
2630 //
2631 // Stack and backing store memory can be filtered to remove
2632 // data unnecessary for stack walking. This can improve
2633 // compression of stacks and also deletes data that may
2634 // be private and should not be stored in a dump.
2635 // Memory can also be scanned to see what modules are
2636 // referenced by stack and backing store memory to allow
2637 // omission of other modules to reduce dump size.
2638 // In either of these modes the ModuleReferencedByMemory flag
2639 // is set for all modules referenced before the base
2640 // module callbacks occur.
2641 //
2642 // On some operating systems a list of modules that were
2643 // recently unloaded is kept in addition to the currently
2644 // loaded module list. This information can be saved in
2645 // the dump if desired.
2646 //
2647 // Stack and backing store memory can be scanned for referenced
2648 // pages in order to pick up data referenced by locals or other
2649 // stack memory. This can increase the size of a dump significantly.
2650 //
2651 // Module paths may contain undesired information such as user names
2652 // or other important directory names so they can be stripped. This
2653 // option reduces the ability to locate the proper image later
2654 // and should only be used in certain situations.
2655 //
2656 // Complete operating system per-process and per-thread information can
2657 // be gathered and stored in the dump.
2658 //
2659 // The virtual address space can be scanned for various types
2660 // of memory to be included in the dump.
2661 //
2662
2663 const
2664 MiniDumpNormal = $0000;
2665 {$EXTERNALSYM MiniDumpNormal}
2666 MiniDumpWithDataSegs = $0001;
2667 {$EXTERNALSYM MiniDumpWithDataSegs}
2668 MiniDumpWithFullMemory = $0002;
2669 {$EXTERNALSYM MiniDumpWithFullMemory}
2670 MiniDumpWithHandleData = $0004;
2671 {$EXTERNALSYM MiniDumpWithHandleData}
2672 MiniDumpFilterMemory = $0008;
2673 {$EXTERNALSYM MiniDumpFilterMemory}
2674 MiniDumpScanMemory = $0010;
2675 {$EXTERNALSYM MiniDumpScanMemory}
2676 MiniDumpWithUnloadedModules = $0020;
2677 {$EXTERNALSYM MiniDumpWithUnloadedModules}
2678 MiniDumpWithIndirectlyReferencedMemory = $0040;
2679 {$EXTERNALSYM MiniDumpWithIndirectlyReferencedMemory}
2680 MiniDumpFilterModulePaths = $0080;
2681 {$EXTERNALSYM MiniDumpFilterModulePaths}
2682 MiniDumpWithProcessThreadData = $0100;
2683 {$EXTERNALSYM MiniDumpWithProcessThreadData}
2684 MiniDumpWithPrivateReadWriteMemory = $0200;
2685 {$EXTERNALSYM MiniDumpWithPrivateReadWriteMemory}
2686
2687 type
2688 _MINIDUMP_TYPE = DWORD;
2689 {$EXTERNALSYM _MINIDUMP_TYPE}
2690 MINIDUMP_TYPE = _MINIDUMP_TYPE;
2691 {$EXTERNALSYM MINIDUMP_TYPE}
2692 TMinidumpType = MINIDUMP_TYPE;
2693
2694 //
2695 // The minidump callback should modify the FieldsToWrite parameter to reflect
2696 // what portions of the specified thread or module should be written to the
2697 // file.
2698 //
2699
2700 MINIDUMP_CALLBACK_ROUTINE = function(CallbackParam: PVOID; CallbackInput: PMINIDUMP_CALLBACK_INPUT;
2701 CallbackOutput: PMINIDUMP_CALLBACK_OUTPUT): BOOL; stdcall;
2702 {$EXTERNALSYM MINIDUMP_CALLBACK_ROUTINE}
2703 TMinidumpCallbackRoutine = MINIDUMP_CALLBACK_ROUTINE;
2704
2705 PMINIDUMP_CALLBACK_INFORMATION = ^MINIDUMP_CALLBACK_INFORMATION;
2706 {$EXTERNALSYM PMINIDUMP_CALLBACK_INFORMATION}
2707 _MINIDUMP_CALLBACK_INFORMATION = record
2708 CallbackRoutine: MINIDUMP_CALLBACK_ROUTINE;
2709 CallbackParam: PVOID;
2710 end;
2711 {$EXTERNALSYM _MINIDUMP_CALLBACK_INFORMATION}
2712 MINIDUMP_CALLBACK_INFORMATION = _MINIDUMP_CALLBACK_INFORMATION;
2713 {$EXTERNALSYM MINIDUMP_CALLBACK_INFORMATION}
2714 TMinidumpCallbackInformation = MINIDUMP_CALLBACK_INFORMATION;
2715 PMinidumpCallbackInformation = PMINIDUMP_CALLBACK_INFORMATION;
2716
2717 //++
2718 //
2719 // PVOID
2720 // RVA_TO_ADDR(
2721 // PVOID Mapping,
2722 // ULONG Rva
2723 // )
2724 //
2725 // Routine Description:
2726 //
2727 // Map an RVA that is contained within a mapped file to it's associated
2728 // flat address.
2729 //
2730 // Arguments:
2731 //
2732 // Mapping - Base address of mapped file containing the RVA.
2733 //
2734 // Rva - An Rva to fixup.
2735 //
2736 // Return Values:
2737 //
2738 // A pointer to the desired data.
2739 //
2740 //--
2741
2742
RVA_TO_ADDRnull2743 function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
2744 {$EXTERNALSYM RVA_TO_ADDR}
2745
2746
MiniDumpWriteDumpnull2747 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;
2748 {$EXTERNALSYM MiniDumpWriteDump}
2749
MiniDumpReadDumpStreamnull2750 function MiniDumpReadDumpStream(BaseOfDump: PVOID; StreamNumber: ULONG; var Dir: PMINIDUMP_DIRECTORY; var StreamPointer: PVOID; var StreamSize: ULONG): BOOL; stdcall;
2751 {$EXTERNALSYM MiniDumpReadDumpStream}
2752
2753 {$ENDIF JWA_IMPLEMENTATIONSECTION}
2754
2755 {$IFNDEF JWA_OMIT_SECTIONS}
2756 implementation
2757 //uses ...
2758 {$ENDIF JWA_OMIT_SECTIONS}
2759
2760 {$IFNDEF JWA_INTERFACESECTION}
2761
2762 {$IFNDEF JWA_INCLUDEMODE}
2763 const
2764 ImageHlpLib = 'imagehlp.dll';
2765 {$IFDEF UNICODE}
2766 AWSuffix = 'W';
2767 {$ELSE}
2768 AWSuffix = 'A';
2769 {$ENDIF UNICODE}
2770 {$ENDIF JWA_INCLUDEMODE}
2771
2772 procedure Address32To64(a32: LPADDRESS; a64: LPADDRESS64);
2773 begin
2774 a64^.Offset := {ULONG64(LONG64(LONG(}a32^.Offset{)))};
2775 a64^.Segment := a32^.Segment;
2776 a64^.Mode := a32^.Mode;
2777 end;
2778
2779 procedure Address64To32(a64: LPADDRESS64; a32: LPADDRESS);
2780 begin
2781 a32^.Offset := ULONG(a64^.Offset);
2782 a32^.Segment := a64^.Segment;
2783 a32^.Mode := a64^.Mode;
2784 end;
2785
2786 procedure KdHelp32To64(p32: PKDHELP; p64: PKDHELP64);
2787 begin
2788 p64^.Thread := p32^.Thread;
2789 p64^.ThCallbackStack := p32^.ThCallbackStack;
2790 p64^.NextCallback := p32^.NextCallback;
2791 p64^.FramePointer := p32^.FramePointer;
2792 p64^.KiCallUserMode := p32^.KiCallUserMode;
2793 p64^.KeUserCallbackDispatcher := p32^.KeUserCallbackDispatcher;
2794 p64^.SystemRangeStart := p32^.SystemRangeStart;
2795 end;
2796
RVA_TO_ADDRnull2797 function RVA_TO_ADDR(Mapping, Rva: Pointer): Pointer;
2798 begin
2799 Result := Pointer(Cardinal(Mapping) + Cardinal(Rva));
2800 end;
2801
2802
2803 {$IFDEF DYNAMIC_LINK}
2804
2805
2806 var
2807 _BindImage: Pointer;
2808
BindImagenull2809 function BindImage;
2810 begin
2811 GetProcedureAddress(_BindImage, ImageHlpLib, 'BindImage');
2812 asm
2813 MOV ESP, EBP
2814 POP EBP
2815 JMP [_BindImage]
2816 end;
2817 end;
2818
2819 var
2820 _BindImageEx: Pointer;
2821
BindImageExnull2822 function BindImageEx;
2823 begin
2824 GetProcedureAddress(_BindImageEx, ImageHlpLib, 'BindImageEx');
2825 asm
2826 MOV ESP, EBP
2827 POP EBP
2828 JMP [_BindImageEx]
2829 end;
2830 end;
2831
2832 var
2833 _ReBaseImage: Pointer;
2834
ReBaseImagenull2835 function ReBaseImage;
2836 begin
2837 GetProcedureAddress(_ReBaseImage, ImageHlpLib, 'ReBaseImage');
2838 asm
2839 MOV ESP, EBP
2840 POP EBP
2841 JMP [_ReBaseImage]
2842 end;
2843 end;
2844
2845 var
2846 _ReBaseImage64: Pointer;
2847
ReBaseImage64null2848 function ReBaseImage64;
2849 begin
2850 GetProcedureAddress(_ReBaseImage64, ImageHlpLib, 'ReBaseImage64');
2851 asm
2852 MOV ESP, EBP
2853 POP EBP
2854 JMP [_ReBaseImage64]
2855 end;
2856 end;
2857
2858 var
2859 _CheckSumMappedFile: Pointer;
2860
CheckSumMappedFilenull2861 function CheckSumMappedFile;
2862 begin
2863 GetProcedureAddress(_CheckSumMappedFile, ImageHlpLib, 'CheckSumMappedFile');
2864 asm
2865 MOV ESP, EBP
2866 POP EBP
2867 JMP [_CheckSumMappedFile]
2868 end;
2869 end;
2870
2871 var
2872 _MapFileAndCheckSumA: Pointer;
2873
MapFileAndCheckSumAnull2874 function MapFileAndCheckSumA;
2875 begin
2876 GetProcedureAddress(_MapFileAndCheckSumA, ImageHlpLib, 'MapFileAndCheckSumA');
2877 asm
2878 MOV ESP, EBP
2879 POP EBP
2880 JMP [_MapFileAndCheckSumA]
2881 end;
2882 end;
2883
2884 var
2885 _MapFileAndCheckSumW: Pointer;
2886
MapFileAndCheckSumWnull2887 function MapFileAndCheckSumW;
2888 begin
2889 GetProcedureAddress(_MapFileAndCheckSumW, ImageHlpLib, 'MapFileAndCheckSumW');
2890 asm
2891 MOV ESP, EBP
2892 POP EBP
2893 JMP [_MapFileAndCheckSumW]
2894 end;
2895 end;
2896
2897 var
2898 _MapFileAndCheckSum: Pointer;
2899
MapFileAndCheckSumnull2900 function MapFileAndCheckSum;
2901 begin
2902 GetProcedureAddress(_MapFileAndCheckSum, ImageHlpLib, 'MapFileAndCheckSum' + AWSuffix);
2903 asm
2904 MOV ESP, EBP
2905 POP EBP
2906 JMP [_MapFileAndCheckSum]
2907 end;
2908 end;
2909
2910 var
2911 _GetImageConfigInformation: Pointer;
2912
GetImageConfigInformationnull2913 function GetImageConfigInformation;
2914 begin
2915 GetProcedureAddress(_GetImageConfigInformation, ImageHlpLib, 'GetImageConfigInformation');
2916 asm
2917 MOV ESP, EBP
2918 POP EBP
2919 JMP [_GetImageConfigInformation]
2920 end;
2921 end;
2922
2923 var
2924 _GetImageUnusedHeaderBytes: Pointer;
2925
GetImageUnusedHeaderBytesnull2926 function GetImageUnusedHeaderBytes;
2927 begin
2928 GetProcedureAddress(_GetImageUnusedHeaderBytes, ImageHlpLib, 'GetImageUnusedHeaderBytes');
2929 asm
2930 MOV ESP, EBP
2931 POP EBP
2932 JMP [_GetImageUnusedHeaderBytes]
2933 end;
2934 end;
2935
2936 var
2937 _SetImageConfigInformation: Pointer;
2938
SetImageConfigInformationnull2939 function SetImageConfigInformation;
2940 begin
2941 GetProcedureAddress(_SetImageConfigInformation, ImageHlpLib, 'SetImageConfigInformation');
2942 asm
2943 MOV ESP, EBP
2944 POP EBP
2945 JMP [_SetImageConfigInformation]
2946 end;
2947 end;
2948
2949 var
2950 _ImageGetDigestStream: Pointer;
2951
ImageGetDigestStreamnull2952 function ImageGetDigestStream;
2953 begin
2954 GetProcedureAddress(_ImageGetDigestStream, ImageHlpLib, 'ImageGetDigestStream');
2955 asm
2956 MOV ESP, EBP
2957 POP EBP
2958 JMP [_ImageGetDigestStream]
2959 end;
2960 end;
2961
2962 var
2963 _ImageAddCertificate: Pointer;
2964
ImageAddCertificatenull2965 function ImageAddCertificate;
2966 begin
2967 GetProcedureAddress(_ImageAddCertificate, ImageHlpLib, 'ImageAddCertificate');
2968 asm
2969 MOV ESP, EBP
2970 POP EBP
2971 JMP [_ImageAddCertificate]
2972 end;
2973 end;
2974
2975 var
2976 _ImageRemoveCertificate: Pointer;
2977
ImageRemoveCertificatenull2978 function ImageRemoveCertificate;
2979 begin
2980 GetProcedureAddress(_ImageRemoveCertificate, ImageHlpLib, 'ImageRemoveCertificate');
2981 asm
2982 MOV ESP, EBP
2983 POP EBP
2984 JMP [_ImageRemoveCertificate]
2985 end;
2986 end;
2987
2988 var
2989 _ImageEnumerateCertificates: Pointer;
2990
ImageEnumerateCertificatesnull2991 function ImageEnumerateCertificates;
2992 begin
2993 GetProcedureAddress(_ImageEnumerateCertificates, ImageHlpLib, 'ImageEnumerateCertificates');
2994 asm
2995 MOV ESP, EBP
2996 POP EBP
2997 JMP [_ImageEnumerateCertificates]
2998 end;
2999 end;
3000
3001 var
3002 _ImageGetCertificateData: Pointer;
3003
ImageGetCertificateDatanull3004 function ImageGetCertificateData;
3005 begin
3006 GetProcedureAddress(_ImageGetCertificateData, ImageHlpLib, 'ImageGetCertificateData');
3007 asm
3008 MOV ESP, EBP
3009 POP EBP
3010 JMP [_ImageGetCertificateData]
3011 end;
3012 end;
3013
3014 var
3015 _ImageGetCertificateHeader: Pointer;
3016
ImageGetCertificateHeadernull3017 function ImageGetCertificateHeader;
3018 begin
3019 GetProcedureAddress(_ImageGetCertificateHeader, ImageHlpLib, 'ImageGetCertificateHeader');
3020 asm
3021 MOV ESP, EBP
3022 POP EBP
3023 JMP [_ImageGetCertificateHeader]
3024 end;
3025 end;
3026
3027 var
3028 _ImageLoad: Pointer;
3029
ImageLoadnull3030 function ImageLoad;
3031 begin
3032 GetProcedureAddress(_ImageLoad, ImageHlpLib, 'ImageLoad');
3033 asm
3034 MOV ESP, EBP
3035 POP EBP
3036 JMP [_ImageLoad]
3037 end;
3038 end;
3039
3040 var
3041 _ImageUnload: Pointer;
3042
ImageUnloadnull3043 function ImageUnload;
3044 begin
3045 GetProcedureAddress(_ImageUnload, ImageHlpLib, 'ImageUnload');
3046 asm
3047 MOV ESP, EBP
3048 POP EBP
3049 JMP [_ImageUnload]
3050 end;
3051 end;
3052
3053 var
3054 _MapAndLoad: Pointer;
3055
MapAndLoadnull3056 function MapAndLoad;
3057 begin
3058 GetProcedureAddress(_MapAndLoad, ImageHlpLib, 'MapAndLoad');
3059 asm
3060 MOV ESP, EBP
3061 POP EBP
3062 JMP [_MapAndLoad]
3063 end;
3064 end;
3065
3066 var
3067 _UnMapAndLoad: Pointer;
3068
UnMapAndLoadnull3069 function UnMapAndLoad;
3070 begin
3071 GetProcedureAddress(_UnMapAndLoad, ImageHlpLib, 'UnMapAndLoad');
3072 asm
3073 MOV ESP, EBP
3074 POP EBP
3075 JMP [_UnMapAndLoad]
3076 end;
3077 end;
3078
3079 var
3080 _TouchFileTimes: Pointer;
3081
TouchFileTimesnull3082 function TouchFileTimes;
3083 begin
3084 GetProcedureAddress(_TouchFileTimes, ImageHlpLib, 'TouchFileTimes');
3085 asm
3086 MOV ESP, EBP
3087 POP EBP
3088 JMP [_TouchFileTimes]
3089 end;
3090 end;
3091
3092 var
3093 _SplitSymbols: Pointer;
3094
SplitSymbolsnull3095 function SplitSymbols;
3096 begin
3097 GetProcedureAddress(_SplitSymbols, ImageHlpLib, 'SplitSymbols');
3098 asm
3099 MOV ESP, EBP
3100 POP EBP
3101 JMP [_SplitSymbols]
3102 end;
3103 end;
3104
3105 var
3106 _UpdateDebugInfoFile: Pointer;
3107
UpdateDebugInfoFilenull3108 function UpdateDebugInfoFile;
3109 begin
3110 GetProcedureAddress(_UpdateDebugInfoFile, ImageHlpLib, 'UpdateDebugInfoFile');
3111 asm
3112 MOV ESP, EBP
3113 POP EBP
3114 JMP [_UpdateDebugInfoFile]
3115 end;
3116 end;
3117
3118 var
3119 _UpdateDebugInfoFileEx: Pointer;
3120
UpdateDebugInfoFileExnull3121 function UpdateDebugInfoFileEx;
3122 begin
3123 GetProcedureAddress(_UpdateDebugInfoFileEx, ImageHlpLib, 'UpdateDebugInfoFileEx');
3124 asm
3125 MOV ESP, EBP
3126 POP EBP
3127 JMP [_UpdateDebugInfoFileEx]
3128 end;
3129 end;
3130
3131 var
3132 _FindDebugInfoFile: Pointer;
3133
FindDebugInfoFilenull3134 function FindDebugInfoFile;
3135 begin
3136 GetProcedureAddress(_FindDebugInfoFile, ImageHlpLib, 'FindDebugInfoFile');
3137 asm
3138 MOV ESP, EBP
3139 POP EBP
3140 JMP [_FindDebugInfoFile]
3141 end;
3142 end;
3143
3144 var
3145 _FindDebugInfoFileEx: Pointer;
3146
FindDebugInfoFileExnull3147 function FindDebugInfoFileEx;
3148 begin
3149 GetProcedureAddress(_FindDebugInfoFileEx, ImageHlpLib, 'FindDebugInfoFileEx');
3150 asm
3151 MOV ESP, EBP
3152 POP EBP
3153 JMP [_FindDebugInfoFileEx]
3154 end;
3155 end;
3156
3157 var
3158 _SymFindFileInPath: Pointer;
3159
SymFindFileInPathnull3160 function SymFindFileInPath;
3161 begin
3162 GetProcedureAddress(_SymFindFileInPath, ImageHlpLib, 'SymFindFileInPath');
3163 asm
3164 MOV ESP, EBP
3165 POP EBP
3166 JMP [_SymFindFileInPath]
3167 end;
3168 end;
3169
3170 var
3171 _FindExecutableImage: Pointer;
3172
FindExecutableImagenull3173 function FindExecutableImage;
3174 begin
3175 GetProcedureAddress(_FindExecutableImage, ImageHlpLib, 'FindExecutableImage');
3176 asm
3177 MOV ESP, EBP
3178 POP EBP
3179 JMP [_FindExecutableImage]
3180 end;
3181 end;
3182
3183 var
3184 _FindExecutableImageEx: Pointer;
3185
FindExecutableImageExnull3186 function FindExecutableImageEx;
3187 begin
3188 GetProcedureAddress(_FindExecutableImageEx, ImageHlpLib, 'FindExecutableImageEx');
3189 asm
3190 MOV ESP, EBP
3191 POP EBP
3192 JMP [_FindExecutableImageEx]
3193 end;
3194 end;
3195
3196 var
3197 _ImageNtHeader: Pointer;
3198
ImageNtHeadernull3199 function ImageNtHeader;
3200 begin
3201 GetProcedureAddress(_ImageNtHeader, ImageHlpLib, 'ImageNtHeader');
3202 asm
3203 MOV ESP, EBP
3204 POP EBP
3205 JMP [_ImageNtHeader]
3206 end;
3207 end;
3208
3209 var
3210 _ImageDirectoryEntryToDataEx: Pointer;
3211
ImageDirectoryEntryToDataExnull3212 function ImageDirectoryEntryToDataEx;
3213 begin
3214 GetProcedureAddress(_ImageDirectoryEntryToDataEx, ImageHlpLib, 'ImageDirectoryEntryToDataEx');
3215 asm
3216 MOV ESP, EBP
3217 POP EBP
3218 JMP [_ImageDirectoryEntryToDataEx]
3219 end;
3220 end;
3221
3222 var
3223 _ImageDirectoryEntryToData: Pointer;
3224
ImageDirectoryEntryToDatanull3225 function ImageDirectoryEntryToData;
3226 begin
3227 GetProcedureAddress(_ImageDirectoryEntryToData, ImageHlpLib, 'ImageDirectoryEntryToData');
3228 asm
3229 MOV ESP, EBP
3230 POP EBP
3231 JMP [_ImageDirectoryEntryToData]
3232 end;
3233 end;
3234
3235 var
3236 _ImageRvaToSection: Pointer;
3237
ImageRvaToSectionnull3238 function ImageRvaToSection;
3239 begin
3240 GetProcedureAddress(_ImageRvaToSection, ImageHlpLib, 'ImageRvaToSection');
3241 asm
3242 MOV ESP, EBP
3243 POP EBP
3244 JMP [_ImageRvaToSection]
3245 end;
3246 end;
3247
3248 var
3249 _ImageRvaToVa: Pointer;
3250
ImageRvaToVanull3251 function ImageRvaToVa;
3252 begin
3253 GetProcedureAddress(_ImageRvaToVa, ImageHlpLib, 'ImageRvaToVa');
3254 asm
3255 MOV ESP, EBP
3256 POP EBP
3257 JMP [_ImageRvaToVa]
3258 end;
3259 end;
3260
3261 var
3262 _MapDebugInformation: Pointer;
3263
MapDebugInformationnull3264 function MapDebugInformation;
3265 begin
3266 GetProcedureAddress(_MapDebugInformation, ImageHlpLib, 'MapDebugInformation');
3267 asm
3268 MOV ESP, EBP
3269 POP EBP
3270 JMP [_MapDebugInformation]
3271 end;
3272 end;
3273
3274 var
3275 _UnmapDebugInformation: Pointer;
3276
UnmapDebugInformationnull3277 function UnmapDebugInformation;
3278 begin
3279 GetProcedureAddress(_UnmapDebugInformation, ImageHlpLib, 'UnmapDebugInformation');
3280 asm
3281 MOV ESP, EBP
3282 POP EBP
3283 JMP [_UnmapDebugInformation]
3284 end;
3285 end;
3286
3287 var
3288 _SearchTreeForFile: Pointer;
3289
SearchTreeForFilenull3290 function SearchTreeForFile;
3291 begin
3292 GetProcedureAddress(_SearchTreeForFile, ImageHlpLib, 'SearchTreeForFile');
3293 asm
3294 MOV ESP, EBP
3295 POP EBP
3296 JMP [_SearchTreeForFile]
3297 end;
3298 end;
3299
3300 var
3301 _EnumDirTree: Pointer;
3302
EnumDirTreenull3303 function EnumDirTree;
3304 begin
3305 GetProcedureAddress(_EnumDirTree, ImageHlpLib, 'EnumDirTree');
3306 asm
3307 MOV ESP, EBP
3308 POP EBP
3309 JMP [_EnumDirTree]
3310 end;
3311 end;
3312
3313 var
3314 _MakeSureDirectoryPathExists: Pointer;
3315
MakeSureDirectoryPathExistsnull3316 function MakeSureDirectoryPathExists;
3317 begin
3318 GetProcedureAddress(_MakeSureDirectoryPathExists, ImageHlpLib, 'MakeSureDirectoryPathExists');
3319 asm
3320 MOV ESP, EBP
3321 POP EBP
3322 JMP [_MakeSureDirectoryPathExists]
3323 end;
3324 end;
3325
3326 var
3327 _UnDecorateSymbolName: Pointer;
3328
UnDecorateSymbolNamenull3329 function UnDecorateSymbolName;
3330 begin
3331 GetProcedureAddress(_UnDecorateSymbolName, ImageHlpLib, 'UnDecorateSymbolName');
3332 asm
3333 MOV ESP, EBP
3334 POP EBP
3335 JMP [_UnDecorateSymbolName]
3336 end;
3337 end;
3338
3339 var
3340 _StackWalk64: Pointer;
3341
StackWalk64null3342 function StackWalk64;
3343 begin
3344 GetProcedureAddress(_StackWalk64, ImageHlpLib, 'StackWalk64');
3345 asm
3346 MOV ESP, EBP
3347 POP EBP
3348 JMP [_StackWalk64]
3349 end;
3350 end;
3351
3352 var
3353 _StackWalk: Pointer;
3354
StackWalknull3355 function StackWalk;
3356 begin
3357 GetProcedureAddress(_StackWalk, ImageHlpLib, 'StackWalk');
3358 asm
3359 MOV ESP, EBP
3360 POP EBP
3361 JMP [_StackWalk]
3362 end;
3363 end;
3364
3365 var
3366 _ImagehlpApiVersion: Pointer;
3367
ImagehlpApiVersionnull3368 function ImagehlpApiVersion;
3369 begin
3370 GetProcedureAddress(_ImagehlpApiVersion, ImageHlpLib, 'ImagehlpApiVersion');
3371 asm
3372 MOV ESP, EBP
3373 POP EBP
3374 JMP [_ImagehlpApiVersion]
3375 end;
3376 end;
3377
3378 var
3379 _ImagehlpApiVersionEx: Pointer;
3380
ImagehlpApiVersionExnull3381 function ImagehlpApiVersionEx;
3382 begin
3383 GetProcedureAddress(_ImagehlpApiVersionEx, ImageHlpLib, 'ImagehlpApiVersionEx');
3384 asm
3385 MOV ESP, EBP
3386 POP EBP
3387 JMP [_ImagehlpApiVersionEx]
3388 end;
3389 end;
3390
3391 var
3392 _GetTimestampForLoadedLibrary: Pointer;
3393
GetTimestampForLoadedLibrarynull3394 function GetTimestampForLoadedLibrary;
3395 begin
3396 GetProcedureAddress(_GetTimestampForLoadedLibrary, ImageHlpLib, 'GetTimestampForLoadedLibrary');
3397 asm
3398 MOV ESP, EBP
3399 POP EBP
3400 JMP [_GetTimestampForLoadedLibrary]
3401 end;
3402 end;
3403
3404 var
3405 _SymSetOptions: Pointer;
3406
SymSetOptionsnull3407 function SymSetOptions;
3408 begin
3409 GetProcedureAddress(_SymSetOptions, ImageHlpLib, 'SymSetOptions');
3410 asm
3411 MOV ESP, EBP
3412 POP EBP
3413 JMP [_SymSetOptions]
3414 end;
3415 end;
3416
3417 var
3418 _SymGetOptions: Pointer;
3419
SymGetOptionsnull3420 function SymGetOptions;
3421 begin
3422 GetProcedureAddress(_SymGetOptions, ImageHlpLib, 'SymGetOptions');
3423 asm
3424 MOV ESP, EBP
3425 POP EBP
3426 JMP [_SymGetOptions]
3427 end;
3428 end;
3429
3430 var
3431 _SymCleanup: Pointer;
3432
SymCleanupnull3433 function SymCleanup;
3434 begin
3435 GetProcedureAddress(_SymCleanup, ImageHlpLib, 'SymCleanup');
3436 asm
3437 MOV ESP, EBP
3438 POP EBP
3439 JMP [_SymCleanup]
3440 end;
3441 end;
3442
3443 var
3444 _SymMatchString: Pointer;
3445
SymMatchStringnull3446 function SymMatchString;
3447 begin
3448 GetProcedureAddress(_SymMatchString, ImageHlpLib, 'SymMatchString');
3449 asm
3450 MOV ESP, EBP
3451 POP EBP
3452 JMP [_SymMatchString]
3453 end;
3454 end;
3455
3456
3457 var
3458 _SymEnumSourceFiles: Pointer;
3459
SymEnumSourceFilesnull3460 function SymEnumSourceFiles;
3461 begin
3462 GetProcedureAddress(_SymEnumSourceFiles, ImageHlpLib, 'SymEnumSourceFiles');
3463 asm
3464 MOV ESP, EBP
3465 POP EBP
3466 JMP [_SymEnumSourceFiles]
3467 end;
3468 end;
3469
3470 var
3471 _SymEnumerateModules64: Pointer;
3472
SymEnumerateModules64null3473 function SymEnumerateModules64;
3474 begin
3475 GetProcedureAddress(_SymEnumerateModules64, ImageHlpLib, 'SymEnumerateModules64');
3476 asm
3477 MOV ESP, EBP
3478 POP EBP
3479 JMP [_SymEnumerateModules64]
3480 end;
3481 end;
3482
3483 var
3484 _SymEnumerateModules: Pointer;
3485
SymEnumerateModulesnull3486 function SymEnumerateModules;
3487 begin
3488 GetProcedureAddress(_SymEnumerateModules, ImageHlpLib, 'SymEnumerateModules');
3489 asm
3490 MOV ESP, EBP
3491 POP EBP
3492 JMP [_SymEnumerateModules]
3493 end;
3494 end;
3495
3496 var
3497 _SymEnumerateSymbols64: Pointer;
3498
SymEnumerateSymbols64null3499 function SymEnumerateSymbols64;
3500 begin
3501 GetProcedureAddress(_SymEnumerateSymbols64, ImageHlpLib, 'SymEnumerateSymbols64');
3502 asm
3503 MOV ESP, EBP
3504 POP EBP
3505 JMP [_SymEnumerateSymbols64]
3506 end;
3507 end;
3508
3509 var
3510 _SymEnumerateSymbolsW64: Pointer;
3511
SymEnumerateSymbolsW64null3512 function SymEnumerateSymbolsW64;
3513 begin
3514 GetProcedureAddress(_SymEnumerateSymbolsW64, ImageHlpLib, 'SymEnumerateSymbolsW64');
3515 asm
3516 MOV ESP, EBP
3517 POP EBP
3518 JMP [_SymEnumerateSymbolsW64]
3519 end;
3520 end;
3521
3522 var
3523 _SymEnumerateSymbols: Pointer;
3524
SymEnumerateSymbolsnull3525 function SymEnumerateSymbols;
3526 begin
3527 GetProcedureAddress(_SymEnumerateSymbols, ImageHlpLib, 'SymEnumerateSymbols');
3528 asm
3529 MOV ESP, EBP
3530 POP EBP
3531 JMP [_SymEnumerateSymbols]
3532 end;
3533 end;
3534
3535 var
3536 _SymEnumerateSymbolsW: Pointer;
3537
SymEnumerateSymbolsWnull3538 function SymEnumerateSymbolsW;
3539 begin
3540 GetProcedureAddress(_SymEnumerateSymbolsW, ImageHlpLib, 'SymEnumerateSymbolsW');
3541 asm
3542 MOV ESP, EBP
3543 POP EBP
3544 JMP [_SymEnumerateSymbolsW]
3545 end;
3546 end;
3547
3548 var
3549 _EnumerateLoadedModules64: Pointer;
3550
EnumerateLoadedModules64null3551 function EnumerateLoadedModules64;
3552 begin
3553 GetProcedureAddress(_EnumerateLoadedModules64, ImageHlpLib, 'EnumerateLoadedModules64');
3554 asm
3555 MOV ESP, EBP
3556 POP EBP
3557 JMP [_EnumerateLoadedModules64]
3558 end;
3559 end;
3560
3561 var
3562 _EnumerateLoadedModules: Pointer;
3563
EnumerateLoadedModulesnull3564 function EnumerateLoadedModules;
3565 begin
3566 GetProcedureAddress(_EnumerateLoadedModules, ImageHlpLib, 'EnumerateLoadedModules');
3567 asm
3568 MOV ESP, EBP
3569 POP EBP
3570 JMP [_EnumerateLoadedModules]
3571 end;
3572 end;
3573
3574 var
3575 _SymFunctionTableAccess64: Pointer;
3576
SymFunctionTableAccess64null3577 function SymFunctionTableAccess64;
3578 begin
3579 GetProcedureAddress(_SymFunctionTableAccess64, ImageHlpLib, 'SymFunctionTableAccess64');
3580 asm
3581 MOV ESP, EBP
3582 POP EBP
3583 JMP [_SymFunctionTableAccess64]
3584 end;
3585 end;
3586
3587 var
3588 _SymFunctionTableAccess: Pointer;
3589
SymFunctionTableAccessnull3590 function SymFunctionTableAccess;
3591 begin
3592 GetProcedureAddress(_SymFunctionTableAccess, ImageHlpLib, 'SymFunctionTableAccess');
3593 asm
3594 MOV ESP, EBP
3595 POP EBP
3596 JMP [_SymFunctionTableAccess]
3597 end;
3598 end;
3599
3600 var
3601 _SymGetModuleInfo64: Pointer;
3602
SymGetModuleInfo64null3603 function SymGetModuleInfo64;
3604 begin
3605 GetProcedureAddress(_SymGetModuleInfo64, ImageHlpLib, 'SymGetModuleInfo64');
3606 asm
3607 MOV ESP, EBP
3608 POP EBP
3609 JMP [_SymGetModuleInfo64]
3610 end;
3611 end;
3612
3613 var
3614 _SymGetModuleInfoW64: Pointer;
3615
SymGetModuleInfoW64null3616 function SymGetModuleInfoW64;
3617 begin
3618 GetProcedureAddress(_SymGetModuleInfoW64, ImageHlpLib, 'SymGetModuleInfoW64');
3619 asm
3620 MOV ESP, EBP
3621 POP EBP
3622 JMP [_SymGetModuleInfoW64]
3623 end;
3624 end;
3625
3626 var
3627 _SymGetModuleInfo: Pointer;
3628
SymGetModuleInfonull3629 function SymGetModuleInfo;
3630 begin
3631 GetProcedureAddress(_SymGetModuleInfo, ImageHlpLib, 'SymGetModuleInfo');
3632 asm
3633 MOV ESP, EBP
3634 POP EBP
3635 JMP [_SymGetModuleInfo]
3636 end;
3637 end;
3638
3639 var
3640 _SymGetModuleInfoW: Pointer;
3641
SymGetModuleInfoWnull3642 function SymGetModuleInfoW;
3643 begin
3644 GetProcedureAddress(_SymGetModuleInfoW, ImageHlpLib, 'SymGetModuleInfoW');
3645 asm
3646 MOV ESP, EBP
3647 POP EBP
3648 JMP [_SymGetModuleInfoW]
3649 end;
3650 end;
3651
3652 var
3653 _SymGetModuleBase64: Pointer;
3654
SymGetModuleBase64null3655 function SymGetModuleBase64;
3656 begin
3657 GetProcedureAddress(_SymGetModuleBase64, ImageHlpLib, 'SymGetModuleBase64');
3658 asm
3659 MOV ESP, EBP
3660 POP EBP
3661 JMP [_SymGetModuleBase64]
3662 end;
3663 end;
3664
3665 var
3666 _SymGetModuleBase: Pointer;
3667
SymGetModuleBasenull3668 function SymGetModuleBase;
3669 begin
3670 GetProcedureAddress(_SymGetModuleBase, ImageHlpLib, 'SymGetModuleBase');
3671 asm
3672 MOV ESP, EBP
3673 POP EBP
3674 JMP [_SymGetModuleBase]
3675 end;
3676 end;
3677
3678 var
3679 _SymGetSymNext64: Pointer;
3680
SymGetSymNext64null3681 function SymGetSymNext64;
3682 begin
3683 GetProcedureAddress(_SymGetSymNext64, ImageHlpLib, 'SymGetSymNext64');
3684 asm
3685 MOV ESP, EBP
3686 POP EBP
3687 JMP [_SymGetSymNext64]
3688 end;
3689 end;
3690
3691 var
3692 _SymGetSymNext: Pointer;
3693
SymGetSymNextnull3694 function SymGetSymNext;
3695 begin
3696 GetProcedureAddress(_SymGetSymNext, ImageHlpLib, 'SymGetSymNext');
3697 asm
3698 MOV ESP, EBP
3699 POP EBP
3700 JMP [_SymGetSymNext]
3701 end;
3702 end;
3703
3704 var
3705 _SymGetSymPrev64: Pointer;
3706
SymGetSymPrev64null3707 function SymGetSymPrev64;
3708 begin
3709 GetProcedureAddress(_SymGetSymPrev64, ImageHlpLib, 'SymGetSymPrev64');
3710 asm
3711 MOV ESP, EBP
3712 POP EBP
3713 JMP [_SymGetSymPrev64]
3714 end;
3715 end;
3716
3717 var
3718 _SymGetSymPrev: Pointer;
3719
SymGetSymPrevnull3720 function SymGetSymPrev;
3721 begin
3722 GetProcedureAddress(_SymGetSymPrev, ImageHlpLib, 'SymGetSymPrev');
3723 asm
3724 MOV ESP, EBP
3725 POP EBP
3726 JMP [_SymGetSymPrev]
3727 end;
3728 end;
3729
3730 var
3731 _SymGetLineFromAddr64: Pointer;
3732
SymGetLineFromAddr64null3733 function SymGetLineFromAddr64;
3734 begin
3735 GetProcedureAddress(_SymGetLineFromAddr64, ImageHlpLib, 'SymGetLineFromAddr64');
3736 asm
3737 MOV ESP, EBP
3738 POP EBP
3739 JMP [_SymGetLineFromAddr64]
3740 end;
3741 end;
3742
3743 var
3744 _SymGetLineFromAddr: Pointer;
3745
SymGetLineFromAddrnull3746 function SymGetLineFromAddr;
3747 begin
3748 GetProcedureAddress(_SymGetLineFromAddr, ImageHlpLib, 'SymGetLineFromAddr');
3749 asm
3750 MOV ESP, EBP
3751 POP EBP
3752 JMP [_SymGetLineFromAddr]
3753 end;
3754 end;
3755
3756 var
3757 _SymGetLineFromName64: Pointer;
3758
SymGetLineFromName64null3759 function SymGetLineFromName64;
3760 begin
3761 GetProcedureAddress(_SymGetLineFromName64, ImageHlpLib, 'SymGetLineFromName64');
3762 asm
3763 MOV ESP, EBP
3764 POP EBP
3765 JMP [_SymGetLineFromName64]
3766 end;
3767 end;
3768
3769 var
3770 _SymGetLineFromName: Pointer;
3771
SymGetLineFromNamenull3772 function SymGetLineFromName;
3773 begin
3774 GetProcedureAddress(_SymGetLineFromName, ImageHlpLib, 'SymGetLineFromName');
3775 asm
3776 MOV ESP, EBP
3777 POP EBP
3778 JMP [_SymGetLineFromName]
3779 end;
3780 end;
3781
3782 var
3783 _SymGetLineNext64: Pointer;
3784
SymGetLineNext64null3785 function SymGetLineNext64;
3786 begin
3787 GetProcedureAddress(_SymGetLineNext64, ImageHlpLib, 'SymGetLineNext64');
3788 asm
3789 MOV ESP, EBP
3790 POP EBP
3791 JMP [_SymGetLineNext64]
3792 end;
3793 end;
3794
3795 var
3796 _SymGetLineNext: Pointer;
3797
SymGetLineNextnull3798 function SymGetLineNext;
3799 begin
3800 GetProcedureAddress(_SymGetLineNext, ImageHlpLib, 'SymGetLineNext');
3801 asm
3802 MOV ESP, EBP
3803 POP EBP
3804 JMP [_SymGetLineNext]
3805 end;
3806 end;
3807
3808 var
3809 _SymGetLinePrev64: Pointer;
3810
SymGetLinePrev64null3811 function SymGetLinePrev64;
3812 begin
3813 GetProcedureAddress(_SymGetLinePrev64, ImageHlpLib, 'SymGetLinePrev64');
3814 asm
3815 MOV ESP, EBP
3816 POP EBP
3817 JMP [_SymGetLinePrev64]
3818 end;
3819 end;
3820
3821 var
3822 _SymGetLinePrev: Pointer;
3823
SymGetLinePrevnull3824 function SymGetLinePrev;
3825 begin
3826 GetProcedureAddress(_SymGetLinePrev, ImageHlpLib, 'SymGetLinePrev');
3827 asm
3828 MOV ESP, EBP
3829 POP EBP
3830 JMP [_SymGetLinePrev]
3831 end;
3832 end;
3833
3834 var
3835 _SymMatchFileName: Pointer;
3836
SymMatchFileNamenull3837 function SymMatchFileName;
3838 begin
3839 GetProcedureAddress(_SymMatchFileName, ImageHlpLib, 'SymMatchFileName');
3840 asm
3841 MOV ESP, EBP
3842 POP EBP
3843 JMP [_SymMatchFileName]
3844 end;
3845 end;
3846
3847 var
3848 _SymInitialize: Pointer;
3849
SymInitializenull3850 function SymInitialize;
3851 begin
3852 GetProcedureAddress(_SymInitialize, ImageHlpLib, 'SymInitialize');
3853 asm
3854 MOV ESP, EBP
3855 POP EBP
3856 JMP [_SymInitialize]
3857 end;
3858 end;
3859
3860 var
3861 _SymGetSearchPath: Pointer;
3862
SymGetSearchPathnull3863 function SymGetSearchPath;
3864 begin
3865 GetProcedureAddress(_SymGetSearchPath, ImageHlpLib, 'SymGetSearchPath');
3866 asm
3867 MOV ESP, EBP
3868 POP EBP
3869 JMP [_SymGetSearchPath]
3870 end;
3871 end;
3872
3873 var
3874 _SymSetSearchPath: Pointer;
3875
SymSetSearchPathnull3876 function SymSetSearchPath;
3877 begin
3878 GetProcedureAddress(_SymSetSearchPath, ImageHlpLib, 'SymSetSearchPath');
3879 asm
3880 MOV ESP, EBP
3881 POP EBP
3882 JMP [_SymSetSearchPath]
3883 end;
3884 end;
3885
3886 var
3887 _SymLoadModuleEx: Pointer;
3888
SymLoadModuleExnull3889 function SymLoadModuleEx;
3890 begin
3891 GetProcedureAddress(_SymLoadModuleEx, ImageHlpLib, 'SymLoadModuleEx');
3892 asm
3893 MOV ESP, EBP
3894 POP EBP
3895 JMP [_SymLoadModuleEx]
3896 end;
3897 end;
3898
3899 var
3900 _SymLoadModule64: Pointer;
3901
SymLoadModule64null3902 function SymLoadModule64;
3903 begin
3904 GetProcedureAddress(_SymLoadModule64, ImageHlpLib, 'SymLoadModule64');
3905 asm
3906 MOV ESP, EBP
3907 POP EBP
3908 JMP [_SymLoadModule64]
3909 end;
3910 end;
3911
3912 var
3913 _SymLoadModule: Pointer;
3914
SymLoadModulenull3915 function SymLoadModule;
3916 begin
3917 GetProcedureAddress(_SymLoadModule, ImageHlpLib, 'SymLoadModule');
3918 asm
3919 MOV ESP, EBP
3920 POP EBP
3921 JMP [_SymLoadModule]
3922 end;
3923 end;
3924
3925 var
3926 _SymUnloadModule64: Pointer;
3927
SymUnloadModule64null3928 function SymUnloadModule64;
3929 begin
3930 GetProcedureAddress(_SymUnloadModule64, ImageHlpLib, 'SymUnloadModule64');
3931 asm
3932 MOV ESP, EBP
3933 POP EBP
3934 JMP [_SymUnloadModule64]
3935 end;
3936 end;
3937
3938 var
3939 _SymUnloadModule: Pointer;
3940
SymUnloadModulenull3941 function SymUnloadModule;
3942 begin
3943 GetProcedureAddress(_SymUnloadModule, ImageHlpLib, 'SymUnloadModule');
3944 asm
3945 MOV ESP, EBP
3946 POP EBP
3947 JMP [_SymUnloadModule]
3948 end;
3949 end;
3950
3951 var
3952 _SymUnDName64: Pointer;
3953
SymUnDName64null3954 function SymUnDName64;
3955 begin
3956 GetProcedureAddress(_SymUnDName64, ImageHlpLib, 'SymUnDName64');
3957 asm
3958 MOV ESP, EBP
3959 POP EBP
3960 JMP [_SymUnDName64]
3961 end;
3962 end;
3963
3964 var
3965 _SymUnDName: Pointer;
3966
SymUnDNamenull3967 function SymUnDName;
3968 begin
3969 GetProcedureAddress(_SymUnDName, ImageHlpLib, 'SymUnDName');
3970 asm
3971 MOV ESP, EBP
3972 POP EBP
3973 JMP [_SymUnDName]
3974 end;
3975 end;
3976
3977 var
3978 _SymRegisterCallback64: Pointer;
3979
SymRegisterCallback64null3980 function SymRegisterCallback64;
3981 begin
3982 GetProcedureAddress(_SymRegisterCallback64, ImageHlpLib, 'SymRegisterCallback64');
3983 asm
3984 MOV ESP, EBP
3985 POP EBP
3986 JMP [_SymRegisterCallback64]
3987 end;
3988 end;
3989
3990 var
3991 _SymRegFuncEntryCallback64: Pointer;
3992
SymRegisterFunctionEntryCallback64null3993 function SymRegisterFunctionEntryCallback64;
3994 begin
3995 GetProcedureAddress(_SymRegFuncEntryCallback64, ImageHlpLib, 'SymRegisterFunctionEntryCallback64');
3996 asm
3997 MOV ESP, EBP
3998 POP EBP
3999 JMP [_SymRegFuncEntryCallback64]
4000 end;
4001 end;
4002
4003 var
4004 _SymRegisterCallback: Pointer;
4005
SymRegisterCallbacknull4006 function SymRegisterCallback;
4007 begin
4008 GetProcedureAddress(_SymRegisterCallback, ImageHlpLib, 'SymRegisterCallback');
4009 asm
4010 MOV ESP, EBP
4011 POP EBP
4012 JMP [_SymRegisterCallback]
4013 end;
4014 end;
4015
4016 var
4017 _SymRegisterFuncEntryCallback: Pointer;
4018
SymRegisterFunctionEntryCallbacknull4019 function SymRegisterFunctionEntryCallback;
4020 begin
4021 GetProcedureAddress(_SymRegisterFuncEntryCallback, ImageHlpLib, 'SymRegisterFunctionEntryCallback');
4022 asm
4023 MOV ESP, EBP
4024 POP EBP
4025 JMP [_SymRegisterFuncEntryCallback]
4026 end;
4027 end;
4028
4029 var
4030 _SymSetContext: Pointer;
4031
SymSetContextnull4032 function SymSetContext;
4033 begin
4034 GetProcedureAddress(_SymSetContext, ImageHlpLib, 'SymSetContext');
4035 asm
4036 MOV ESP, EBP
4037 POP EBP
4038 JMP [_SymSetContext]
4039 end;
4040 end;
4041
4042 var
4043 _SymFromAddr: Pointer;
4044
SymFromAddrnull4045 function SymFromAddr;
4046 begin
4047 GetProcedureAddress(_SymFromAddr, ImageHlpLib, 'SymFromAddr');
4048 asm
4049 MOV ESP, EBP
4050 POP EBP
4051 JMP [_SymFromAddr]
4052 end;
4053 end;
4054
4055 var
4056 _SymFromName: Pointer;
4057
SymFromNamenull4058 function SymFromName;
4059 begin
4060 GetProcedureAddress(_SymFromName, ImageHlpLib, 'SymFromName');
4061 asm
4062 MOV ESP, EBP
4063 POP EBP
4064 JMP [_SymFromName]
4065 end;
4066 end;
4067
4068 var
4069 _SymEnumSymbolsForAddr: Pointer;
4070
SymEnumSymbolsForAddrnull4071 function SymEnumSymbolsForAddr;
4072 begin
4073 GetProcedureAddress(_SymEnumSymbolsForAddr, ImageHlpLib, 'SymEnumSymbolsForAddr');
4074 asm
4075 MOV ESP, EBP
4076 POP EBP
4077 JMP [_SymEnumSymbolsForAddr]
4078 end;
4079 end;
4080
4081 var
4082 _SymEnumSymbols: Pointer;
4083
SymEnumSymbolsnull4084 function SymEnumSymbols;
4085 begin
4086 GetProcedureAddress(_SymEnumSymbols, ImageHlpLib, 'SymEnumSymbols');
4087 asm
4088 MOV ESP, EBP
4089 POP EBP
4090 JMP [_SymEnumSymbols]
4091 end;
4092 end;
4093
4094 var
4095 _SymGetTypeInfo: Pointer;
4096
SymGetTypeInfonull4097 function SymGetTypeInfo;
4098 begin
4099 GetProcedureAddress(_SymGetTypeInfo, ImageHlpLib, 'SymGetTypeInfo');
4100 asm
4101 MOV ESP, EBP
4102 POP EBP
4103 JMP [_SymGetTypeInfo]
4104 end;
4105 end;
4106
4107 var
4108 _SymEnumTypes: Pointer;
4109
SymEnumTypesnull4110 function SymEnumTypes;
4111 begin
4112 GetProcedureAddress(_SymEnumTypes, ImageHlpLib, 'SymEnumTypes');
4113 asm
4114 MOV ESP, EBP
4115 POP EBP
4116 JMP [_SymEnumTypes]
4117 end;
4118 end;
4119
4120 var
4121 _SymGetTypeFromName: Pointer;
4122
SymGetTypeFromNamenull4123 function SymGetTypeFromName;
4124 begin
4125 GetProcedureAddress(_SymGetTypeFromName, ImageHlpLib, 'SymGetTypeFromName');
4126 asm
4127 MOV ESP, EBP
4128 POP EBP
4129 JMP [_SymGetTypeFromName]
4130 end;
4131 end;
4132
4133 var
4134 _SymAddSymbol: Pointer;
4135
SymAddSymbolnull4136 function SymAddSymbol;
4137 begin
4138 GetProcedureAddress(_SymAddSymbol, ImageHlpLib, 'SymAddSymbol');
4139 asm
4140 MOV ESP, EBP
4141 POP EBP
4142 JMP [_SymAddSymbol]
4143 end;
4144 end;
4145
4146 var
4147 _SymDeleteSymbol: Pointer;
4148
SymDeleteSymbolnull4149 function SymDeleteSymbol;
4150 begin
4151 GetProcedureAddress(_SymDeleteSymbol, ImageHlpLib, 'SymDeleteSymbol');
4152 asm
4153 MOV ESP, EBP
4154 POP EBP
4155 JMP [_SymDeleteSymbol]
4156 end;
4157 end;
4158
4159 var
4160 _DbgHelpCreateUserDump: Pointer;
4161
DbgHelpCreateUserDumpnull4162 function DbgHelpCreateUserDump;
4163 begin
4164 GetProcedureAddress(_DbgHelpCreateUserDump, ImageHlpLib, 'DbgHelpCreateUserDump');
4165 asm
4166 MOV ESP, EBP
4167 POP EBP
4168 JMP [_DbgHelpCreateUserDump]
4169 end;
4170 end;
4171
4172 var
4173 _DbgHelpCreateUserDumpW: Pointer;
4174
DbgHelpCreateUserDumpWnull4175 function DbgHelpCreateUserDumpW;
4176 begin
4177 GetProcedureAddress(_DbgHelpCreateUserDumpW, ImageHlpLib, 'DbgHelpCreateUserDumpW');
4178 asm
4179 MOV ESP, EBP
4180 POP EBP
4181 JMP [_DbgHelpCreateUserDumpW]
4182 end;
4183 end;
4184
4185 var
4186 _SymGetSymFromAddr64: Pointer;
4187
SymGetSymFromAddr64null4188 function SymGetSymFromAddr64;
4189 begin
4190 GetProcedureAddress(_SymGetSymFromAddr64, ImageHlpLib, 'SymGetSymFromAddr64');
4191 asm
4192 MOV ESP, EBP
4193 POP EBP
4194 JMP [_SymGetSymFromAddr64]
4195 end;
4196 end;
4197
4198 var
4199 _SymGetSymFromAddr: Pointer;
4200
SymGetSymFromAddrnull4201 function SymGetSymFromAddr;
4202 begin
4203 GetProcedureAddress(_SymGetSymFromAddr, ImageHlpLib, 'SymGetSymFromAddr');
4204 asm
4205 MOV ESP, EBP
4206 POP EBP
4207 JMP [_SymGetSymFromAddr]
4208 end;
4209 end;
4210
4211 var
4212 _SymGetSymFromName64: Pointer;
4213
SymGetSymFromName64null4214 function SymGetSymFromName64;
4215 begin
4216 GetProcedureAddress(_SymGetSymFromName64, ImageHlpLib, 'SymGetSymFromName64');
4217 asm
4218 MOV ESP, EBP
4219 POP EBP
4220 JMP [_SymGetSymFromName64]
4221 end;
4222 end;
4223
4224 var
4225 _SymGetSymFromName: Pointer;
4226
SymGetSymFromNamenull4227 function SymGetSymFromName;
4228 begin
4229 GetProcedureAddress(_SymGetSymFromName, ImageHlpLib, 'SymGetSymFromName');
4230 asm
4231 MOV ESP, EBP
4232 POP EBP
4233 JMP [_SymGetSymFromName]
4234 end;
4235 end;
4236
4237 var
4238 _FindFileInPath: Pointer;
4239
FindFileInPathnull4240 function FindFileInPath;
4241 begin
4242 GetProcedureAddress(_FindFileInPath, ImageHlpLib, 'FindFileInPath');
4243 asm
4244 MOV ESP, EBP
4245 POP EBP
4246 JMP [_FindFileInPath]
4247 end;
4248 end;
4249
4250 var
4251 _FindFileInSearchPath: Pointer;
4252
FindFileInSearchPathnull4253 function FindFileInSearchPath;
4254 begin
4255 GetProcedureAddress(_FindFileInSearchPath, ImageHlpLib, 'FindFileInSearchPath');
4256 asm
4257 MOV ESP, EBP
4258 POP EBP
4259 JMP [_FindFileInSearchPath]
4260 end;
4261 end;
4262
4263 var
4264 _SymEnumSym: Pointer;
4265
SymEnumSymnull4266 function SymEnumSym;
4267 begin
4268 GetProcedureAddress(_SymEnumSym, ImageHlpLib, 'SymEnumSym');
4269 asm
4270 MOV ESP, EBP
4271 POP EBP
4272 JMP [_SymEnumSym]
4273 end;
4274 end;
4275
4276 var
4277 _MiniDumpWriteDump: Pointer;
4278
MiniDumpWriteDumpnull4279 function MiniDumpWriteDump;
4280 begin
4281 GetProcedureAddress(_MiniDumpWriteDump, ImageHlpLib, 'MiniDumpWriteDump');
4282 asm
4283 MOV ESP, EBP
4284 POP EBP
4285 JMP [_MiniDumpWriteDump]
4286 end;
4287 end;
4288
4289 var
4290 _MiniDumpReadDumpStream: Pointer;
4291
MiniDumpReadDumpStreamnull4292 function MiniDumpReadDumpStream;
4293 begin
4294 GetProcedureAddress(_MiniDumpReadDumpStream, ImageHlpLib, 'MiniDumpReadDumpStream');
4295 asm
4296 MOV ESP, EBP
4297 POP EBP
4298 JMP [_MiniDumpReadDumpStream]
4299 end;
4300 end;
4301
4302
4303 {$ELSE}
4304
BindImagenull4305 function BindImage; external ImageHlpLib name 'BindImage';
BindImageExnull4306 function BindImageEx; external ImageHlpLib name 'BindImageEx';
ReBaseImagenull4307 function ReBaseImage; external ImageHlpLib name 'ReBaseImage';
ReBaseImage64null4308 function ReBaseImage64; external ImageHlpLib name 'ReBaseImage64';
CheckSumMappedFilenull4309 function CheckSumMappedFile; external ImageHlpLib name 'CheckSumMappedFile';
MapFileAndCheckSumAnull4310 function MapFileAndCheckSumA; external ImageHlpLib name 'MapFileAndCheckSumA';
MapFileAndCheckSumWnull4311 function MapFileAndCheckSumW; external ImageHlpLib name 'MapFileAndCheckSumW';
MapFileAndCheckSumnull4312 function MapFileAndCheckSum; external ImageHlpLib name 'MapFileAndCheckSum' + AWSuffix;
GetImageConfigInformationnull4313 function GetImageConfigInformation; external ImageHlpLib name 'GetImageConfigInformation';
GetImageUnusedHeaderBytesnull4314 function GetImageUnusedHeaderBytes; external ImageHlpLib name 'GetImageUnusedHeaderBytes';
SetImageConfigInformationnull4315 function SetImageConfigInformation; external ImageHlpLib name 'SetImageConfigInformation';
ImageGetDigestStreamnull4316 function ImageGetDigestStream; external ImageHlpLib name 'ImageGetDigestStream';
ImageAddCertificatenull4317 function ImageAddCertificate; external ImageHlpLib name 'ImageAddCertificate';
ImageRemoveCertificatenull4318 function ImageRemoveCertificate; external ImageHlpLib name 'ImageRemoveCertificate';
ImageEnumerateCertificatesnull4319 function ImageEnumerateCertificates; external ImageHlpLib name 'ImageEnumerateCertificates';
ImageGetCertificateDatanull4320 function ImageGetCertificateData; external ImageHlpLib name 'ImageGetCertificateData';
ImageGetCertificateHeadernull4321 function ImageGetCertificateHeader; external ImageHlpLib name 'ImageGetCertificateHeader';
ImageLoadnull4322 function ImageLoad; external ImageHlpLib name 'ImageLoad';
ImageUnloadnull4323 function ImageUnload; external ImageHlpLib name 'ImageUnload';
MapAndLoadnull4324 function MapAndLoad; external ImageHlpLib name 'MapAndLoad';
UnMapAndLoadnull4325 function UnMapAndLoad; external ImageHlpLib name 'UnMapAndLoad';
TouchFileTimesnull4326 function TouchFileTimes; external ImageHlpLib name 'TouchFileTimes';
SplitSymbolsnull4327 function SplitSymbols; external ImageHlpLib name 'SplitSymbols';
UpdateDebugInfoFilenull4328 function UpdateDebugInfoFile; external ImageHlpLib name 'UpdateDebugInfoFile';
UpdateDebugInfoFileExnull4329 function UpdateDebugInfoFileEx; external ImageHlpLib name 'UpdateDebugInfoFileEx';
FindDebugInfoFilenull4330 function FindDebugInfoFile; external ImageHlpLib name 'FindDebugInfoFile';
FindDebugInfoFileExnull4331 function FindDebugInfoFileEx; external ImageHlpLib name 'FindDebugInfoFileEx';
SymFindFileInPathnull4332 function SymFindFileInPath; external ImageHlpLib name 'SymFindFileInPath';
FindExecutableImagenull4333 function FindExecutableImage; external ImageHlpLib name 'FindExecutableImage';
FindExecutableImageExnull4334 function FindExecutableImageEx; external ImageHlpLib name 'FindExecutableImageEx';
ImageNtHeadernull4335 function ImageNtHeader; external ImageHlpLib name 'ImageNtHeader';
ImageDirectoryEntryToDataExnull4336 function ImageDirectoryEntryToDataEx; external ImageHlpLib name 'ImageDirectoryEntryToDataEx';
ImageDirectoryEntryToDatanull4337 function ImageDirectoryEntryToData; external ImageHlpLib name 'ImageDirectoryEntryToData';
ImageRvaToSectionnull4338 function ImageRvaToSection; external ImageHlpLib name 'ImageRvaToSection';
ImageRvaToVanull4339 function ImageRvaToVa; external ImageHlpLib name 'ImageRvaToVa';
MapDebugInformationnull4340 function MapDebugInformation; external ImageHlpLib name 'MapDebugInformation';
UnmapDebugInformationnull4341 function UnmapDebugInformation; external ImageHlpLib name 'UnmapDebugInformation';
SearchTreeForFilenull4342 function SearchTreeForFile; external ImageHlpLib name 'SearchTreeForFile';
EnumDirTreenull4343 function EnumDirTree; external ImageHlpLib name 'EnumDirTree';
MakeSureDirectoryPathExistsnull4344 function MakeSureDirectoryPathExists; external ImageHlpLib name 'MakeSureDirectoryPathExists';
UnDecorateSymbolNamenull4345 function UnDecorateSymbolName; external ImageHlpLib name 'UnDecorateSymbolName';
StackWalk64null4346 function StackWalk64; external ImageHlpLib name 'StackWalk64';
StackWalknull4347 function StackWalk; external ImageHlpLib name 'StackWalk';
ImagehlpApiVersionnull4348 function ImagehlpApiVersion; external ImageHlpLib name 'ImagehlpApiVersion';
ImagehlpApiVersionExnull4349 function ImagehlpApiVersionEx; external ImageHlpLib name 'ImagehlpApiVersionEx';
GetTimestampForLoadedLibrarynull4350 function GetTimestampForLoadedLibrary; external ImageHlpLib name 'GetTimestampForLoadedLibrary';
SymSetOptionsnull4351 function SymSetOptions; external ImageHlpLib name 'SymSetOptions';
SymGetOptionsnull4352 function SymGetOptions; external ImageHlpLib name 'SymGetOptions';
SymCleanupnull4353 function SymCleanup; external ImageHlpLib name 'SymCleanup';
SymMatchStringnull4354 function SymMatchString; external ImageHlpLib name 'SymMatchString';
SymEnumSourceFilesnull4355 function SymEnumSourceFiles; external ImageHlpLib name 'SymEnumSourceFiles';
SymEnumerateModules64null4356 function SymEnumerateModules64; external ImageHlpLib name 'SymEnumerateModules64';
SymEnumerateModulesnull4357 function SymEnumerateModules; external ImageHlpLib name 'SymEnumerateModules';
SymEnumerateSymbols64null4358 function SymEnumerateSymbols64; external ImageHlpLib name 'SymEnumerateSymbols64';
SymEnumerateSymbolsW64null4359 function SymEnumerateSymbolsW64; external ImageHlpLib name 'SymEnumerateSymbolsW64';
SymEnumerateSymbolsnull4360 function SymEnumerateSymbols; external ImageHlpLib name 'SymEnumerateSymbols';
SymEnumerateSymbolsWnull4361 function SymEnumerateSymbolsW; external ImageHlpLib name 'SymEnumerateSymbolsW';
EnumerateLoadedModules64null4362 function EnumerateLoadedModules64; external ImageHlpLib name 'EnumerateLoadedModules64';
EnumerateLoadedModulesnull4363 function EnumerateLoadedModules; external ImageHlpLib name 'EnumerateLoadedModules';
SymFunctionTableAccess64null4364 function SymFunctionTableAccess64; external ImageHlpLib name 'SymFunctionTableAccess64';
SymFunctionTableAccessnull4365 function SymFunctionTableAccess; external ImageHlpLib name 'SymFunctionTableAccess';
SymGetModuleInfo64null4366 function SymGetModuleInfo64; external ImageHlpLib name 'SymGetModuleInfo64';
SymGetModuleInfoW64null4367 function SymGetModuleInfoW64; external ImageHlpLib name 'SymGetModuleInfoW64';
SymGetModuleInfonull4368 function SymGetModuleInfo; external ImageHlpLib name 'SymGetModuleInfo';
SymGetModuleInfoWnull4369 function SymGetModuleInfoW; external ImageHlpLib name 'SymGetModuleInfoW';
SymGetModuleBase64null4370 function SymGetModuleBase64; external ImageHlpLib name 'SymGetModuleBase64';
SymGetModuleBasenull4371 function SymGetModuleBase; external ImageHlpLib name 'SymGetModuleBase';
SymGetSymNext64null4372 function SymGetSymNext64; external ImageHlpLib name 'SymGetSymNext64';
SymGetSymNextnull4373 function SymGetSymNext; external ImageHlpLib name 'SymGetSymNext';
SymGetSymPrev64null4374 function SymGetSymPrev64; external ImageHlpLib name 'SymGetSymPrev64';
SymGetSymPrevnull4375 function SymGetSymPrev; external ImageHlpLib name 'SymGetSymPrev';
SymGetLineFromAddr64null4376 function SymGetLineFromAddr64; external ImageHlpLib name 'SymGetLineFromAddr64';
SymGetLineFromAddrnull4377 function SymGetLineFromAddr; external ImageHlpLib name 'SymGetLineFromAddr';
SymGetLineFromName64null4378 function SymGetLineFromName64; external ImageHlpLib name 'SymGetLineFromName64';
SymGetLineFromNamenull4379 function SymGetLineFromName; external ImageHlpLib name 'SymGetLineFromName';
SymGetLineNext64null4380 function SymGetLineNext64; external ImageHlpLib name 'SymGetLineNext64';
SymGetLineNextnull4381 function SymGetLineNext; external ImageHlpLib name 'SymGetLineNext';
SymGetLinePrev64null4382 function SymGetLinePrev64; external ImageHlpLib name 'SymGetLinePrev64';
SymGetLinePrevnull4383 function SymGetLinePrev; external ImageHlpLib name 'SymGetLinePrev';
SymMatchFileNamenull4384 function SymMatchFileName; external ImageHlpLib name 'SymMatchFileName';
SymInitializenull4385 function SymInitialize; external ImageHlpLib name 'SymInitialize';
SymGetSearchPathnull4386 function SymGetSearchPath; external ImageHlpLib name 'SymGetSearchPath';
SymSetSearchPathnull4387 function SymSetSearchPath; external ImageHlpLib name 'SymSetSearchPath';
SymLoadModuleExnull4388 function SymLoadModuleEx; external ImageHlpLib name 'SymLoadModuleEx';
SymLoadModule64null4389 function SymLoadModule64; external ImageHlpLib name 'SymLoadModule64';
SymLoadModulenull4390 function SymLoadModule; external ImageHlpLib name 'SymLoadModule';
SymUnloadModule64null4391 function SymUnloadModule64; external ImageHlpLib name 'SymUnloadModule64';
SymUnloadModulenull4392 function SymUnloadModule; external ImageHlpLib name 'SymUnloadModule';
SymUnDName64null4393 function SymUnDName64; external ImageHlpLib name 'SymUnDName64';
SymUnDNamenull4394 function SymUnDName; external ImageHlpLib name 'SymUnDName';
SymRegisterCallback64null4395 function SymRegisterCallback64; external ImageHlpLib name 'SymRegisterCallback64';
SymRegisterFunctionEntryCallback64null4396 function SymRegisterFunctionEntryCallback64; external ImageHlpLib name 'SymRegisterFunctionEntryCallback64';
SymRegisterCallbacknull4397 function SymRegisterCallback; external ImageHlpLib name 'SymRegisterCallback';
SymRegisterFunctionEntryCallbacknull4398 function SymRegisterFunctionEntryCallback; external ImageHlpLib name 'SymRegisterFunctionEntryCallback';
SymSetContextnull4399 function SymSetContext; external ImageHlpLib name 'SymSetContext';
SymFromAddrnull4400 function SymFromAddr; external ImageHlpLib name 'SymFromAddr';
SymFromNamenull4401 function SymFromName; external ImageHlpLib name 'SymFromName';
SymEnumSymbolsForAddrnull4402 function SymEnumSymbolsForAddr; external ImageHlpLib name 'SymEnumSymbolsForAddr';
SymEnumSymbolsnull4403 function SymEnumSymbols; external ImageHlpLib name 'SymEnumSymbols';
SymGetTypeInfonull4404 function SymGetTypeInfo; external ImageHlpLib name 'SymGetTypeInfo';
SymEnumTypesnull4405 function SymEnumTypes; external ImageHlpLib name 'SymEnumTypes';
SymGetTypeFromNamenull4406 function SymGetTypeFromName; external ImageHlpLib name 'SymGetTypeFromName';
SymAddSymbolnull4407 function SymAddSymbol; external ImageHlpLib name 'SymAddSymbol';
SymDeleteSymbolnull4408 function SymDeleteSymbol; external ImageHlpLib name 'SymDeleteSymbol';
DbgHelpCreateUserDumpnull4409 function DbgHelpCreateUserDump; external ImageHlpLib name 'DbgHelpCreateUserDump';
DbgHelpCreateUserDumpWnull4410 function DbgHelpCreateUserDumpW; external ImageHlpLib name 'DbgHelpCreateUserDumpW';
SymGetSymFromAddr64null4411 function SymGetSymFromAddr64; external ImageHlpLib name 'SymGetSymFromAddr64';
SymGetSymFromAddrnull4412 function SymGetSymFromAddr; external ImageHlpLib name 'SymGetSymFromAddr';
SymGetSymFromName64null4413 function SymGetSymFromName64; external ImageHlpLib name 'SymGetSymFromName64';
SymGetSymFromNamenull4414 function SymGetSymFromName; external ImageHlpLib name 'SymGetSymFromName';
FindFileInPathnull4415 function FindFileInPath; external ImageHlpLib name 'FindFileInPath';
FindFileInSearchPathnull4416 function FindFileInSearchPath; external ImageHlpLib name 'FindFileInSearchPath';
SymEnumSymnull4417 function SymEnumSym; external ImageHlpLib name 'SymEnumSym';
MiniDumpWriteDumpnull4418 function MiniDumpWriteDump; external ImageHlpLib name 'MiniDumpWriteDump';
MiniDumpReadDumpStreamnull4419 function MiniDumpReadDumpStream; external ImageHlpLib name 'MiniDumpReadDumpStream';
4420
4421 {$ENDIF DYNAMIC_LINK}
4422
4423 {$ENDIF JWA_INTERFACESECTION}
4424
4425 {$IFNDEF JWA_OMIT_SECTIONS}
4426 end.
4427 {$ENDIF JWA_OMIT_SECTIONS}
4428