mirror of
git://source.winehq.org/git/wine.git
synced 2024-08-31 10:44:06 +00:00
![Austin English](/assets/img/avatar_default.png)
Signed-off-by: Austin English <austinenglish@gmail.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
1537 lines
56 KiB
C
1537 lines
56 KiB
C
/*
|
|
* Declarations for DBGHELP
|
|
*
|
|
* Copyright (C) 2003 Eric Pouech
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#ifndef __WINE_DBGHELP_H
|
|
#define __WINE_DBGHELP_H
|
|
|
|
/* A set of documentation macros (see also imagehlp.h) */
|
|
#ifndef __deref_out
|
|
# define __deref_out
|
|
#endif
|
|
#ifndef __deref_out_opt
|
|
# define __deref_out_opt
|
|
#endif
|
|
#ifndef __deref_opt_out
|
|
# define __deref_opt_out
|
|
#endif
|
|
#ifndef __in
|
|
# define __in
|
|
#endif
|
|
#ifndef __in_opt
|
|
# define __in_opt
|
|
#endif
|
|
#ifndef __in_bcount
|
|
# define __in_bcount(x)
|
|
#endif
|
|
#ifndef __in_bcount_opt
|
|
# define __in_bcount_opt(x)
|
|
#endif
|
|
#ifndef __in_ecount
|
|
# define __in_ecount(x)
|
|
#endif
|
|
#ifndef __inout
|
|
# define __inout
|
|
#endif
|
|
#ifndef __inout_opt
|
|
# define __inout_opt
|
|
#endif
|
|
#ifndef __inout_bcount
|
|
# define __inout_bcount(x)
|
|
#endif
|
|
#ifndef __inout_ecount
|
|
# define __inout_ecount(x)
|
|
#endif
|
|
#ifndef __out
|
|
# define __out
|
|
#endif
|
|
#ifndef __out_opt
|
|
# define __out_opt
|
|
#endif
|
|
#ifndef __out_bcount
|
|
# define __out_bcount(x)
|
|
#endif
|
|
#ifndef __out_bcount_opt
|
|
# define __out_bcount_opt(x)
|
|
#endif
|
|
#ifndef __out_ecount
|
|
# define __out_ecount(x)
|
|
#endif
|
|
#ifndef __out_ecount_opt
|
|
# define __out_ecount_opt(x)
|
|
#endif
|
|
#ifndef __out_xcount
|
|
# define __out_xcount(x)
|
|
#endif
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
#ifdef _WIN64
|
|
#ifndef _IMAGEHLP64
|
|
#define _IMAGEHLP64
|
|
#endif
|
|
#endif
|
|
|
|
#define IMAGEAPI WINAPI
|
|
#define DBHLPAPI IMAGEAPI
|
|
|
|
typedef struct _LOADED_IMAGE
|
|
{
|
|
PSTR ModuleName;
|
|
HANDLE hFile;
|
|
PUCHAR MappedAddress;
|
|
PIMAGE_NT_HEADERS FileHeader;
|
|
PIMAGE_SECTION_HEADER LastRvaSection;
|
|
ULONG NumberOfSections;
|
|
PIMAGE_SECTION_HEADER Sections;
|
|
ULONG Characteristics;
|
|
BOOLEAN fSystemImage;
|
|
BOOLEAN fDOSImage;
|
|
BOOLEAN fReadOnly;
|
|
UCHAR Version;
|
|
LIST_ENTRY Links;
|
|
ULONG SizeOfImage;
|
|
} LOADED_IMAGE, *PLOADED_IMAGE;
|
|
|
|
/*************************
|
|
* IMAGEHLP equiv *
|
|
*************************/
|
|
|
|
typedef enum
|
|
{
|
|
AddrMode1616,
|
|
AddrMode1632,
|
|
AddrModeReal,
|
|
AddrModeFlat
|
|
} ADDRESS_MODE;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define ADDRESS ADDRESS64
|
|
#define LPADDRESS LPADDRESS64
|
|
#else
|
|
typedef struct _tagADDRESS
|
|
{
|
|
DWORD Offset;
|
|
WORD Segment;
|
|
ADDRESS_MODE Mode;
|
|
} ADDRESS, *LPADDRESS;
|
|
#endif
|
|
|
|
typedef struct _tagADDRESS64
|
|
{
|
|
DWORD64 Offset;
|
|
WORD Segment;
|
|
ADDRESS_MODE Mode;
|
|
} ADDRESS64, *LPADDRESS64;
|
|
|
|
#define SYMF_OMAP_GENERATED 0x00000001
|
|
#define SYMF_OMAP_MODIFIED 0x00000002
|
|
#define SYMF_USER_GENERATED 0x00000004
|
|
#define SYMF_REGISTER 0x00000008
|
|
#define SYMF_REGREL 0x00000010
|
|
#define SYMF_FRAMEREL 0x00000020
|
|
#define SYMF_PARAMETER 0x00000040
|
|
#define SYMF_LOCAL 0x00000080
|
|
#define SYMF_CONSTANT 0x00000100
|
|
#define SYMF_EXPORT 0x00000200
|
|
#define SYMF_FORWARDER 0x00000400
|
|
#define SYMF_FUNCTION 0x00000800
|
|
#define SYMF_VIRTUAL 0x00001000
|
|
#define SYMF_THUNK 0x00002000
|
|
#define SYMF_TLSREL 0x00004000
|
|
|
|
typedef enum
|
|
{
|
|
SymNone = 0,
|
|
SymCoff,
|
|
SymCv,
|
|
SymPdb,
|
|
SymExport,
|
|
SymDeferred,
|
|
SymSym,
|
|
SymDia,
|
|
SymVirtual,
|
|
NumSymTypes
|
|
} SYM_TYPE;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
|
|
#define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64
|
|
#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
|
|
#define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64
|
|
#else
|
|
typedef struct _IMAGEHLP_SYMBOL
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD Address;
|
|
DWORD Size;
|
|
DWORD Flags;
|
|
DWORD MaxNameLength;
|
|
CHAR Name[1];
|
|
} IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
|
|
|
|
typedef struct _IMAGEHLP_SYMBOLW
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD Address;
|
|
DWORD Size;
|
|
DWORD Flags;
|
|
DWORD MaxNameLength;
|
|
WCHAR Name[1];
|
|
} IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW;
|
|
#endif
|
|
|
|
typedef struct _IMAGEHLP_SYMBOL64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD64 Address;
|
|
DWORD Size;
|
|
DWORD Flags;
|
|
DWORD MaxNameLength;
|
|
CHAR Name[1];
|
|
} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
|
|
|
|
typedef struct _IMAGEHLP_SYMBOLW64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD64 Address;
|
|
DWORD Size;
|
|
DWORD Flags;
|
|
DWORD MaxNameLength;
|
|
WCHAR Name[1];
|
|
} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
|
|
#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
|
|
#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
|
|
#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
|
|
#else
|
|
typedef struct _IMAGEHLP_MODULE
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD BaseOfImage;
|
|
DWORD ImageSize;
|
|
DWORD TimeDateStamp;
|
|
DWORD CheckSum;
|
|
DWORD NumSyms;
|
|
SYM_TYPE SymType;
|
|
CHAR ModuleName[32];
|
|
CHAR ImageName[256];
|
|
CHAR LoadedImageName[256];
|
|
} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
|
|
|
|
typedef struct _IMAGEHLP_MODULEW
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD BaseOfImage;
|
|
DWORD ImageSize;
|
|
DWORD TimeDateStamp;
|
|
DWORD CheckSum;
|
|
DWORD NumSyms;
|
|
SYM_TYPE SymType;
|
|
WCHAR ModuleName[32];
|
|
WCHAR ImageName[256];
|
|
WCHAR LoadedImageName[256];
|
|
} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
|
|
#endif
|
|
|
|
typedef struct _IMAGEHLP_MODULE64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD64 BaseOfImage;
|
|
DWORD ImageSize;
|
|
DWORD TimeDateStamp;
|
|
DWORD CheckSum;
|
|
DWORD NumSyms;
|
|
SYM_TYPE SymType;
|
|
CHAR ModuleName[32];
|
|
CHAR ImageName[256];
|
|
CHAR LoadedImageName[256];
|
|
CHAR LoadedPdbName[256];
|
|
DWORD CVSig;
|
|
CHAR CVData[MAX_PATH*3];
|
|
DWORD PdbSig;
|
|
GUID PdbSig70;
|
|
DWORD PdbAge;
|
|
BOOL PdbUnmatched;
|
|
BOOL DbgUnmatched;
|
|
BOOL LineNumbers;
|
|
BOOL GlobalSymbols;
|
|
BOOL TypeInfo;
|
|
BOOL SourceIndexed;
|
|
BOOL Publics;
|
|
} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
|
|
|
|
typedef struct _IMAGEHLP_MODULEW64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD64 BaseOfImage;
|
|
DWORD ImageSize;
|
|
DWORD TimeDateStamp;
|
|
DWORD CheckSum;
|
|
DWORD NumSyms;
|
|
SYM_TYPE SymType;
|
|
WCHAR ModuleName[32];
|
|
WCHAR ImageName[256];
|
|
WCHAR LoadedImageName[256];
|
|
WCHAR LoadedPdbName[256];
|
|
DWORD CVSig;
|
|
WCHAR CVData[MAX_PATH*3];
|
|
DWORD PdbSig;
|
|
GUID PdbSig70;
|
|
DWORD PdbAge;
|
|
BOOL PdbUnmatched;
|
|
BOOL DbgUnmatched;
|
|
BOOL LineNumbers;
|
|
BOOL GlobalSymbols;
|
|
BOOL TypeInfo;
|
|
BOOL SourceIndexed;
|
|
BOOL Publics;
|
|
} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define IMAGEHLP_LINE IMAGEHLP_LINE64
|
|
#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
|
|
#define IMAGEHLP_LINEW IMAGEHLP_LINEW64
|
|
#define PIMAGEHLP_LINEW PIMAGEHLP_LINEW64
|
|
#else
|
|
typedef struct _IMAGEHLP_LINE
|
|
{
|
|
DWORD SizeOfStruct;
|
|
PVOID Key;
|
|
DWORD LineNumber;
|
|
PCHAR FileName;
|
|
DWORD Address;
|
|
} IMAGEHLP_LINE, *PIMAGEHLP_LINE;
|
|
|
|
typedef struct _IMAGEHLP_LINEW
|
|
{
|
|
DWORD SizeOfStruct;
|
|
PVOID Key;
|
|
DWORD LineNumber;
|
|
PWSTR FileName;
|
|
DWORD Address;
|
|
} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
|
|
#endif
|
|
|
|
typedef struct _IMAGEHLP_LINE64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
PVOID Key;
|
|
DWORD LineNumber;
|
|
PCHAR FileName;
|
|
DWORD64 Address;
|
|
} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
|
|
|
|
typedef struct _IMAGEHLP_LINEW64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
PVOID Key;
|
|
DWORD LineNumber;
|
|
PWSTR FileName;
|
|
DWORD64 Address;
|
|
} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
|
|
|
|
typedef struct _SOURCEFILE
|
|
{
|
|
DWORD64 ModBase;
|
|
PCHAR FileName;
|
|
} SOURCEFILE, *PSOURCEFILE;
|
|
|
|
typedef struct _SOURCEFILEW
|
|
{
|
|
DWORD64 ModBase;
|
|
PWSTR FileName;
|
|
} SOURCEFILEW, *PSOURCEFILEW;
|
|
|
|
#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
|
|
#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
|
|
#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
|
|
#define CBA_SYMBOLS_UNLOADED 0x00000004
|
|
#define CBA_DUPLICATE_SYMBOL 0x00000005
|
|
#define CBA_READ_MEMORY 0x00000006
|
|
#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
|
|
#define CBA_SET_OPTIONS 0x00000008
|
|
#define CBA_EVENT 0x00000010
|
|
#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
|
|
#define CBA_DEBUG_INFO 0x10000000
|
|
|
|
typedef struct _IMAGEHLP_CBA_READ_MEMORY
|
|
{
|
|
DWORD64 addr;
|
|
PVOID buf;
|
|
DWORD bytes;
|
|
DWORD *bytesread;
|
|
} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
|
|
|
|
enum
|
|
{
|
|
sevInfo = 0,
|
|
sevProblem,
|
|
sevAttn,
|
|
sevFatal,
|
|
sevMax
|
|
};
|
|
|
|
#define EVENT_SRCSPEW_START 100
|
|
#define EVENT_SRCSPEW 100
|
|
#define EVENT_SRCSPEW_END 199
|
|
|
|
typedef struct _IMAGEHLP_CBA_EVENT
|
|
{
|
|
DWORD severity;
|
|
DWORD code;
|
|
PCHAR desc;
|
|
PVOID object;
|
|
} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
|
|
|
|
typedef struct _IMAGEHLP_CBA_EVENTW
|
|
{
|
|
DWORD severity;
|
|
DWORD code;
|
|
PCWSTR desc;
|
|
PVOID object;
|
|
} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
|
|
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
|
|
#else
|
|
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD BaseOfImage;
|
|
DWORD CheckSum;
|
|
DWORD TimeDateStamp;
|
|
CHAR FileName[MAX_PATH];
|
|
BOOLEAN Reparse;
|
|
HANDLE hFile;
|
|
} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
|
|
#endif
|
|
|
|
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD64 BaseOfImage;
|
|
DWORD CheckSum;
|
|
DWORD TimeDateStamp;
|
|
CHAR FileName[MAX_PATH];
|
|
BOOLEAN Reparse;
|
|
HANDLE hFile;
|
|
DWORD Flags;
|
|
} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
|
|
|
|
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD64 BaseOfImage;
|
|
DWORD CheckSum;
|
|
DWORD TimeDateStamp;
|
|
WCHAR FileName[MAX_PATH + 1];
|
|
BOOLEAN Reparse;
|
|
HANDLE hFile;
|
|
DWORD Flags;
|
|
} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
|
|
#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
|
|
#else
|
|
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD NumberOfDups;
|
|
PIMAGEHLP_SYMBOL Symbol;
|
|
DWORD SelectedSymbol;
|
|
} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
|
|
#endif
|
|
|
|
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64
|
|
{
|
|
DWORD SizeOfStruct;
|
|
DWORD NumberOfDups;
|
|
PIMAGEHLP_SYMBOL64 Symbol;
|
|
DWORD SelectedSymbol;
|
|
} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
|
|
|
|
#define SYMOPT_CASE_INSENSITIVE 0x00000001
|
|
#define SYMOPT_UNDNAME 0x00000002
|
|
#define SYMOPT_DEFERRED_LOADS 0x00000004
|
|
#define SYMOPT_NO_CPP 0x00000008
|
|
#define SYMOPT_LOAD_LINES 0x00000010
|
|
#define SYMOPT_OMAP_FIND_NEAREST 0x00000020
|
|
#define SYMOPT_LOAD_ANYTHING 0x00000040
|
|
#define SYMOPT_IGNORE_CVREC 0x00000080
|
|
#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
|
|
#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
|
|
#define SYMOPT_EXACT_SYMBOLS 0x00000400
|
|
#define SYMOPT_WILD_UNDERSCORE 0x00000800
|
|
#define SYMOPT_USE_DEFAULTS 0x00001000
|
|
/* latest SDK defines:
|
|
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
|
|
#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
|
|
*/
|
|
#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
|
|
#define SYMOPT_PUBLICS_ONLY 0x00004000
|
|
#define SYMOPT_NO_PUBLICS 0x00008000
|
|
#define SYMOPT_AUTO_PUBLICS 0x00010000
|
|
#define SYMOPT_NO_IMAGE_SEARCH 0x00020000
|
|
#define SYMOPT_SECURE 0x00040000
|
|
#define SYMOPT_NO_PROMPTS 0x00080000
|
|
#define SYMOPT_OVERWRITE 0x00100000
|
|
#define SYMOPT_IGNORE_IMAGEDIR 0x00200000
|
|
|
|
#define SYMOPT_DEBUG 0x80000000
|
|
|
|
typedef struct _IMAGEHLP_STACK_FRAME
|
|
{
|
|
ULONG64 InstructionOffset;
|
|
ULONG64 ReturnOffset;
|
|
ULONG64 FrameOffset;
|
|
ULONG64 StackOffset;
|
|
ULONG64 BackingStoreOffset;
|
|
ULONG64 FuncTableEntry;
|
|
ULONG64 Params[4];
|
|
ULONG64 Reserved[5];
|
|
BOOL Virtual;
|
|
ULONG Reserved2;
|
|
} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
|
|
|
|
typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
|
|
|
|
#define DBHHEADER_DEBUGDIRS 0x1
|
|
typedef struct _DBGHELP_MODLOAD_DATA
|
|
{
|
|
DWORD ssize;
|
|
DWORD ssig;
|
|
PVOID data;
|
|
DWORD size;
|
|
DWORD flags;
|
|
} MODLOAD_DATA, *PMODLOAD_DATA;
|
|
|
|
/*************************
|
|
* MiniDUMP *
|
|
*************************/
|
|
|
|
#include <pshpack4.h>
|
|
/* DebugHelp */
|
|
|
|
#define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */
|
|
#define MINIDUMP_VERSION (42899)
|
|
|
|
typedef DWORD RVA;
|
|
typedef ULONG64 RVA64;
|
|
|
|
typedef enum _MINIDUMP_TYPE
|
|
{
|
|
MiniDumpNormal = 0x0000,
|
|
MiniDumpWithDataSegs = 0x0001,
|
|
MiniDumpWithFullMemory = 0x0002,
|
|
MiniDumpWithHandleData = 0x0004,
|
|
MiniDumpFilterMemory = 0x0008,
|
|
MiniDumpScanMemory = 0x0010,
|
|
MiniDumpWithUnloadedModules = 0x0020,
|
|
MiniDumpWithIndirectlyReferencedMemory = 0x0040,
|
|
MiniDumpFilterModulePaths = 0x0080,
|
|
MiniDumpWithProcessThreadData = 0x0100,
|
|
MiniDumpWithPrivateReadWriteMemory = 0x0200,
|
|
MiniDumpWithoutOptionalData = 0x0400,
|
|
MiniDumpWithFullMemoryInfo = 0x0800,
|
|
MiniDumpWithThreadInfo = 0x1000,
|
|
MiniDumpWithCodeSegs = 0x2000
|
|
} MINIDUMP_TYPE;
|
|
|
|
typedef enum _MINIDUMP_CALLBACK_TYPE
|
|
{
|
|
ModuleCallback,
|
|
ThreadCallback,
|
|
ThreadExCallback,
|
|
IncludeThreadCallback,
|
|
IncludeModuleCallback,
|
|
MemoryCallback,
|
|
} MINIDUMP_CALLBACK_TYPE;
|
|
|
|
typedef struct _MINIDUMP_THREAD_CALLBACK
|
|
{
|
|
ULONG ThreadId;
|
|
HANDLE ThreadHandle;
|
|
CONTEXT Context;
|
|
ULONG SizeOfContext;
|
|
ULONG64 StackBase;
|
|
ULONG64 StackEnd;
|
|
} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
|
|
|
|
typedef struct _MINIDUMP_THREAD_EX_CALLBACK
|
|
{
|
|
ULONG ThreadId;
|
|
HANDLE ThreadHandle;
|
|
CONTEXT Context;
|
|
ULONG SizeOfContext;
|
|
ULONG64 StackBase;
|
|
ULONG64 StackEnd;
|
|
ULONG64 BackingStoreBase;
|
|
ULONG64 BackingStoreEnd;
|
|
} MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
|
|
|
|
typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
|
|
{
|
|
ULONG ThreadId;
|
|
} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
|
|
|
|
typedef enum _THREAD_WRITE_FLAGS
|
|
{
|
|
ThreadWriteThread = 0x0001,
|
|
ThreadWriteStack = 0x0002,
|
|
ThreadWriteContext = 0x0004,
|
|
ThreadWriteBackingStore = 0x0008,
|
|
ThreadWriteInstructionWindow = 0x0010,
|
|
ThreadWriteThreadData = 0x0020,
|
|
ThreadWriteThreadInfo = 0x0040
|
|
} THREAD_WRITE_FLAGS;
|
|
|
|
typedef struct _MINIDUMP_MODULE_CALLBACK
|
|
{
|
|
PWCHAR FullPath;
|
|
ULONG64 BaseOfImage;
|
|
ULONG SizeOfImage;
|
|
ULONG CheckSum;
|
|
ULONG TimeDateStamp;
|
|
VS_FIXEDFILEINFO VersionInfo;
|
|
PVOID CvRecord;
|
|
ULONG SizeOfCvRecord;
|
|
PVOID MiscRecord;
|
|
ULONG SizeOfMiscRecord;
|
|
} MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
|
|
|
|
typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
|
|
{
|
|
ULONG64 BaseOfImage;
|
|
} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
|
|
|
|
typedef enum _MODULE_WRITE_FLAGS
|
|
{
|
|
ModuleWriteModule = 0x0001,
|
|
ModuleWriteDataSeg = 0x0002,
|
|
ModuleWriteMiscRecord = 0x0004,
|
|
ModuleWriteCvRecord = 0x0008,
|
|
ModuleReferencedByMemory = 0x0010,
|
|
ModuleWriteTlsData = 0x0020,
|
|
ModuleWriteCodeSegs = 0x0040,
|
|
} MODULE_WRITE_FLAGS;
|
|
|
|
typedef struct _MINIDUMP_CALLBACK_INPUT
|
|
{
|
|
ULONG ProcessId;
|
|
HANDLE ProcessHandle;
|
|
ULONG CallbackType;
|
|
union
|
|
{
|
|
MINIDUMP_THREAD_CALLBACK Thread;
|
|
MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
|
|
MINIDUMP_MODULE_CALLBACK Module;
|
|
MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
|
|
MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
|
|
} DUMMYUNIONNAME;
|
|
} MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
|
|
|
|
typedef struct _MINIDUMP_CALLBACK_OUTPUT
|
|
{
|
|
union
|
|
{
|
|
ULONG ModuleWriteFlags;
|
|
ULONG ThreadWriteFlags;
|
|
struct
|
|
{
|
|
ULONG64 MemoryBase;
|
|
ULONG MemorySize;
|
|
} DUMMYSTRUCTNAME;
|
|
} DUMMYUNIONNAME;
|
|
} MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
|
|
|
|
typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT);
|
|
|
|
typedef struct _MINIDUMP_CALLBACK_INFORMATION
|
|
{
|
|
MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
|
|
void* CallbackParam;
|
|
} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
|
|
|
|
typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
|
|
{
|
|
ULONG DataSize;
|
|
RVA Rva;
|
|
} MINIDUMP_LOCATION_DESCRIPTOR;
|
|
|
|
typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64
|
|
{
|
|
ULONG64 DataSize;
|
|
RVA64 Rva;
|
|
} MINIDUMP_LOCATION_DESCRIPTOR64;
|
|
|
|
typedef struct _MINIDUMP_DIRECTORY
|
|
{
|
|
ULONG StreamType;
|
|
MINIDUMP_LOCATION_DESCRIPTOR Location;
|
|
} MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
|
|
|
|
typedef struct _MINIDUMP_EXCEPTION
|
|
{
|
|
ULONG ExceptionCode;
|
|
ULONG ExceptionFlags;
|
|
ULONG64 ExceptionRecord;
|
|
ULONG64 ExceptionAddress;
|
|
ULONG NumberParameters;
|
|
ULONG __unusedAlignment;
|
|
ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
|
|
} MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
|
|
|
|
typedef struct _MINIDUMP_EXCEPTION_INFORMATION
|
|
{
|
|
DWORD ThreadId;
|
|
PEXCEPTION_POINTERS ExceptionPointers;
|
|
BOOL ClientPointers;
|
|
} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
|
|
|
|
typedef struct MINIDUMP_EXCEPTION_STREAM
|
|
{
|
|
ULONG ThreadId;
|
|
ULONG __alignment;
|
|
MINIDUMP_EXCEPTION ExceptionRecord;
|
|
MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
|
|
} MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
|
|
|
|
typedef struct _MINIDUMP_HEADER
|
|
{
|
|
DWORD Signature;
|
|
DWORD Version;
|
|
DWORD NumberOfStreams;
|
|
RVA StreamDirectoryRva;
|
|
DWORD CheckSum;
|
|
union
|
|
{
|
|
DWORD Reserved;
|
|
DWORD TimeDateStamp;
|
|
} DUMMYUNIONNAME;
|
|
ULONG64 Flags;
|
|
} MINIDUMP_HEADER, *PMINIDUMP_HEADER;
|
|
|
|
typedef struct _MINIDUMP_MEMORY_DESCRIPTOR
|
|
{
|
|
ULONG64 StartOfMemoryRange;
|
|
MINIDUMP_LOCATION_DESCRIPTOR Memory;
|
|
} MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
|
|
|
|
typedef struct _MINIDUMP_MEMORY_LIST
|
|
{
|
|
ULONG NumberOfMemoryRanges;
|
|
MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[1]; /* FIXME: 0-sized array not supported */
|
|
} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
|
|
|
|
#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
|
|
#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
|
|
|
|
typedef struct _MINIDUMP_MISC_INFO
|
|
{
|
|
ULONG SizeOfInfo;
|
|
ULONG Flags1;
|
|
ULONG ProcessId;
|
|
ULONG ProcessCreateTime;
|
|
ULONG ProcessUserTime;
|
|
ULONG ProcessKernelTime;
|
|
} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
|
|
|
|
typedef struct _MINIDUMP_MODULE
|
|
{
|
|
ULONG64 BaseOfImage;
|
|
ULONG SizeOfImage;
|
|
ULONG CheckSum;
|
|
ULONG TimeDateStamp;
|
|
RVA ModuleNameRva;
|
|
VS_FIXEDFILEINFO VersionInfo;
|
|
MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
|
|
MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
|
|
ULONG64 Reserved0;
|
|
ULONG64 Reserved1;
|
|
} MINIDUMP_MODULE, *PMINIDUMP_MODULE;
|
|
|
|
typedef struct _MINIDUMP_MODULE_LIST
|
|
{
|
|
ULONG NumberOfModules;
|
|
MINIDUMP_MODULE Modules[1]; /* FIXME: 0-sized array not supported */
|
|
} MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
|
|
|
|
typedef struct _MINIDUMP_STRING
|
|
{
|
|
ULONG Length;
|
|
WCHAR Buffer[1]; /* FIXME: O-sized array not supported */
|
|
} MINIDUMP_STRING, *PMINIDUMP_STRING;
|
|
|
|
typedef struct _MINIDUMP_SYSTEM_INFO
|
|
{
|
|
USHORT ProcessorArchitecture;
|
|
USHORT ProcessorLevel;
|
|
USHORT ProcessorRevision;
|
|
union
|
|
{
|
|
USHORT Reserved0;
|
|
struct
|
|
{
|
|
UCHAR NumberOfProcessors;
|
|
UCHAR ProductType;
|
|
} DUMMYSTRUCTNAME;
|
|
} DUMMYUNIONNAME;
|
|
|
|
ULONG MajorVersion;
|
|
ULONG MinorVersion;
|
|
ULONG BuildNumber;
|
|
ULONG PlatformId;
|
|
|
|
RVA CSDVersionRva;
|
|
union
|
|
{
|
|
ULONG Reserved1;
|
|
struct
|
|
{
|
|
USHORT SuiteMask;
|
|
USHORT Reserved2;
|
|
} DUMMYSTRUCTNAME;
|
|
} DUMMYUNIONNAME1;
|
|
union _CPU_INFORMATION
|
|
{
|
|
struct
|
|
{
|
|
ULONG VendorId[3];
|
|
ULONG VersionInformation;
|
|
ULONG FeatureInformation;
|
|
ULONG AMDExtendedCpuFeatures;
|
|
} X86CpuInfo;
|
|
struct
|
|
{
|
|
ULONG64 ProcessorFeatures[2];
|
|
} OtherCpuInfo;
|
|
} Cpu;
|
|
|
|
} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
|
|
|
|
typedef struct _MINIDUMP_THREAD
|
|
{
|
|
ULONG ThreadId;
|
|
ULONG SuspendCount;
|
|
ULONG PriorityClass;
|
|
ULONG Priority;
|
|
ULONG64 Teb;
|
|
MINIDUMP_MEMORY_DESCRIPTOR Stack;
|
|
MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
|
|
} MINIDUMP_THREAD, *PMINIDUMP_THREAD;
|
|
|
|
typedef struct _MINIDUMP_THREAD_LIST
|
|
{
|
|
ULONG NumberOfThreads;
|
|
MINIDUMP_THREAD Threads[1]; /* FIXME: no support of 0 sized array */
|
|
} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
|
|
|
|
typedef struct _MINIDUMP_USER_STREAM
|
|
{
|
|
ULONG Type;
|
|
ULONG BufferSize;
|
|
void* Buffer;
|
|
} MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
|
|
|
|
typedef struct _MINIDUMP_USER_STREAM_INFORMATION
|
|
{
|
|
ULONG UserStreamCount;
|
|
PMINIDUMP_USER_STREAM UserStreamArray;
|
|
} MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
|
|
|
|
typedef enum _MINIDUMP_STREAM_TYPE
|
|
{
|
|
UnusedStream = 0,
|
|
ReservedStream0 = 1,
|
|
ReservedStream1 = 2,
|
|
ThreadListStream = 3,
|
|
ModuleListStream = 4,
|
|
MemoryListStream = 5,
|
|
ExceptionStream = 6,
|
|
SystemInfoStream = 7,
|
|
ThreadExListStream = 8,
|
|
Memory64ListStream = 9,
|
|
CommentStreamA = 10,
|
|
CommentStreamW = 11,
|
|
HandleDataStream = 12,
|
|
FunctionTableStream = 13,
|
|
UnloadedModuleListStream = 14,
|
|
MiscInfoStream = 15,
|
|
MemoryInfoListStream = 16,
|
|
ThreadInfoListStream = 17,
|
|
|
|
LastReservedStream = 0xffff
|
|
} MINIDUMP_STREAM_TYPE;
|
|
|
|
BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
|
|
const PMINIDUMP_EXCEPTION_INFORMATION,
|
|
const PMINIDUMP_USER_STREAM_INFORMATION,
|
|
const PMINIDUMP_CALLBACK_INFORMATION);
|
|
BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*,
|
|
ULONG*);
|
|
|
|
#include <poppack.h>
|
|
|
|
/*************************
|
|
* MODULE handling *
|
|
*************************/
|
|
|
|
/* flags for SymLoadModuleEx */
|
|
#define SLMFLAG_VIRTUAL 0x1
|
|
#define SLMFLAG_NO_SYMBOLS 0x4
|
|
|
|
typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
|
|
BOOL WINAPI EnumerateLoadedModules64(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID);
|
|
typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID);
|
|
BOOL WINAPI EnumerateLoadedModulesW64(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID);
|
|
BOOL WINAPI EnumerateLoadedModulesEx(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID);
|
|
BOOL WINAPI EnumerateLoadedModulesExW(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID);
|
|
BOOL WINAPI SymEnumerateModules64(HANDLE, PSYM_ENUMMODULES_CALLBACK64, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID);
|
|
BOOL WINAPI SymEnumerateModulesW64(HANDLE, PSYM_ENUMMODULES_CALLBACKW64, PVOID);
|
|
BOOL WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64);
|
|
BOOL WINAPI SymGetModuleInfoW64(HANDLE, DWORD64, PIMAGEHLP_MODULEW64);
|
|
DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64);
|
|
DWORD64 WINAPI SymLoadModule64(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD);
|
|
DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD,
|
|
PMODLOAD_DATA, DWORD);
|
|
DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD,
|
|
PMODLOAD_DATA, DWORD);
|
|
BOOL WINAPI SymUnloadModule64(HANDLE, DWORD64);
|
|
|
|
/*************************
|
|
* Symbol Handling *
|
|
*************************/
|
|
|
|
#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
|
|
#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER /* 0x08 */
|
|
#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL /* 0x10 */
|
|
#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL /* 0x20 */
|
|
#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER /* 0x40 */
|
|
#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL /* 0x80 */
|
|
#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT /* 0x100 */
|
|
#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION /* 0x800 */
|
|
|
|
#define SYMFLAG_VALUEPRESENT 0x00000001
|
|
#define SYMFLAG_REGISTER 0x00000008
|
|
#define SYMFLAG_REGREL 0x00000010
|
|
#define SYMFLAG_FRAMEREL 0x00000020
|
|
#define SYMFLAG_PARAMETER 0x00000040
|
|
#define SYMFLAG_LOCAL 0x00000080
|
|
#define SYMFLAG_CONSTANT 0x00000100
|
|
#define SYMFLAG_EXPORT 0x00000200
|
|
#define SYMFLAG_FORWARDER 0x00000400
|
|
#define SYMFLAG_FUNCTION 0x00000800
|
|
#define SYMFLAG_VIRTUAL 0x00001000
|
|
#define SYMFLAG_THUNK 0x00002000
|
|
#define SYMFLAG_TLSREL 0x00004000
|
|
#define SYMFLAG_SLOT 0x00008000
|
|
|
|
#define MAX_SYM_NAME 2000
|
|
|
|
typedef struct _SYMBOL_INFO
|
|
{
|
|
ULONG SizeOfStruct;
|
|
ULONG TypeIndex;
|
|
ULONG64 Reserved[2];
|
|
ULONG Index;
|
|
ULONG Size;
|
|
ULONG64 ModBase;
|
|
ULONG Flags;
|
|
ULONG64 Value;
|
|
ULONG64 Address;
|
|
ULONG Register;
|
|
ULONG Scope;
|
|
ULONG Tag;
|
|
ULONG NameLen;
|
|
ULONG MaxNameLen;
|
|
CHAR Name[1];
|
|
} SYMBOL_INFO, *PSYMBOL_INFO;
|
|
|
|
typedef struct _SYMBOL_INFOW
|
|
{
|
|
ULONG SizeOfStruct;
|
|
ULONG TypeIndex;
|
|
ULONG64 Reserved[2];
|
|
ULONG Index;
|
|
ULONG Size;
|
|
ULONG64 ModBase;
|
|
ULONG Flags;
|
|
ULONG64 Value;
|
|
ULONG64 Address;
|
|
ULONG Register;
|
|
ULONG Scope;
|
|
ULONG Tag;
|
|
ULONG NameLen;
|
|
ULONG MaxNameLen;
|
|
WCHAR Name[1];
|
|
} SYMBOL_INFOW, *PSYMBOL_INFOW;
|
|
|
|
typedef struct _SYMBOL_INFO_PACKAGE
|
|
{
|
|
SYMBOL_INFO si;
|
|
CHAR name[MAX_SYM_NAME+1];
|
|
} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
|
|
|
|
typedef struct _SYMBOL_INFO_PACKAGEW
|
|
{
|
|
SYMBOL_INFOW si;
|
|
WCHAR name[MAX_SYM_NAME+1];
|
|
} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
|
|
|
|
typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
|
|
{
|
|
TI_GET_SYMTAG,
|
|
TI_GET_SYMNAME,
|
|
TI_GET_LENGTH,
|
|
TI_GET_TYPE,
|
|
TI_GET_TYPEID,
|
|
TI_GET_BASETYPE,
|
|
TI_GET_ARRAYINDEXTYPEID,
|
|
TI_FINDCHILDREN,
|
|
TI_GET_DATAKIND,
|
|
TI_GET_ADDRESSOFFSET,
|
|
TI_GET_OFFSET,
|
|
TI_GET_VALUE,
|
|
TI_GET_COUNT,
|
|
TI_GET_CHILDRENCOUNT,
|
|
TI_GET_BITPOSITION,
|
|
TI_GET_VIRTUALBASECLASS,
|
|
TI_GET_VIRTUALTABLESHAPEID,
|
|
TI_GET_VIRTUALBASEPOINTEROFFSET,
|
|
TI_GET_CLASSPARENTID,
|
|
TI_GET_NESTED,
|
|
TI_GET_SYMINDEX,
|
|
TI_GET_LEXICALPARENT,
|
|
TI_GET_ADDRESS,
|
|
TI_GET_THISADJUST,
|
|
TI_GET_UDTKIND,
|
|
TI_IS_EQUIV_TO,
|
|
TI_GET_CALLING_CONVENTION,
|
|
} IMAGEHLP_SYMBOL_TYPE_INFO;
|
|
|
|
#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001
|
|
#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002
|
|
typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS
|
|
{
|
|
ULONG SizeOfStruct;
|
|
ULONG Flags;
|
|
ULONG NumIds;
|
|
PULONG TypeIds;
|
|
ULONG64 TagFilter;
|
|
ULONG NumReqs;
|
|
IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
|
|
PULONG_PTR ReqOffsets;
|
|
PULONG ReqSizes;
|
|
ULONG_PTR ReqStride;
|
|
ULONG_PTR BufferSize;
|
|
PVOID Buffer;
|
|
ULONG EntriesMatched;
|
|
ULONG EntriesFilled;
|
|
ULONG64 TagsFound;
|
|
ULONG64 AllReqsValid;
|
|
ULONG NumReqsValid;
|
|
PULONG64 ReqsValid;
|
|
} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
|
|
|
|
typedef struct _TI_FINDCHILDREN_PARAMS
|
|
{
|
|
ULONG Count;
|
|
ULONG Start;
|
|
ULONG ChildId[1];
|
|
} TI_FINDCHILDREN_PARAMS;
|
|
|
|
#define UNDNAME_COMPLETE (0x0000)
|
|
#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001)
|
|
#define UNDNAME_NO_MS_KEYWORDS (0x0002)
|
|
#define UNDNAME_NO_FUNCTION_RETURNS (0x0004)
|
|
#define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
|
|
#define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
|
|
#define UNDNAME_NO_MS_THISTYPE (0x0020)
|
|
#define UNDNAME_NO_CV_THISTYPE (0x0040)
|
|
#define UNDNAME_NO_THISTYPE (0x0060)
|
|
#define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080)
|
|
#define UNDNAME_NO_THROW_SIGNATURES (0x0100)
|
|
#define UNDNAME_NO_MEMBER_TYPE (0x0200)
|
|
#define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
|
|
#define UNDNAME_32_BIT_DECODE (0x0800)
|
|
#define UNDNAME_NAME_ONLY (0x1000)
|
|
#define UNDNAME_NO_ARGUMENTS (0x2000)
|
|
#define UNDNAME_NO_SPECIAL_SYMS (0x4000)
|
|
|
|
#define SYMSEARCH_MASKOBJS 0x01
|
|
#define SYMSEARCH_RECURSE 0x02
|
|
#define SYMSEARCH_GLOBALSONLY 0x04
|
|
|
|
BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID);
|
|
BOOL WINAPI SymGetTypeInfoEx(HANDLE, DWORD64, PIMAGEHLP_GET_TYPE_INFO_PARAMS);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID);
|
|
BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
|
|
BOOL WINAPI SymEnumTypesW(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
|
|
BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*);
|
|
BOOL WINAPI SymFromAddrW(HANDLE, DWORD64, DWORD64*, SYMBOL_INFOW*);
|
|
BOOL WINAPI SymFromToken(HANDLE, DWORD64, DWORD, PSYMBOL_INFO);
|
|
BOOL WINAPI SymFromTokenW(HANDLE, DWORD64, DWORD, PSYMBOL_INFOW);
|
|
BOOL WINAPI SymFromName(HANDLE, PCSTR, PSYMBOL_INFO);
|
|
BOOL WINAPI SymFromNameW(HANDLE, PCWSTR, PSYMBOL_INFOW);
|
|
BOOL WINAPI SymGetSymFromAddr64(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
|
|
BOOL WINAPI SymGetSymFromName64(HANDLE, PCSTR, PIMAGEHLP_SYMBOL64);
|
|
BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, PCSTR, PSYMBOL_INFO);
|
|
BOOL WINAPI SymGetTypeFromNameW(HANDLE, ULONG64, PCWSTR, PSYMBOL_INFOW);
|
|
BOOL WINAPI SymGetSymNext64(HANDLE, PIMAGEHLP_SYMBOL64);
|
|
BOOL WINAPI SymGetSymNextW64(HANDLE, PIMAGEHLP_SYMBOLW64);
|
|
BOOL WINAPI SymGetSymPrev64(HANDLE, PIMAGEHLP_SYMBOL64);
|
|
BOOL WINAPI SymGetSymPrevW64(HANDLE, PIMAGEHLP_SYMBOLW64);
|
|
BOOL WINAPI SymEnumSym(HANDLE,ULONG64,PSYM_ENUMERATESYMBOLS_CALLBACK,PVOID);
|
|
BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK,
|
|
PVOID);
|
|
BOOL WINAPI SymEnumSymbolsW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMERATESYMBOLS_CALLBACKW,
|
|
PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID);
|
|
BOOL WINAPI SymEnumerateSymbols64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64, PVOID);
|
|
BOOL WINAPI SymEnumerateSymbolsW64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64W, PVOID);
|
|
BOOL WINAPI SymEnumSymbolsForAddr(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
|
|
BOOL WINAPI SymEnumSymbolsForAddrW(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
|
|
typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64);
|
|
BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
|
|
BOOL WINAPI SymRegisterCallbackW64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
|
|
BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64, PSTR, DWORD);
|
|
BOOL WINAPI SymMatchString(PCSTR, PCSTR, BOOL);
|
|
BOOL WINAPI SymMatchStringA(PCSTR, PCSTR, BOOL);
|
|
BOOL WINAPI SymMatchStringW(PCWSTR, PCWSTR, BOOL);
|
|
BOOL WINAPI SymSearch(HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD);
|
|
BOOL WINAPI SymSearchW(HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD);
|
|
DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD);
|
|
DWORD WINAPI UnDecorateSymbolNameW(PCWSTR, PWSTR, DWORD, DWORD);
|
|
BOOL WINAPI SymGetScope(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
|
|
BOOL WINAPI SymGetScopeW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
|
|
BOOL WINAPI SymFromIndex(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
|
|
BOOL WINAPI SymFromIndexW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
|
|
BOOL WINAPI SymAddSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD, DWORD);
|
|
BOOL WINAPI SymAddSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD, DWORD);
|
|
BOOL WINAPI SymDeleteSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD);
|
|
BOOL WINAPI SymDeleteSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD);
|
|
|
|
/*************************
|
|
* Source Files *
|
|
*************************/
|
|
typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID);
|
|
|
|
BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, PCSTR, PSYM_ENUMSOURCEFILES_CALLBACK,
|
|
PVOID);
|
|
BOOL WINAPI SymEnumSourceFilesW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMSOURCEFILES_CALLBACKW, PVOID);
|
|
BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
|
|
BOOL WINAPI SymGetLineFromAddrW64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINEW64);
|
|
BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64);
|
|
BOOL WINAPI SymGetLinePrevW64(HANDLE, PIMAGEHLP_LINEW64);
|
|
BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64);
|
|
BOOL WINAPI SymGetLineNextW64(HANDLE, PIMAGEHLP_LINEW64);
|
|
BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64);
|
|
BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64);
|
|
ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG);
|
|
BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD);
|
|
BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD);
|
|
BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*);
|
|
BOOL WINAPI SymGetSourceFileTokenW(HANDLE, ULONG64, PCWSTR, PVOID*, DWORD*);
|
|
BOOL WINAPI SymGetSourceFileFromToken(HANDLE, PVOID, PCSTR, PSTR, DWORD);
|
|
BOOL WINAPI SymGetSourceFileFromTokenW(HANDLE, PVOID, PCWSTR, PWSTR, DWORD);
|
|
BOOL WINAPI SymGetSourceVarFromToken(HANDLE, PVOID, PCSTR, PCSTR, PSTR, DWORD);
|
|
BOOL WINAPI SymGetSourceVarFromTokenW(HANDLE, PVOID, PCWSTR, PCWSTR, PWSTR, DWORD);
|
|
|
|
typedef struct _SRCCODEINFO
|
|
{
|
|
DWORD SizeOfStruct;
|
|
PVOID Key;
|
|
DWORD64 ModBase;
|
|
CHAR Obj[MAX_PATH+1];
|
|
CHAR FileName[MAX_PATH+1];
|
|
DWORD LineNumber;
|
|
DWORD64 Address;
|
|
} SRCCODEINFO, *PSRCCODEINFO;
|
|
|
|
typedef struct _SRCCODEINFOW
|
|
{
|
|
DWORD SizeOfStruct;
|
|
PVOID Key;
|
|
DWORD64 ModBase;
|
|
WCHAR Obj[MAX_PATH+1];
|
|
WCHAR FileName[MAX_PATH+1];
|
|
DWORD LineNumber;
|
|
DWORD64 Address;
|
|
} SRCCODEINFOW, *PSRCCODEINFOW;
|
|
|
|
typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID);
|
|
typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID);
|
|
BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID);
|
|
BOOL WINAPI SymEnumLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, PSYM_ENUMLINES_CALLBACKW, PVOID);
|
|
BOOL WINAPI SymEnumSourceLines(HANDLE, ULONG64, PCSTR, PCSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACK, PVOID);
|
|
BOOL WINAPI SymEnumSourceLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACKW, PVOID);
|
|
|
|
/*************************
|
|
* File & image handling *
|
|
*************************/
|
|
BOOL WINAPI SymInitialize(HANDLE, PCSTR, BOOL);
|
|
BOOL WINAPI SymInitializeW(HANDLE, PCWSTR, BOOL);
|
|
BOOL WINAPI SymCleanup(HANDLE);
|
|
|
|
HANDLE WINAPI FindDebugInfoFile(PCSTR, PCSTR, PSTR);
|
|
typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
|
|
typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
|
|
HANDLE WINAPI FindDebugInfoFileEx(PCSTR, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
|
|
HANDLE WINAPI FindDebugInfoFileExW(PCWSTR, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
|
|
HANDLE WINAPI SymFindDebugInfoFile(HANDLE, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
|
|
HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
|
|
typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID);
|
|
typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID);
|
|
BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
|
|
PSTR, PFINDFILEINPATHCALLBACK, PVOID);
|
|
BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
|
|
PSTR, PFINDFILEINPATHCALLBACK, PVOID);
|
|
BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD,
|
|
PWSTR, PFINDFILEINPATHCALLBACKW, PVOID);
|
|
HANDLE WINAPI FindExecutableImage(PCSTR, PCSTR, PSTR);
|
|
typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
|
|
typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
|
|
HANDLE WINAPI FindExecutableImageEx(PCSTR, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
|
|
HANDLE WINAPI FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
|
|
HANDLE WINAPI SymFindExecutableImage(HANDLE, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
|
|
HANDLE WINAPI SymFindExecutableImageW(HANDLE, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
|
|
PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID);
|
|
PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG,
|
|
PIMAGE_SECTION_HEADER *);
|
|
PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG);
|
|
PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG);
|
|
PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*);
|
|
BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD);
|
|
BOOL WINAPI SymGetSearchPathW(HANDLE, PWSTR, DWORD);
|
|
BOOL WINAPI SymSetSearchPath(HANDLE, PCSTR);
|
|
BOOL WINAPI SymSetSearchPathW(HANDLE, PCWSTR);
|
|
DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE);
|
|
BOOL WINAPI MakeSureDirectoryPathExists(PCSTR);
|
|
BOOL WINAPI SearchTreeForFile(PCSTR, PCSTR, PSTR);
|
|
BOOL WINAPI SearchTreeForFileW(PCWSTR, PCWSTR, PWSTR);
|
|
typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(PCSTR, PVOID);
|
|
typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID);
|
|
BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, PSTR, PENUMDIRTREE_CALLBACK, PVOID);
|
|
BOOL WINAPI EnumDirTreeW(HANDLE, PCWSTR, PCWSTR, PWSTR, PENUMDIRTREE_CALLBACKW, PVOID);
|
|
BOOL WINAPI SymMatchFileName(PCSTR, PCSTR, PSTR*, PSTR*);
|
|
BOOL WINAPI SymMatchFileNameW(PCWSTR, PCWSTR, PWSTR*, PWSTR*);
|
|
PCHAR WINAPI SymSetHomeDirectory(HANDLE, PCSTR);
|
|
PWSTR WINAPI SymSetHomeDirectoryW(HANDLE, PCWSTR);
|
|
PCHAR WINAPI SymGetHomeDirectory(DWORD, PSTR, size_t);
|
|
PWSTR WINAPI SymGetHomeDirectoryW(DWORD, PWSTR, size_t);
|
|
#define hdBase 0
|
|
#define hdSym 1
|
|
#define hdSrc 2
|
|
#define hdMax 3
|
|
|
|
/*************************
|
|
* Context management *
|
|
*************************/
|
|
BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT);
|
|
|
|
|
|
/*************************
|
|
* Stack management *
|
|
*************************/
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define KDHELP KDHELP64
|
|
#define PKDHELP PKDHELP64
|
|
#else
|
|
typedef struct _KDHELP
|
|
{
|
|
DWORD Thread;
|
|
DWORD ThCallbackStack;
|
|
DWORD NextCallback;
|
|
DWORD FramePointer;
|
|
DWORD KiCallUserMode;
|
|
DWORD KeUserCallbackDispatcher;
|
|
DWORD SystemRangeStart;
|
|
} KDHELP, *PKDHELP;
|
|
#endif
|
|
|
|
typedef struct _KDHELP64
|
|
{
|
|
DWORD64 Thread;
|
|
DWORD ThCallbackStack;
|
|
DWORD ThCallbackBStore;
|
|
DWORD NextCallback;
|
|
DWORD FramePointer;
|
|
DWORD64 KiCallUserMode;
|
|
DWORD64 KeUserCallbackDispatcher;
|
|
DWORD64 SystemRangeStart;
|
|
DWORD64 Reserved[8];
|
|
} KDHELP64, *PKDHELP64;
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
#define STACKFRAME STACKFRAME64
|
|
#define LPSTACKFRAME LPSTACKFRAME64
|
|
#else
|
|
typedef struct _STACKFRAME
|
|
{
|
|
ADDRESS AddrPC;
|
|
ADDRESS AddrReturn;
|
|
ADDRESS AddrFrame;
|
|
ADDRESS AddrStack;
|
|
PVOID FuncTableEntry;
|
|
DWORD Params[4];
|
|
BOOL Far;
|
|
BOOL Virtual;
|
|
DWORD Reserved[3];
|
|
KDHELP KdHelp;
|
|
ADDRESS AddrBStore;
|
|
} STACKFRAME, *LPSTACKFRAME;
|
|
#endif
|
|
|
|
typedef struct _STACKFRAME64
|
|
{
|
|
ADDRESS64 AddrPC;
|
|
ADDRESS64 AddrReturn;
|
|
ADDRESS64 AddrFrame;
|
|
ADDRESS64 AddrStack;
|
|
ADDRESS64 AddrBStore;
|
|
PVOID FuncTableEntry;
|
|
DWORD64 Params[4];
|
|
BOOL Far;
|
|
BOOL Virtual;
|
|
DWORD64 Reserved[3];
|
|
KDHELP64 KdHelp;
|
|
} STACKFRAME64, *LPSTACKFRAME64;
|
|
|
|
typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64)
|
|
(HANDLE, DWORD64, PVOID, DWORD, PDWORD);
|
|
typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64);
|
|
typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64);
|
|
typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64);
|
|
BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID,
|
|
PREAD_PROCESS_MEMORY_ROUTINE64,
|
|
PFUNCTION_TABLE_ACCESS_ROUTINE64,
|
|
PGET_MODULE_BASE_ROUTINE64,
|
|
PTRANSLATE_ADDRESS_ROUTINE64);
|
|
|
|
PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64);
|
|
|
|
typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64);
|
|
|
|
BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64);
|
|
|
|
/*************************
|
|
* Version, global stuff *
|
|
*************************/
|
|
|
|
#define API_VERSION_NUMBER 9
|
|
|
|
typedef struct API_VERSION
|
|
{
|
|
USHORT MajorVersion;
|
|
USHORT MinorVersion;
|
|
USHORT Revision;
|
|
USHORT Reserved;
|
|
} API_VERSION, *LPAPI_VERSION;
|
|
|
|
LPAPI_VERSION WINAPI ImagehlpApiVersion(void);
|
|
LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION);
|
|
|
|
typedef struct _IMAGE_DEBUG_INFORMATION
|
|
{
|
|
LIST_ENTRY List;
|
|
DWORD ReservedSize;
|
|
PVOID ReservedMappedBase;
|
|
USHORT ReservedMachine;
|
|
USHORT ReservedCharacteristics;
|
|
DWORD ReservedCheckSum;
|
|
DWORD ImageBase;
|
|
DWORD SizeOfImage;
|
|
DWORD ReservedNumberOfSections;
|
|
PIMAGE_SECTION_HEADER ReservedSections;
|
|
DWORD ReservedExportedNamesSize;
|
|
PSTR ReservedExportedNames;
|
|
DWORD ReservedNumberOfFunctionTableEntries;
|
|
PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
|
|
DWORD ReservedLowestFunctionStartingAddress;
|
|
DWORD ReservedHighestFunctionEndingAddress;
|
|
DWORD ReservedNumberOfFpoTableEntries;
|
|
PFPO_DATA ReservedFpoTableEntries;
|
|
DWORD SizeOfCoffSymbols;
|
|
PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
|
|
DWORD ReservedSizeOfCodeViewSymbols;
|
|
PVOID ReservedCodeViewSymbols;
|
|
PSTR ImageFilePath;
|
|
PSTR ImageFileName;
|
|
PSTR ReservedDebugFilePath;
|
|
DWORD ReservedTimeDateStamp;
|
|
BOOL ReservedRomImage;
|
|
PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
|
|
DWORD ReservedNumberOfDebugDirectories;
|
|
DWORD ReservedOriginalFunctionTableBaseAddress;
|
|
DWORD Reserved[ 2 ];
|
|
} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
|
|
|
|
|
|
PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PCSTR, PCSTR, ULONG);
|
|
|
|
BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
|
|
|
|
DWORD WINAPI SymGetOptions(void);
|
|
DWORD WINAPI SymSetOptions(DWORD);
|
|
|
|
BOOL WINAPI SymSetParentWindow(HWND);
|
|
|
|
/*************************
|
|
* Version, global stuff *
|
|
*************************/
|
|
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVEROPENPROC)(void);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERCLOSEPROC)(void);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
|
|
typedef BOOL (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64);
|
|
typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR);
|
|
typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR);
|
|
|
|
#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
|
|
|
|
/* 32-bit functions */
|
|
|
|
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
|
|
|
|
#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
|
|
#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
|
|
#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
|
|
#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
|
|
#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
|
|
#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
|
|
#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
|
|
#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
|
|
#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACKW64
|
|
#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
|
|
|
|
#define EnumerateLoadedModules EnumerateLoadedModules64
|
|
#define StackWalk StackWalk64
|
|
#define SymEnumerateModules SymEnumerateModules64
|
|
#define SymEnumerateSymbols SymEnumerateSymbols64
|
|
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
|
|
#define SymFunctionTableAccess SymFunctionTableAccess64
|
|
#define SymGetLineFromAddr SymGetLineFromAddr64
|
|
#define SymGetLineFromAddrW SymGetLineFromAddrW64
|
|
#define SymGetLineFromName SymGetLineFromName64
|
|
#define SymGetLineNext SymGetLineNext64
|
|
#define SymGetLineNextW SymGetLineNextW64
|
|
#define SymGetLinePrev SymGetLinePrev64
|
|
#define SymGetLinePrevW SymGetLinePrevW64
|
|
#define SymGetModuleBase SymGetModuleBase64
|
|
#define SymGetModuleInfo SymGetModuleInfo64
|
|
#define SymGetModuleInfoW SymGetModuleInfoW64
|
|
#define SymGetSymFromAddr SymGetSymFromAddr64
|
|
#define SymGetSymFromName SymGetSymFromName64
|
|
#define SymGetSymNext SymGetSymNext64
|
|
#define SymGetSymNextW SymGetSymNextW64
|
|
#define SymGetSymPrev SymGetSymPrev64
|
|
#define SymGetSymPrevW SymGetSymPrevW64
|
|
#define SymLoadModule SymLoadModule64
|
|
#define SymRegisterCallback SymRegisterCallback64
|
|
#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
|
|
#define SymUnDName SymUnDName64
|
|
#define SymUnloadModule SymUnloadModule64
|
|
|
|
#else
|
|
|
|
typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
|
|
typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD);
|
|
typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD);
|
|
typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE, DWORD, PVOID, DWORD, PDWORD);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
|
|
typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, ULONG, ULONG, PVOID);
|
|
typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID);
|
|
typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID);
|
|
typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS);
|
|
|
|
BOOL WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID);
|
|
BOOL WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID, PREAD_PROCESS_MEMORY_ROUTINE, PFUNCTION_TABLE_ACCESS_ROUTINE, PGET_MODULE_BASE_ROUTINE, PTRANSLATE_ADDRESS_ROUTINE);
|
|
BOOL WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID);
|
|
BOOL WINAPI SymEnumerateSymbols(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACK, PVOID);
|
|
BOOL WINAPI SymEnumerateSymbolsW(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACKW, PVOID);
|
|
PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD);
|
|
BOOL WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE);
|
|
BOOL WINAPI SymGetLineFromAddrW(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINEW);
|
|
BOOL WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE);
|
|
BOOL WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE);
|
|
BOOL WINAPI SymGetLineNextW(HANDLE, PIMAGEHLP_LINEW);
|
|
BOOL WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE);
|
|
BOOL WINAPI SymGetLinePrevW(HANDLE, PIMAGEHLP_LINEW);
|
|
DWORD WINAPI SymGetModuleBase(HANDLE, DWORD);
|
|
BOOL WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE);
|
|
BOOL WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW);
|
|
BOOL WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
|
|
BOOL WINAPI SymGetSymFromName(HANDLE, PCSTR, PIMAGEHLP_SYMBOL);
|
|
BOOL WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL);
|
|
BOOL WINAPI SymGetSymNextW(HANDLE, PIMAGEHLP_SYMBOLW);
|
|
BOOL WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL);
|
|
BOOL WINAPI SymGetSymPrevW(HANDLE, PIMAGEHLP_SYMBOLW);
|
|
DWORD WINAPI SymLoadModule(HANDLE, HANDLE, PCSTR, PCSTR, DWORD, DWORD);
|
|
BOOL WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID);
|
|
BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID);
|
|
BOOL WINAPI SymRefreshModuleList(HANDLE);
|
|
BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD);
|
|
BOOL WINAPI SymUnloadModule(HANDLE, DWORD);
|
|
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C" */
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
#endif /* __WINE_DBGHELP_H */
|