WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/src/gallium/auxiliary/util/dbghelp.h

Rev	Author	Line No.	Line
4358	Serge	1	/**
		2	* This file has no copyright assigned and is placed in the Public Domain.
		3	* This file is part of the w64 mingw-runtime package.
		4	* No warranty is given; refer to the file DISCLAIMER.PD within this package.
		5	*/
		6	#ifndef _DBGHELP_
		7	#define _DBGHELP_
		8
		9	#ifdef _WIN64
		10	#ifndef _IMAGEHLP64
		11	#define _IMAGEHLP64
		12	#endif
		13	#endif
		14
		15	#ifdef __cplusplus
		16	extern "C" {
		17	#endif
		18
		19	#define IMAGEAPI DECLSPEC_IMPORT WINAPI
		20	#define DBHLP_DEPRECIATED __declspec(deprecated)
		21
		22	#define DBHLPAPI IMAGEAPI
		23
		24	#define IMAGE_SEPARATION (64*1024)
		25
		26	typedef struct _LOADED_IMAGE {
		27	PSTR ModuleName;
		28	HANDLE hFile;
		29	PUCHAR MappedAddress;
		30	#ifdef _IMAGEHLP64
		31	PIMAGE_NT_HEADERS64 FileHeader;
		32	#else
		33	PIMAGE_NT_HEADERS32 FileHeader;
		34	#endif
		35	PIMAGE_SECTION_HEADER LastRvaSection;
		36	ULONG NumberOfSections;
		37	PIMAGE_SECTION_HEADER Sections;
		38	ULONG Characteristics;
		39	BOOLEAN fSystemImage;
		40	BOOLEAN fDOSImage;
		41	LIST_ENTRY Links;
		42	ULONG SizeOfImage;
		43	} LOADED_IMAGE,*PLOADED_IMAGE;
		44
		45	#define MAX_SYM_NAME 2000
		46
		47	typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
		48	typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR filename,PVOID context);
		49	typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
		50
		51	typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR);
		52	typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
		53	typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
		54	typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64);
		55	typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context);
		56	typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
		57	typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR);
		58
		59	HANDLE IMAGEAPI FindDebugInfoFile(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath);
		60	HANDLE IMAGEAPI FindDebugInfoFileEx(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData);
		61	BOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context);
		62	HANDLE IMAGEAPI FindExecutableImage(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath);
		63	HANDLE IMAGEAPI FindExecutableImageEx(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData);
		64	PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base);
		65	PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader);
		66	PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size);
		67	PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva);
		68	PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection);
		69
		70	#define SSRVOPT_CALLBACK 0x0001
		71	#define SSRVOPT_DWORD 0x0002
		72	#define SSRVOPT_DWORDPTR 0x0004
		73	#define SSRVOPT_GUIDPTR 0x0008
		74	#define SSRVOPT_OLDGUIDPTR 0x0010
		75	#define SSRVOPT_UNATTENDED 0x0020
		76	#define SSRVOPT_NOCOPY 0x0040
		77	#define SSRVOPT_PARENTWIN 0x0080
		78	#define SSRVOPT_PARAMTYPE 0x0100
		79	#define SSRVOPT_SECURE 0x0200
		80	#define SSRVOPT_TRACE 0x0400
		81	#define SSRVOPT_SETCONTEXT 0x0800
		82	#define SSRVOPT_PROXY 0x1000
		83	#define SSRVOPT_DOWNSTREAM_STORE 0x2000
		84	#define SSRVOPT_RESET ((ULONG_PTR)-1)
		85
		86	#define SSRVACTION_TRACE 1
		87	#define SSRVACTION_QUERYCANCEL 2
		88	#define SSRVACTION_EVENT 3
		89
		90	#ifndef _WIN64
		91
		92	typedef struct _IMAGE_DEBUG_INFORMATION {
		93	LIST_ENTRY List;
		94	DWORD ReservedSize;
		95	PVOID ReservedMappedBase;
		96	USHORT ReservedMachine;
		97	USHORT ReservedCharacteristics;
		98	DWORD ReservedCheckSum;
		99	DWORD ImageBase;
		100	DWORD SizeOfImage;
		101	DWORD ReservedNumberOfSections;
		102	PIMAGE_SECTION_HEADER ReservedSections;
		103	DWORD ReservedExportedNamesSize;
		104	PSTR ReservedExportedNames;
		105	DWORD ReservedNumberOfFunctionTableEntries;
		106	PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
		107	DWORD ReservedLowestFunctionStartingAddress;
		108	DWORD ReservedHighestFunctionEndingAddress;
		109	DWORD ReservedNumberOfFpoTableEntries;
		110	PFPO_DATA ReservedFpoTableEntries;
		111	DWORD SizeOfCoffSymbols;
		112	PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
		113	DWORD ReservedSizeOfCodeViewSymbols;
		114	PVOID ReservedCodeViewSymbols;
		115	PSTR ImageFilePath;
		116	PSTR ImageFileName;
		117	PSTR ReservedDebugFilePath;
		118	DWORD ReservedTimeDateStamp;
		119	BOOL ReservedRomImage;
		120	PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
		121	DWORD ReservedNumberOfDebugDirectories;
		122	DWORD ReservedOriginalFunctionTableBaseAddress;
		123	DWORD Reserved[2 ];
		124	} IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION;
		125
		126	PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase);
		127	BOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo);
		128	#endif
		129
		130	typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData);
		131
		132	BOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer);
		133	BOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData);
		134	BOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath);
		135
		136	#define UNDNAME_COMPLETE (0x0000)
		137	#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001)
		138	#define UNDNAME_NO_MS_KEYWORDS (0x0002)
		139	#define UNDNAME_NO_FUNCTION_RETURNS (0x0004)
		140	#define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
		141	#define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
		142	#define UNDNAME_NO_MS_THISTYPE (0x0020)
		143	#define UNDNAME_NO_CV_THISTYPE (0x0040)
		144	#define UNDNAME_NO_THISTYPE (0x0060)
		145	#define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080)
		146	#define UNDNAME_NO_THROW_SIGNATURES (0x0100)
		147	#define UNDNAME_NO_MEMBER_TYPE (0x0200)
		148	#define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
		149	#define UNDNAME_32_BIT_DECODE (0x0800)
		150	#define UNDNAME_NAME_ONLY (0x1000)
		151	#define UNDNAME_NO_ARGUMENTS (0x2000)
		152	#define UNDNAME_NO_SPECIAL_SYMS (0x4000)
		153
		154	DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags);
		155
		156	#define DBHHEADER_DEBUGDIRS 0x1
		157
		158	typedef struct _MODLOAD_DATA {
		159	DWORD ssize;
		160	DWORD ssig;
		161	PVOID data;
		162	DWORD size;
		163	DWORD flags;
		164	} MODLOAD_DATA,*PMODLOAD_DATA;
		165
		166	typedef enum {
		167	AddrMode1616,AddrMode1632,AddrModeReal,AddrModeFlat
		168	} ADDRESS_MODE;
		169
		170	typedef struct _tagADDRESS64 {
		171	DWORD64 Offset;
		172	WORD Segment;
		173	ADDRESS_MODE Mode;
		174	} ADDRESS64,*LPADDRESS64;
		175
		176	#ifdef _IMAGEHLP64
		177	#define ADDRESS ADDRESS64
		178	#define LPADDRESS LPADDRESS64
		179	#else
		180	typedef struct _tagADDRESS {
		181	DWORD Offset;
		182	WORD Segment;
		183	ADDRESS_MODE Mode;
		184	} ADDRESS,*LPADDRESS;
		185
		186	static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) {
		187	a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
		188	a64->Segment = a32->Segment;
		189	a64->Mode = a32->Mode;
		190	}
		191
		192	static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) {
		193	a32->Offset = (ULONG)a64->Offset;
		194	a32->Segment = a64->Segment;
		195	a32->Mode = a64->Mode;
		196	}
		197	#endif
		198
		199	typedef struct _KDHELP64 {
		200	DWORD64 Thread;
		201	DWORD ThCallbackStack;
		202	DWORD ThCallbackBStore;
		203	DWORD NextCallback;
		204	DWORD FramePointer;
		205	DWORD64 KiCallUserMode;
		206	DWORD64 KeUserCallbackDispatcher;
		207	DWORD64 SystemRangeStart;
		208	DWORD64 Reserved[8];
		209	} KDHELP64,*PKDHELP64;
		210
		211	#ifdef _IMAGEHLP64
		212	#define KDHELP KDHELP64
		213	#define PKDHELP PKDHELP64
		214	#else
		215	typedef struct _KDHELP {
		216	DWORD Thread;
		217	DWORD ThCallbackStack;
		218	DWORD NextCallback;
		219	DWORD FramePointer;
		220	DWORD KiCallUserMode;
		221	DWORD KeUserCallbackDispatcher;
		222	DWORD SystemRangeStart;
		223	DWORD ThCallbackBStore;
		224	DWORD Reserved[8];
		225	} KDHELP,*PKDHELP;
		226
		227	static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) {
		228	p64->Thread = p32->Thread;
		229	p64->ThCallbackStack = p32->ThCallbackStack;
		230	p64->NextCallback = p32->NextCallback;
		231	p64->FramePointer = p32->FramePointer;
		232	p64->KiCallUserMode = p32->KiCallUserMode;
		233	p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
		234	p64->SystemRangeStart = p32->SystemRangeStart;
		235	}
		236	#endif
		237
		238	typedef struct _tagSTACKFRAME64 {
		239	ADDRESS64 AddrPC;
		240	ADDRESS64 AddrReturn;
		241	ADDRESS64 AddrFrame;
		242	ADDRESS64 AddrStack;
		243	ADDRESS64 AddrBStore;
		244	PVOID FuncTableEntry;
		245	DWORD64 Params[4];
		246	BOOL Far;
		247	BOOL Virtual;
		248	DWORD64 Reserved[3];
		249	KDHELP64 KdHelp;
		250	} STACKFRAME64,*LPSTACKFRAME64;
		251
		252	#ifdef _IMAGEHLP64
		253	#define STACKFRAME STACKFRAME64
		254	#define LPSTACKFRAME LPSTACKFRAME64
		255	#else
		256	typedef struct _tagSTACKFRAME {
		257	ADDRESS AddrPC;
		258	ADDRESS AddrReturn;
		259	ADDRESS AddrFrame;
		260	ADDRESS AddrStack;
		261	PVOID FuncTableEntry;
		262	DWORD Params[4];
		263	BOOL Far;
		264	BOOL Virtual;
		265	DWORD Reserved[3];
		266	KDHELP KdHelp;
		267	ADDRESS AddrBStore;
		268	} STACKFRAME,*LPSTACKFRAME;
		269	#endif
		270
		271	typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead);
		272	typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase);
		273	typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address);
		274	typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr);
		275
		276	BOOL IMAGEAPI StackWalk64(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME64 StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
		277
		278	#ifdef _IMAGEHLP64
		279	#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
		280	#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
		281	#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
		282	#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
		283	#define StackWalk StackWalk64
		284	#else
		285	typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead);
		286	typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase);
		287	typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address);
		288	typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr);
		289
		290	BOOL IMAGEAPI StackWalk(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
		291	#endif
		292
		293	#define API_VERSION_NUMBER 9
		294
		295	typedef struct API_VERSION {
		296	USHORT MajorVersion;
		297	USHORT MinorVersion;
		298	USHORT Revision;
		299	USHORT Reserved;
		300	} API_VERSION,*LPAPI_VERSION;
		301
		302	LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
		303	LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion);
		304	DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module);
		305
		306	typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext);
		307	typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
		308	typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
		309	typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext);
		310	typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext);
		311	typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext);
		312	typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext);
		313
		314	#ifdef _IMAGEHLP64
		315	#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
		316	#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
		317	#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
		318	#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
		319	#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
		320	#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
		321	#else
		322	typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR ModuleName,ULONG BaseOfDll,PVOID UserContext);
		323	typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
		324	typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
		325	typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext);
		326	typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext);
		327	#endif
		328
		329	#define SYMFLAG_VALUEPRESENT 0x00000001
		330	#define SYMFLAG_REGISTER 0x00000008
		331	#define SYMFLAG_REGREL 0x00000010
		332	#define SYMFLAG_FRAMEREL 0x00000020
		333	#define SYMFLAG_PARAMETER 0x00000040
		334	#define SYMFLAG_LOCAL 0x00000080
		335	#define SYMFLAG_CONSTANT 0x00000100
		336	#define SYMFLAG_EXPORT 0x00000200
		337	#define SYMFLAG_FORWARDER 0x00000400
		338	#define SYMFLAG_FUNCTION 0x00000800
		339	#define SYMFLAG_VIRTUAL 0x00001000
		340	#define SYMFLAG_THUNK 0x00002000
		341	#define SYMFLAG_TLSREL 0x00004000
		342
		343	typedef enum {
		344	SymNone = 0,SymCoff,SymCv,SymPdb,SymExport,SymDeferred,SymSym,SymDia,SymVirtual,NumSymTypes
		345	} SYM_TYPE;
		346
		347	typedef struct _IMAGEHLP_SYMBOL64 {
		348	DWORD SizeOfStruct;
		349	DWORD64 Address;
		350	DWORD Size;
		351	DWORD Flags;
		352	DWORD MaxNameLength;
		353	CHAR Name[1];
		354	} IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64;
		355
		356	typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
		357	IMAGEHLP_SYMBOL64 sym;
		358	CHAR name[MAX_SYM_NAME + 1];
		359	} IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE;
		360
		361	#ifdef _IMAGEHLP64
		362
		363	#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
		364	#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
		365	#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
		366	#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
		367	#else
		368
		369	typedef struct _IMAGEHLP_SYMBOL {
		370	DWORD SizeOfStruct;
		371	DWORD Address;
		372	DWORD Size;
		373	DWORD Flags;
		374	DWORD MaxNameLength;
		375	CHAR Name[1];
		376	} IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL;
		377
		378	typedef struct _IMAGEHLP_SYMBOL_PACKAGE {
		379	IMAGEHLP_SYMBOL sym;
		380	CHAR name[MAX_SYM_NAME + 1];
		381	} IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE;
		382	#endif
		383
		384	typedef struct _IMAGEHLP_MODULE64 {
		385	DWORD SizeOfStruct;
		386	DWORD64 BaseOfImage;
		387	DWORD ImageSize;
		388	DWORD TimeDateStamp;
		389	DWORD CheckSum;
		390	DWORD NumSyms;
		391	SYM_TYPE SymType;
		392	CHAR ModuleName[32];
		393	CHAR ImageName[256];
		394	CHAR LoadedImageName[256];
		395	CHAR LoadedPdbName[256];
		396	DWORD CVSig;
		397	CHAR CVData[MAX_PATH*3];
		398	DWORD PdbSig;
		399	GUID PdbSig70;
		400	DWORD PdbAge;
		401	BOOL PdbUnmatched;
		402	BOOL DbgUnmatched;
		403	BOOL LineNumbers;
		404	BOOL GlobalSymbols;
		405	BOOL TypeInfo;
		406	} IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64;
		407
		408	typedef struct _IMAGEHLP_MODULE64W {
		409	DWORD SizeOfStruct;
		410	DWORD64 BaseOfImage;
		411	DWORD ImageSize;
		412	DWORD TimeDateStamp;
		413	DWORD CheckSum;
		414	DWORD NumSyms;
		415	SYM_TYPE SymType;
		416	WCHAR ModuleName[32];
		417	WCHAR ImageName[256];
		418	WCHAR LoadedImageName[256];
		419	WCHAR LoadedPdbName[256];
		420	DWORD CVSig;
		421	WCHAR CVData[MAX_PATH*3];
		422	DWORD PdbSig;
		423	GUID PdbSig70;
		424	DWORD PdbAge;
		425	BOOL PdbUnmatched;
		426	BOOL DbgUnmatched;
		427	BOOL LineNumbers;
		428	BOOL GlobalSymbols;
		429	BOOL TypeInfo;
		430	} IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64;
		431
		432	#ifdef _IMAGEHLP64
		433	#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
		434	#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
		435	#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
		436	#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
		437	#else
		438	typedef struct _IMAGEHLP_MODULE {
		439	DWORD SizeOfStruct;
		440	DWORD BaseOfImage;
		441	DWORD ImageSize;
		442	DWORD TimeDateStamp;
		443	DWORD CheckSum;
		444	DWORD NumSyms;
		445	SYM_TYPE SymType;
		446	CHAR ModuleName[32];
		447	CHAR ImageName[256];
		448	CHAR LoadedImageName[256];
		449	} IMAGEHLP_MODULE,*PIMAGEHLP_MODULE;
		450
		451	typedef struct _IMAGEHLP_MODULEW {
		452	DWORD SizeOfStruct;
		453	DWORD BaseOfImage;
		454	DWORD ImageSize;
		455	DWORD TimeDateStamp;
		456	DWORD CheckSum;
		457	DWORD NumSyms;
		458	SYM_TYPE SymType;
		459	WCHAR ModuleName[32];
		460	WCHAR ImageName[256];
		461	WCHAR LoadedImageName[256];
		462	} IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW;
		463	#endif
		464
		465	typedef struct _IMAGEHLP_LINE64 {
		466	DWORD SizeOfStruct;
		467	PVOID Key;
		468	DWORD LineNumber;
		469	PCHAR FileName;
		470	DWORD64 Address;
		471	} IMAGEHLP_LINE64,*PIMAGEHLP_LINE64;
		472
		473	#ifdef _IMAGEHLP64
		474	#define IMAGEHLP_LINE IMAGEHLP_LINE64
		475	#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
		476	#else
		477	typedef struct _IMAGEHLP_LINE {
		478	DWORD SizeOfStruct;
		479	PVOID Key;
		480	DWORD LineNumber;
		481	PCHAR FileName;
		482	DWORD Address;
		483	} IMAGEHLP_LINE,*PIMAGEHLP_LINE;
		484	#endif
		485
		486	typedef struct _SOURCEFILE {
		487	DWORD64 ModBase;
		488	PCHAR FileName;
		489	} SOURCEFILE,*PSOURCEFILE;
		490
		491	#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
		492	#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
		493	#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
		494	#define CBA_SYMBOLS_UNLOADED 0x00000004
		495	#define CBA_DUPLICATE_SYMBOL 0x00000005
		496	#define CBA_READ_MEMORY 0x00000006
		497	#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
		498	#define CBA_SET_OPTIONS 0x00000008
		499	#define CBA_EVENT 0x00000010
		500	#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
		501	#define CBA_DEBUG_INFO 0x10000000
		502
		503	typedef struct _IMAGEHLP_CBA_READ_MEMORY {
		504	DWORD64 addr;
		505	PVOID buf;
		506	DWORD bytes;
		507	DWORD *bytesread;
		508	} IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY;
		509
		510	enum {
		511	sevInfo = 0,sevProblem,sevAttn,sevFatal,sevMax
		512	};
		513
		514	typedef struct _IMAGEHLP_CBA_EVENT {
		515	DWORD severity;
		516	DWORD code;
		517	PCHAR desc;
		518	PVOID object;
		519	} IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT;
		520
		521	typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
		522	DWORD SizeOfStruct;
		523	DWORD64 BaseOfImage;
		524	DWORD CheckSum;
		525	DWORD TimeDateStamp;
		526	CHAR FileName[MAX_PATH];
		527	BOOLEAN Reparse;
		528	HANDLE hFile;
		529	DWORD Flags;
		530	} IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
		531
		532	#define DSLFLAG_MISMATCHED_PDB 0x1
		533	#define DSLFLAG_MISMATCHED_DBG 0x2
		534
		535	#ifdef _IMAGEHLP64
		536	#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
		537	#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
		538	#else
		539	typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
		540	DWORD SizeOfStruct;
		541	DWORD BaseOfImage;
		542	DWORD CheckSum;
		543	DWORD TimeDateStamp;
		544	CHAR FileName[MAX_PATH];
		545	BOOLEAN Reparse;
		546	HANDLE hFile;
		547	} IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
		548	#endif
		549
		550	typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
		551	DWORD SizeOfStruct;
		552	DWORD NumberOfDups;
		553	PIMAGEHLP_SYMBOL64 Symbol;
		554	DWORD SelectedSymbol;
		555	} IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64;
		556
		557	#ifdef _IMAGEHLP64
		558	#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
		559	#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
		560	#else
		561	typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
		562	DWORD SizeOfStruct;
		563	DWORD NumberOfDups;
		564	PIMAGEHLP_SYMBOL Symbol;
		565	DWORD SelectedSymbol;
		566	} IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL;
		567	#endif
		568
		569	BOOL IMAGEAPI SymSetParentWindow(HWND hwnd);
		570	PCHAR IMAGEAPI SymSetHomeDirectory(PCSTR dir);
		571	PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size);
		572
		573	enum {
		574	hdBase = 0,hdSym,hdSrc,hdMax
		575	};
		576
		577	#define SYMOPT_CASE_INSENSITIVE 0x00000001
		578	#define SYMOPT_UNDNAME 0x00000002
		579	#define SYMOPT_DEFERRED_LOADS 0x00000004
		580	#define SYMOPT_NO_CPP 0x00000008
		581	#define SYMOPT_LOAD_LINES 0x00000010
		582	#define SYMOPT_OMAP_FIND_NEAREST 0x00000020
		583	#define SYMOPT_LOAD_ANYTHING 0x00000040
		584	#define SYMOPT_IGNORE_CVREC 0x00000080
		585	#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
		586	#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
		587	#define SYMOPT_EXACT_SYMBOLS 0x00000400
		588	#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
		589	#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
		590	#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
		591	#define SYMOPT_PUBLICS_ONLY 0x00004000
		592	#define SYMOPT_NO_PUBLICS 0x00008000
		593	#define SYMOPT_AUTO_PUBLICS 0x00010000
		594	#define SYMOPT_NO_IMAGE_SEARCH 0x00020000
		595	#define SYMOPT_SECURE 0x00040000
		596	#define SYMOPT_NO_PROMPTS 0x00080000
		597
		598	#define SYMOPT_DEBUG 0x80000000
		599
		600	DWORD IMAGEAPI SymSetOptions(DWORD SymOptions);
		601	DWORD IMAGEAPI SymGetOptions(VOID);
		602	BOOL IMAGEAPI SymCleanup(HANDLE hProcess);
		603	BOOL IMAGEAPI SymMatchString(LPSTR string,LPSTR expression,BOOL fCase);
		604
		605	typedef BOOL (CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext);
		606
		607	BOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,LPSTR Mask,PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles,PVOID UserContext);
		608	BOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext);
		609
		610	#ifdef _IMAGEHLP64
		611	#define SymEnumerateModules SymEnumerateModules64
		612	#else
		613	BOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext);
		614	#endif
		615
		616	BOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext);
		617	BOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext);
		618
		619	#ifdef _IMAGEHLP64
		620	#define SymEnumerateSymbols SymEnumerateSymbols64
		621	#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
		622	#else
		623	BOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
		624	BOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
		625	#endif
		626
		627	BOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext);
		628	#ifdef _IMAGEHLP64
		629	#define EnumerateLoadedModules EnumerateLoadedModules64
		630	#else
		631	BOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext);
		632	#endif
		633
		634	PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase);
		635
		636	#ifdef _IMAGEHLP64
		637	#define SymFunctionTableAccess SymFunctionTableAccess64
		638	#else
		639	PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase);
		640	#endif
		641
		642	BOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo);
		643	BOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo);
		644
		645	#ifdef _IMAGEHLP64
		646	#define SymGetModuleInfo SymGetModuleInfo64
		647	#define SymGetModuleInfoW SymGetModuleInfoW64
		648	#else
		649	BOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo);
		650	BOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo);
		651	#endif
		652
		653	DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr);
		654
		655	#ifdef _IMAGEHLP64
		656	#define SymGetModuleBase SymGetModuleBase64
		657	#else
		658	DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr);
		659	#endif
		660
		661	BOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
		662
		663	#ifdef _IMAGEHLP64
		664	#define SymGetSymNext SymGetSymNext64
		665	#else
		666	BOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
		667	#endif
		668
		669	BOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
		670
		671	#ifdef _IMAGEHLP64
		672	#define SymGetSymPrev SymGetSymPrev64
		673	#else
		674	BOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
		675	#endif
		676
		677	typedef struct _SRCCODEINFO {
		678	DWORD SizeOfStruct;
		679	PVOID Key;
		680	DWORD64 ModBase;
		681	CHAR Obj[MAX_PATH + 1];
		682	CHAR FileName[MAX_PATH + 1];
		683	DWORD LineNumber;
		684	DWORD64 Address;
		685	} SRCCODEINFO,*PSRCCODEINFO;
		686
		687	typedef BOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext);
		688
		689	BOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext);
		690	BOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64);
		691
		692	#ifdef _IMAGEHLP64
		693	#define SymGetLineFromAddr SymGetLineFromAddr64
		694	#else
		695	BOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line);
		696	#endif
		697
		698	BOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line);
		699
		700	#ifdef _IMAGEHLP64
		701	#define SymGetLineFromName SymGetLineFromName64
		702	#else
		703	BOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line);
		704	#endif
		705
		706	BOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
		707
		708	#ifdef _IMAGEHLP64
		709	#define SymGetLineNext SymGetLineNext64
		710	#else
		711	BOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line);
		712	#endif
		713
		714	BOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
		715
		716	#ifdef _IMAGEHLP64
		717	#define SymGetLinePrev SymGetLinePrev64
		718	#else
		719	BOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line);
		720	#endif
		721
		722	BOOL IMAGEAPI SymMatchFileName(PSTR FileName,PSTR Match,PSTR FileNameStop,PSTR MatchStop);
		723	BOOL IMAGEAPI SymInitialize(HANDLE hProcess,PSTR UserSearchPath,BOOL fInvadeProcess);
		724	BOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength);
		725	BOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PSTR SearchPath);
		726	DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll);
		727
		728	#define SLMFLAG_VIRTUAL 0x1
		729
		730	DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
		731
		732	#ifdef _IMAGEHLP64
		733	#define SymLoadModule SymLoadModule64
		734	#else
		735	DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll);
		736	#endif
		737
		738	BOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll);
		739
		740	#ifdef _IMAGEHLP64
		741	#define SymUnloadModule SymUnloadModule64
		742	#else
		743	BOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll);
		744	#endif
		745
		746	BOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength);
		747
		748	#ifdef _IMAGEHLP64
		749	#define SymUnDName SymUnDName64
		750	#else
		751	BOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength);
		752	#endif
		753
		754	BOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
		755
		756	BOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext);
		757
		758	#ifdef _IMAGEHLP64
		759	#define SymRegisterCallback SymRegisterCallback64
		760	#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
		761	#else
		762	BOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext);
		763	BOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext);
		764	#endif
		765
		766	typedef struct _IMAGEHLP_SYMBOL_SRC {
		767	DWORD sizeofstruct;
		768	DWORD type;
		769	char file[MAX_PATH];
		770	} IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC;
		771
		772	typedef struct _MODULE_TYPE_INFO {
		773	USHORT dataLength;
		774	USHORT leaf;
		775	BYTE data[1];
		776	} MODULE_TYPE_INFO,*PMODULE_TYPE_INFO;
		777
		778	typedef struct _SYMBOL_INFO {
		779	ULONG SizeOfStruct;
		780	ULONG TypeIndex;
		781	ULONG64 Reserved[2];
		782	ULONG info;
		783	ULONG Size;
		784	ULONG64 ModBase;
		785	ULONG Flags;
		786	ULONG64 Value;
		787	ULONG64 Address;
		788	ULONG Register;
		789	ULONG Scope;
		790	ULONG Tag;
		791	ULONG NameLen;
		792	ULONG MaxNameLen;
		793	CHAR Name[1];
		794	} SYMBOL_INFO,*PSYMBOL_INFO;
		795
		796	typedef struct _SYMBOL_INFO_PACKAGE {
		797	SYMBOL_INFO si;
		798	CHAR name[MAX_SYM_NAME + 1];
		799	} SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE;
		800
		801	typedef struct _IMAGEHLP_STACK_FRAME
		802	{
		803	ULONG64 InstructionOffset;
		804	ULONG64 ReturnOffset;
		805	ULONG64 FrameOffset;
		806	ULONG64 StackOffset;
		807	ULONG64 BackingStoreOffset;
		808	ULONG64 FuncTableEntry;
		809	ULONG64 Params[4];
		810	ULONG64 Reserved[5];
		811	BOOL Virtual;
		812	ULONG Reserved2;
		813	} IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME;
		814
		815	typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT;
		816
		817	BOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context);
		818	BOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol);
		819	BOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol);
		820	BOOL IMAGEAPI SymFromName(HANDLE hProcess,LPSTR Name,PSYMBOL_INFO Symbol);
		821
		822	typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext);
		823
		824	BOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
		825	BOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
		826
		827	#define SYMENUMFLAG_FULLSRCH 1
		828	#define SYMENUMFLAG_SPEEDSRCH 2
		829
		830	typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
		831	TI_GET_SYMTAG,TI_GET_SYMNAME,TI_GET_LENGTH,TI_GET_TYPE,TI_GET_TYPEID,TI_GET_BASETYPE,TI_GET_ARRAYINDEXTYPEID,TI_FINDCHILDREN,
		832	TI_GET_DATAKIND,TI_GET_ADDRESSOFFSET,TI_GET_OFFSET,TI_GET_VALUE,TI_GET_COUNT,TI_GET_CHILDRENCOUNT,TI_GET_BITPOSITION,TI_GET_VIRTUALBASECLASS,
		833	TI_GET_VIRTUALTABLESHAPEID,TI_GET_VIRTUALBASEPOINTEROFFSET,TI_GET_CLASSPARENTID,TI_GET_NESTED,TI_GET_SYMINDEX,TI_GET_LEXICALPARENT,
		834	TI_GET_ADDRESS,TI_GET_THISADJUST,TI_GET_UDTKIND,TI_IS_EQUIV_TO,TI_GET_CALLING_CONVENTION
		835	} IMAGEHLP_SYMBOL_TYPE_INFO;
		836
		837	typedef struct _TI_FINDCHILDREN_PARAMS {
		838	ULONG Count;
		839	ULONG Start;
		840	ULONG ChildId[1];
		841	} TI_FINDCHILDREN_PARAMS;
		842
		843	BOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo);
		844	BOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
		845	BOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,LPSTR Name,PSYMBOL_INFO Symbol);
		846	BOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
		847	BOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags);
		848
		849	typedef BOOL (WINAPI PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID Data,LPDWORD DataLength,PVOID UserData);
		850
		851	BOOL WINAPI DbgHelpCreateUserDump(LPSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
		852	BOOL WINAPI DbgHelpCreateUserDumpW(LPWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
		853	BOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol);
		854
		855	#ifdef _IMAGEHLP64
		856	#define SymGetSymFromAddr SymGetSymFromAddr64
		857	#else
		858	BOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol);
		859	#endif
		860
		861	BOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL64 Symbol);
		862
		863	#ifdef _IMAGEHLP64
		864	#define SymGetSymFromName SymGetSymFromName64
		865	#else
		866	BOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL Symbol);
		867	#endif
		868
		869	DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FilePath);
		870	DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,DWORD one,DWORD two,DWORD three,LPSTR FilePath);
		871	DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
		872
		873	#define SYMF_OMAP_GENERATED 0x00000001
		874	#define SYMF_OMAP_MODIFIED 0x00000002
		875	#define SYMF_REGISTER 0x00000008
		876	#define SYMF_REGREL 0x00000010
		877	#define SYMF_FRAMEREL 0x00000020
		878	#define SYMF_PARAMETER 0x00000040
		879	#define SYMF_LOCAL 0x00000080
		880	#define SYMF_CONSTANT 0x00000100
		881	#define SYMF_EXPORT 0x00000200
		882	#define SYMF_FORWARDER 0x00000400
		883	#define SYMF_FUNCTION 0x00000800
		884	#define SYMF_VIRTUAL 0x00001000
		885	#define SYMF_THUNK 0x00002000
		886	#define SYMF_TLSREL 0x00004000
		887
		888	#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
		889	#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER
		890	#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL
		891	#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL
		892	#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER
		893	#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL
		894	#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT
		895	#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION
		896	#define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL
		897	#define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK
		898	#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL
		899
		900	#include
		901
		902	#define MINIDUMP_SIGNATURE ('PMDM')
		903	#define MINIDUMP_VERSION (42899)
		904	typedef DWORD RVA;
		905	typedef ULONG64 RVA64;
		906
		907	typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
		908	ULONG32 DataSize;
		909	RVA Rva;
		910	} MINIDUMP_LOCATION_DESCRIPTOR;
		911
		912	typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
		913	ULONG64 DataSize;
		914	RVA64 Rva;
		915	} MINIDUMP_LOCATION_DESCRIPTOR64;
		916
		917	typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
		918	ULONG64 StartOfMemoryRange;
		919	MINIDUMP_LOCATION_DESCRIPTOR Memory;
		920	} MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR;
		921
		922	typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
		923	ULONG64 StartOfMemoryRange;
		924	ULONG64 DataSize;
		925	} MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64;
		926
		927	typedef struct _MINIDUMP_HEADER {
		928	ULONG32 Signature;
		929	ULONG32 Version;
		930	ULONG32 NumberOfStreams;
		931	RVA StreamDirectoryRva;
		932	ULONG32 CheckSum;
		933	union {
		934	ULONG32 Reserved;
		935	ULONG32 TimeDateStamp;
		936	} DUMMYUNIONNAME;
		937	ULONG64 Flags;
		938	} MINIDUMP_HEADER,*PMINIDUMP_HEADER;
		939
		940	typedef struct _MINIDUMP_DIRECTORY {
		941	ULONG32 StreamType;
		942	MINIDUMP_LOCATION_DESCRIPTOR Location;
		943	} MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY;
		944
		945	typedef struct _MINIDUMP_STRING {
		946	ULONG32 Length;
		947	WCHAR Buffer [0];
		948	} MINIDUMP_STRING,*PMINIDUMP_STRING;
		949
		950	typedef enum _MINIDUMP_STREAM_TYPE {
		951	UnusedStream = 0,ReservedStream0 = 1,ReservedStream1 = 2,ThreadListStream = 3,ModuleListStream = 4,MemoryListStream = 5,
		952	ExceptionStream = 6,SystemInfoStream = 7,ThreadExListStream = 8,Memory64ListStream = 9,CommentStreamA = 10,CommentStreamW = 11,
		953	HandleDataStream = 12,FunctionTableStream = 13,UnloadedModuleListStream = 14,MiscInfoStream = 15,LastReservedStream = 0xffff
		954	} MINIDUMP_STREAM_TYPE;
		955
		956	typedef union _CPU_INFORMATION {
		957	struct {
		958	ULONG32 VendorId [3 ];
		959	ULONG32 VersionInformation;
		960	ULONG32 FeatureInformation;
		961	ULONG32 AMDExtendedCpuFeatures;
		962	} X86CpuInfo;
		963	struct {
		964	ULONG64 ProcessorFeatures [2 ];
		965	} OtherCpuInfo;
		966	} CPU_INFORMATION,*PCPU_INFORMATION;
		967
		968	typedef struct _MINIDUMP_SYSTEM_INFO {
		969	USHORT ProcessorArchitecture;
		970	USHORT ProcessorLevel;
		971	USHORT ProcessorRevision;
		972	union {
		973	USHORT Reserved0;
		974	struct {
		975	UCHAR NumberOfProcessors;
		976	UCHAR ProductType;
		977	} DUMMYSTRUCTNAME;
		978	} DUMMYUNIONNAME;
		979	ULONG32 MajorVersion;
		980	ULONG32 MinorVersion;
		981	ULONG32 BuildNumber;
		982	ULONG32 PlatformId;
		983	RVA CSDVersionRva;
		984	union {
		985	ULONG32 Reserved1;
		986	struct {
		987	USHORT SuiteMask;
		988	USHORT Reserved2;
		989	} DUMMYSTRUCTNAME;
		990	} DUMMYUNIONNAME1;
		991	CPU_INFORMATION Cpu;
		992	} MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO;
		993
		994	C_ASSERT (sizeof (((PPROCESS_INFORMATION)0)->dwThreadId)==4);
		995
		996	typedef struct _MINIDUMP_THREAD {
		997	ULONG32 ThreadId;
		998	ULONG32 SuspendCount;
		999	ULONG32 PriorityClass;
		1000	ULONG32 Priority;
		1001	ULONG64 Teb;
		1002	MINIDUMP_MEMORY_DESCRIPTOR Stack;
		1003	MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
		1004	} MINIDUMP_THREAD,*PMINIDUMP_THREAD;
		1005
		1006	typedef struct _MINIDUMP_THREAD_LIST {
		1007	ULONG32 NumberOfThreads;
		1008	MINIDUMP_THREAD Threads [0];
		1009	} MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST;
		1010
		1011	typedef struct _MINIDUMP_THREAD_EX {
		1012	ULONG32 ThreadId;
		1013	ULONG32 SuspendCount;
		1014	ULONG32 PriorityClass;
		1015	ULONG32 Priority;
		1016	ULONG64 Teb;
		1017	MINIDUMP_MEMORY_DESCRIPTOR Stack;
		1018	MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
		1019	MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
		1020	} MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX;
		1021
		1022	typedef struct _MINIDUMP_THREAD_EX_LIST {
		1023	ULONG32 NumberOfThreads;
		1024	MINIDUMP_THREAD_EX Threads [0];
		1025	} MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST;
		1026
		1027	typedef struct _MINIDUMP_EXCEPTION {
		1028	ULONG32 ExceptionCode;
		1029	ULONG32 ExceptionFlags;
		1030	ULONG64 ExceptionRecord;
		1031	ULONG64 ExceptionAddress;
		1032	ULONG32 NumberParameters;
		1033	ULONG32 __unusedAlignment;
		1034	ULONG64 ExceptionInformation [EXCEPTION_MAXIMUM_PARAMETERS ];
		1035	} MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION;
		1036
		1037	typedef struct MINIDUMP_EXCEPTION_STREAM {
		1038	ULONG32 ThreadId;
		1039	ULONG32 __alignment;
		1040	MINIDUMP_EXCEPTION ExceptionRecord;
		1041	MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
		1042	} MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM;
		1043
		1044	typedef struct _MINIDUMP_MODULE {
		1045	ULONG64 BaseOfImage;
		1046	ULONG32 SizeOfImage;
		1047	ULONG32 CheckSum;
		1048	ULONG32 TimeDateStamp;
		1049	RVA ModuleNameRva;
		1050	VS_FIXEDFILEINFO VersionInfo;
		1051	MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
		1052	MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
		1053	ULONG64 Reserved0;
		1054	ULONG64 Reserved1;
		1055	} MINIDUMP_MODULE,*PMINIDUMP_MODULE;
		1056
		1057	typedef struct _MINIDUMP_MODULE_LIST {
		1058	ULONG32 NumberOfModules;
		1059	MINIDUMP_MODULE Modules [0 ];
		1060	} MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST;
		1061
		1062	typedef struct _MINIDUMP_MEMORY_LIST {
		1063	ULONG32 NumberOfMemoryRanges;
		1064	MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0];
		1065	} MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST;
		1066
		1067	typedef struct _MINIDUMP_MEMORY64_LIST {
		1068	ULONG64 NumberOfMemoryRanges;
		1069	RVA64 BaseRva;
		1070	MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0];
		1071	} MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST;
		1072
		1073	typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
		1074	DWORD ThreadId;
		1075	PEXCEPTION_POINTERS ExceptionPointers;
		1076	BOOL ClientPointers;
		1077	} MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION;
		1078
		1079	typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
		1080	DWORD ThreadId;
		1081	ULONG64 ExceptionRecord;
		1082	ULONG64 ContextRecord;
		1083	BOOL ClientPointers;
		1084	} MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64;
		1085
		1086	typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
		1087	ULONG64 Handle;
		1088	RVA TypeNameRva;
		1089	RVA ObjectNameRva;
		1090	ULONG32 Attributes;
		1091	ULONG32 GrantedAccess;
		1092	ULONG32 HandleCount;
		1093	ULONG32 PointerCount;
		1094	} MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR;
		1095
		1096	typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
		1097	ULONG32 SizeOfHeader;
		1098	ULONG32 SizeOfDescriptor;
		1099	ULONG32 NumberOfDescriptors;
		1100	ULONG32 Reserved;
		1101	} MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM;
		1102
		1103	typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
		1104	ULONG64 MinimumAddress;
		1105	ULONG64 MaximumAddress;
		1106	ULONG64 BaseAddress;
		1107	ULONG32 EntryCount;
		1108	ULONG32 SizeOfAlignPad;
		1109	} MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
		1110
		1111	typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
		1112	ULONG32 SizeOfHeader;
		1113	ULONG32 SizeOfDescriptor;
		1114	ULONG32 SizeOfNativeDescriptor;
		1115	ULONG32 SizeOfFunctionEntry;
		1116	ULONG32 NumberOfDescriptors;
		1117	ULONG32 SizeOfAlignPad;
		1118	} MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM;
		1119
		1120	typedef struct _MINIDUMP_UNLOADED_MODULE {
		1121	ULONG64 BaseOfImage;
		1122	ULONG32 SizeOfImage;
		1123	ULONG32 CheckSum;
		1124	ULONG32 TimeDateStamp;
		1125	RVA ModuleNameRva;
		1126	} MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE;
		1127
		1128	typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
		1129	ULONG32 SizeOfHeader;
		1130	ULONG32 SizeOfEntry;
		1131	ULONG32 NumberOfEntries;
		1132	} MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST;
		1133
		1134	#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
		1135	#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
		1136
		1137	typedef struct _MINIDUMP_MISC_INFO {
		1138	ULONG32 SizeOfInfo;
		1139	ULONG32 Flags1;
		1140	ULONG32 ProcessId;
		1141	ULONG32 ProcessCreateTime;
		1142	ULONG32 ProcessUserTime;
		1143	ULONG32 ProcessKernelTime;
		1144	} MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO;
		1145
		1146	typedef struct _MINIDUMP_USER_RECORD {
		1147	ULONG32 Type;
		1148	MINIDUMP_LOCATION_DESCRIPTOR Memory;
		1149	} MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD;
		1150
		1151	typedef struct _MINIDUMP_USER_STREAM {
		1152	ULONG32 Type;
		1153	ULONG BufferSize;
		1154	PVOID Buffer;
		1155	} MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM;
		1156
		1157	typedef struct _MINIDUMP_USER_STREAM_INFORMATION {
		1158	ULONG UserStreamCount;
		1159	PMINIDUMP_USER_STREAM UserStreamArray;
		1160	} MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION;
		1161
		1162	typedef enum _MINIDUMP_CALLBACK_TYPE {
		1163	ModuleCallback,ThreadCallback,ThreadExCallback,IncludeThreadCallback,IncludeModuleCallback,MemoryCallback
		1164	} MINIDUMP_CALLBACK_TYPE;
		1165
		1166	typedef struct _MINIDUMP_THREAD_CALLBACK {
		1167	ULONG ThreadId;
		1168	HANDLE ThreadHandle;
		1169	CONTEXT Context;
		1170	ULONG SizeOfContext;
		1171	ULONG64 StackBase;
		1172	ULONG64 StackEnd;
		1173	} MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK;
		1174
		1175	typedef struct _MINIDUMP_THREAD_EX_CALLBACK {
		1176	ULONG ThreadId;
		1177	HANDLE ThreadHandle;
		1178	CONTEXT Context;
		1179	ULONG SizeOfContext;
		1180	ULONG64 StackBase;
		1181	ULONG64 StackEnd;
		1182	ULONG64 BackingStoreBase;
		1183	ULONG64 BackingStoreEnd;
		1184	} MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK;
		1185
		1186	typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK {
		1187	ULONG ThreadId;
		1188	} MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK;
		1189
		1190	typedef enum _THREAD_WRITE_FLAGS {
		1191	ThreadWriteThread = 0x0001,ThreadWriteStack = 0x0002,ThreadWriteContext = 0x0004,ThreadWriteBackingStore = 0x0008,
		1192	ThreadWriteInstructionWindow = 0x0010,ThreadWriteThreadData = 0x0020
		1193	} THREAD_WRITE_FLAGS;
		1194
		1195	typedef struct _MINIDUMP_MODULE_CALLBACK {
		1196	PWCHAR FullPath;
		1197	ULONG64 BaseOfImage;
		1198	ULONG SizeOfImage;
		1199	ULONG CheckSum;
		1200	ULONG TimeDateStamp;
		1201	VS_FIXEDFILEINFO VersionInfo;
		1202	PVOID CvRecord;
		1203	ULONG SizeOfCvRecord;
		1204	PVOID MiscRecord;
		1205	ULONG SizeOfMiscRecord;
		1206	} MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK;
		1207
		1208	typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK {
		1209	ULONG64 BaseOfImage;
		1210	} MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK;
		1211
		1212	typedef enum _MODULE_WRITE_FLAGS {
		1213	ModuleWriteModule = 0x0001,ModuleWriteDataSeg = 0x0002,ModuleWriteMiscRecord = 0x0004,ModuleWriteCvRecord = 0x0008,
		1214	ModuleReferencedByMemory = 0x0010
		1215	} MODULE_WRITE_FLAGS;
		1216
		1217	typedef struct _MINIDUMP_CALLBACK_INPUT {
		1218	ULONG ProcessId;
		1219	HANDLE ProcessHandle;
		1220	ULONG CallbackType;
		1221	union {
		1222	MINIDUMP_THREAD_CALLBACK Thread;
		1223	MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
		1224	MINIDUMP_MODULE_CALLBACK Module;
		1225	MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
		1226	MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
		1227	} DUMMYUNIONNAME;
		1228	} MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT;
		1229
		1230	typedef struct _MINIDUMP_CALLBACK_OUTPUT {
		1231	union {
		1232	ULONG ModuleWriteFlags;
		1233	ULONG ThreadWriteFlags;
		1234	struct {
		1235	ULONG64 MemoryBase;
		1236	ULONG MemorySize;
		1237	} DUMMYSTRUCTNAME;
		1238	} DUMMYUNIONNAME;
		1239	} MINIDUMP_CALLBACK_OUTPUT,*PMINIDUMP_CALLBACK_OUTPUT;
		1240
		1241	typedef enum _MINIDUMP_TYPE {
		1242	MiniDumpNormal = 0x0000,MiniDumpWithDataSegs = 0x0001,MiniDumpWithFullMemory = 0x0002,MiniDumpWithHandleData = 0x0004,
		1243	MiniDumpFilterMemory = 0x0008,MiniDumpScanMemory = 0x0010,MiniDumpWithUnloadedModules = 0x0020,MiniDumpWithIndirectlyReferencedMemory = 0x0040,
		1244	MiniDumpFilterModulePaths = 0x0080,MiniDumpWithProcessThreadData = 0x0100,MiniDumpWithPrivateReadWriteMemory = 0x0200,
		1245	MiniDumpWithoutOptionalData = 0x0400
		1246	} MINIDUMP_TYPE;
		1247
		1248	typedef BOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
		1249
		1250	typedef struct _MINIDUMP_CALLBACK_INFORMATION {
		1251	MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
		1252	PVOID CallbackParam;
		1253	} MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION;
		1254
		1255	#define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
		1256
		1257	BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess,DWORD ProcessId,HANDLE hFile,MINIDUMP_TYPE DumpType,CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
		1258	BOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY Dir,PVOID StreamPointer,ULONG *StreamSize);
		1259
		1260	#include
		1261
		1262	#ifdef __cplusplus
		1263	}
		1264	#endif
		1265	#endif

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/src/gallium/auxiliary/util/dbghelp.h – Rev 4358