Headers diff for dbghelp.dll between 5.2.3790.1830-Windows 5.0 and 6.0.6001.18000-Windows 6.0 versions



 dbghelp.h (5.2.3790.1830-Windows 5.0)   dbghelp.h (6.0.6001.18000-Windows 6.0) 
/*++ BUILD Version: 0001 Increment this if a change has global effects /*++ BUILD Version: 0000 Increment this if a change has global effects
Copyright (c) Microsoft Corporation. All rights reserved. Copyright (c) Microsoft Corporation. All rights reserved.
Module Name: Module Name:
dbghelp.h dbghelp.h
Abstract: Abstract:
This module defines the prototypes and constants required for the image This module defines the prototypes and constants required for the image
skipping to change at line 38 skipping to change at line 38
// of every API, if a choice exists. The 64 bit version // of every API, if a choice exists. The 64 bit version
// works great on 32 bit platforms, and is forward // works great on 32 bit platforms, and is forward
// compatible to 64 bit platforms. // compatible to 64 bit platforms.
#ifdef _WIN64 #ifdef _WIN64
#ifndef _IMAGEHLP64 #ifndef _IMAGEHLP64
#define _IMAGEHLP64 #define _IMAGEHLP64
#endif #endif
#endif #endif
// for those without specstrings.h
#ifndef __specstrings
#define __in
#define __out
#define __inout
#define __in_opt
#define __out_opt
#define __inout_opt
#define __in_ecount(x)
#define __out_ecount(x)
#define __inout_ecount(x)
#define __in_bcount(x)
#define __out_bcount(x)
#define __inout_bcount(x)
#define __out_xcount(x)
#define __deref_opt_out
#define __deref_out
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifdef _IMAGEHLP_SOURCE_ #ifdef _IMAGEHLP_SOURCE_
#define IMAGEAPI __stdcall #define IMAGEAPI __stdcall
#define DBHLP_DEPRECIATED #define DBHLP_DEPRECIATED
#else #else
#define IMAGEAPI DECLSPEC_IMPORT __stdcall #define IMAGEAPI DECLSPEC_IMPORT __stdcall
#if (_MSC_VER >= 1300) && !defined(MIDL_PASS) #if (_MSC_VER >= 1300) && !defined(MIDL_PASS)
#define DBHLP_DEPRECIATED __declspec(deprecated) #define DBHLP_DEPRECIATED __declspec(deprecated)
#else #else
#define DBHLP_DEPRECIATED #define DBHLP_DEPRECIATED
#endif #endif
#endif #endif
#define DBHLPAPI IMAGEAPI #define DBHLPAPI IMAGEAPI
#define IMAGE_SEPARATION (64*1024) #define IMAGE_SEPARATION (64*1024)
// Observant readers may notice that 2 new fields,
// 'fReadOnly' and 'Version' have been added to
// the LOADED_IMAGE structure after 'fDOSImage'.
// This does not change the size of the structure
// from previous headers. That is because while
// 'fDOSImage' is a byte, it is padded by the
// compiler to 4 bytes. So the 2 new fields are
// slipped into the extra space.
typedef struct _LOADED_IMAGE { typedef struct _LOADED_IMAGE {
PSTR ModuleName; PSTR ModuleName;
HANDLE hFile; HANDLE hFile;
PUCHAR MappedAddress; PUCHAR MappedAddress;
#ifdef _IMAGEHLP64 #ifdef _IMAGEHLP64
PIMAGE_NT_HEADERS64 FileHeader; PIMAGE_NT_HEADERS64 FileHeader;
#else #else
PIMAGE_NT_HEADERS32 FileHeader; PIMAGE_NT_HEADERS32 FileHeader;
#endif #endif
PIMAGE_SECTION_HEADER LastRvaSection; PIMAGE_SECTION_HEADER LastRvaSection;
ULONG NumberOfSections; ULONG NumberOfSections;
PIMAGE_SECTION_HEADER Sections; PIMAGE_SECTION_HEADER Sections;
ULONG Characteristics; ULONG Characteristics;
BOOLEAN fSystemImage; BOOLEAN fSystemImage;
BOOLEAN fDOSImage; BOOLEAN fDOSImage;
BOOLEAN fReadOnly;
UCHAR Version;
LIST_ENTRY Links; LIST_ENTRY Links;
ULONG SizeOfImage; ULONG SizeOfImage;
} LOADED_IMAGE, *PLOADED_IMAGE; } LOADED_IMAGE, *PLOADED_IMAGE;
#define MAX_SYM_NAME 2000 #define MAX_SYM_NAME 2000
// Error codes set by dbghelp functions. Call GetLastError
// to see them.
// Dbghelp also sets error codes found in winerror.h
#define ERROR_IMAGE_NOT_STRIPPED 0x8800 // the image is not stripped. No db
g file available.
#define ERROR_NO_DBG_POINTER 0x8801 // image is stripped but there is no
pointer to a dbg file
#define ERROR_NO_PDB_POINTER 0x8802 // image does not point to a pdb fil
e
typedef BOOL
(CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(
__in HANDLE FileHandle,
__in PCSTR FileName,
__in PVOID CallerData
);
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindDebugInfoFile ( SymFindDebugInfoFile(
PSTR FileName, __in HANDLE hProcess,
PSTR SymbolPath, __in PCSTR FileName,
PSTR DebugFilePath __out_ecount(MAX_PATH + 1) PSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACK Callback,
__in_opt PVOID CallerData
); );
typedef BOOL typedef BOOL
(CALLBACK *PFIND_DEBUG_FILE_CALLBACK)( (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(
HANDLE FileHandle, __in HANDLE FileHandle,
PSTR FileName, __in PCWSTR FileName,
PVOID CallerData __in PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindDebugInfoFileW(
__in HANDLE hProcess,
__in PCWSTR FileName,
__out_ecount(MAX_PATH + 1) PWSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACKW Callback,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
FindDebugInfoFile (
__in PCSTR FileName,
__in PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindDebugInfoFileEx ( FindDebugInfoFileEx (
PSTR FileName, __in PCSTR FileName,
PSTR SymbolPath, __in PCSTR SymbolPath,
PSTR DebugFilePath, __out_ecount(MAX_PATH + 1) PSTR DebugFilePath,
PFIND_DEBUG_FILE_CALLBACK Callback, __in_opt PFIND_DEBUG_FILE_CALLBACK Callback,
PVOID CallerData __in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
FindDebugInfoFileExW (
__in PCWSTR FileName,
__in PCWSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PWSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACKW Callback,
__in_opt PVOID CallerData
); );
typedef BOOL typedef BOOL
(CALLBACK *PFINDFILEINPATHCALLBACK)( (CALLBACK *PFINDFILEINPATHCALLBACK)(
PSTR filename, PCSTR filename,
PVOID context PVOID context
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFindFileInPath( SymFindFileInPath(
HANDLE hprocess, __in HANDLE hprocess,
LPSTR SearchPath, __in_opt PCSTR SearchPath,
LPSTR FileName, __in PCSTR FileName,
PVOID id, __in_opt PVOID id,
DWORD two, __in DWORD two,
DWORD three, __in DWORD three,
DWORD flags, __in DWORD flags,
LPSTR FoundFile, __out_ecount(MAX_PATH + 1) PSTR FoundFile,
PFINDFILEINPATHCALLBACK callback, __in_opt PFINDFILEINPATHCALLBACK callback,
PVOID context __in_opt PVOID context
); );
HANDLE typedef BOOL
(CALLBACK *PFINDFILEINPATHCALLBACKW)(
__in PCWSTR filename,
__in PVOID context
);
BOOL
IMAGEAPI IMAGEAPI
FindExecutableImage( SymFindFileInPathW(
PSTR FileName, __in HANDLE hprocess,
PSTR SymbolPath, __in_opt PCWSTR SearchPath,
PSTR ImageFilePath __in PCWSTR FileName,
__in_opt PVOID id,
__in DWORD two,
__in DWORD three,
__in DWORD flags,
__out_ecount(MAX_PATH + 1) PWSTR FoundFile,
__in_opt PFINDFILEINPATHCALLBACKW callback,
__in_opt PVOID context
); );
typedef BOOL typedef BOOL
(CALLBACK *PFIND_EXE_FILE_CALLBACK)( (CALLBACK *PFIND_EXE_FILE_CALLBACK)(
HANDLE FileHandle, __in HANDLE FileHandle,
PSTR FileName, __in PCSTR FileName,
PVOID CallerData __in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindExecutableImage(
__in HANDLE hProcess,
__in PCSTR FileName,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath,
__in PFIND_EXE_FILE_CALLBACK Callback,
__in PVOID CallerData
);
typedef BOOL
(CALLBACK *PFIND_EXE_FILE_CALLBACKW)(
__in HANDLE FileHandle,
__in PCWSTR FileName,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindExecutableImageW(
__in HANDLE hProcess,
__in PCWSTR FileName,
__out_ecount(MAX_PATH + 1) PWSTR ImageFilePath,
__in PFIND_EXE_FILE_CALLBACKW Callback,
__in PVOID CallerData
);
HANDLE
IMAGEAPI
FindExecutableImage(
__in PCSTR FileName,
__in PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindExecutableImageEx( FindExecutableImageEx(
PSTR FileName, __in PCSTR FileName,
PSTR SymbolPath, __in PCSTR SymbolPath,
PSTR ImageFilePath, __out_ecount(MAX_PATH + 1) PSTR ImageFilePath,
PFIND_EXE_FILE_CALLBACK Callback, __in_opt PFIND_EXE_FILE_CALLBACK Callback,
PVOID CallerData __in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
FindExecutableImageExW(
__in PCWSTR FileName,
__in PCWSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PWSTR ImageFilePath,
__in_opt PFIND_EXE_FILE_CALLBACKW Callback,
__in PVOID CallerData
); );
PIMAGE_NT_HEADERS PIMAGE_NT_HEADERS
IMAGEAPI IMAGEAPI
ImageNtHeader ( ImageNtHeader (
IN PVOID Base __in PVOID Base
); );
PVOID PVOID
IMAGEAPI IMAGEAPI
ImageDirectoryEntryToDataEx ( ImageDirectoryEntryToDataEx (
IN PVOID Base, __in PVOID Base,
IN BOOLEAN MappedAsImage, __in BOOLEAN MappedAsImage,
IN USHORT DirectoryEntry, __in USHORT DirectoryEntry,
OUT PULONG Size, __out PULONG Size,
OUT PIMAGE_SECTION_HEADER *FoundHeader OPTIONAL __out_opt PIMAGE_SECTION_HEADER *FoundHeader
); );
PVOID PVOID
IMAGEAPI IMAGEAPI
ImageDirectoryEntryToData ( ImageDirectoryEntryToData (
IN PVOID Base, __in PVOID Base,
IN BOOLEAN MappedAsImage, __in BOOLEAN MappedAsImage,
IN USHORT DirectoryEntry, __in USHORT DirectoryEntry,
OUT PULONG Size __out PULONG Size
); );
PIMAGE_SECTION_HEADER PIMAGE_SECTION_HEADER
IMAGEAPI IMAGEAPI
ImageRvaToSection( ImageRvaToSection(
IN PIMAGE_NT_HEADERS NtHeaders, __in PIMAGE_NT_HEADERS NtHeaders,
IN PVOID Base, __in PVOID Base,
IN ULONG Rva __in ULONG Rva
); );
PVOID PVOID
IMAGEAPI IMAGEAPI
ImageRvaToVa( ImageRvaToVa(
IN PIMAGE_NT_HEADERS NtHeaders, __in PIMAGE_NT_HEADERS NtHeaders,
IN PVOID Base, __in PVOID Base,
IN ULONG Rva, __in ULONG Rva,
IN OUT PIMAGE_SECTION_HEADER *LastRvaSection __in_opt OUT PIMAGE_SECTION_HEADER *LastRvaSection
); );
// Symbol server exports
typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR, LPCSTR, PVOID, DWORD, DWORD, LP
STR);
typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action, ULONG
64 data, ULONG64 context);
typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR);
#define SSRVOPT_CALLBACK 0x0001
#define SSRVOPT_DWORD 0x0002
#define SSRVOPT_DWORDPTR 0x0004
#define SSRVOPT_GUIDPTR 0x0008
#define SSRVOPT_OLDGUIDPTR 0x0010
#define SSRVOPT_UNATTENDED 0x0020
#define SSRVOPT_NOCOPY 0x0040
#define SSRVOPT_PARENTWIN 0x0080
#define SSRVOPT_PARAMTYPE 0x0100
#define SSRVOPT_SECURE 0x0200
#define SSRVOPT_TRACE 0x0400
#define SSRVOPT_SETCONTEXT 0x0800
#define SSRVOPT_PROXY 0x1000
#define SSRVOPT_DOWNSTREAM_STORE 0x2000
#define SSRVOPT_RESET ((ULONG_PTR)-1)
#define SSRVACTION_TRACE 1
#define SSRVACTION_QUERYCANCEL 2
#define SSRVACTION_EVENT 3
#ifndef _WIN64 #ifndef _WIN64
// This api won't be ported to Win64 - Fix your code. // This api won't be ported to Win64 - Fix your code.
typedef struct _IMAGE_DEBUG_INFORMATION { typedef struct _IMAGE_DEBUG_INFORMATION {
LIST_ENTRY List; LIST_ENTRY List;
DWORD ReservedSize; DWORD ReservedSize;
PVOID ReservedMappedBase; PVOID ReservedMappedBase;
USHORT ReservedMachine; USHORT ReservedMachine;
USHORT ReservedCharacteristics; USHORT ReservedCharacteristics;
DWORD ReservedCheckSum; DWORD ReservedCheckSum;
skipping to change at line 274 skipping to change at line 378
DWORD ReservedOriginalFunctionTableBaseAddress; DWORD ReservedOriginalFunctionTableBaseAddress;
DWORD Reserved[ 2 ]; DWORD Reserved[ 2 ];
} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION; } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
PIMAGE_DEBUG_INFORMATION PIMAGE_DEBUG_INFORMATION
IMAGEAPI IMAGEAPI
MapDebugInformation( MapDebugInformation(
HANDLE FileHandle, __in_opt HANDLE FileHandle,
PSTR FileName, __in PCSTR FileName,
PSTR SymbolPath, __in_opt PCSTR SymbolPath,
DWORD ImageBase __in ULONG ImageBase
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
UnmapDebugInformation( UnmapDebugInformation(
PIMAGE_DEBUG_INFORMATION DebugInfo __out_xcount(unknown) PIMAGE_DEBUG_INFORMATION DebugInfo
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SearchTreeForFile( SearchTreeForFile(
PSTR RootPath, __in PCSTR RootPath,
PSTR InputPathName, __in PCSTR InputPathName,
PSTR OutputPathBuffer __out_ecount(MAX_PATH + 1) PSTR OutputPathBuffer
);
BOOL
IMAGEAPI
SearchTreeForFileW(
__in PCWSTR RootPath,
__in PCWSTR InputPathName,
__out_ecount(MAX_PATH + 1) PWSTR OutputPathBuffer
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMDIRTREE_CALLBACK)( (CALLBACK *PENUMDIRTREE_CALLBACK)(
LPCSTR FilePath, __in PCSTR FilePath,
PVOID CallerData __in_opt PVOID CallerData
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumDirTree( EnumDirTree(
HANDLE hProcess, __in HANDLE hProcess,
PSTR RootPath, __in PCSTR RootPath,
PSTR InputPathName, __in PCSTR InputPathName,
PSTR OutputPathBuffer, __out_ecount_opt(MAX_PATH + 1) PSTR OutputPathBuffer,
PENUMDIRTREE_CALLBACK Callback, __in_opt PENUMDIRTREE_CALLBACK cb,
PVOID CallbackData __in_opt PVOID data
);
typedef BOOL
(CALLBACK *PENUMDIRTREE_CALLBACKW)(
__in PCWSTR FilePath,
__in_opt PVOID CallerData
);
BOOL
IMAGEAPI
EnumDirTreeW(
__in HANDLE hProcess,
__in PCWSTR RootPath,
__in PCWSTR InputPathName,
__out_ecount_opt(MAX_PATH + 1) PWSTR OutputPathBuffer,
__in_opt PENUMDIRTREE_CALLBACKW cb,
__in_opt PVOID data
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
MakeSureDirectoryPathExists( MakeSureDirectoryPathExists(
PCSTR DirPath __in PCSTR DirPath
); );
// //
// UnDecorateSymbolName Flags // UnDecorateSymbolName Flags
// //
#define UNDNAME_COMPLETE (0x0000) // Enable full undecoration #define UNDNAME_COMPLETE (0x0000) // Enable full undecoration
#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) // Remove leading underscores from MS extended keywords #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) // Remove leading underscores from MS extended keywords
#define UNDNAME_NO_MS_KEYWORDS (0x0002) // Disable expansion of MS ex tended keywords #define UNDNAME_NO_MS_KEYWORDS (0x0002) // Disable expansion of MS ex tended keywords
#define UNDNAME_NO_FUNCTION_RETURNS (0x0004) // Disable expansion of retur n type for primary declaration #define UNDNAME_NO_FUNCTION_RETURNS (0x0004) // Disable expansion of retur n type for primary declaration
skipping to change at line 346 skipping to change at line 475
#define UNDNAME_32_BIT_DECODE (0x0800) // Undecorate 32-bit decorate d names #define UNDNAME_32_BIT_DECODE (0x0800) // Undecorate 32-bit decorate d names
#define UNDNAME_NAME_ONLY (0x1000) // Crack only the name for pr imary declaration; #define UNDNAME_NAME_ONLY (0x1000) // Crack only the name for pr imary declaration;
// return just [scope::]name. Does expand template params // return just [scope::]name. Does expand template params
#define UNDNAME_NO_ARGUMENTS (0x2000) // Don't undecorate arguments to function #define UNDNAME_NO_ARGUMENTS (0x2000) // Don't undecorate arguments to function
#define UNDNAME_NO_SPECIAL_SYMS (0x4000) // Don't undecorate special n ames (v-table, vcall, vector xxx, metatype, etc) #define UNDNAME_NO_SPECIAL_SYMS (0x4000) // Don't undecorate special n ames (v-table, vcall, vector xxx, metatype, etc)
DWORD DWORD
IMAGEAPI IMAGEAPI
WINAPI WINAPI
UnDecorateSymbolName( UnDecorateSymbolName(
PCSTR DecoratedName, // Name to undecorate __in PCSTR name,
PSTR UnDecoratedName, // If NULL, it will be allocated __out_ecount(maxStringLength) PSTR outputString,
DWORD UndecoratedLength, // The maximym length __in DWORD maxStringLength,
DWORD Flags // See above. __in DWORD flags
);
DWORD
IMAGEAPI
WINAPI
UnDecorateSymbolNameW(
__in PCWSTR name,
__out_ecount(maxStringLength) PWSTR outputString,
__in DWORD maxStringLength,
__in DWORD flags
); );
// //
// these values are used for synthesized file types // these values are used for synthesized file types
// that can be passed in as image headers instead of // that can be passed in as image headers instead of
// the standard ones from ntimage.h // the standard ones from ntimage.h
// //
#define DBHHEADER_DEBUGDIRS 0x1 #define DBHHEADER_DEBUGDIRS 0x1
skipping to change at line 398 skipping to change at line 537
#else #else
typedef struct _tagADDRESS { typedef struct _tagADDRESS {
DWORD Offset; DWORD Offset;
WORD Segment; WORD Segment;
ADDRESS_MODE Mode; ADDRESS_MODE Mode;
} ADDRESS, *LPADDRESS; } ADDRESS, *LPADDRESS;
__inline __inline
void void
Address32To64( Address32To64(
LPADDRESS a32, __in LPADDRESS a32,
LPADDRESS64 a64 __out LPADDRESS64 a64
) )
{ {
a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset; a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
a64->Segment = a32->Segment; a64->Segment = a32->Segment;
a64->Mode = a32->Mode; a64->Mode = a32->Mode;
} }
__inline __inline
void void
Address64To32( Address64To32(
LPADDRESS64 a64, __in LPADDRESS64 a64,
LPADDRESS a32 __out LPADDRESS a32
) )
{ {
a32->Offset = (ULONG)a64->Offset; a32->Offset = (ULONG)a64->Offset;
a32->Segment = a64->Segment; a32->Segment = a64->Segment;
a32->Mode = a64->Mode; a32->Mode = a64->Mode;
} }
#endif #endif
// //
// This structure is included in the STACKFRAME structure, // This structure is included in the STACKFRAME structure,
skipping to change at line 475 skipping to change at line 614
// //
// Address of the user mode dispatcher function // Address of the user mode dispatcher function
// //
DWORD64 KeUserCallbackDispatcher; DWORD64 KeUserCallbackDispatcher;
// //
// Lowest kernel mode address // Lowest kernel mode address
// //
DWORD64 SystemRangeStart; DWORD64 SystemRangeStart;
DWORD64 Reserved[8]; //
// Address of the user mode exception dispatcher function.
// Added in API version 10.
//
DWORD64 KiUserExceptionDispatcher;
//
// Stack bounds, added in API version 11.
//
DWORD64 StackBase;
DWORD64 StackLimit;
DWORD64 Reserved[5];
} KDHELP64, *PKDHELP64; } KDHELP64, *PKDHELP64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define KDHELP KDHELP64 #define KDHELP KDHELP64
#define PKDHELP PKDHELP64 #define PKDHELP PKDHELP64
#else #else
typedef struct _KDHELP { typedef struct _KDHELP {
// //
skipping to change at line 527 skipping to change at line 678
// Lowest kernel mode address // Lowest kernel mode address
// //
DWORD SystemRangeStart; DWORD SystemRangeStart;
// //
// offset in thread object to pointer to the current callback backing // offset in thread object to pointer to the current callback backing
// store frame in kernel stack. // store frame in kernel stack.
// //
DWORD ThCallbackBStore; DWORD ThCallbackBStore;
DWORD Reserved[8]; //
// Address of the user mode exception dispatcher function.
// Added in API version 10.
//
DWORD KiUserExceptionDispatcher;
//
// Stack bounds, added in API version 11.
//
DWORD StackBase;
DWORD StackLimit;
DWORD Reserved[5];
} KDHELP, *PKDHELP; } KDHELP, *PKDHELP;
__inline __inline
void void
KdHelp32To64( KdHelp32To64(
PKDHELP p32, __in PKDHELP p32,
PKDHELP64 p64 __out PKDHELP64 p64
) )
{ {
p64->Thread = p32->Thread; p64->Thread = p32->Thread;
p64->ThCallbackStack = p32->ThCallbackStack; p64->ThCallbackStack = p32->ThCallbackStack;
p64->NextCallback = p32->NextCallback; p64->NextCallback = p32->NextCallback;
p64->FramePointer = p32->FramePointer; p64->FramePointer = p32->FramePointer;
p64->KiCallUserMode = p32->KiCallUserMode; p64->KiCallUserMode = p32->KiCallUserMode;
p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher; p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
p64->SystemRangeStart = p32->SystemRangeStart; p64->SystemRangeStart = p32->SystemRangeStart;
p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher;
p64->StackBase = p32->StackBase;
p64->StackLimit = p32->StackLimit;
} }
#endif #endif
typedef struct _tagSTACKFRAME64 { typedef struct _tagSTACKFRAME64 {
ADDRESS64 AddrPC; // program counter ADDRESS64 AddrPC; // program counter
ADDRESS64 AddrReturn; // return address ADDRESS64 AddrReturn; // return address
ADDRESS64 AddrFrame; // frame pointer ADDRESS64 AddrFrame; // frame pointer
ADDRESS64 AddrStack; // stack pointer ADDRESS64 AddrStack; // stack pointer
ADDRESS64 AddrBStore; // backing store pointer ADDRESS64 AddrBStore; // backing store pointer
PVOID FuncTableEntry; // pointer to pdata/fpo or NULL PVOID FuncTableEntry; // pointer to pdata/fpo or NULL
skipping to change at line 584 skipping to change at line 750
BOOL Virtual; // is this a virtual frame? BOOL Virtual; // is this a virtual frame?
DWORD Reserved[3]; DWORD Reserved[3];
KDHELP KdHelp; KDHELP KdHelp;
ADDRESS AddrBStore; // backing store pointer ADDRESS AddrBStore; // backing store pointer
} STACKFRAME, *LPSTACKFRAME; } STACKFRAME, *LPSTACKFRAME;
#endif #endif
typedef typedef
BOOL BOOL
(__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)( (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(
HANDLE hProcess, __in HANDLE hProcess,
DWORD64 qwBaseAddress, __in DWORD64 qwBaseAddress,
PVOID lpBuffer, __out_bcount(nSize) PVOID lpBuffer,
DWORD nSize, __in DWORD nSize,
LPDWORD lpNumberOfBytesRead __out LPDWORD lpNumberOfBytesRead
); );
typedef typedef
PVOID PVOID
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)( (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)(
HANDLE hProcess, __in HANDLE ahProcess,
DWORD64 AddrBase __in DWORD64 AddrBase
); );
typedef typedef
DWORD64 DWORD64
(__stdcall *PGET_MODULE_BASE_ROUTINE64)( (__stdcall *PGET_MODULE_BASE_ROUTINE64)(
HANDLE hProcess, __in HANDLE hProcess,
DWORD64 Address __in DWORD64 Address
); );
typedef typedef
DWORD64 DWORD64
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)( (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(
HANDLE hProcess, __in HANDLE hProcess,
HANDLE hThread, __in HANDLE hThread,
LPADDRESS64 lpaddr __in LPADDRESS64 lpaddr
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
StackWalk64( StackWalk64(
DWORD MachineType, __in DWORD MachineType,
HANDLE hProcess, __in HANDLE hProcess,
HANDLE hThread, __in HANDLE hThread,
LPSTACKFRAME64 StackFrame, __inout LPSTACKFRAME64 StackFrame,
PVOID ContextRecord, __inout PVOID ContextRecord,
PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, __in_opt PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, __in_opt PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress __in_opt PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64 #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64 #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64 #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64 #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
#define StackWalk StackWalk64 #define StackWalk StackWalk64
#else #else
typedef typedef
BOOL BOOL
(__stdcall *PREAD_PROCESS_MEMORY_ROUTINE)( (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE)(
HANDLE hProcess, __in HANDLE hProcess,
DWORD lpBaseAddress, __in DWORD lpBaseAddress,
PVOID lpBuffer, __out_bcount(nSize) PVOID lpBuffer,
DWORD nSize, __in DWORD nSize,
PDWORD lpNumberOfBytesRead __out PDWORD lpNumberOfBytesRead
); );
typedef typedef
PVOID PVOID
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)( (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)(
HANDLE hProcess, __in HANDLE hProcess,
DWORD AddrBase __in DWORD AddrBase
); );
typedef typedef
DWORD DWORD
(__stdcall *PGET_MODULE_BASE_ROUTINE)( (__stdcall *PGET_MODULE_BASE_ROUTINE)(
HANDLE hProcess, __in HANDLE hProcess,
DWORD Address __in DWORD Address
); );
typedef typedef
DWORD DWORD
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE)( (__stdcall *PTRANSLATE_ADDRESS_ROUTINE)(
HANDLE hProcess, __in HANDLE hProcess,
HANDLE hThread, __in HANDLE hThread,
LPADDRESS lpaddr __out LPADDRESS lpaddr
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
StackWalk( StackWalk(
DWORD MachineType, DWORD MachineType,
HANDLE hProcess, __in HANDLE hProcess,
HANDLE hThread, __in HANDLE hThread,
LPSTACKFRAME StackFrame, __inout LPSTACKFRAME StackFrame,
PVOID ContextRecord, __inout PVOID ContextRecord,
PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, __in_opt PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, __in_opt PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
PTRANSLATE_ADDRESS_ROUTINE TranslateAddress __in_opt PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
); );
#endif #endif
#define API_VERSION_NUMBER 9 #define API_VERSION_NUMBER 11
typedef struct API_VERSION { typedef struct API_VERSION {
USHORT MajorVersion; USHORT MajorVersion;
USHORT MinorVersion; USHORT MinorVersion;
USHORT Revision; USHORT Revision;
USHORT Reserved; USHORT Reserved;
} API_VERSION, *LPAPI_VERSION; } API_VERSION, *LPAPI_VERSION;
LPAPI_VERSION LPAPI_VERSION
IMAGEAPI IMAGEAPI
ImagehlpApiVersion( ImagehlpApiVersion(
VOID VOID
); );
LPAPI_VERSION LPAPI_VERSION
IMAGEAPI IMAGEAPI
ImagehlpApiVersionEx( ImagehlpApiVersionEx(
LPAPI_VERSION AppVersion __in LPAPI_VERSION AppVersion
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
GetTimestampForLoadedLibrary( GetTimestampForLoadedLibrary(
HMODULE Module __in HMODULE Module
); );
// //
// typedefs for function pointers // typedefs for function pointers
// //
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMMODULES_CALLBACK64)( (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(
PSTR ModuleName, __in PCSTR ModuleName,
DWORD64 BaseOfDll, __in DWORD64 BaseOfDll,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)( (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(
PSTR SymbolName, __in PCWSTR ModuleName,
DWORD64 SymbolAddress, __in DWORD64 BaseOfDll,
ULONG SymbolSize, __in_opt PVOID UserContext
PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)( (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(
PWSTR SymbolName, __in PCSTR ModuleName,
DWORD64 SymbolAddress, __in DWORD64 ModuleBase,
ULONG SymbolSize, __in ULONG ModuleSize,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMLOADED_MODULES_CALLBACK64)( (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(
PSTR ModuleName, __in PCWSTR ModuleName,
DWORD64 ModuleBase, __in DWORD64 ModuleBase,
ULONG ModuleSize, __in ULONG ModuleSize,
PVOID UserContext __in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(
__in PCSTR SymbolName,
__in DWORD64 SymbolAddress,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(
__in PCWSTR SymbolName,
__in DWORD64 SymbolAddress,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)( (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(
HANDLE hProcess, __in HANDLE hProcess,
ULONG ActionCode, __in ULONG ActionCode,
ULONG64 CallbackData, __in_opt ULONG64 CallbackData,
ULONG64 UserContext __in_opt ULONG64 UserContext
); );
typedef typedef
PVOID PVOID
(CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)( (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(
HANDLE hProcess, __in HANDLE hProcess,
DWORD AddrBase, __in DWORD AddrBase,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef typedef
PVOID PVOID
(CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)( (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(
HANDLE hProcess, __in HANDLE hProcess,
ULONG64 AddrBase, __in ULONG64 AddrBase,
ULONG64 UserContext __in ULONG64 UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64 #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64 #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64 #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64 #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64 #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
#else #else
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMMODULES_CALLBACK)( (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(
PSTR ModuleName, __in PCSTR ModuleName,
ULONG BaseOfDll, __in ULONG BaseOfDll,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)( (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(
PSTR SymbolName, __in PCSTR SymbolName,
ULONG SymbolAddress, __in ULONG SymbolAddress,
ULONG SymbolSize, __in ULONG SymbolSize,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)( (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(
PWSTR SymbolName, __in PCWSTR SymbolName,
ULONG SymbolAddress, __in ULONG SymbolAddress,
ULONG SymbolSize, __in ULONG SymbolSize,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMLOADED_MODULES_CALLBACK)( (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(
PSTR ModuleName, __in PCSTR ModuleName,
ULONG ModuleBase, __in ULONG ModuleBase,
ULONG ModuleSize, __in ULONG ModuleSize,
PVOID UserContext __in_opt PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYMBOL_REGISTERED_CALLBACK)( (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(
HANDLE hProcess, __in HANDLE hProcess,
ULONG ActionCode, __in ULONG ActionCode,
PVOID CallbackData, __in_opt PVOID CallbackData,
PVOID UserContext __in_opt PVOID UserContext
); );
#endif #endif
// values found in SYMBOL_INFO.Tag
//
// This was taken from cvconst.h and should
// not override any values found there.
//
// #define _NO_CVCONST_H_ if you don't
// have access to that file...
#ifdef _NO_CVCONST_H
// DIA enums
enum SymTagEnum
{
SymTagNull,
SymTagExe,
SymTagCompiland,
SymTagCompilandDetails,
SymTagCompilandEnv,
SymTagFunction,
SymTagBlock,
SymTagData,
SymTagAnnotation,
SymTagLabel,
SymTagPublicSymbol,
SymTagUDT,
SymTagEnum,
SymTagFunctionType,
SymTagPointerType,
SymTagArrayType,
SymTagBaseType,
SymTagTypedef,
SymTagBaseClass,
SymTagFriend,
SymTagFunctionArgType,
SymTagFuncDebugStart,
SymTagFuncDebugEnd,
SymTagUsingNamespace,
SymTagVTableShape,
SymTagVTable,
SymTagCustom,
SymTagThunk,
SymTagCustomType,
SymTagManagedType,
SymTagDimension,
SymTagMax
};
#endif
// //
// flags found in SYMBOL_INFO.Flags // flags found in SYMBOL_INFO.Flags
// //
#define SYMFLAG_VALUEPRESENT 0x00000001 #define SYMFLAG_VALUEPRESENT 0x00000001
#define SYMFLAG_REGISTER 0x00000008 #define SYMFLAG_REGISTER 0x00000008
#define SYMFLAG_REGREL 0x00000010 #define SYMFLAG_REGREL 0x00000010
#define SYMFLAG_FRAMEREL 0x00000020 #define SYMFLAG_FRAMEREL 0x00000020
#define SYMFLAG_PARAMETER 0x00000040 #define SYMFLAG_PARAMETER 0x00000040
#define SYMFLAG_LOCAL 0x00000080 #define SYMFLAG_LOCAL 0x00000080
#define SYMFLAG_CONSTANT 0x00000100 #define SYMFLAG_CONSTANT 0x00000100
#define SYMFLAG_EXPORT 0x00000200 #define SYMFLAG_EXPORT 0x00000200
#define SYMFLAG_FORWARDER 0x00000400 #define SYMFLAG_FORWARDER 0x00000400
#define SYMFLAG_FUNCTION 0x00000800 #define SYMFLAG_FUNCTION 0x00000800
#define SYMFLAG_VIRTUAL 0x00001000 #define SYMFLAG_VIRTUAL 0x00001000
#define SYMFLAG_THUNK 0x00002000 #define SYMFLAG_THUNK 0x00002000
#define SYMFLAG_TLSREL 0x00004000 #define SYMFLAG_TLSREL 0x00004000
#define SYMFLAG_SLOT 0x00008000
#define SYMFLAG_ILREL 0x00010000
#define SYMFLAG_METADATA 0x00020000
#define SYMFLAG_CLR_TOKEN 0x00040000
// this resets SymNext/Prev to the beginning
// of the module passed in the address field
#define SYMFLAG_RESET 0x80000000
// //
// symbol type enumeration // symbol type enumeration
// //
typedef enum { typedef enum {
SymNone = 0, SymNone = 0,
SymCoff, SymCoff,
SymCv, SymCv,
SymPdb, SymPdb,
SymExport, SymExport,
skipping to change at line 862 skipping to change at line 1102
SymDia, SymDia,
SymVirtual, SymVirtual,
NumSymTypes NumSymTypes
} SYM_TYPE; } SYM_TYPE;
// //
// symbol data structure // symbol data structure
// //
typedef struct _IMAGEHLP_SYMBOL64 { typedef struct _IMAGEHLP_SYMBOL64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL64)
P_SYMBOL64) DWORD64 Address; // virtual address including dll base addres
DWORD64 Address; // virtual address inclu s
ding dll base address DWORD Size; // estimated size of symbol, can be zero
DWORD Size; // estimated size of sym DWORD Flags; // info about the symbols, see the SYMF defi
bol, can be zero nes
DWORD Flags; // info about the symbol DWORD MaxNameLength; // maximum size of symbol name in 'Name'
s, see the SYMF defines CHAR Name[1]; // symbol name (null terminated string)
DWORD MaxNameLength; // maximum size of symbo
l name in 'Name'
CHAR Name[1]; // symbol name (null ter
minated string)
} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64; } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
typedef struct _IMAGEHLP_SYMBOL64_PACKAGE { typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
IMAGEHLP_SYMBOL64 sym; IMAGEHLP_SYMBOL64 sym;
CHAR name[MAX_SYM_NAME + 1]; CHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOL64_PACKAGE, *PIMAGEHLP_SYMBOL64_PACKAGE; } IMAGEHLP_SYMBOL64_PACKAGE, *PIMAGEHLP_SYMBOL64_PACKAGE;
typedef struct _IMAGEHLP_SYMBOLW64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOLW64)
DWORD64 Address; // virtual address including dll base addres
s
DWORD Size; // estimated size of symbol, can be zero
DWORD Flags; // info about the symbols, see the SYMF defi
nes
DWORD MaxNameLength; // maximum size of symbol name in 'Name'
WCHAR Name[1]; // symbol name (null terminated string)
} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
typedef struct _IMAGEHLP_SYMBOLW64_PACKAGE {
IMAGEHLP_SYMBOLW64 sym;
WCHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOLW64_PACKAGE, *PIMAGEHLP_SYMBOLW64_PACKAGE;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
#define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64
#define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64
#define IMAGEHLP_SYMBOLW_PACKAGE IMAGEHLP_SYMBOLW64_PACKAGE
#define PIMAGEHLP_SYMBOLW_PACKAGE PIMAGEHLP_SYMBOLW64_PACKAGE
#else #else
typedef struct _IMAGEHLP_SYMBOL { typedef struct _IMAGEHLP_SYMBOL {
DWORD SizeOfStruct; // set to sizeof(IMAGEH DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL)
LP_SYMBOL) DWORD Address; // virtual address including dll base address
DWORD Address; // virtual address incl DWORD Size; // estimated size of symbol, can be zero
uding dll base address DWORD Flags; // info about the symbols, see the SYMF defin
DWORD Size; // estimated size of sy es
mbol, can be zero
DWORD Flags; // info about the symbo
ls, see the SYMF defines
DWORD MaxNameLength; // maximum size of symb ol name in 'Name' DWORD MaxNameLength; // maximum size of symb ol name in 'Name'
CHAR Name[1]; // symbol name (null te rminated string) CHAR Name[1]; // symbol name (null te rminated string)
} IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL; } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
typedef struct _IMAGEHLP_SYMBOL_PACKAGE { typedef struct _IMAGEHLP_SYMBOL_PACKAGE {
IMAGEHLP_SYMBOL sym; IMAGEHLP_SYMBOL sym;
CHAR name[MAX_SYM_NAME + 1]; CHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOL_PACKAGE, *PIMAGEHLP_SYMBOL_PACKAGE; } IMAGEHLP_SYMBOL_PACKAGE, *PIMAGEHLP_SYMBOL_PACKAGE;
typedef struct _IMAGEHLP_SYMBOLW {
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOLW)
DWORD Address; // virtual address including dll base address
DWORD Size; // estimated size of symbol, can be zero
DWORD Flags; // info about the symbols, see the SYMF defin
es
DWORD MaxNameLength; // maximum size of symb
ol name in 'Name'
WCHAR Name[1]; // symbol name (null te
rminated string)
} IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW;
typedef struct _IMAGEHLP_SYMBOLW_PACKAGE {
IMAGEHLP_SYMBOLW sym;
WCHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOLW_PACKAGE, *PIMAGEHLP_SYMBOLW_PACKAGE;
#endif #endif
// //
// module data structure // module data structure
// //
typedef struct _IMAGEHLP_MODULE64 { typedef struct _IMAGEHLP_MODULE64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)
P_MODULE64) DWORD64 BaseOfImage; // base load address of module
DWORD64 BaseOfImage; // base load address of DWORD ImageSize; // virtual size of the loaded module
module DWORD TimeDateStamp; // date/time stamp from pe header
DWORD ImageSize; // virtual size of the l DWORD CheckSum; // checksum from the pe header
oaded module DWORD NumSyms; // number of symbols in the symbol table
DWORD TimeDateStamp; // date/time stamp from SYM_TYPE SymType; // type of symbols loaded
pe header CHAR ModuleName[32]; // module name
DWORD CheckSum; // checksum from the pe CHAR ImageName[256]; // image name
header CHAR LoadedImageName[256]; // symbol file name
DWORD NumSyms; // number of symbols in
the symbol table
SYM_TYPE SymType; // type of symbols loade
d
CHAR ModuleName[32]; // module name
CHAR ImageName[256]; // image name
// new elements: 07-Jun-2002 // new elements: 07-Jun-2002
CHAR LoadedImageName[256]; // symbol file name CHAR LoadedPdbName[256]; // pdb file name
CHAR LoadedPdbName[256]; // pdb file name DWORD CVSig; // Signature of the CV record in the debug
DWORD CVSig; // Signature of the CV r directories
ecord in the debug directories CHAR CVData[MAX_PATH * 3]; // Contents of the CV record
CHAR CVData[MAX_PATH * 3]; // Contents o DWORD PdbSig; // Signature of PDB
f the CV record GUID PdbSig70; // Signature of PDB (VC 7 and up)
DWORD PdbSig; // Signature of PDB DWORD PdbAge; // DBI age of pdb
GUID PdbSig70; // Signature of PDB (VC BOOL PdbUnmatched; // loaded an unmatched pdb
7 and up) BOOL DbgUnmatched; // loaded an unmatched dbg
DWORD PdbAge; // DBI age of pdb BOOL LineNumbers; // we have line number information
BOOL PdbUnmatched; // loaded an unmatched p BOOL GlobalSymbols; // we have internal symbol information
db BOOL TypeInfo; // we have type information
BOOL DbgUnmatched; // loaded an unmatched d // new elements: 17-Dec-2003
bg BOOL SourceIndexed; // pdb supports source server
BOOL LineNumbers; // we have line number i BOOL Publics; // contains public symbols
nformation
BOOL GlobalSymbols; // we have internal symb
ol information
BOOL TypeInfo; // we have type informat
ion
} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
typedef struct _IMAGEHLP_MODULE64W { typedef struct _IMAGEHLP_MODULEW64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)
P_MODULE64) DWORD64 BaseOfImage; // base load address of module
DWORD64 BaseOfImage; // base load address of DWORD ImageSize; // virtual size of the loaded module
module DWORD TimeDateStamp; // date/time stamp from pe header
DWORD ImageSize; // virtual size of the l DWORD CheckSum; // checksum from the pe header
oaded module DWORD NumSyms; // number of symbols in the symbol table
DWORD TimeDateStamp; // date/time stamp from SYM_TYPE SymType; // type of symbols loaded
pe header WCHAR ModuleName[32]; // module name
DWORD CheckSum; // checksum from the pe WCHAR ImageName[256]; // image name
header
DWORD NumSyms; // number of symbols in
the symbol table
SYM_TYPE SymType; // type of symbols loade
d
WCHAR ModuleName[32]; // module name
WCHAR ImageName[256]; // image name
// new elements: 07-Jun-2002 // new elements: 07-Jun-2002
WCHAR LoadedImageName[256]; // symbol file name WCHAR LoadedImageName[256]; // symbol file name
WCHAR LoadedPdbName[256]; // pdb file name WCHAR LoadedPdbName[256]; // pdb file name
DWORD CVSig; // Signature of the CV r DWORD CVSig; // Signature of the CV record in the debug
ecord in the debug directories directories
WCHAR CVData[MAX_PATH * 3]; // Contents o WCHAR CVData[MAX_PATH * 3]; // Contents of the CV record
f the CV record DWORD PdbSig; // Signature of PDB
DWORD PdbSig; // Signature of PDB GUID PdbSig70; // Signature of PDB (VC 7 and up)
GUID PdbSig70; // Signature of PDB (VC DWORD PdbAge; // DBI age of pdb
7 and up) BOOL PdbUnmatched; // loaded an unmatched pdb
DWORD PdbAge; // DBI age of pdb BOOL DbgUnmatched; // loaded an unmatched dbg
BOOL PdbUnmatched; // loaded an unmatched p BOOL LineNumbers; // we have line number information
db BOOL GlobalSymbols; // we have internal symbol information
BOOL DbgUnmatched; // loaded an unmatched d BOOL TypeInfo; // we have type information
bg // new elements: 17-Dec-2003
BOOL LineNumbers; // we have line number i BOOL SourceIndexed; // pdb supports source server
nformation BOOL Publics; // contains public symbols
BOOL GlobalSymbols; // we have internal symb
ol information
BOOL TypeInfo; // we have type informat
ion
} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64; } IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_MODULE IMAGEHLP_MODULE64 #define IMAGEHLP_MODULE IMAGEHLP_MODULE64
#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64 #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64 #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64 #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
#else #else
typedef struct _IMAGEHLP_MODULE { typedef struct _IMAGEHLP_MODULE {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE)
P_MODULE) DWORD BaseOfImage; // base load address of module
DWORD BaseOfImage; // base load address of DWORD ImageSize; // virtual size of the loaded module
module DWORD TimeDateStamp; // date/time stamp from pe header
DWORD ImageSize; // virtual size of the l DWORD CheckSum; // checksum from the pe header
oaded module DWORD NumSyms; // number of symbols in the symbol table
DWORD TimeDateStamp; // date/time stamp from SYM_TYPE SymType; // type of symbols loaded
pe header CHAR ModuleName[32]; // module name
DWORD CheckSum; // checksum from the pe CHAR ImageName[256]; // image name
header CHAR LoadedImageName[256]; // symbol file name
DWORD NumSyms; // number of symbols in
the symbol table
SYM_TYPE SymType; // type of symbols loade
d
CHAR ModuleName[32]; // module name
CHAR ImageName[256]; // image name
CHAR LoadedImageName[256]; // symbol file name
} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE; } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
typedef struct _IMAGEHLP_MODULEW { typedef struct _IMAGEHLP_MODULEW {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE)
P_MODULE) DWORD BaseOfImage; // base load address of module
DWORD BaseOfImage; // base load address of DWORD ImageSize; // virtual size of the loaded module
module DWORD TimeDateStamp; // date/time stamp from pe header
DWORD ImageSize; // virtual size of the l DWORD CheckSum; // checksum from the pe header
oaded module DWORD NumSyms; // number of symbols in the symbol table
DWORD TimeDateStamp; // date/time stamp from SYM_TYPE SymType; // type of symbols loaded
pe header WCHAR ModuleName[32]; // module name
DWORD CheckSum; // checksum from the pe WCHAR ImageName[256]; // image name
header WCHAR LoadedImageName[256]; // symbol file name
DWORD NumSyms; // number of symbols in
the symbol table
SYM_TYPE SymType; // type of symbols loade
d
WCHAR ModuleName[32]; // module name
WCHAR ImageName[256]; // image name
WCHAR LoadedImageName[256]; // symbol file name
} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW; } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
#endif #endif
// //
// source file line data structure // source file line data structure
// //
typedef struct _IMAGEHLP_LINE64 { typedef struct _IMAGEHLP_LINE64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)
P_LINE64) PVOID Key; // internal
PVOID Key; // internal DWORD LineNumber; // line number in file
DWORD LineNumber; // line number in file PCHAR FileName; // full filename
PCHAR FileName; // full filename DWORD64 Address; // first instruction of line
DWORD64 Address; // first instruction of
line
} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64; } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
typedef struct _IMAGEHLP_LINEW64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)
PVOID Key; // internal
DWORD LineNumber; // line number in file
PWSTR FileName; // full filename
DWORD64 Address; // first instruction of line
} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_LINE IMAGEHLP_LINE64 #define IMAGEHLP_LINE IMAGEHLP_LINE64
#define PIMAGEHLP_LINE PIMAGEHLP_LINE64 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64
#else #else
typedef struct _IMAGEHLP_LINE { typedef struct _IMAGEHLP_LINE {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE)
P_LINE) PVOID Key; // internal
PVOID Key; // internal DWORD LineNumber; // line number in file
DWORD LineNumber; // line number in file PCHAR FileName; // full filename
PCHAR FileName; // full filename DWORD Address; // first instruction of line
DWORD Address; // first instruction of
line
} IMAGEHLP_LINE, *PIMAGEHLP_LINE; } IMAGEHLP_LINE, *PIMAGEHLP_LINE;
typedef struct _IMAGEHLP_LINEW {
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)
PVOID Key; // internal
DWORD LineNumber; // line number in file
PCHAR FileName; // full filename
DWORD64 Address; // first instruction of line
} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
#endif #endif
// //
// source file structure // source file structure
// //
typedef struct _SOURCEFILE { typedef struct _SOURCEFILE {
DWORD64 ModBase; // base address of loade DWORD64 ModBase; // base address of loaded module
d module PCHAR FileName; // full filename of source
PCHAR FileName; // full filename of sour
ce
} SOURCEFILE, *PSOURCEFILE; } SOURCEFILE, *PSOURCEFILE;
typedef struct _SOURCEFILEW {
DWORD64 ModBase; // base address of loaded module
PWSTR FileName; // full filename of source
} SOURCEFILEW, *PSOURCEFILEW;
// //
// data structures used for registered symbol callbacks // data structures used for registered symbol callbacks
// //
#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
#define CBA_SYMBOLS_UNLOADED 0x00000004 #define CBA_SYMBOLS_UNLOADED 0x00000004
#define CBA_DUPLICATE_SYMBOL 0x00000005 #define CBA_DUPLICATE_SYMBOL 0x00000005
#define CBA_READ_MEMORY 0x00000006 #define CBA_READ_MEMORY 0x00000006
skipping to change at line 1052 skipping to change at line 1351
} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY; } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
enum { enum {
sevInfo = 0, sevInfo = 0,
sevProblem, sevProblem,
sevAttn, sevAttn,
sevFatal, sevFatal,
sevMax // unused sevMax // unused
}; };
#define EVENT_SRCSPEW_START 100
#define EVENT_SRCSPEW 100
#define EVENT_SRCSPEW_END 199
typedef struct _IMAGEHLP_CBA_EVENT { typedef struct _IMAGEHLP_CBA_EVENT {
DWORD severity; // values from sevInfo t o sevFatal DWORD severity; // values from sevInfo t o sevFatal
DWORD code; // numerical code IDs th e error DWORD code; // numerical code IDs th e error
PCHAR desc; // may contain a text de scription of the error PCHAR desc; // may contain a text de scription of the error
PVOID object; // value dependant upon the error code PVOID object; // value dependant upon the error code
} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT; } IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
typedef struct _IMAGEHLP_CBA_EVENTW {
DWORD severity; // values from sevInfo
to sevFatal
DWORD code; // numerical code IDs t
he error
PCWSTR desc; // may contain a text d
escription of the error
PVOID object; // value dependant upon
the error code
} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 { typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_L
P_DEFERRED_SYMBOL_LOAD64) OAD64)
DWORD64 BaseOfImage; // base load address of DWORD64 BaseOfImage; // base load address of module
module DWORD CheckSum; // checksum from the pe header
DWORD CheckSum; // checksum from the pe DWORD TimeDateStamp; // date/time stamp from pe header
header CHAR FileName[MAX_PATH]; // symbols file or image name
DWORD TimeDateStamp; // date/time stamp from BOOLEAN Reparse; // load failure reparse
pe header HANDLE hFile; // file handle, if passed
CHAR FileName[MAX_PATH]; // symbols file or image DWORD Flags; //
name
BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passe
d
DWORD Flags; //
} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; } IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
#define DSLFLAG_MISMATCHED_PDB 0x1 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_L
OADW64)
DWORD64 BaseOfImage; // base load address of module
DWORD CheckSum; // checksum from the pe header
DWORD TimeDateStamp; // date/time stamp from pe header
WCHAR FileName[MAX_PATH + 1]; // symbols file or image name
BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passed
DWORD Flags; //
} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
#define DSLFLAG_MISMATCHED_PDB 0x1
#define DSLFLAG_MISMATCHED_DBG 0x2 #define DSLFLAG_MISMATCHED_DBG 0x2
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
#else #else
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD { typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_L
P_DEFERRED_SYMBOL_LOAD) OAD)
DWORD BaseOfImage; // base load address of DWORD BaseOfImage; // base load address of module
module DWORD CheckSum; // checksum from the pe header
DWORD CheckSum; // checksum from the pe DWORD TimeDateStamp; // date/time stamp from pe header
header CHAR FileName[MAX_PATH]; // symbols file or image name
DWORD TimeDateStamp; // date/time stamp from BOOLEAN Reparse; // load failure reparse
pe header HANDLE hFile; // file handle, if passed
CHAR FileName[MAX_PATH]; // symbols file or image
name
BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passe
d
} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD; } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
#endif #endif
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 { typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DUPLICA
P_DUPLICATE_SYMBOL64) TE_SYMBOL64)
DWORD NumberOfDups; // number of duplicates DWORD NumberOfDups; // number of duplicates in the Sy
in the Symbol array mbol array
PIMAGEHLP_SYMBOL64 Symbol; // array of duplicate sy PIMAGEHLP_SYMBOL64 Symbol; // array of duplicate symbols
mbols DWORD SelectedSymbol; // symbol selected (-1 to start)
DWORD SelectedSymbol; // symbol selected (-1 t
o start)
} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64; } IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64 #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64 #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
#else #else
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL { typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
DWORD SizeOfStruct; // set to sizeof(IMAGEHL DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DUPLICATE
P_DUPLICATE_SYMBOL) _SYMBOL)
DWORD NumberOfDups; // number of duplicates DWORD NumberOfDups; // number of duplicates in the Symb
in the Symbol array ol array
PIMAGEHLP_SYMBOL Symbol; // array of duplicate sy PIMAGEHLP_SYMBOL Symbol; // array of duplicate symbols
mbols DWORD SelectedSymbol; // symbol selected (-1 to start)
DWORD SelectedSymbol; // symbol selected (-1 t
o start)
} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL; } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
#endif #endif
// If dbghelp ever needs to display graphical UI, it will use this as the parent window. // If dbghelp ever needs to display graphical UI, it will use this as the parent window.
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetParentWindow( SymSetParentWindow(
HWND hwnd __in HWND hwnd
); );
PCHAR PCHAR
IMAGEAPI IMAGEAPI
SymSetHomeDirectory( SymSetHomeDirectory(
PCSTR dir __in_opt HANDLE hProcess,
__in_opt PCSTR dir
);
PWSTR
IMAGEAPI
SymSetHomeDirectoryW(
__in_opt HANDLE hProcess,
__in_opt PCWSTR dir
); );
PCHAR PCHAR
IMAGEAPI IMAGEAPI
SymGetHomeDirectory( SymGetHomeDirectory(
DWORD type, __in DWORD type,
PSTR dir, __out_ecount(size) PSTR dir,
size_t size __in size_t size
);
PWSTR
IMAGEAPI
SymGetHomeDirectoryW(
__in DWORD type,
__out_ecount(size) PWSTR dir,
__in size_t size
); );
typedef enum { typedef enum {
hdBase = 0, // root directory for dbghelp hdBase = 0, // root directory for dbghelp
hdSym, // where symbols are stored hdSym, // where symbols are stored
hdSrc, // where source is stored hdSrc, // where source is stored
hdMax // end marker hdMax // end marker
}; };
// //
skipping to change at line 1160 skipping to change at line 1497
#define SYMOPT_EXACT_SYMBOLS 0x00000400 #define SYMOPT_EXACT_SYMBOLS 0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
#define SYMOPT_PUBLICS_ONLY 0x00004000 #define SYMOPT_PUBLICS_ONLY 0x00004000
#define SYMOPT_NO_PUBLICS 0x00008000 #define SYMOPT_NO_PUBLICS 0x00008000
#define SYMOPT_AUTO_PUBLICS 0x00010000 #define SYMOPT_AUTO_PUBLICS 0x00010000
#define SYMOPT_NO_IMAGE_SEARCH 0x00020000 #define SYMOPT_NO_IMAGE_SEARCH 0x00020000
#define SYMOPT_SECURE 0x00040000 #define SYMOPT_SECURE 0x00040000
#define SYMOPT_NO_PROMPTS 0x00080000 #define SYMOPT_NO_PROMPTS 0x00080000
#define SYMOPT_OVERWRITE 0x00100000
#define SYMOPT_IGNORE_IMAGEDIR 0x00200000
#define SYMOPT_FLAT_DIRECTORY 0x00400000
#define SYMOPT_FAVOR_COMPRESSED 0x00800000
#define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000
#define SYMOPT_DEBUG 0x80000000 #define SYMOPT_DEBUG 0x80000000
DWORD DWORD
IMAGEAPI IMAGEAPI
SymSetOptions( SymSetOptions(
IN DWORD SymOptions __in DWORD SymOptions
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
SymGetOptions( SymGetOptions(
VOID VOID
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymCleanup( SymCleanup(
IN HANDLE hProcess __in HANDLE hProcess
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymMatchString( SymMatchString(
IN LPSTR string, __in PCSTR string,
IN LPSTR expression, __in PCSTR expression,
IN BOOL fCase __in BOOL fCase
); );
typedef BOOL BOOL
(CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)( IMAGEAPI
PSOURCEFILE pSourceFile, SymMatchStringA(
PVOID UserContext __in PCSTR string,
__in PCSTR expression,
__in BOOL fCase
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSourceFiles( SymMatchStringW(
IN HANDLE hProcess, __in PCWSTR string,
IN ULONG64 ModBase, __in PCWSTR expression,
IN LPSTR Mask, __in BOOL fCase
IN PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles, );
IN PVOID UserContext
typedef BOOL
(CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(
__in PSOURCEFILE pSourceFile,
__in_opt PVOID UserContext
); );
// for backwards compatibility - don't use this
#define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateModules64( SymEnumSourceFiles(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, __in ULONG64 ModBase,
IN PVOID UserContext __in_opt PCSTR Mask,
__in PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(
__in PSOURCEFILEW pSourceFile,
__in_opt PVOID UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateModules SymEnumerateModules64
#else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateModules( SymEnumSourceFilesW(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, __in ULONG64 ModBase,
IN PVOID UserContext __in_opt PCWSTR Mask,
__in PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,
__in_opt PVOID UserContext
); );
#endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbols64( SymEnumerateModules64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 BaseOfDll, __in PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,
IN PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback, __in_opt PVOID UserContext
IN PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbolsW64( SymEnumerateModulesW64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 BaseOfDll, __in PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,
IN PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback, __in_opt PVOID UserContext
IN PVOID UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateSymbols SymEnumerateSymbols64 #define SymEnumerateModules SymEnumerateModules64
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbols( SymEnumerateModules(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD BaseOfDll, __in PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
IN PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext
IN PVOID UserContext
); );
#endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbolsW( EnumerateLoadedModules64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD BaseOfDll, __in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
IN PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext
IN PVOID UserContext
); );
#endif
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumerateLoadedModules64( EnumerateLoadedModulesW64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, __in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
IN PVOID UserContext __in PVOID UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define EnumerateLoadedModules EnumerateLoadedModules64 #define EnumerateLoadedModules EnumerateLoadedModules64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumerateLoadedModules( EnumerateLoadedModules(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, __in PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
IN PVOID UserContext __in_opt PVOID UserContext
); );
#endif #endif
PVOID PVOID
IMAGEAPI IMAGEAPI
SymFunctionTableAccess64( SymFunctionTableAccess64(
HANDLE hProcess, __in HANDLE hProcess,
DWORD64 AddrBase __in DWORD64 AddrBase
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymFunctionTableAccess SymFunctionTableAccess64 #define SymFunctionTableAccess SymFunctionTableAccess64
#else #else
PVOID PVOID
IMAGEAPI IMAGEAPI
SymFunctionTableAccess( SymFunctionTableAccess(
HANDLE hProcess, __in HANDLE hProcess,
DWORD AddrBase __in DWORD AddrBase
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetModuleInfo64( SymGetModuleInfo64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 qwAddr, __in DWORD64 qwAddr,
OUT PIMAGEHLP_MODULE64 ModuleInfo __out PIMAGEHLP_MODULE64 ModuleInfo
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetModuleInfoW64( SymGetModuleInfoW64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 qwAddr, __in DWORD64 qwAddr,
OUT PIMAGEHLP_MODULEW64 ModuleInfo __out PIMAGEHLP_MODULEW64 ModuleInfo
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetModuleInfo SymGetModuleInfo64 #define SymGetModuleInfo SymGetModuleInfo64
#define SymGetModuleInfoW SymGetModuleInfoW64 #define SymGetModuleInfoW SymGetModuleInfoW64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetModuleInfo( SymGetModuleInfo(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD dwAddr, __in DWORD dwAddr,
OUT PIMAGEHLP_MODULE ModuleInfo __out PIMAGEHLP_MODULE ModuleInfo
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetModuleInfoW( SymGetModuleInfoW(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD dwAddr, __in DWORD dwAddr,
OUT PIMAGEHLP_MODULEW ModuleInfo __out PIMAGEHLP_MODULEW ModuleInfo
); );
#endif #endif
DWORD64 DWORD64
IMAGEAPI IMAGEAPI
SymGetModuleBase64( SymGetModuleBase64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 qwAddr __in DWORD64 qwAddr
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetModuleBase SymGetModuleBase64 #define SymGetModuleBase SymGetModuleBase64
#else #else
DWORD DWORD
IMAGEAPI IMAGEAPI
SymGetModuleBase( SymGetModuleBase(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD dwAddr __in DWORD dwAddr
);
#endif
BOOL
IMAGEAPI
SymGetSymNext64(
IN HANDLE hProcess,
IN OUT PIMAGEHLP_SYMBOL64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymNext SymGetSymNext64
#else
BOOL
IMAGEAPI
SymGetSymNext(
IN HANDLE hProcess,
IN OUT PIMAGEHLP_SYMBOL Symbol
);
#endif
BOOL
IMAGEAPI
SymGetSymPrev64(
IN HANDLE hProcess,
IN OUT PIMAGEHLP_SYMBOL64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymPrev SymGetSymPrev64
#else
BOOL
IMAGEAPI
SymGetSymPrev(
IN HANDLE hProcess,
IN OUT PIMAGEHLP_SYMBOL Symbol
); );
#endif #endif
typedef struct _SRCCODEINFO { typedef struct _SRCCODEINFO {
DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO) DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO)
PVOID Key; // not used PVOID Key; // not used
DWORD64 ModBase; // base address of module this applies to DWORD64 ModBase; // base address of module this applies to
CHAR Obj[MAX_PATH + 1]; // the object file within the module CHAR Obj[MAX_PATH + 1]; // the object file within the module
CHAR FileName[MAX_PATH + 1]; // full filename CHAR FileName[MAX_PATH + 1]; // full filename
DWORD LineNumber; // line number in file DWORD LineNumber; // line number in file
DWORD64 Address; // first instruction of line DWORD64 Address; // first instruction of line
} SRCCODEINFO, *PSRCCODEINFO; } SRCCODEINFO, *PSRCCODEINFO;
typedef struct _SRCCODEINFOW {
DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO)
PVOID Key; // not used
DWORD64 ModBase; // base address of module this applies to
WCHAR Obj[MAX_PATH + 1]; // the object file within the module
WCHAR FileName[MAX_PATH + 1]; // full filename
DWORD LineNumber; // line number in file
DWORD64 Address; // first instruction of line
} SRCCODEINFOW, *PSRCCODEINFOW;
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMLINES_CALLBACK)( (CALLBACK *PSYM_ENUMLINES_CALLBACK)(
PSRCCODEINFO LineInfo, __in PSRCCODEINFO LineInfo,
PVOID UserContext __in_opt PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumLines( SymEnumLines(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 Base, __in ULONG64 Base,
IN PCSTR Obj, __in_opt PCSTR Obj,
IN PCSTR File, __in_opt PCSTR File,
IN PSYM_ENUMLINES_CALLBACK EnumLinesCallback, __in PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
IN PVOID UserContext __in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK *PSYM_ENUMLINES_CALLBACKW)(
__in PSRCCODEINFOW LineInfo,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumLinesW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCWSTR Obj,
__in_opt PCWSTR File,
__in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
__in_opt PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromAddr64( SymGetLineFromAddr64(
__in HANDLE hProcess,
__in DWORD64 qwAddr,
__out PDWORD pdwDisplacement,
__out PIMAGEHLP_LINE64 Line64
);
BOOL
IMAGEAPI
SymEnumSourceLines(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCSTR Obj,
__in_opt PCSTR File,
__in_opt DWORD Line,
__in DWORD Flags,
__in PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSourceLinesW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCWSTR Obj,
__in_opt PCWSTR File,
__in_opt DWORD Line,
__in DWORD Flags,
__in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
__in_opt PVOID UserContext
);
// flags for SymEnumSourceLines
#define ESLFLAG_FULLPATH 0x1
#define ESLFLAG_NEAREST 0x2
#define ESLFLAG_PREV 0x4
#define ESLFLAG_NEXT 0x8
BOOL
IMAGEAPI
SymGetLineFromAddrW64(
IN HANDLE hProcess, IN HANDLE hProcess,
IN DWORD64 qwAddr, IN DWORD64 qwAddr,
OUT PDWORD pdwDisplacement, OUT PDWORD pdwDisplacement,
OUT PIMAGEHLP_LINE64 Line64 OUT PIMAGEHLP_LINEW64 Line64
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineFromAddr SymGetLineFromAddr64 #define SymGetLineFromAddr SymGetLineFromAddr64
#define SymGetLineFromAddrW SymGetLineFromAddrW64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromAddr( SymGetLineFromAddr(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD dwAddr, __in DWORD dwAddr,
OUT PDWORD pdwDisplacement, __out PDWORD pdwDisplacement,
OUT PIMAGEHLP_LINE Line __out PIMAGEHLP_LINE Line
);
BOOL
IMAGEAPI
SymGetLineFromAddrW(
__in HANDLE hProcess,
__in DWORD dwAddr,
__out PDWORD pdwDisplacement,
__out PIMAGEHLP_LINEW Line
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromName64( SymGetLineFromName64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSTR ModuleName, __in_opt PCSTR ModuleName,
IN PSTR FileName, __in_opt PCSTR FileName,
IN DWORD dwLineNumber, __in DWORD dwLineNumber,
OUT PLONG plDisplacement, __out PLONG plDisplacement,
IN OUT PIMAGEHLP_LINE64 Line __inout PIMAGEHLP_LINE64 Line
);
BOOL
IMAGEAPI
SymGetLineFromNameW64(
__in HANDLE hProcess,
__in_opt PCWSTR ModuleName,
__in_opt PCWSTR FileName,
__in DWORD dwLineNumber,
__out PLONG plDisplacement,
__inout PIMAGEHLP_LINEW64 Line
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineFromName SymGetLineFromName64 #define SymGetLineFromName SymGetLineFromName64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromName( SymGetLineFromName(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSTR ModuleName, __in_opt PCSTR ModuleName,
IN PSTR FileName, __in_opt PCSTR FileName,
IN DWORD dwLineNumber, __in DWORD dwLineNumber,
OUT PLONG plDisplacement, __out PLONG plDisplacement,
IN OUT PIMAGEHLP_LINE Line __inout PIMAGEHLP_LINE Line
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineNext64( SymGetLineNext64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN OUT PIMAGEHLP_LINE64 Line __inout PIMAGEHLP_LINE64 Line
);
BOOL
IMAGEAPI
SymGetLineNextW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW64 Line
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineNext SymGetLineNext64 #define SymGetLineNext SymGetLineNext64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineNext( SymGetLineNext(
IN HANDLE hProcess, __in HANDLE hProcess,
IN OUT PIMAGEHLP_LINE Line __inout PIMAGEHLP_LINE Line
);
BOOL
IMAGEAPI
SymGetLineNextW(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW Line
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLinePrev64( SymGetLinePrev64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN OUT PIMAGEHLP_LINE64 Line __inout PIMAGEHLP_LINE64 Line
);
BOOL
IMAGEAPI
SymGetLinePrevW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW64 Line
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLinePrev SymGetLinePrev64 #define SymGetLinePrev SymGetLinePrev64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLinePrev( SymGetLinePrev(
IN HANDLE hProcess, __in HANDLE hProcess,
IN OUT PIMAGEHLP_LINE Line __inout PIMAGEHLP_LINE Line
);
BOOL
IMAGEAPI
SymGetLinePrevW(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW Line
); );
#endif #endif
ULONG
IMAGEAPI
SymGetFileLineOffsets64(
__in HANDLE hProcess,
__in_opt PCSTR ModuleName,
__in PCSTR FileName,
__out_ecount(BufferLines) PDWORD64 Buffer,
__in ULONG BufferLines
);
BOOL BOOL
IMAGEAPI IMAGEAPI
SymMatchFileName( SymMatchFileName(
IN PSTR FileName, __in PCSTR FileName,
IN PSTR Match, __in PCSTR Match,
OUT PSTR *FileNameStop, __deref_opt_out PSTR *FileNameStop,
OUT PSTR *MatchStop __deref_opt_out PSTR *MatchStop
);
BOOL
IMAGEAPI
SymMatchFileNameW(
__in PCWSTR FileName,
__in PCWSTR Match,
__deref_opt_out PWSTR *FileNameStop,
__deref_opt_out PWSTR *MatchStop
);
BOOL
IMAGEAPI
SymGetSourceFile(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PCSTR Params,
__in PCSTR FileSpec,
__out_ecount(Size) PSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceFileW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PCWSTR Params,
__in PCWSTR FileSpec,
__out_ecount(Size) PWSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceFileToken(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PCSTR FileSpec,
__deref_out PVOID *Token,
__out DWORD *Size
);
BOOL
IMAGEAPI
SymGetSourceFileTokenW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PCWSTR FileSpec,
__deref_out PVOID *Token,
__out DWORD *Size
);
BOOL
IMAGEAPI
SymGetSourceFileFromToken(
__in HANDLE hProcess,
__in PVOID Token,
__in PCSTR Params,
__out_ecount(Size) PSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceFileFromTokenW(
__in HANDLE hProcess,
__in PVOID Token,
__in PCWSTR Params,
__out_ecount(Size) PWSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceVarFromToken(
__in HANDLE hProcess,
__in PVOID Token,
__in_opt PCSTR Params,
__in PCSTR VarName,
__out_ecount(Size) PSTR Value,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceVarFromTokenW(
__in HANDLE hProcess,
__in PVOID Token,
__in_opt PCWSTR Params,
__in PCWSTR VarName,
__out_ecount(Size) PWSTR Value,
__in DWORD Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymInitialize( SymInitialize(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSTR UserSearchPath, __in_opt PCSTR UserSearchPath,
IN BOOL fInvadeProcess __in BOOL fInvadeProcess
);
BOOL
IMAGEAPI
SymInitializeW(
__in HANDLE hProcess,
__in_opt PCWSTR UserSearchPath,
__in BOOL fInvadeProcess
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSearchPath( SymGetSearchPath(
IN HANDLE hProcess, __in HANDLE hProcess,
OUT PSTR SearchPath, __out_ecount(SearchPathLength) PSTR SearchPath,
IN DWORD SearchPathLength __in DWORD SearchPathLength
);
BOOL
IMAGEAPI
SymGetSearchPathW(
__in HANDLE hProcess,
__out_ecount(SearchPathLength) PWSTR SearchPath,
__in DWORD SearchPathLength
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetSearchPath( SymSetSearchPath(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSTR SearchPath __in_opt PCSTR SearchPath
); );
DWORD64 BOOL
IMAGEAPI IMAGEAPI
SymLoadModule64( SymSetSearchPathW(
IN HANDLE hProcess, __in HANDLE hProcess,
IN HANDLE hFile, __in_opt PCWSTR SearchPath
IN PSTR ImageName,
IN PSTR ModuleName,
IN DWORD64 BaseOfDll,
IN DWORD SizeOfDll
); );
#define SLMFLAG_VIRTUAL 0x1 #define SLMFLAG_VIRTUAL 0x1
#define SLMFLAG_ALT_INDEX 0x2
#define SLMFLAG_NO_SYMBOLS 0x4
DWORD64 DWORD64
IMAGEAPI IMAGEAPI
SymLoadModuleEx( SymLoadModuleEx(
IN HANDLE hProcess, __in HANDLE hProcess,
IN HANDLE hFile, __in_opt HANDLE hFile,
IN PSTR ImageName, __in_opt PCSTR ImageName,
IN PSTR ModuleName, __in_opt PCSTR ModuleName,
IN DWORD64 BaseOfDll, __in DWORD64 BaseOfDll,
IN DWORD DllSize, __in DWORD DllSize,
IN PMODLOAD_DATA Data, __in_opt PMODLOAD_DATA Data,
IN DWORD Flags __in_opt DWORD Flags
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) DWORD64
#define SymLoadModule SymLoadModule64
#else
DWORD
IMAGEAPI IMAGEAPI
SymLoadModule( SymLoadModuleExW(
IN HANDLE hProcess, __in HANDLE hProcess,
IN HANDLE hFile, __in_opt HANDLE hFile,
IN PSTR ImageName, __in_opt PCWSTR ImageName,
IN PSTR ModuleName, __in_opt PCWSTR ModuleName,
IN DWORD BaseOfDll, __in DWORD64 BaseOfDll,
IN DWORD SizeOfDll __in DWORD DllSize,
__in_opt PMODLOAD_DATA Data,
__in_opt DWORD Flags
); );
#endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymUnloadModule64( SymUnloadModule64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 BaseOfDll __in DWORD64 BaseOfDll
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymUnloadModule SymUnloadModule64 #define SymUnloadModule SymUnloadModule64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymUnloadModule( SymUnloadModule(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD BaseOfDll __in DWORD BaseOfDll
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymUnDName64( SymUnDName64(
IN PIMAGEHLP_SYMBOL64 sym, // Symbol to undecorate __in PIMAGEHLP_SYMBOL64 sym, // Symbol to undecorate
OUT PSTR UnDecName, // Buffer to store undecorated nam __out_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorat
e in ed name in
IN DWORD UnDecNameLength // Size of the buffer __in DWORD UnDecNameLength // Size of the buffer
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymUnDName SymUnDName64 #define SymUnDName SymUnDName64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymUnDName( SymUnDName(
IN PIMAGEHLP_SYMBOL sym, // Symbol to undecorate __in PIMAGEHLP_SYMBOL sym, // Symbol to undecorate
OUT PSTR UnDecName, // Buffer to store undecorated name __out_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorat
in ed name in
IN DWORD UnDecNameLength // Size of the buffer __in DWORD UnDecNameLength // Size of the buffer
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymRegisterCallback64( SymRegisterCallback64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, __in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
IN ULONG64 UserContext __in ULONG64 UserContext
);
BOOL
IMAGEAPI
SymRegisterCallbackW64(
__in HANDLE hProcess,
__in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
__in ULONG64 UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymRegisterFunctionEntryCallback64( SymRegisterFunctionEntryCallback64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction, __in PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,
IN ULONG64 UserContext __in ULONG64 UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymRegisterCallback SymRegisterCallback64 #define SymRegisterCallback SymRegisterCallback64
#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64 #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymRegisterCallback( SymRegisterCallback(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSYMBOL_REGISTERED_CALLBACK CallbackFunction, __in PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
IN PVOID UserContext __in_opt PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymRegisterFunctionEntryCallback( SymRegisterFunctionEntryCallback(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction, __in PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,
IN PVOID UserContext __in_opt PVOID UserContext
); );
#endif #endif
typedef struct _IMAGEHLP_SYMBOL_SRC { typedef struct _IMAGEHLP_SYMBOL_SRC {
DWORD sizeofstruct; DWORD sizeofstruct;
DWORD type; DWORD type;
char file[MAX_PATH]; char file[MAX_PATH];
} IMAGEHLP_SYMBOL_SRC, *PIMAGEHLP_SYMBOL_SRC; } IMAGEHLP_SYMBOL_SRC, *PIMAGEHLP_SYMBOL_SRC;
typedef struct _MODULE_TYPE_INFO { // AKA TYPTYP typedef struct _MODULE_TYPE_INFO { // AKA TYPTYP
USHORT dataLength; USHORT dataLength;
USHORT leaf; USHORT leaf;
BYTE data[1]; BYTE data[1];
} MODULE_TYPE_INFO, *PMODULE_TYPE_INFO; } MODULE_TYPE_INFO, *PMODULE_TYPE_INFO;
typedef struct _SYMBOL_INFO { typedef struct _SYMBOL_INFO {
ULONG SizeOfStruct; ULONG SizeOfStruct;
ULONG TypeIndex; // Type Index of symbol ULONG TypeIndex; // Type Index of symbol
ULONG64 Reserved[2]; ULONG64 Reserved[2];
ULONG info; ULONG Index;
ULONG Size; ULONG Size;
ULONG64 ModBase; // Base Address of module comtaining this symb ol ULONG64 ModBase; // Base Address of module comtaining this symb ol
ULONG Flags; ULONG Flags;
ULONG64 Value; // Value of symbol, ValuePresent should be 1 ULONG64 Value; // Value of symbol, ValuePresent should be 1
ULONG64 Address; // Address of symbol including base address of module ULONG64 Address; // Address of symbol including base address of module
ULONG Register; // register holding value or pointer to value ULONG Register; // register holding value or pointer to value
ULONG Scope; // scope of the symbol ULONG Scope; // scope of the symbol
ULONG Tag; // pdb classification ULONG Tag; // pdb classification
ULONG NameLen; // Actual length of name ULONG NameLen; // Actual length of name
ULONG MaxNameLen; ULONG MaxNameLen;
CHAR Name[1]; // Name of symbol CHAR Name[1]; // Name of symbol
} SYMBOL_INFO, *PSYMBOL_INFO; } SYMBOL_INFO, *PSYMBOL_INFO;
typedef struct _SYMBOL_INFO_PACKAGE { typedef struct _SYMBOL_INFO_PACKAGE {
SYMBOL_INFO si; SYMBOL_INFO si;
CHAR name[MAX_SYM_NAME + 1]; CHAR name[MAX_SYM_NAME + 1];
} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE; } SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
typedef struct _SYMBOL_INFOW {
ULONG SizeOfStruct;
ULONG TypeIndex; // Type Index of symbol
ULONG64 Reserved[2];
ULONG Index;
ULONG Size;
ULONG64 ModBase; // Base Address of module comtaining this symb
ol
ULONG Flags;
ULONG64 Value; // Value of symbol, ValuePresent should be 1
ULONG64 Address; // Address of symbol including base address of
module
ULONG Register; // register holding value or pointer to value
ULONG Scope; // scope of the symbol
ULONG Tag; // pdb classification
ULONG NameLen; // Actual length of name
ULONG MaxNameLen;
WCHAR Name[1]; // Name of symbol
} SYMBOL_INFOW, *PSYMBOL_INFOW;
typedef struct _SYMBOL_INFO_PACKAGEW {
SYMBOL_INFOW si;
WCHAR name[MAX_SYM_NAME + 1];
} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
typedef struct _IMAGEHLP_STACK_FRAME typedef struct _IMAGEHLP_STACK_FRAME
{ {
ULONG64 InstructionOffset; ULONG64 InstructionOffset;
ULONG64 ReturnOffset; ULONG64 ReturnOffset;
ULONG64 FrameOffset; ULONG64 FrameOffset;
ULONG64 StackOffset; ULONG64 StackOffset;
ULONG64 BackingStoreOffset; ULONG64 BackingStoreOffset;
ULONG64 FuncTableEntry; ULONG64 FuncTableEntry;
ULONG64 Params[4]; ULONG64 Params[4];
ULONG64 Reserved[5]; ULONG64 Reserved[5];
BOOL Virtual; BOOL Virtual;
ULONG Reserved2; ULONG Reserved2;
} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME; } IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT; typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetContext( SymSetContext(
HANDLE hProcess, __in HANDLE hProcess,
PIMAGEHLP_STACK_FRAME StackFrame, __in PIMAGEHLP_STACK_FRAME StackFrame,
PIMAGEHLP_CONTEXT Context __in_opt PIMAGEHLP_CONTEXT Context
);
typedef BOOL
(CALLBACK *PSYM_ENUMPROCESSES_CALLBACK)(
__in HANDLE hProcess,
__in PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumProcesses(
__in PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback,
__in PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromAddr( SymFromAddr(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 Address, __in DWORD64 Address,
OUT PDWORD64 Displacement, __out_opt PDWORD64 Displacement,
IN OUT PSYMBOL_INFO Symbol __inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromAddrW(
__in HANDLE hProcess,
__in DWORD64 Address,
__out_opt PDWORD64 Displacement,
__inout PSYMBOL_INFOW Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromToken( SymFromToken(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 Base, __in DWORD64 Base,
IN DWORD Token, __in DWORD Token,
IN OUT PSYMBOL_INFO Symbol __inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromTokenW(
__in HANDLE hProcess,
__in DWORD64 Base,
__in DWORD Token,
__inout PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymNext(
__in HANDLE hProcess,
__inout PSYMBOL_INFO si
);
BOOL
IMAGEAPI
SymNextW(
__in HANDLE hProcess,
__inout PSYMBOL_INFOW siw
);
BOOL
IMAGEAPI
SymPrev(
__in HANDLE hProcess,
__inout PSYMBOL_INFO si
);
BOOL
IMAGEAPI
SymPrevW(
__in HANDLE hProcess,
__inout PSYMBOL_INFOW siw
); );
// While SymFromName will provide a symbol from a name, // While SymFromName will provide a symbol from a name,
// SymEnumSymbols can provide the same matching information // SymEnumSymbols can provide the same matching information
// for ALL symbols with a matching name, even regular // for ALL symbols with a matching name, even regular
// expressions. That way you can search across modules // expressions. That way you can search across modules
// and differentiate between identically named symbols. // and differentiate between identically named symbols.
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromName( SymFromName(
IN HANDLE hProcess, __in HANDLE hProcess,
IN LPSTR Name, __in PCSTR Name,
OUT PSYMBOL_INFO Symbol __inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromNameW(
__in HANDLE hProcess,
__in PCWSTR Name,
__inout PSYMBOL_INFOW Symbol
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)( (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(
PSYMBOL_INFO pSymInfo, __in PSYMBOL_INFO pSymInfo,
ULONG SymbolSize, __in ULONG SymbolSize,
PVOID UserContext __in_opt PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSymbols( SymEnumSymbols(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 BaseOfDll, __in ULONG64 BaseOfDll,
IN PCSTR Mask, __in_opt PCSTR Mask,
IN PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
IN PVOID UserContext __in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(
__in PSYMBOL_INFOW pSymInfo,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbolsW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCWSTR Mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSymbolsForAddr( SymEnumSymbolsForAddr(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 Address, __in DWORD64 Address,
IN PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
IN PVOID UserContext __in_opt PVOID UserContext
); );
#define SYMENUMFLAG_FULLSRCH 1 BOOL
#define SYMENUMFLAG_SPEEDSRCH 2 IMAGEAPI
SymEnumSymbolsForAddrW(
__in HANDLE hProcess,
__in DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
#define SYMSEARCH_MASKOBJS 0x01 // used internally to implement other AP
Is
#define SYMSEARCH_RECURSE 0X02 // recurse scopes
#define SYMSEARCH_GLOBALSONLY 0X04 // search only for global symbols
BOOL
IMAGEAPI
SymSearch(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt DWORD Index,
__in_opt DWORD SymTag,
__in_opt PCSTR Mask,
__in_opt DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext,
__in DWORD Options
);
BOOL
IMAGEAPI
SymSearchW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt DWORD Index,
__in_opt DWORD SymTag,
__in_opt PCWSTR Mask,
__in_opt DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext,
__in DWORD Options
);
BOOL
IMAGEAPI
SymGetScope(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymGetScopeW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymFromIndex(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromIndexW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFOW Symbol
);
typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO { typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
TI_GET_SYMTAG, TI_GET_SYMTAG,
TI_GET_SYMNAME, TI_GET_SYMNAME,
TI_GET_LENGTH, TI_GET_LENGTH,
TI_GET_TYPE, TI_GET_TYPE,
TI_GET_TYPEID, TI_GET_TYPEID,
TI_GET_BASETYPE, TI_GET_BASETYPE,
TI_GET_ARRAYINDEXTYPEID, TI_GET_ARRAYINDEXTYPEID,
TI_FINDCHILDREN, TI_FINDCHILDREN,
skipping to change at line 1802 skipping to change at line 2540
TI_GET_VIRTUALBASEPOINTEROFFSET, TI_GET_VIRTUALBASEPOINTEROFFSET,
TI_GET_CLASSPARENTID, TI_GET_CLASSPARENTID,
TI_GET_NESTED, TI_GET_NESTED,
TI_GET_SYMINDEX, TI_GET_SYMINDEX,
TI_GET_LEXICALPARENT, TI_GET_LEXICALPARENT,
TI_GET_ADDRESS, TI_GET_ADDRESS,
TI_GET_THISADJUST, TI_GET_THISADJUST,
TI_GET_UDTKIND, TI_GET_UDTKIND,
TI_IS_EQUIV_TO, TI_IS_EQUIV_TO,
TI_GET_CALLING_CONVENTION, TI_GET_CALLING_CONVENTION,
TI_IS_CLOSE_EQUIV_TO,
TI_GTIEX_REQS_VALID,
TI_GET_VIRTUALBASEOFFSET,
TI_GET_VIRTUALBASEDISPINDEX,
TI_GET_IS_REFERENCE,
IMAGEHLP_SYMBOL_TYPE_INFO_MAX,
} IMAGEHLP_SYMBOL_TYPE_INFO; } IMAGEHLP_SYMBOL_TYPE_INFO;
typedef struct _TI_FINDCHILDREN_PARAMS { typedef struct _TI_FINDCHILDREN_PARAMS {
ULONG Count; ULONG Count;
ULONG Start; ULONG Start;
ULONG ChildId[1]; ULONG ChildId[1];
} TI_FINDCHILDREN_PARAMS; } TI_FINDCHILDREN_PARAMS;
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetTypeInfo( SymGetTypeInfo(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 ModBase, __in DWORD64 ModBase,
IN ULONG TypeId, __in ULONG TypeId,
IN IMAGEHLP_SYMBOL_TYPE_INFO GetType, __in IMAGEHLP_SYMBOL_TYPE_INFO GetType,
OUT PVOID pInfo __out PVOID pInfo
);
#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001
#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002
typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS {
IN ULONG SizeOfStruct;
IN ULONG Flags;
IN ULONG NumIds;
IN PULONG TypeIds;
IN ULONG64 TagFilter;
IN ULONG NumReqs;
IN IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
IN PULONG_PTR ReqOffsets;
IN PULONG ReqSizes;
IN ULONG_PTR ReqStride;
IN ULONG_PTR BufferSize;
OUT PVOID Buffer;
OUT ULONG EntriesMatched;
OUT ULONG EntriesFilled;
OUT ULONG64 TagsFound;
OUT ULONG64 AllReqsValid;
IN ULONG NumReqsValid;
OUT PULONG64 ReqsValid OPTIONAL;
} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
BOOL
IMAGEAPI
SymGetTypeInfoEx(
__in HANDLE hProcess,
__in DWORD64 ModBase,
__inout PIMAGEHLP_GET_TYPE_INFO_PARAMS Params
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumTypes( SymEnumTypes(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 BaseOfDll, __in ULONG64 BaseOfDll,
IN PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
IN PVOID UserContext __in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumTypesW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetTypeFromName( SymGetTypeFromName(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 BaseOfDll, __in ULONG64 BaseOfDll,
IN LPSTR Name, __in PCSTR Name,
OUT PSYMBOL_INFO Symbol __inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymGetTypeFromNameW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PCWSTR Name,
__inout PSYMBOL_INFOW Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymAddSymbol( SymAddSymbol(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 BaseOfDll, __in ULONG64 BaseOfDll,
IN PCSTR Name, __in PCSTR Name,
IN DWORD64 Address, __in DWORD64 Address,
IN DWORD Size, __in DWORD Size,
IN DWORD Flags __in DWORD Flags
);
BOOL
IMAGEAPI
SymAddSymbolW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PCWSTR Name,
__in DWORD64 Address,
__in DWORD Size,
__in DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymDeleteSymbol( SymDeleteSymbol(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 BaseOfDll, __in ULONG64 BaseOfDll,
IN PCSTR Name, __in_opt PCSTR Name,
IN DWORD64 Address, __in DWORD64 Address,
IN DWORD Flags __in DWORD Flags
);
BOOL
IMAGEAPI
SymDeleteSymbolW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCWSTR Name,
__in DWORD64 Address,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymRefreshModuleList(
__in HANDLE hProcess
);
BOOL
IMAGEAPI
SymSrvIsStoreW(
__in HANDLE hProcess,
__in PCWSTR path
);
BOOL
IMAGEAPI
SymSrvIsStore(
__in HANDLE hProcess,
__in PCSTR path
);
PCSTR
IMAGEAPI
SymSrvDeltaName(
__in HANDLE hProcess,
__in_opt PCSTR SymPath,
__in PCSTR Type,
__in PCSTR File1,
__in PCSTR File2
);
PCWSTR
IMAGEAPI
SymSrvDeltaNameW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR Type,
__in PCWSTR File1,
__in PCWSTR File2
);
PCSTR
IMAGEAPI
SymSrvGetSupplement(
__in HANDLE hProcess,
__in_opt PCSTR SymPath,
__in PCSTR Node,
__in PCSTR File
);
PCWSTR
IMAGEAPI
SymSrvGetSupplementW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR Node,
__in PCWSTR File
);
BOOL
IMAGEAPI
SymSrvGetFileIndexes(
__in PCSTR File,
__out GUID *Id,
__out PDWORD Val1,
__out_opt PDWORD Val2,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexesW(
__in PCWSTR File,
__out GUID *Id,
__out PDWORD Val1,
__out_opt PDWORD Val2,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexStringW(
__in HANDLE hProcess,
__in_opt PCWSTR SrvPath,
__in PCWSTR File,
__out_ecount(Size) PWSTR Index,
__in size_t Size,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexString(
__in HANDLE hProcess,
__in_opt PCSTR SrvPath,
__in PCSTR File,
__out_ecount(Size) PSTR Index,
__in size_t Size,
__in DWORD Flags
);
typedef struct {
DWORD sizeofstruct;
char file[MAX_PATH +1];
BOOL stripped;
DWORD timestamp;
DWORD size;
char dbgfile[MAX_PATH +1];
char pdbfile[MAX_PATH + 1];
GUID guid;
DWORD sig;
DWORD age;
} SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO;
typedef struct {
DWORD sizeofstruct;
WCHAR file[MAX_PATH +1];
BOOL stripped;
DWORD timestamp;
DWORD size;
WCHAR dbgfile[MAX_PATH +1];
WCHAR pdbfile[MAX_PATH + 1];
GUID guid;
DWORD sig;
DWORD age;
} SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW;
BOOL
IMAGEAPI
SymSrvGetFileIndexInfo(
__in PCSTR File,
__out PSYMSRV_INDEX_INFO Info,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexInfoW(
__in PCWSTR File,
__out PSYMSRV_INDEX_INFOW Info,
__in DWORD Flags
);
PCSTR
IMAGEAPI
SymSrvStoreSupplement(
__in HANDLE hProcess,
__in_opt PCSTR SrvPath,
__in PCSTR Node,
__in PCSTR File,
__in DWORD Flags
);
PCWSTR
IMAGEAPI
SymSrvStoreSupplementW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR Node,
__in PCWSTR File,
__in DWORD Flags
);
PCSTR
IMAGEAPI
SymSrvStoreFile(
__in HANDLE hProcess,
__in_opt PCSTR SrvPath,
__in PCSTR File,
__in DWORD Flags
);
PCWSTR
IMAGEAPI
SymSrvStoreFileW(
__in HANDLE hProcess,
__in_opt PCWSTR SrvPath,
__in PCWSTR File,
__in DWORD Flags
);
// used by SymGetSymbolFile's "Type" parameter
typedef enum {
sfImage = 0,
sfDbg,
sfPdb,
sfMpd,
sfMax
};
BOOL
IMAGEAPI
SymGetSymbolFile(
__in HANDLE hProcess,
__in_opt PCSTR SymPath,
__in PCSTR ImageFile,
__in DWORD Type,
__out_ecount(cSymbolFile) PSTR SymbolFile,
__in size_t cSymbolFile,
__out_ecount(cDbgFile) PSTR DbgFile,
__in size_t cDbgFile
);
BOOL
IMAGEAPI
SymGetSymbolFileW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR ImageFile,
__in DWORD Type,
__out_ecount(cSymbolFile) PWSTR SymbolFile,
__in size_t cSymbolFile,
__out_ecount(cDbgFile) PWSTR DbgFile,
__in size_t cDbgFile
); );
// //
// Full user-mode dump creation. // Full user-mode dump creation.
// //
typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)( typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(
DWORD DataType, __in DWORD DataType,
PVOID* Data, __in PVOID* Data,
LPDWORD DataLength, __out LPDWORD DataLength,
PVOID UserData __in_opt PVOID UserData
); );
BOOL BOOL
WINAPI WINAPI
DbgHelpCreateUserDump( DbgHelpCreateUserDump(
IN LPSTR FileName, __in_opt LPCSTR FileName,
IN PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback, __in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
IN PVOID UserData __in_opt PVOID UserData
); );
BOOL BOOL
WINAPI WINAPI
DbgHelpCreateUserDumpW( DbgHelpCreateUserDumpW(
IN LPWSTR FileName, __in_opt LPCWSTR FileName,
IN PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback, __in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
IN PVOID UserData __in_opt PVOID UserData
); );
// ----------------------------------------------------------------- // -----------------------------------------------------------------
// The following 4 legacy APIs are fully supported, but newer // The following 4 legacy APIs are fully supported, but newer
// ones are recommended. SymFromName and SymFromAddr provide // ones are recommended. SymFromName and SymFromAddr provide
// much more detailed info on the returned symbol. // much more detailed info on the returned symbol.
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymFromAddr64( SymGetSymFromAddr64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD64 qwAddr, __in DWORD64 qwAddr,
OUT PDWORD64 pdwDisplacement, __out_opt PDWORD64 pdwDisplacement,
OUT PIMAGEHLP_SYMBOL64 Symbol __inout PIMAGEHLP_SYMBOL64 Symbol
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymFromAddr SymGetSymFromAddr64 #define SymGetSymFromAddr SymGetSymFromAddr64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymFromAddr( SymGetSymFromAddr(
IN HANDLE hProcess, __in HANDLE hProcess,
IN DWORD dwAddr, __in DWORD dwAddr,
OUT PDWORD pdwDisplacement, __out_opt PDWORD pdwDisplacement,
OUT PIMAGEHLP_SYMBOL Symbol __inout PIMAGEHLP_SYMBOL Symbol
); );
#endif #endif
// While following two APIs will provide a symbol from a name, // While following two APIs will provide a symbol from a name,
// SymEnumSymbols can provide the same matching information // SymEnumSymbols can provide the same matching information
// for ALL symbols with a matching name, even regular // for ALL symbols with a matching name, even regular
// expressions. That way you can search across modules // expressions. That way you can search across modules
// and differentiate between identically named symbols. // and differentiate between identically named symbols.
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymFromName64( SymGetSymFromName64(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSTR Name, __in PCSTR Name,
OUT PIMAGEHLP_SYMBOL64 Symbol __inout PIMAGEHLP_SYMBOL64 Symbol
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymFromName SymGetSymFromName64 #define SymGetSymFromName SymGetSymFromName64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymFromName( SymGetSymFromName(
IN HANDLE hProcess, __in HANDLE hProcess,
IN PSTR Name, __in PCSTR Name,
OUT PIMAGEHLP_SYMBOL Symbol __inout PIMAGEHLP_SYMBOL Symbol
); );
#endif #endif
// Symbol server exports
typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR
);
typedef BOOL (WINAPI *PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PST
R);
typedef BOOL (WINAPI *PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, P
WSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROC)(PCSTR, PCSTR, PCSTR, PSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCA)(PCSTR, PCSTR, PCSTR, PSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCW)(PCWSTR, PCWSTR, PCWSTR, PWSTR);
typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSWPROC)(UINT_PTR, ULONG64);
typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action, ULONG
64 data, ULONG64 context);
typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(PCSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROCA)(PCSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROCW)(PCWSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERGETVERSION)(LPAPI_VERSION);
typedef BOOL (WINAPI *PSYMBOLSERVERDELTANAME)(PCSTR, PVOID, DWORD, DWORD, PVOID,
DWORD, DWORD, PSTR, size_t);
typedef BOOL (WINAPI *PSYMBOLSERVERDELTANAMEW)(PCWSTR, PVOID, DWORD, DWORD, PVOI
D, DWORD, DWORD, PWSTR, size_t);
typedef BOOL (WINAPI *PSYMBOLSERVERGETSUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, siz
e_t);
typedef BOOL (WINAPI *PSYMBOLSERVERGETSUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR
, size_t);
typedef BOOL (WINAPI *PSYMBOLSERVERSTORESUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, s
ize_t, DWORD);
typedef BOOL (WINAPI *PSYMBOLSERVERSTORESUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWS
TR, size_t, DWORD);
typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRING)(PVOID, DWORD, DWORD, PSTR, si
ze_t);
typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRINGW)(PVOID, DWORD, DWORD, PWSTR,
size_t);
typedef BOOL (WINAPI *PSYMBOLSERVERSTOREFILE)(PCSTR, PCSTR, PVOID, DWORD, DWORD,
PSTR, size_t, DWORD);
typedef BOOL (WINAPI *PSYMBOLSERVERSTOREFILEW)(PCWSTR, PCWSTR, PVOID, DWORD, DWO
RD, PWSTR, size_t, DWORD);
typedef BOOL (WINAPI *PSYMBOLSERVERISSTORE)(PCSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERISSTOREW)(PCWSTR);
typedef DWORD (WINAPI *PSYMBOLSERVERVERSION)();
typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERMESSAGEPROC)(UINT_PTR action, ULONG6
4 data, ULONG64 context);
#define SYMSRV_VERSION 2
#define SSRVOPT_CALLBACK 0x000001
#define SSRVOPT_DWORD 0x000002
#define SSRVOPT_DWORDPTR 0x000004
#define SSRVOPT_GUIDPTR 0x000008
#define SSRVOPT_OLDGUIDPTR 0x000010
#define SSRVOPT_UNATTENDED 0x000020
#define SSRVOPT_NOCOPY 0x000040
#define SSRVOPT_GETPATH 0x000040
#define SSRVOPT_PARENTWIN 0x000080
#define SSRVOPT_PARAMTYPE 0x000100
#define SSRVOPT_SECURE 0x000200
#define SSRVOPT_TRACE 0x000400
#define SSRVOPT_SETCONTEXT 0x000800
#define SSRVOPT_PROXY 0x001000
#define SSRVOPT_DOWNSTREAM_STORE 0x002000
#define SSRVOPT_OVERWRITE 0x004000
#define SSRVOPT_RESETTOU 0x008000
#define SSRVOPT_CALLBACKW 0x010000
#define SSRVOPT_FLAT_DEFAULT_STORE 0x020000
#define SSRVOPT_PROXYW 0x040000
#define SSRVOPT_MESSAGE 0x080000
#define SSRVOPT_SERVICE 0x100000 // deprecated
#define SSRVOPT_FAVOR_COMPRESSED 0x200000
#define SSRVOPT_MAX 0x40000
#define SSRVOPT_RESET ((ULONG_PTR)-1)
#define NUM_SSRVOPTS 30
#define SSRVACTION_TRACE 1
#define SSRVACTION_QUERYCANCEL 2
#define SSRVACTION_EVENT 3
#define SSRVACTION_EVENTW 4
#define SYMSTOREOPT_COMPRESS 0x01
#define SYMSTOREOPT_OVERWRITE 0x02
#define SYMSTOREOPT_RETURNINDEX 0x04
#define SYMSTOREOPT_POINTER 0x08
#define SYMSTOREOPT_ALT_INDEX 0x10
#define SYMSTOREOPT_UNICODE 0x20
#define SYMSTOREOPT_PASS_IF_EXISTS 0x40
#ifdef DBGHELP_TRANSLATE_TCHAR
#define SymInitialize SymInitializeW
#define SymAddSymbol SymAddSymbolW
#define SymDeleteSymbol SymDeleteSymbolW
#define SearchTreeForFile SearchTreeForFileW
#define UnDecorateSymbolName UnDecorateSymbolNameW
#define SymGetLineFromName64 SymGetLineFromNameW64
#define SymGetLineFromAddr64 SymGetLineFromAddrW64
#define SymGetLineNext64 SymGetLineNextW64
#define SymGetLinePrev64 SymGetLinePrevW64
#define SymFromName SymFromNameW
#define SymFindExecutableImage SymFindExecutableImageW
#define FindExecutableImageEx FindExecutableImageExW
#define SymSearch SymSearchW
#define SymEnumLines SymEnumLinesW
#define SymEnumSourceLines SymEnumSourceLinesW
#define SymGetTypeFromName SymGetTypeFromNameW
#define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW
#define SymFromAddr SymFromAddrW
#define SymMatchString SymMatchStringW
#define SymEnumSourceFiles SymEnumSourceFilesW
#define SymEnumSymbols SymEnumSymbolsW
#define SymLoadModuleEx SymLoadModuleExW
#define SymSetSearchPath SymSetSearchPathW
#define SymGetSearchPath SymGetSearchPathW
#define EnumDirTree EnumDirTreeW
#define SymFromToken SymFromTokenW
#define SymFromIndex SymFromIndexW
#define SymGetScope SymGetScopeW
#define SymNext SymNextW
#define SymPrev SymPrevW
#define SymEnumTypes SymEnumTypesW
#define SymRegisterCallback64 SymRegisterCallbackW64
#define SymFindDebugInfoFile SymFindDebugInfoFileW
#define FindDebugInfoFileEx FindDebugInfoFileExW
#define SymFindFileInPath SymFindFileInPathW
#define SymEnumerateModules64 SymEnumerateModulesW64
#define SymSetHomeDirectory SymSetHomeDirectoryW
#define SymGetHomeDirectory SymGetHomeDirectoryW
#define SymGetSourceFile SymGetSourceFileW
#define SymGetSourceFileToken SymGetSourceFileTokenW
#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
#define SymGetSourceFileToken SymGetSourceFileTokenW
#define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64
#define SymFindFileInPath SymFindFileInPathW
#define SymMatchFileName SymMatchFileNameW
#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
#define SymGetModuleInfo64 SymGetModuleInfoW64
#define SymSrvIsStore SymSrvIsStoreW
#define SymSrvDeltaName SymSrvDeltaNameW
#define SymSrvGetSupplement SymSrvGetSupplementW
#define SymSrvStoreSupplement SymSrvStoreSupplementW
#define SymSrvGetFileIndexes SymSrvGetFileIndexes
#define SymSrvGetFileIndexString SymSrvGetFileIndexStringW
#define SymSrvStoreFile SymSrvStoreFileW
#define SymGetSymbolFile SymGetSymbolFileW
#define EnumerateLoadedModules64 EnumerateLoadedModulesW64
#define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW
#define IMAGEHLP_LINE64 IMAGEHLP_LINEW64
#define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64
#define SYMBOL_INFO SYMBOL_INFOW
#define PSYMBOL_INFO PSYMBOL_INFOW
#define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW
#define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW
#define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW
#define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW
#define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW
#define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW
#define SRCCODEINFO SRCCODEINFOW
#define PSRCCODEINFO PSRCCODEINFOW
#define SOURCEFILE SOURCEFILEW
#define PSOURCEFILE PSOURCEFILEW
#define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW
#define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW
#define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW
#define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW
#define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64
#define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW
#define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW
#define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64
#define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64
#define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOw
#define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW
#define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW
#define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW
#endif
// ----------------------------------------------------------------- // -----------------------------------------------------------------
// The following APIs exist only for backwards compatibility // The following APIs exist only for backwards compatibility
// with a pre-release version documented in an MSDN release. // with a pre-release version documented in an MSDN release.
// You should use SymFindFileInPath if you want to maintain // You should use SymFindFileInPath if you want to maintain
// future compatibility. // future compatibility.
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
FindFileInPath( FindFileInPath(
HANDLE hprocess, __in HANDLE hprocess,
LPSTR SearchPath, __in PCSTR SearchPath,
LPSTR FileName, __in PCSTR FileName,
PVOID id, __in PVOID id,
DWORD two, __in DWORD two,
DWORD three, __in DWORD three,
DWORD flags, __in DWORD flags,
LPSTR FilePath __out_ecount(MAX_PATH + 1) PSTR FilePath
); );
// You should use SymFindFileInPath if you want to maintain // You should use SymFindFileInPath if you want to maintain
// future compatibility. // future compatibility.
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
FindFileInSearchPath( FindFileInSearchPath(
HANDLE hprocess, __in HANDLE hprocess,
LPSTR SearchPath, __in PCSTR SearchPath,
LPSTR FileName, __in PCSTR FileName,
DWORD one, __in DWORD one,
DWORD two, __in DWORD two,
DWORD three, __in DWORD three,
LPSTR FilePath __out_ecount(MAX_PATH + 1) PSTR FilePath
); );
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSym( SymEnumSym(
IN HANDLE hProcess, __in HANDLE hProcess,
IN ULONG64 BaseOfDll, __in ULONG64 BaseOfDll,
IN PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
IN PVOID UserContext __in_opt PVOID UserContext
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbols64(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,
__in_opt PVOID UserContext
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbolsW64(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,
__in_opt PVOID UserContext
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateSymbols SymEnumerateSymbols64
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
#else
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbols(
__in HANDLE hProcess,
__in ULONG BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbolsW(
__in HANDLE hProcess,
__in ULONG BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
#endif
// use SymLoadModuleEx
DWORD64
IMAGEAPI
SymLoadModule64(
__in HANDLE hProcess,
__in_opt HANDLE hFile,
__in_opt PCSTR ImageName,
__in_opt PCSTR ModuleName,
__in DWORD64 BaseOfDll,
__in DWORD SizeOfDll
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymLoadModule SymLoadModule64
#else
DWORD
IMAGEAPI
SymLoadModule(
__in HANDLE hProcess,
__in_opt HANDLE hFile,
__in_opt PCSTR ImageName,
__in_opt PCSTR ModuleName,
__in DWORD BaseOfDll,
__in DWORD SizeOfDll
);
#endif
BOOL
IMAGEAPI
SymGetSymNext64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL64 Symbol
);
BOOL
IMAGEAPI
SymGetSymNextW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymNext SymGetSymNext64
#define SymGetSymNextW SymGetSymNextW64
#else
BOOL
IMAGEAPI
SymGetSymNext(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL Symbol
);
BOOL
IMAGEAPI
SymGetSymNextW(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW Symbol
);
#endif
BOOL
IMAGEAPI
SymGetSymPrev64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL64 Symbol
);
BOOL
IMAGEAPI
SymGetSymPrevW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymPrev SymGetSymPrev64
#define SymGetSymPrevW SymGetSymPrevW64
#else
BOOL
IMAGEAPI
SymGetSymPrev(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL Symbol
);
BOOL
IMAGEAPI
SymGetSymPrevW(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW Symbol
); );
#endif
// These values should not be used. // These values should not be used.
// They have been replaced by SYMFLAG_ values. // They have been replaced by SYMFLAG_ values.
#define SYMF_OMAP_GENERATED 0x00000001 #define SYMF_OMAP_GENERATED 0x00000001
#define SYMF_OMAP_MODIFIED 0x00000002 #define SYMF_OMAP_MODIFIED 0x00000002
#define SYMF_REGISTER 0x00000008 #define SYMF_REGISTER 0x00000008
#define SYMF_REGREL 0x00000010 #define SYMF_REGREL 0x00000010
#define SYMF_FRAMEREL 0x00000020 #define SYMF_FRAMEREL 0x00000020
#define SYMF_PARAMETER 0x00000040 #define SYMF_PARAMETER 0x00000040
skipping to change at line 2115 skipping to change at line 3456
ExceptionStream = 6, ExceptionStream = 6,
SystemInfoStream = 7, SystemInfoStream = 7,
ThreadExListStream = 8, ThreadExListStream = 8,
Memory64ListStream = 9, Memory64ListStream = 9,
CommentStreamA = 10, CommentStreamA = 10,
CommentStreamW = 11, CommentStreamW = 11,
HandleDataStream = 12, HandleDataStream = 12,
FunctionTableStream = 13, FunctionTableStream = 13,
UnloadedModuleListStream = 14, UnloadedModuleListStream = 14,
MiscInfoStream = 15, MiscInfoStream = 15,
MemoryInfoListStream = 16,
ThreadInfoListStream = 17,
HandleOperationListStream = 18,
ceStreamNull = 0x8000,
ceStreamSystemInfo = 0x8001,
ceStreamException = 0x8002,
ceStreamModuleList = 0x8003,
ceStreamProcessList = 0x8004,
ceStreamThreadList = 0x8005,
ceStreamThreadContextList = 0x8006,
ceStreamThreadCallStackList = 0x8007,
ceStreamMemoryVirtualList = 0x8008,
ceStreamMemoryPhysicalList = 0x8009,
ceStreamBucketParameters = 0x800A,
LastReservedStream = 0xffff LastReservedStream = 0xffff
} MINIDUMP_STREAM_TYPE; } MINIDUMP_STREAM_TYPE;
// //
// The minidump system information contains processor and // The minidump system information contains processor and
// Operating System specific information. // Operating System specific information.
// //
skipping to change at line 2377 skipping to change at line 3733
DWORD ThreadId; DWORD ThreadId;
ULONG64 ExceptionRecord; ULONG64 ExceptionRecord;
ULONG64 ContextRecord; ULONG64 ContextRecord;
BOOL ClientPointers; BOOL ClientPointers;
} MINIDUMP_EXCEPTION_INFORMATION64, *PMINIDUMP_EXCEPTION_INFORMATION64; } MINIDUMP_EXCEPTION_INFORMATION64, *PMINIDUMP_EXCEPTION_INFORMATION64;
// //
// Support for capturing system handle state at the time of the dump. // Support for capturing system handle state at the time of the dump.
// //
// Per-handle object information varies according to
// the OS, the OS version, the processor type and
// so on. The minidump gives a minidump identifier
// to each possible data format for identification
// purposes but does not control nor describe the actual data.
typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
MiniHandleObjectInformationNone,
MiniThreadInformation1,
MiniMutantInformation1,
MiniMutantInformation2,
MiniProcessInformation1,
MiniProcessInformation2,
MiniHandleObjectInformationTypeMax
} MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION {
RVA NextInfoRva;
ULONG32 InfoType;
ULONG32 SizeOfInfo;
// Raw information follows.
} MINIDUMP_HANDLE_OBJECT_INFORMATION;
typedef struct _MINIDUMP_HANDLE_DESCRIPTOR { typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
ULONG64 Handle; ULONG64 Handle;
RVA TypeNameRva; RVA TypeNameRva;
RVA ObjectNameRva; RVA ObjectNameRva;
ULONG32 Attributes; ULONG32 Attributes;
ULONG32 GrantedAccess; ULONG32 GrantedAccess;
ULONG32 HandleCount; ULONG32 HandleCount;
ULONG32 PointerCount; ULONG32 PointerCount;
} MINIDUMP_HANDLE_DESCRIPTOR, *PMINIDUMP_HANDLE_DESCRIPTOR; } MINIDUMP_HANDLE_DESCRIPTOR, *PMINIDUMP_HANDLE_DESCRIPTOR;
typedef struct _MINIDUMP_HANDLE_DESCRIPTOR_2 {
ULONG64 Handle;
RVA TypeNameRva;
RVA ObjectNameRva;
ULONG32 Attributes;
ULONG32 GrantedAccess;
ULONG32 HandleCount;
ULONG32 PointerCount;
RVA ObjectInfoRva;
ULONG32 Reserved0;
} MINIDUMP_HANDLE_DESCRIPTOR_2, *PMINIDUMP_HANDLE_DESCRIPTOR_2;
// The latest MINIDUMP_HANDLE_DESCRIPTOR definition.
typedef MINIDUMP_HANDLE_DESCRIPTOR_2 MINIDUMP_HANDLE_DESCRIPTOR_N;
typedef MINIDUMP_HANDLE_DESCRIPTOR_N *PMINIDUMP_HANDLE_DESCRIPTOR_N;
typedef struct _MINIDUMP_HANDLE_DATA_STREAM { typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
ULONG32 SizeOfHeader; ULONG32 SizeOfHeader;
ULONG32 SizeOfDescriptor; ULONG32 SizeOfDescriptor;
ULONG32 NumberOfDescriptors; ULONG32 NumberOfDescriptors;
ULONG32 Reserved; ULONG32 Reserved;
} MINIDUMP_HANDLE_DATA_STREAM, *PMINIDUMP_HANDLE_DATA_STREAM; } MINIDUMP_HANDLE_DATA_STREAM, *PMINIDUMP_HANDLE_DATA_STREAM;
// Some operating systems can track the last operations
// performed on a handle. For example, Application Verifier
// can enable this for some versions of Windows. The
// handle operation list collects handle operations
// known for the dump target.
// Each entry is an AVRF_HANDLE_OPERATION.
typedef struct _MINIDUMP_HANDLE_OPERATION_LIST {
ULONG32 SizeOfHeader;
ULONG32 SizeOfEntry;
ULONG32 NumberOfEntries;
ULONG32 Reserved;
} MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST;
// //
// Support for capturing dynamic function table state at the time of the dump. // Support for capturing dynamic function table state at the time of the dump.
// //
typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR { typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
ULONG64 MinimumAddress; ULONG64 MinimumAddress;
ULONG64 MaximumAddress; ULONG64 MaximumAddress;
ULONG64 BaseAddress; ULONG64 BaseAddress;
ULONG32 EntryCount; ULONG32 EntryCount;
ULONG32 SizeOfAlignPad; ULONG32 SizeOfAlignPad;
skipping to change at line 2447 skipping to change at line 3854
ULONG32 NumberOfEntries; ULONG32 NumberOfEntries;
} MINIDUMP_UNLOADED_MODULE_LIST, *PMINIDUMP_UNLOADED_MODULE_LIST; } MINIDUMP_UNLOADED_MODULE_LIST, *PMINIDUMP_UNLOADED_MODULE_LIST;
// //
// The miscellaneous information stream contains a variety // The miscellaneous information stream contains a variety
// of small pieces of information. A member is valid if // of small pieces of information. A member is valid if
// it's within the available size and its corresponding // it's within the available size and its corresponding
// bit is set. // bit is set.
// //
#define MINIDUMP_MISC1_PROCESS_ID 0x00000001 #define MINIDUMP_MISC1_PROCESS_ID 0x00000001
#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
#define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004
typedef struct _MINIDUMP_MISC_INFO { typedef struct _MINIDUMP_MISC_INFO {
ULONG32 SizeOfInfo; ULONG32 SizeOfInfo;
ULONG32 Flags1; ULONG32 Flags1;
ULONG32 ProcessId; ULONG32 ProcessId;
ULONG32 ProcessCreateTime; ULONG32 ProcessCreateTime;
ULONG32 ProcessUserTime; ULONG32 ProcessUserTime;
ULONG32 ProcessKernelTime; ULONG32 ProcessKernelTime;
} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO; } MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
typedef struct _MINIDUMP_MISC_INFO_2 {
ULONG32 SizeOfInfo;
ULONG32 Flags1;
ULONG32 ProcessId;
ULONG32 ProcessCreateTime;
ULONG32 ProcessUserTime;
ULONG32 ProcessKernelTime;
ULONG32 ProcessorMaxMhz;
ULONG32 ProcessorCurrentMhz;
ULONG32 ProcessorMhzLimit;
ULONG32 ProcessorMaxIdleState;
ULONG32 ProcessorCurrentIdleState;
} MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2;
// The latest MINIDUMP_MISC_INFO definition.
typedef MINIDUMP_MISC_INFO_2 MINIDUMP_MISC_INFO_N;
typedef MINIDUMP_MISC_INFO_N* PMINIDUMP_MISC_INFO_N;
//
// The memory information stream contains memory region
// description information. This stream corresponds to
// what VirtualQuery would return for the process the
// dump was created for.
//
typedef struct _MINIDUMP_MEMORY_INFO {
ULONG64 BaseAddress;
ULONG64 AllocationBase;
ULONG32 AllocationProtect;
ULONG32 __alignment1;
ULONG64 RegionSize;
ULONG32 State;
ULONG32 Protect;
ULONG32 Type;
ULONG32 __alignment2;
} MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO;
typedef struct _MINIDUMP_MEMORY_INFO_LIST {
ULONG SizeOfHeader;
ULONG SizeOfEntry;
ULONG64 NumberOfEntries;
} MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST;
//
// The memory information stream contains memory region
// description information. This stream corresponds to
// what VirtualQuery would return for the process the
// dump was created for.
//
// Thread dump writer status flags.
#define MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001
#define MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002
#define MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004
#define MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008
#define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010
#define MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020
typedef struct _MINIDUMP_THREAD_INFO {
ULONG32 ThreadId;
ULONG32 DumpFlags;
ULONG32 DumpError;
ULONG32 ExitStatus;
ULONG64 CreateTime;
ULONG64 ExitTime;
ULONG64 KernelTime;
ULONG64 UserTime;
ULONG64 StartAddress;
ULONG64 Affinity;
} MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO;
typedef struct _MINIDUMP_THREAD_INFO_LIST {
ULONG SizeOfHeader;
ULONG SizeOfEntry;
ULONG NumberOfEntries;
} MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST;
// //
// Support for arbitrary user-defined information. // Support for arbitrary user-defined information.
// //
typedef struct _MINIDUMP_USER_RECORD { typedef struct _MINIDUMP_USER_RECORD {
ULONG32 Type; ULONG32 Type;
MINIDUMP_LOCATION_DESCRIPTOR Memory; MINIDUMP_LOCATION_DESCRIPTOR Memory;
} MINIDUMP_USER_RECORD, *PMINIDUMP_USER_RECORD; } MINIDUMP_USER_RECORD, *PMINIDUMP_USER_RECORD;
typedef struct _MINIDUMP_USER_STREAM { typedef struct _MINIDUMP_USER_STREAM {
skipping to change at line 2491 skipping to change at line 3976
// Callback support. // Callback support.
// //
typedef enum _MINIDUMP_CALLBACK_TYPE { typedef enum _MINIDUMP_CALLBACK_TYPE {
ModuleCallback, ModuleCallback,
ThreadCallback, ThreadCallback,
ThreadExCallback, ThreadExCallback,
IncludeThreadCallback, IncludeThreadCallback,
IncludeModuleCallback, IncludeModuleCallback,
MemoryCallback, MemoryCallback,
CancelCallback,
WriteKernelMinidumpCallback,
KernelMinidumpStatusCallback,
RemoveMemoryCallback,
IncludeVmRegionCallback,
IoStartCallback,
IoWriteAllCallback,
IoFinishCallback,
ReadMemoryFailureCallback,
SecondaryFlagsCallback,
} MINIDUMP_CALLBACK_TYPE; } MINIDUMP_CALLBACK_TYPE;
typedef struct _MINIDUMP_THREAD_CALLBACK { typedef struct _MINIDUMP_THREAD_CALLBACK {
ULONG ThreadId; ULONG ThreadId;
HANDLE ThreadHandle; HANDLE ThreadHandle;
CONTEXT Context; CONTEXT Context;
ULONG SizeOfContext; ULONG SizeOfContext;
ULONG64 StackBase; ULONG64 StackBase;
ULONG64 StackEnd; ULONG64 StackEnd;
} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK; } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
skipping to change at line 2524 skipping to change at line 4019
ULONG ThreadId; ULONG ThreadId;
} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK; } MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
typedef enum _THREAD_WRITE_FLAGS { typedef enum _THREAD_WRITE_FLAGS {
ThreadWriteThread = 0x0001, ThreadWriteThread = 0x0001,
ThreadWriteStack = 0x0002, ThreadWriteStack = 0x0002,
ThreadWriteContext = 0x0004, ThreadWriteContext = 0x0004,
ThreadWriteBackingStore = 0x0008, ThreadWriteBackingStore = 0x0008,
ThreadWriteInstructionWindow = 0x0010, ThreadWriteInstructionWindow = 0x0010,
ThreadWriteThreadData = 0x0020, ThreadWriteThreadData = 0x0020,
ThreadWriteThreadInfo = 0x0040,
} THREAD_WRITE_FLAGS; } THREAD_WRITE_FLAGS;
typedef struct _MINIDUMP_MODULE_CALLBACK { typedef struct _MINIDUMP_MODULE_CALLBACK {
PWCHAR FullPath; PWCHAR FullPath;
ULONG64 BaseOfImage; ULONG64 BaseOfImage;
ULONG SizeOfImage; ULONG SizeOfImage;
ULONG CheckSum; ULONG CheckSum;
ULONG TimeDateStamp; ULONG TimeDateStamp;
VS_FIXEDFILEINFO VersionInfo; VS_FIXEDFILEINFO VersionInfo;
PVOID CvRecord; PVOID CvRecord;
skipping to change at line 2548 skipping to change at line 4044
typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK { typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK {
ULONG64 BaseOfImage; ULONG64 BaseOfImage;
} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK; } MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
typedef enum _MODULE_WRITE_FLAGS { typedef enum _MODULE_WRITE_FLAGS {
ModuleWriteModule = 0x0001, ModuleWriteModule = 0x0001,
ModuleWriteDataSeg = 0x0002, ModuleWriteDataSeg = 0x0002,
ModuleWriteMiscRecord = 0x0004, ModuleWriteMiscRecord = 0x0004,
ModuleWriteCvRecord = 0x0008, ModuleWriteCvRecord = 0x0008,
ModuleReferencedByMemory = 0x0010 ModuleReferencedByMemory = 0x0010,
ModuleWriteTlsData = 0x0020,
ModuleWriteCodeSegs = 0x0040,
} MODULE_WRITE_FLAGS; } MODULE_WRITE_FLAGS;
typedef struct _MINIDUMP_IO_CALLBACK {
HANDLE Handle;
ULONG64 Offset;
PVOID Buffer;
ULONG BufferBytes;
} MINIDUMP_IO_CALLBACK, *PMINIDUMP_IO_CALLBACK;
typedef struct _MINIDUMP_READ_MEMORY_FAILURE_CALLBACK
{
ULONG64 Offset;
ULONG Bytes;
HRESULT FailureStatus;
} MINIDUMP_READ_MEMORY_FAILURE_CALLBACK,
*PMINIDUMP_READ_MEMORY_FAILURE_CALLBACK;
typedef struct _MINIDUMP_CALLBACK_INPUT { typedef struct _MINIDUMP_CALLBACK_INPUT {
ULONG ProcessId; ULONG ProcessId;
HANDLE ProcessHandle; HANDLE ProcessHandle;
ULONG CallbackType; ULONG CallbackType;
union { union {
HRESULT Status;
MINIDUMP_THREAD_CALLBACK Thread; MINIDUMP_THREAD_CALLBACK Thread;
MINIDUMP_THREAD_EX_CALLBACK ThreadEx; MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
MINIDUMP_MODULE_CALLBACK Module; MINIDUMP_MODULE_CALLBACK Module;
MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
MINIDUMP_IO_CALLBACK Io;
MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure;
ULONG SecondaryFlags;
}; };
} MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT; } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
typedef struct _MINIDUMP_CALLBACK_OUTPUT { typedef struct _MINIDUMP_CALLBACK_OUTPUT {
union { union {
ULONG ModuleWriteFlags; ULONG ModuleWriteFlags;
ULONG ThreadWriteFlags; ULONG ThreadWriteFlags;
ULONG SecondaryFlags;
struct { struct {
ULONG64 MemoryBase; ULONG64 MemoryBase;
ULONG MemorySize; ULONG MemorySize;
}; };
struct {
BOOL CheckCancel;
BOOL Cancel;
};
HANDLE Handle;
struct {
MINIDUMP_MEMORY_INFO VmRegion;
BOOL Continue;
};
HRESULT Status;
}; };
} MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
// //
// A normal minidump contains just the information // A normal minidump contains just the information
// necessary to capture stack traces for all of the // necessary to capture stack traces for all of the
// existing threads in a process. // existing threads in a process.
// //
// A minidump with data segments includes all of the data // A minidump with data segments includes all of the data
// sections from loaded modules in order to capture // sections from loaded modules in order to capture
skipping to change at line 2630 skipping to change at line 4158
// The virtual address space can be scanned for various types // The virtual address space can be scanned for various types
// of memory to be included in the dump. // of memory to be included in the dump.
// //
// Code which is concerned with potentially private information // Code which is concerned with potentially private information
// getting into the minidump can set a flag that automatically // getting into the minidump can set a flag that automatically
// modifies all existing and future flags to avoid placing // modifies all existing and future flags to avoid placing
// unnecessary data in the dump. Basic data, such as stack // unnecessary data in the dump. Basic data, such as stack
// information, will still be included but optional data, such // information, will still be included but optional data, such
// as indirect memory, will not. // as indirect memory, will not.
// //
// When doing a full memory dump it's possible to store all
// of the enumerated memory region descriptive information
// in a memory information stream.
//
// Additional thread information beyond the basic thread
// structure can be collected if desired.
//
// A minidump with code segments includes all of the code
// and code-related sections from loaded modules in order
// to capture executable content.
//
// MiniDumpWithoutAuxiliaryState turns off any secondary,
// auxiliary-supported memory gathering.
//
// MiniDumpWithFullAuxiliaryState asks any present auxiliary
// data providers to include all of their state in the dump.
// The exact set of what is provided depends on the auxiliary.
// This can be quite large.
//
typedef enum _MINIDUMP_TYPE { typedef enum _MINIDUMP_TYPE {
MiniDumpNormal = 0x0000, MiniDumpNormal = 0x00000000,
MiniDumpWithDataSegs = 0x0001, MiniDumpWithDataSegs = 0x00000001,
MiniDumpWithFullMemory = 0x0002, MiniDumpWithFullMemory = 0x00000002,
MiniDumpWithHandleData = 0x0004, MiniDumpWithHandleData = 0x00000004,
MiniDumpFilterMemory = 0x0008, MiniDumpFilterMemory = 0x00000008,
MiniDumpScanMemory = 0x0010, MiniDumpScanMemory = 0x00000010,
MiniDumpWithUnloadedModules = 0x0020, MiniDumpWithUnloadedModules = 0x00000020,
MiniDumpWithIndirectlyReferencedMemory = 0x0040, MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
MiniDumpFilterModulePaths = 0x0080, MiniDumpFilterModulePaths = 0x00000080,
MiniDumpWithProcessThreadData = 0x0100, MiniDumpWithProcessThreadData = 0x00000100,
MiniDumpWithPrivateReadWriteMemory = 0x0200, MiniDumpWithPrivateReadWriteMemory = 0x00000200,
MiniDumpWithoutOptionalData = 0x0400, MiniDumpWithoutOptionalData = 0x00000400,
MiniDumpWithFullMemoryInfo = 0x00000800,
MiniDumpWithThreadInfo = 0x00001000,
MiniDumpWithCodeSegs = 0x00002000,
MiniDumpWithoutAuxiliaryState = 0x00004000,
MiniDumpWithFullAuxiliaryState = 0x00008000,
MiniDumpValidTypeFlags = 0x0000ffff,
} MINIDUMP_TYPE; } MINIDUMP_TYPE;
// //
// In addition to the primary flags provided to
// MiniDumpWriteDump there are additional, less
// frequently used options queried via the secondary
// flags callback.
//
// MiniSecondaryWithoutPowerInfo suppresses the minidump
// query that retrieves processor power information for
// MINIDUMP_MISC_INFO.
//
typedef enum _MINIDUMP_SECONDARY_FLAGS {
MiniSecondaryWithoutPowerInfo = 0x00000001,
MiniSecondaryValidFlags = 0x00000001,
} MINIDUMP_SECONDARY_FLAGS;
//
// The minidump callback should modify the FieldsToWrite parameter to reflect // The minidump callback should modify the FieldsToWrite parameter to reflect
// what portions of the specified thread or module should be written to the // what portions of the specified thread or module should be written to the
// file. // file.
// //
typedef typedef
BOOL BOOL
(WINAPI * MINIDUMP_CALLBACK_ROUTINE) ( (WINAPI * MINIDUMP_CALLBACK_ROUTINE) (
IN PVOID CallbackParam, IN PVOID CallbackParam,
IN CONST PMINIDUMP_CALLBACK_INPUT CallbackInput, IN CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,
 End of changes. 193 change blocks. 
724 lines changed or deleted 2255 lines changed or added

This html diff was produced by rfcdiff 1.41.