Headers diff for imagehlp.dll between 6.1.7601.18288-Windows_7.0 and 6.3.9600.17415-Windows_8.1 versions



 imagehlp.h (6.1.7601.18288-Windows_7.0)   imagehlp.h (6.3.9600.17415-Windows_8.1) 
skipping to change at line 25 skipping to change at line 25
--*/ --*/
#ifndef _IMAGEHLP_ #ifndef _IMAGEHLP_
#define _IMAGEHLP_ #define _IMAGEHLP_
#if _MSC_VER > 1020 #if _MSC_VER > 1020
#pragma once #pragma once
#endif #endif
#include <winapifamily.h>
#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
// As a general principal always call the 64 bit version // As a general principal always call the 64 bit version
// 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
#include <pshpack8.h> #include <pshpack8.h>
// For those without specstrings.h
// Since there are different versions of this header, I need to
// individually test each item and define it if it is not around.
#ifndef __in
#define __in
#endif
#ifndef __out
#define __out
#endif
#ifndef __inout
#define __inout
#endif
#ifndef __in_opt
#define __in_opt
#endif
#ifndef __out_opt
#define __out_opt
#endif
#ifndef __inout_opt
#define __inout_opt
#endif
#ifndef __in_ecount
#define __in_ecount(x)
#endif
#ifndef __out_ecount
#define __out_ecount(x)
#endif
#ifndef __inout_ecount
#define __inout_ecount(x)
#endif
#ifndef __in_bcount
#define __in_bcount(x)
#endif
#ifndef __out_bcount
#define __out_bcount(x)
#endif
#ifndef __inout_bcount
#define __inout_bcount(x)
#endif
#ifndef __out_xcount
#define __out_xcount(x)
#endif
#ifndef __deref_opt_out
#define __deref_opt_out
#endif
#ifndef __deref_out
#define __deref_out
#endif
#ifndef __out_ecount_opt
#define __out_ecount_opt(x)
#endif
#ifndef __in_bcount_opt
#define __in_bcount_opt(x)
#endif
#ifndef __out_bcount_opt
#define __out_bcount_opt(x)
#endif
#ifndef __deref_out_opt
#define __deref_out_opt
#endif
#ifndef WINTRUST_H #ifndef WINTRUST_H
#include <wintrust.h> #include <wintrust.h>
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifdef _IMAGEHLP_SOURCE_ #ifdef _IMAGEHLP_SOURCE_
#define IMAGEAPI __stdcall #define IMAGEAPI __stdcall
skipping to change at line 159 skipping to change at line 102
UCHAR Version; 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
BOOL BOOL
IMAGEAPI IMAGEAPI
BindImage( BindImage(
__in PCSTR ImageName, _In_ PCSTR ImageName,
__in PCSTR DllPath, _In_ PCSTR DllPath,
__in PCSTR SymbolPath _In_ PCSTR SymbolPath
); );
typedef enum _IMAGEHLP_STATUS_REASON { typedef enum _IMAGEHLP_STATUS_REASON {
BindOutOfMemory, BindOutOfMemory,
BindRvaToVaFailed, BindRvaToVaFailed,
BindNoRoomInImage, BindNoRoomInImage,
BindImportModuleFailed, BindImportModuleFailed,
BindImportProcedureFailed, BindImportProcedureFailed,
BindImportModule, BindImportModule,
BindImportProcedure, BindImportProcedure,
skipping to change at line 190 skipping to change at line 133
BindImportProcedure64, BindImportProcedure64,
BindForwarder32, BindForwarder32,
BindForwarder64, BindForwarder64,
BindForwarderNOT32, BindForwarderNOT32,
BindForwarderNOT64 BindForwarderNOT64
} IMAGEHLP_STATUS_REASON; } IMAGEHLP_STATUS_REASON;
typedef typedef
BOOL BOOL
(__stdcall *PIMAGEHLP_STATUS_ROUTINE)( (__stdcall *PIMAGEHLP_STATUS_ROUTINE)(
__in IMAGEHLP_STATUS_REASON Reason, _In_ IMAGEHLP_STATUS_REASON Reason,
__in PCSTR ImageName, _In_ PCSTR ImageName,
__in PCSTR DllName, _In_ PCSTR DllName,
__in ULONG_PTR Va, _In_ ULONG_PTR Va,
__in ULONG_PTR Parameter _In_ ULONG_PTR Parameter
); );
typedef typedef
BOOL BOOL
(__stdcall *PIMAGEHLP_STATUS_ROUTINE32)( (__stdcall *PIMAGEHLP_STATUS_ROUTINE32)(
__in IMAGEHLP_STATUS_REASON Reason, _In_ IMAGEHLP_STATUS_REASON Reason,
__in PCSTR ImageName, _In_ PCSTR ImageName,
__in PCSTR DllName, _In_ PCSTR DllName,
__in ULONG Va, _In_ ULONG Va,
__in ULONG_PTR Parameter _In_ ULONG_PTR Parameter
); );
typedef typedef
BOOL BOOL
(__stdcall *PIMAGEHLP_STATUS_ROUTINE64)( (__stdcall *PIMAGEHLP_STATUS_ROUTINE64)(
__in IMAGEHLP_STATUS_REASON Reason, _In_ IMAGEHLP_STATUS_REASON Reason,
__in PCSTR ImageName, _In_ PCSTR ImageName,
__in PCSTR DllName, _In_ PCSTR DllName,
__in ULONG64 Va, _In_ ULONG64 Va,
__in ULONG_PTR Parameter _In_ ULONG_PTR Parameter
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
BindImageEx( BindImageEx(
__in DWORD Flags, _In_ DWORD Flags,
__in PCSTR ImageName, _In_ PCSTR ImageName,
__in PCSTR DllPath, _In_ PCSTR DllPath,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__in_opt PIMAGEHLP_STATUS_ROUTINE StatusRoutine _In_opt_ PIMAGEHLP_STATUS_ROUTINE StatusRoutine
); );
#define BIND_NO_BOUND_IMPORTS 0x00000001 #define BIND_NO_BOUND_IMPORTS 0x00000001
#define BIND_NO_UPDATE 0x00000002 #define BIND_NO_UPDATE 0x00000002
#define BIND_ALL_IMAGES 0x00000004 #define BIND_ALL_IMAGES 0x00000004
#define BIND_CACHE_IMPORT_DLLS 0x00000008 // Cache dll's across #define BIND_CACHE_IMPORT_DLLS 0x00000008 // Cache dll's across
// calls to BindImageEx // calls to BindImageEx
// (same as NT 3.1->NT 4.0) // (same as NT 3.1->NT 4.0)
#define BIND_REPORT_64BIT_VA 0x00000010 #define BIND_REPORT_64BIT_VA 0x00000010
BOOL BOOL
IMAGEAPI IMAGEAPI
ReBaseImage( ReBaseImage(
__in PCSTR CurrentImageName, _In_ PCSTR CurrentImageName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__in BOOL fReBase, // TRUE if actually rebasing, false if only _In_ BOOL fReBase, // TRUE if actually rebasing, false if only
summing summing
__in BOOL fRebaseSysfileOk, // TRUE is system images s/b rebased _In_ BOOL fRebaseSysfileOk, // TRUE is system images s/b rebased
__in BOOL fGoingDown, // TRUE if the image s/b rebased below the _In_ BOOL fGoingDown, // TRUE if the image s/b rebased below the
given base given base
__in ULONG CheckImageSize, // Max size allowed (0 if don't care) _In_ ULONG CheckImageSize, // Max size allowed (0 if don't care)
__out ULONG *OldImageSize, // Returned from the header _Out_ ULONG *OldImageSize, // Returned from the header
__out ULONG_PTR *OldImageBase, // Returned from the header _Out_ ULONG_PTR *OldImageBase, // Returned from the header
__out ULONG *NewImageSize, // Image size rounded to next separation bo _Out_ ULONG *NewImageSize, // Image size rounded to next separation bo
undary undary
__inout ULONG_PTR *NewImageBase, // (in) Desired new address. _Inout_ ULONG_PTR *NewImageBase, // (in) Desired new address.
// (out) Next address (actual if going down ) // (out) Next address (actual if going down )
__in ULONG TimeStamp // new timestamp for image, if non-zero _In_ ULONG TimeStamp // new timestamp for image, if non-zero
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ReBaseImage64( ReBaseImage64(
__in PCSTR CurrentImageName, _In_ PCSTR CurrentImageName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__in BOOL fReBase, // TRUE if actually rebasing, false if only _In_ BOOL fReBase, // TRUE if actually rebasing, false if only
summing summing
__in BOOL fRebaseSysfileOk, // TRUE is system images s/b rebased _In_ BOOL fRebaseSysfileOk, // TRUE is system images s/b rebased
__in BOOL fGoingDown, // TRUE if the image s/b rebased below the g _In_ BOOL fGoingDown, // TRUE if the image s/b rebased below the g
iven base iven base
__in ULONG CheckImageSize, // Max size allowed (0 if don't care) _In_ ULONG CheckImageSize, // Max size allowed (0 if don't care)
__out ULONG *OldImageSize, // Returned from the header _Out_ ULONG *OldImageSize, // Returned from the header
__out ULONG64 *OldImageBase, // Returned from the header _Out_ ULONG64 *OldImageBase, // Returned from the header
__out ULONG *NewImageSize, // Image size rounded to next separation bou _Out_ ULONG *NewImageSize, // Image size rounded to next separation bou
ndary ndary
__inout ULONG64 *NewImageBase, // (in) Desired new address. _Inout_ ULONG64 *NewImageBase, // (in) Desired new address.
// (out) Next address (actual if going down) // (out) Next address (actual if going down)
__in ULONG TimeStamp // new timestamp for image, if non-zero _In_ ULONG TimeStamp // new timestamp for image, if non-zero
); );
// //
// Define checksum return codes. // Define checksum return codes.
// //
#define CHECKSUM_SUCCESS 0 #define CHECKSUM_SUCCESS 0
#define CHECKSUM_OPEN_FAILURE 1 #define CHECKSUM_OPEN_FAILURE 1
#define CHECKSUM_MAP_FAILURE 2 #define CHECKSUM_MAP_FAILURE 2
#define CHECKSUM_MAPVIEW_FAILURE 3 #define CHECKSUM_MAPVIEW_FAILURE 3
skipping to change at line 302 skipping to change at line 245
#define SPLITSYM_SYMBOLPATH_IS_SRC 0x00000004 // The SymbolFilePath contai ns an alternate #define SPLITSYM_SYMBOLPATH_IS_SRC 0x00000004 // The SymbolFilePath contai ns an alternate
// path to locate the pdb. // path to locate the pdb.
// //
// Define checksum function prototypes. // Define checksum function prototypes.
// //
PIMAGE_NT_HEADERS PIMAGE_NT_HEADERS
IMAGEAPI IMAGEAPI
CheckSumMappedFile ( CheckSumMappedFile (
__in PVOID BaseAddress, _In_ PVOID BaseAddress,
__in DWORD FileLength, _In_ DWORD FileLength,
__out PDWORD HeaderSum, _Out_ PDWORD HeaderSum,
__out PDWORD CheckSum _Out_ PDWORD CheckSum
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
MapFileAndCheckSumA ( MapFileAndCheckSumA (
__in PCSTR Filename, _In_ PCSTR Filename,
__out PDWORD HeaderSum, _Out_ PDWORD HeaderSum,
__out PDWORD CheckSum _Out_ PDWORD CheckSum
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
MapFileAndCheckSumW ( MapFileAndCheckSumW (
__in PCWSTR Filename, _In_ PCWSTR Filename,
__out PDWORD HeaderSum, _Out_ PDWORD HeaderSum,
__out PDWORD CheckSum _Out_ PDWORD CheckSum
); );
#ifdef UNICODE #ifdef UNICODE
#define MapFileAndCheckSum MapFileAndCheckSumW #define MapFileAndCheckSum MapFileAndCheckSumW
#else #else
#define MapFileAndCheckSum MapFileAndCheckSumA #define MapFileAndCheckSum MapFileAndCheckSumA
#endif // !UNICODE #endif // !UNICODE
BOOL BOOL
IMAGEAPI IMAGEAPI
GetImageConfigInformation( GetImageConfigInformation(
__in PLOADED_IMAGE LoadedImage, _In_ PLOADED_IMAGE LoadedImage,
__out PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation _Out_ PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
GetImageUnusedHeaderBytes( GetImageUnusedHeaderBytes(
__in PLOADED_IMAGE LoadedImage, _In_ PLOADED_IMAGE LoadedImage,
__out PDWORD SizeUnusedHeaderBytes _Out_ PDWORD SizeUnusedHeaderBytes
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SetImageConfigInformation( SetImageConfigInformation(
__inout PLOADED_IMAGE LoadedImage, _Inout_ PLOADED_IMAGE LoadedImage,
__in PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation _In_ PIMAGE_LOAD_CONFIG_DIRECTORY ImageConfigInformation
); );
// Image Integrity API's // Image Integrity API's
#define CERT_PE_IMAGE_DIGEST_DEBUG_INFO 0x01 #define CERT_PE_IMAGE_DIGEST_DEBUG_INFO 0x01
#define CERT_PE_IMAGE_DIGEST_RESOURCES 0x02 #define CERT_PE_IMAGE_DIGEST_RESOURCES 0x02
#define CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO 0x04 #define CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO 0x04
#define CERT_PE_IMAGE_DIGEST_NON_PE_INFO 0x08 // include data outsid e the PE image #define CERT_PE_IMAGE_DIGEST_NON_PE_INFO 0x08 // include data outsid e the PE image
#define CERT_SECTION_TYPE_ANY 0xFF // Any Certificate typ e #define CERT_SECTION_TYPE_ANY 0xFF // Any Certificate typ e
typedef PVOID DIGEST_HANDLE; typedef PVOID DIGEST_HANDLE;
typedef BOOL (WINAPI *DIGEST_FUNCTION) (DIGEST_HANDLE refdata, PBYTE pData, DWOR D dwLength); typedef BOOL (WINAPI *DIGEST_FUNCTION) (DIGEST_HANDLE refdata, PBYTE pData, DWOR D dwLength);
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageGetDigestStream( ImageGetDigestStream(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in DWORD DigestLevel, _In_ DWORD DigestLevel,
__in DIGEST_FUNCTION DigestFunction, _In_ DIGEST_FUNCTION DigestFunction,
__in DIGEST_HANDLE DigestHandle _In_ DIGEST_HANDLE DigestHandle
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageAddCertificate( ImageAddCertificate(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in LPWIN_CERTIFICATE Certificate, _In_ LPWIN_CERTIFICATE Certificate,
__out PDWORD Index _Out_ PDWORD Index
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageRemoveCertificate( ImageRemoveCertificate(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in DWORD Index _In_ DWORD Index
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageEnumerateCertificates( ImageEnumerateCertificates(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in WORD TypeFilter, _In_ WORD TypeFilter,
__out PDWORD CertificateCount, _Out_ PDWORD CertificateCount,
__inout_ecount_opt(IndexCount) PDWORD Indices, _Inout_updates_opt_(IndexCount) PDWORD Indices,
__in_opt DWORD IndexCount _In_opt_ DWORD IndexCount
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageGetCertificateData( ImageGetCertificateData(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in DWORD CertificateIndex, _In_ DWORD CertificateIndex,
__out LPWIN_CERTIFICATE Certificate, _Out_ LPWIN_CERTIFICATE Certificate,
__inout PDWORD RequiredLength _Inout_ PDWORD RequiredLength
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageGetCertificateHeader( ImageGetCertificateHeader(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in DWORD CertificateIndex, _In_ DWORD CertificateIndex,
__inout LPWIN_CERTIFICATE Certificateheader _Inout_ LPWIN_CERTIFICATE Certificateheader
); );
PLOADED_IMAGE PLOADED_IMAGE
IMAGEAPI IMAGEAPI
ImageLoad( ImageLoad(
__in PCSTR DllName, _In_ PCSTR DllName,
__in_opt PCSTR DllPath _In_opt_ PCSTR DllPath
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
ImageUnload( ImageUnload(
__inout PLOADED_IMAGE LoadedImage _Inout_ PLOADED_IMAGE LoadedImage
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
MapAndLoad( MapAndLoad(
__in PCSTR ImageName, _In_ PCSTR ImageName,
__in_opt PCSTR DllPath, _In_opt_ PCSTR DllPath,
__out PLOADED_IMAGE LoadedImage, _Out_ PLOADED_IMAGE LoadedImage,
__in BOOL DotDll, _In_ BOOL DotDll,
__in BOOL ReadOnly _In_ BOOL ReadOnly
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
UnMapAndLoad( UnMapAndLoad(
__inout PLOADED_IMAGE LoadedImage _Inout_ PLOADED_IMAGE LoadedImage
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
TouchFileTimes ( TouchFileTimes (
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in_opt PSYSTEMTIME pSystemTime _In_opt_ PSYSTEMTIME pSystemTime
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SplitSymbols ( SplitSymbols (
__inout PSTR ImageName, _Inout_ PSTR ImageName,
__in PCSTR SymbolsPath, _In_ PCSTR SymbolsPath,
__inout PSTR SymbolFilePath, _Inout_ PSTR SymbolFilePath,
__in ULONG Flags _In_ ULONG Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
UpdateDebugInfoFile( UpdateDebugInfoFile(
__in PCSTR ImageFileName, _In_ PCSTR ImageFileName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath, _Out_writes_(MAX_PATH + 1) PSTR DebugFilePath,
__in PIMAGE_NT_HEADERS32 NtHeaders _In_ PIMAGE_NT_HEADERS32 NtHeaders
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
UpdateDebugInfoFileEx( UpdateDebugInfoFileEx(
__in PCSTR ImageFileName, _In_ PCSTR ImageFileName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__out_ecount(MAX_PATH+1) PSTR DebugFilePath, _Out_writes_(MAX_PATH+1) PSTR DebugFilePath,
__in PIMAGE_NT_HEADERS32 NtHeaders, _In_ PIMAGE_NT_HEADERS32 NtHeaders,
__in DWORD OldCheckSum _In_ DWORD OldCheckSum
); );
// Error codes set by dbghelp functions. Call GetLastError // Error codes set by dbghelp functions. Call GetLastError
// to see them. // to see them.
// Dbghelp also sets error codes found in winerror.h // 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_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_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 #define ERROR_NO_PDB_POINTER 0x8802 // image does not point to a pdb fil e
typedef BOOL typedef BOOL
(CALLBACK *PFIND_DEBUG_FILE_CALLBACK)( (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in PCSTR FileName, _In_ PCSTR FileName,
__in PVOID CallerData _In_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
SymFindDebugInfoFile( SymFindDebugInfoFile(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PCSTR FileName, _In_ PCSTR FileName,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath, _Out_writes_(MAX_PATH + 1) PSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACK Callback, _In_opt_ PFIND_DEBUG_FILE_CALLBACK Callback,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
typedef BOOL typedef BOOL
(CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)( (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in PCWSTR FileName, _In_ PCWSTR FileName,
__in PVOID CallerData _In_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
SymFindDebugInfoFileW( SymFindDebugInfoFileW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PCWSTR FileName, _In_ PCWSTR FileName,
__out_ecount(MAX_PATH + 1) PWSTR DebugFilePath, _Out_writes_(MAX_PATH + 1) PWSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACKW Callback, _In_opt_ PFIND_DEBUG_FILE_CALLBACKW Callback,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindDebugInfoFile ( FindDebugInfoFile (
__in PCSTR FileName, _In_ PCSTR FileName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath _Out_writes_(MAX_PATH + 1) PSTR DebugFilePath
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindDebugInfoFileEx ( FindDebugInfoFileEx (
__in PCSTR FileName, _In_ PCSTR FileName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath, _Out_writes_(MAX_PATH + 1) PSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACK Callback, _In_opt_ PFIND_DEBUG_FILE_CALLBACK Callback,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindDebugInfoFileExW ( FindDebugInfoFileExW (
__in PCWSTR FileName, _In_ PCWSTR FileName,
__in PCWSTR SymbolPath, _In_ PCWSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PWSTR DebugFilePath, _Out_writes_(MAX_PATH + 1) PWSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACKW Callback, _In_opt_ PFIND_DEBUG_FILE_CALLBACKW Callback,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
typedef BOOL typedef BOOL
(CALLBACK *PFINDFILEINPATHCALLBACK)( (CALLBACK *PFINDFILEINPATHCALLBACK)(
__in PCSTR filename, _In_ PCSTR filename,
__in PVOID context _In_ PVOID context
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFindFileInPath( SymFindFileInPath(
__in HANDLE hprocess, _In_ HANDLE hprocess,
__in_opt PCSTR SearchPath, _In_opt_ PCSTR SearchPath,
__in PCSTR FileName, _In_ PCSTR FileName,
__in_opt PVOID id, _In_opt_ PVOID id,
__in DWORD two, _In_ DWORD two,
__in DWORD three, _In_ DWORD three,
__in DWORD flags, _In_ DWORD flags,
__out_ecount(MAX_PATH + 1) PSTR FoundFile, _Out_writes_(MAX_PATH + 1) PSTR FoundFile,
__in_opt PFINDFILEINPATHCALLBACK callback, _In_opt_ PFINDFILEINPATHCALLBACK callback,
__in_opt PVOID context _In_opt_ PVOID context
); );
typedef BOOL typedef BOOL
(CALLBACK *PFINDFILEINPATHCALLBACKW)( (CALLBACK *PFINDFILEINPATHCALLBACKW)(
__in PCWSTR filename, _In_ PCWSTR filename,
__in PVOID context _In_ PVOID context
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFindFileInPathW( SymFindFileInPathW(
__in HANDLE hprocess, _In_ HANDLE hprocess,
__in_opt PCWSTR SearchPath, _In_opt_ PCWSTR SearchPath,
__in PCWSTR FileName, _In_ PCWSTR FileName,
__in_opt PVOID id, _In_opt_ PVOID id,
__in DWORD two, _In_ DWORD two,
__in DWORD three, _In_ DWORD three,
__in DWORD flags, _In_ DWORD flags,
__out_ecount(MAX_PATH + 1) PWSTR FoundFile, _Out_writes_(MAX_PATH + 1) PWSTR FoundFile,
__in_opt PFINDFILEINPATHCALLBACKW callback, _In_opt_ PFINDFILEINPATHCALLBACKW callback,
__in_opt PVOID context _In_opt_ PVOID context
); );
typedef BOOL typedef BOOL
(CALLBACK *PFIND_EXE_FILE_CALLBACK)( (CALLBACK *PFIND_EXE_FILE_CALLBACK)(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in PCSTR FileName, _In_ PCSTR FileName,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
SymFindExecutableImage( SymFindExecutableImage(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PCSTR FileName, _In_ PCSTR FileName,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath, _Out_writes_(MAX_PATH + 1) PSTR ImageFilePath,
__in PFIND_EXE_FILE_CALLBACK Callback, _In_ PFIND_EXE_FILE_CALLBACK Callback,
__in PVOID CallerData _In_ PVOID CallerData
); );
typedef BOOL typedef BOOL
(CALLBACK *PFIND_EXE_FILE_CALLBACKW)( (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(
__in HANDLE FileHandle, _In_ HANDLE FileHandle,
__in PCWSTR FileName, _In_ PCWSTR FileName,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
SymFindExecutableImageW( SymFindExecutableImageW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PCWSTR FileName, _In_ PCWSTR FileName,
__out_ecount(MAX_PATH + 1) PWSTR ImageFilePath, _Out_writes_(MAX_PATH + 1) PWSTR ImageFilePath,
__in PFIND_EXE_FILE_CALLBACKW Callback, _In_ PFIND_EXE_FILE_CALLBACKW Callback,
__in PVOID CallerData _In_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindExecutableImage( FindExecutableImage(
__in PCSTR FileName, _In_ PCSTR FileName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath _Out_writes_(MAX_PATH + 1) PSTR ImageFilePath
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindExecutableImageEx( FindExecutableImageEx(
__in PCSTR FileName, _In_ PCSTR FileName,
__in PCSTR SymbolPath, _In_ PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath, _Out_writes_(MAX_PATH + 1) PSTR ImageFilePath,
__in_opt PFIND_EXE_FILE_CALLBACK Callback, _In_opt_ PFIND_EXE_FILE_CALLBACK Callback,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
HANDLE HANDLE
IMAGEAPI IMAGEAPI
FindExecutableImageExW( FindExecutableImageExW(
__in PCWSTR FileName, _In_ PCWSTR FileName,
__in PCWSTR SymbolPath, _In_ PCWSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PWSTR ImageFilePath, _Out_writes_(MAX_PATH + 1) PWSTR ImageFilePath,
__in_opt PFIND_EXE_FILE_CALLBACKW Callback, _In_opt_ PFIND_EXE_FILE_CALLBACKW Callback,
__in PVOID CallerData _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_opt PIMAGE_SECTION_HEADER *FoundHeader _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_opt OUT PIMAGE_SECTION_HEADER *LastRvaSection _In_opt_ OUT PIMAGE_SECTION_HEADER *LastRvaSection
); );
#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;
skipping to change at line 747 skipping to change at line 690
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(
__in_opt HANDLE FileHandle, _In_opt_ HANDLE FileHandle,
__in PCSTR FileName, _In_ PCSTR FileName,
__in_opt PCSTR SymbolPath, _In_opt_ PCSTR SymbolPath,
__in ULONG ImageBase _In_ ULONG ImageBase
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
UnmapDebugInformation( UnmapDebugInformation(
__out_xcount(unknown) PIMAGE_DEBUG_INFORMATION DebugInfo _Out_writes_(_Inexpressible_(unknown)) PIMAGE_DEBUG_INFORMATION DebugInfo
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SearchTreeForFile( SearchTreeForFile(
__in PCSTR RootPath, _In_ PCSTR RootPath,
__in PCSTR InputPathName, _In_ PCSTR InputPathName,
__out_ecount(MAX_PATH + 1) PSTR OutputPathBuffer _Out_writes_(MAX_PATH + 1) PSTR OutputPathBuffer
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SearchTreeForFileW( SearchTreeForFileW(
__in PCWSTR RootPath, _In_ PCWSTR RootPath,
__in PCWSTR InputPathName, _In_ PCWSTR InputPathName,
__out_ecount(MAX_PATH + 1) PWSTR OutputPathBuffer _Out_writes_(MAX_PATH + 1) PWSTR OutputPathBuffer
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMDIRTREE_CALLBACK)( (CALLBACK *PENUMDIRTREE_CALLBACK)(
__in PCSTR FilePath, _In_ PCSTR FilePath,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumDirTree( EnumDirTree(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in PCSTR RootPath, _In_ PCSTR RootPath,
__in PCSTR InputPathName, _In_ PCSTR InputPathName,
__out_ecount_opt(MAX_PATH + 1) PSTR OutputPathBuffer, _Out_writes_opt_(MAX_PATH + 1) PSTR OutputPathBuffer,
__in_opt PENUMDIRTREE_CALLBACK cb, _In_opt_ PENUMDIRTREE_CALLBACK cb,
__in_opt PVOID data _In_opt_ PVOID data
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMDIRTREE_CALLBACKW)( (CALLBACK *PENUMDIRTREE_CALLBACKW)(
__in PCWSTR FilePath, _In_ PCWSTR FilePath,
__in_opt PVOID CallerData _In_opt_ PVOID CallerData
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumDirTreeW( EnumDirTreeW(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in PCWSTR RootPath, _In_ PCWSTR RootPath,
__in PCWSTR InputPathName, _In_ PCWSTR InputPathName,
__out_ecount_opt(MAX_PATH + 1) PWSTR OutputPathBuffer, _Out_writes_opt_(MAX_PATH + 1) PWSTR OutputPathBuffer,
__in_opt PENUMDIRTREE_CALLBACKW cb, _In_opt_ PENUMDIRTREE_CALLBACKW cb,
__in_opt PVOID data _In_opt_ PVOID data
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
MakeSureDirectoryPathExists( MakeSureDirectoryPathExists(
__in 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 844 skipping to change at line 787
#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(
__in PCSTR name, _In_ PCSTR name,
__out_ecount(maxStringLength) PSTR outputString, _Out_writes_(maxStringLength) PSTR outputString,
__in DWORD maxStringLength, _In_ DWORD maxStringLength,
__in DWORD flags _In_ DWORD flags
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
WINAPI WINAPI
UnDecorateSymbolNameW( UnDecorateSymbolNameW(
__in PCWSTR name, _In_ PCWSTR name,
__out_ecount(maxStringLength) PWSTR outputString, _Out_writes_(maxStringLength) PWSTR outputString,
__in DWORD maxStringLength, _In_ DWORD maxStringLength,
__in DWORD flags _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
#define DBHHEADER_CVMISC 0x2 #define DBHHEADER_CVMISC 0x2
skipping to change at line 921 skipping to change at line 864
#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(
__in LPADDRESS a32, _In_ LPADDRESS a32,
__out 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(
__in LPADDRESS64 a64, _In_ LPADDRESS64 a64,
__out 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 1010 skipping to change at line 953
// Added in API version 10. // Added in API version 10.
// //
DWORD64 KiUserExceptionDispatcher; DWORD64 KiUserExceptionDispatcher;
// //
// Stack bounds, added in API version 11. // Stack bounds, added in API version 11.
// //
DWORD64 StackBase; DWORD64 StackBase;
DWORD64 StackLimit; DWORD64 StackLimit;
DWORD64 Reserved[5]; //
// Target OS build number. Added in API version 12.
//
DWORD BuildVersion;
DWORD Reserved0;
DWORD64 Reserved1[4];
} 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 1081 skipping to change at line 1029
DWORD StackBase; DWORD StackBase;
DWORD StackLimit; DWORD StackLimit;
DWORD Reserved[5]; DWORD Reserved[5];
} KDHELP, *PKDHELP; } KDHELP, *PKDHELP;
__inline __inline
void void
KdHelp32To64( KdHelp32To64(
__in PKDHELP p32, _In_ PKDHELP p32,
__out 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->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher;
skipping to change at line 1112 skipping to change at line 1060
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
DWORD64 Params[4]; // possible arguments to the function DWORD64 Params[4]; // possible arguments to the function
BOOL Far; // WOW far call BOOL Far; // WOW far call
BOOL Virtual; // is this a virtual frame? BOOL Virtual; // is this a virtual frame?
DWORD64 Reserved[3]; DWORD64 Reserved[3];
KDHELP64 KdHelp; KDHELP64 KdHelp;
} STACKFRAME64, *LPSTACKFRAME64; } STACKFRAME64, *LPSTACKFRAME64;
#define INLINE_FRAME_CONTEXT_INIT 0
#define INLINE_FRAME_CONTEXT_IGNORE 0xFFFFFFFF
typedef struct _tagSTACKFRAME_EX {
// First, STACKFRAME64 structure
ADDRESS64 AddrPC; // program counter
ADDRESS64 AddrReturn; // return address
ADDRESS64 AddrFrame; // frame pointer
ADDRESS64 AddrStack; // stack pointer
ADDRESS64 AddrBStore; // backing store pointer
PVOID FuncTableEntry; // pointer to pdata/fpo or NULL
DWORD64 Params[4]; // possible arguments to the function
BOOL Far; // WOW far call
BOOL Virtual; // is this a virtual frame?
DWORD64 Reserved[3];
KDHELP64 KdHelp;
// Extended STACKFRAME fields
DWORD StackFrameSize;
DWORD InlineFrameContext;
} STACKFRAME_EX, *LPSTACKFRAME_EX;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define STACKFRAME STACKFRAME64 #define STACKFRAME STACKFRAME64
#define LPSTACKFRAME LPSTACKFRAME64 #define LPSTACKFRAME LPSTACKFRAME64
#else #else
typedef struct _tagSTACKFRAME { typedef struct _tagSTACKFRAME {
ADDRESS AddrPC; // program counter ADDRESS AddrPC; // program counter
ADDRESS AddrReturn; // return address ADDRESS AddrReturn; // return address
ADDRESS AddrFrame; // frame pointer ADDRESS AddrFrame; // frame pointer
ADDRESS AddrStack; // stack pointer ADDRESS AddrStack; // stack pointer
PVOID FuncTableEntry; // pointer to pdata/fpo or NULL PVOID FuncTableEntry; // pointer to pdata/fpo or NULL
skipping to change at line 1134 skipping to change at line 1104
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)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 qwBaseAddress, _In_ DWORD64 qwBaseAddress,
__out_bcount(nSize) PVOID lpBuffer, _Out_writes_bytes_(nSize) PVOID lpBuffer,
__in DWORD nSize, _In_ DWORD nSize,
__out LPDWORD lpNumberOfBytesRead _Out_ LPDWORD lpNumberOfBytesRead
); );
typedef typedef
PVOID PVOID
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)( (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)(
__in HANDLE ahProcess, _In_ HANDLE ahProcess,
__in DWORD64 AddrBase _In_ DWORD64 AddrBase
); );
typedef typedef
DWORD64 DWORD64
(__stdcall *PGET_MODULE_BASE_ROUTINE64)( (__stdcall *PGET_MODULE_BASE_ROUTINE64)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 Address _In_ DWORD64 Address
); );
typedef typedef
DWORD64 DWORD64
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)( (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in HANDLE hThread, _In_ HANDLE hThread,
__in LPADDRESS64 lpaddr _In_ LPADDRESS64 lpaddr
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
StackWalk64( StackWalk64(
__in DWORD MachineType, _In_ DWORD MachineType,
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in HANDLE hThread, _In_ HANDLE hThread,
__inout LPSTACKFRAME64 StackFrame, _Inout_ LPSTACKFRAME64 StackFrame,
__inout PVOID ContextRecord, _Inout_ PVOID ContextRecord,
__in_opt PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, _In_opt_ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
__in_opt PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, _In_opt_ PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
__in_opt PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, _In_opt_ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
__in_opt PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress _In_opt_ PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
);
#define SYM_STKWALK_DEFAULT 0x00000000
#define SYM_STKWALK_FORCE_FRAMEPTR 0x00000001
BOOL
IMAGEAPI
StackWalkEx(
_In_ DWORD MachineType,
_In_ HANDLE hProcess,
_In_ HANDLE hThread,
_Inout_ LPSTACKFRAME_EX StackFrame,
_Inout_ PVOID ContextRecord,
_In_opt_ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
_In_opt_ PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
_In_opt_ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
_In_opt_ PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress,
_In_ DWORD Flags
); );
#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)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD lpBaseAddress, _In_ DWORD lpBaseAddress,
__out_bcount(nSize) PVOID lpBuffer, _Out_writes_bytes_(nSize) PVOID lpBuffer,
__in DWORD nSize, _In_ DWORD nSize,
__out PDWORD lpNumberOfBytesRead _Out_ PDWORD lpNumberOfBytesRead
); );
typedef typedef
PVOID PVOID
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)( (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD AddrBase _In_ DWORD AddrBase
); );
typedef typedef
DWORD DWORD
(__stdcall *PGET_MODULE_BASE_ROUTINE)( (__stdcall *PGET_MODULE_BASE_ROUTINE)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD Address _In_ DWORD Address
); );
typedef typedef
DWORD DWORD
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE)( (__stdcall *PTRANSLATE_ADDRESS_ROUTINE)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in HANDLE hThread, _In_ HANDLE hThread,
__out LPADDRESS lpaddr _Out_ LPADDRESS lpaddr
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
StackWalk( StackWalk(
DWORD MachineType, DWORD MachineType,
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in HANDLE hThread, _In_ HANDLE hThread,
__inout LPSTACKFRAME StackFrame, _Inout_ LPSTACKFRAME StackFrame,
__inout PVOID ContextRecord, _Inout_ PVOID ContextRecord,
__in_opt PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, _In_opt_ PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
__in_opt PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, _In_opt_ PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
__in_opt PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, _In_opt_ PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
__in_opt PTRANSLATE_ADDRESS_ROUTINE TranslateAddress _In_opt_ PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
); );
#endif #endif
#define API_VERSION_NUMBER 11 #define API_VERSION_NUMBER 12
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(
__in LPAPI_VERSION AppVersion _In_ LPAPI_VERSION AppVersion
); );
DWORD DWORD
IMAGEAPI IMAGEAPI
GetTimestampForLoadedLibrary( GetTimestampForLoadedLibrary(
__in 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)(
__in PCSTR ModuleName, _In_ PCSTR ModuleName,
__in DWORD64 BaseOfDll, _In_ DWORD64 BaseOfDll,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)( (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(
__in PCWSTR ModuleName, _In_ PCWSTR ModuleName,
__in DWORD64 BaseOfDll, _In_ DWORD64 BaseOfDll,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMLOADED_MODULES_CALLBACK64)( (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(
__in PCSTR ModuleName, _In_ PCSTR ModuleName,
__in DWORD64 ModuleBase, _In_ DWORD64 ModuleBase,
__in ULONG ModuleSize, _In_ ULONG ModuleSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)( (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(
__in PCWSTR ModuleName, _In_ PCWSTR ModuleName,
__in DWORD64 ModuleBase, _In_ DWORD64 ModuleBase,
__in ULONG ModuleSize, _In_ ULONG ModuleSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)( (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(
__in PCSTR SymbolName, _In_ PCSTR SymbolName,
__in DWORD64 SymbolAddress, _In_ DWORD64 SymbolAddress,
__in ULONG SymbolSize, _In_ ULONG SymbolSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)( (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(
__in PCWSTR SymbolName, _In_ PCWSTR SymbolName,
__in DWORD64 SymbolAddress, _In_ DWORD64 SymbolAddress,
__in ULONG SymbolSize, _In_ ULONG SymbolSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)( (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG ActionCode, _In_ ULONG ActionCode,
__in_opt ULONG64 CallbackData, _In_opt_ ULONG64 CallbackData,
__in_opt ULONG64 UserContext _In_opt_ ULONG64 UserContext
); );
typedef typedef
PVOID PVOID
(CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)( (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD AddrBase, _In_ DWORD AddrBase,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef typedef
PVOID PVOID
(CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)( (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 AddrBase, _In_ ULONG64 AddrBase,
__in 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)(
__in PCSTR ModuleName, _In_ PCSTR ModuleName,
__in ULONG BaseOfDll, _In_ ULONG BaseOfDll,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)( (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(
__in PCSTR SymbolName, _In_ PCSTR SymbolName,
__in ULONG SymbolAddress, _In_ ULONG SymbolAddress,
__in ULONG SymbolSize, _In_ ULONG SymbolSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)( (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(
__in PCWSTR SymbolName, _In_ PCWSTR SymbolName,
__in ULONG SymbolAddress, _In_ ULONG SymbolAddress,
__in ULONG SymbolSize, _In_ ULONG SymbolSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PENUMLOADED_MODULES_CALLBACK)( (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(
__in PCSTR ModuleName, _In_ PCSTR ModuleName,
__in ULONG ModuleBase, _In_ ULONG ModuleBase,
__in ULONG ModuleSize, _In_ ULONG ModuleSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYMBOL_REGISTERED_CALLBACK)( (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG ActionCode, _In_ ULONG ActionCode,
__in_opt PVOID CallbackData, _In_opt_ PVOID CallbackData,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#endif #endif
// values found in SYMBOL_INFO.Tag // values found in SYMBOL_INFO.Tag
// //
// This was taken from cvconst.h and should // This was taken from cvconst.h and should
// not override any values found there. // not override any values found there.
// //
// #define _NO_CVCONST_H_ if you don't // #define _NO_CVCONST_H_ if you don't
skipping to change at line 1433 skipping to change at line 1420
SymTagFuncDebugStart, SymTagFuncDebugStart,
SymTagFuncDebugEnd, SymTagFuncDebugEnd,
SymTagUsingNamespace, SymTagUsingNamespace,
SymTagVTableShape, SymTagVTableShape,
SymTagVTable, SymTagVTable,
SymTagCustom, SymTagCustom,
SymTagThunk, SymTagThunk,
SymTagCustomType, SymTagCustomType,
SymTagManagedType, SymTagManagedType,
SymTagDimension, SymTagDimension,
SymTagCallSite,
SymTagMax SymTagMax
}; };
#endif #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_SLOT 0x00008000
#define SYMFLAG_ILREL 0x00010000 #define SYMFLAG_ILREL 0x00010000
#define SYMFLAG_METADATA 0x00020000 #define SYMFLAG_METADATA 0x00020000
#define SYMFLAG_CLR_TOKEN 0x00040000 #define SYMFLAG_CLR_TOKEN 0x00040000
#define SYMFLAG_NULL 0x00080000
#define SYMFLAG_FUNC_NO_RETURN 0x00100000
#define SYMFLAG_SYNTHETIC_ZEROBASE 0x00200000
#define SYMFLAG_PUBLIC_CODE 0x00400000
// this resets SymNext/Prev to the beginning // this resets SymNext/Prev to the beginning
// of the module passed in the address field // of the module passed in the address field
#define SYMFLAG_RESET 0x80000000 #define SYMFLAG_RESET 0x80000000
// //
// symbol type enumeration // symbol type enumeration
// //
typedef enum { typedef enum {
skipping to change at line 1586 skipping to change at line 1578
GUID PdbSig70; // Signature of PDB (VC 7 and up) GUID PdbSig70; // Signature of PDB (VC 7 and up)
DWORD PdbAge; // DBI age of pdb DWORD PdbAge; // DBI age of pdb
BOOL PdbUnmatched; // loaded an unmatched pdb BOOL PdbUnmatched; // loaded an unmatched pdb
BOOL DbgUnmatched; // loaded an unmatched dbg BOOL DbgUnmatched; // loaded an unmatched dbg
BOOL LineNumbers; // we have line number information BOOL LineNumbers; // we have line number information
BOOL GlobalSymbols; // we have internal symbol information BOOL GlobalSymbols; // we have internal symbol information
BOOL TypeInfo; // we have type information BOOL TypeInfo; // we have type information
// new elements: 17-Dec-2003 // new elements: 17-Dec-2003
BOOL SourceIndexed; // pdb supports source server BOOL SourceIndexed; // pdb supports source server
BOOL Publics; // contains public symbols BOOL Publics; // contains public symbols
// new element: 15-Jul-2009
DWORD MachineType; // IMAGE_FILE_MACHINE_XXX from ntimage.h an
d winnt.h
DWORD Reserved; // Padding - don't remove.
} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
typedef struct _IMAGEHLP_MODULEW64 { typedef struct _IMAGEHLP_MODULEW64 {
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64) DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)
DWORD64 BaseOfImage; // base load address of module DWORD64 BaseOfImage; // base load address of module
DWORD ImageSize; // virtual size of the loaded module DWORD ImageSize; // virtual size of the loaded module
DWORD TimeDateStamp; // date/time stamp from pe header DWORD TimeDateStamp; // date/time stamp from pe header
DWORD CheckSum; // checksum from the pe header DWORD CheckSum; // checksum from the pe header
DWORD NumSyms; // number of symbols in the symbol table DWORD NumSyms; // number of symbols in the symbol table
SYM_TYPE SymType; // type of symbols loaded SYM_TYPE SymType; // type of symbols loaded
skipping to change at line 1614 skipping to change at line 1609
GUID PdbSig70; // Signature of PDB (VC 7 and up) GUID PdbSig70; // Signature of PDB (VC 7 and up)
DWORD PdbAge; // DBI age of pdb DWORD PdbAge; // DBI age of pdb
BOOL PdbUnmatched; // loaded an unmatched pdb BOOL PdbUnmatched; // loaded an unmatched pdb
BOOL DbgUnmatched; // loaded an unmatched dbg BOOL DbgUnmatched; // loaded an unmatched dbg
BOOL LineNumbers; // we have line number information BOOL LineNumbers; // we have line number information
BOOL GlobalSymbols; // we have internal symbol information BOOL GlobalSymbols; // we have internal symbol information
BOOL TypeInfo; // we have type information BOOL TypeInfo; // we have type information
// new elements: 17-Dec-2003 // new elements: 17-Dec-2003
BOOL SourceIndexed; // pdb supports source server BOOL SourceIndexed; // pdb supports source server
BOOL Publics; // contains public symbols BOOL Publics; // contains public symbols
// new element: 15-Jul-2009
DWORD MachineType; // IMAGE_FILE_MACHINE_XXX from ntimage.h an
d winnt.h
DWORD Reserved; // Padding - don't remove.
} 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(IMAGEHLP_MODULE) DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE)
skipping to change at line 1721 skipping to change at line 1719
#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
#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
#define CBA_SET_OPTIONS 0x00000008 #define CBA_SET_OPTIONS 0x00000008
#define CBA_EVENT 0x00000010 #define CBA_EVENT 0x00000010
#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
#define CBA_DEBUG_INFO 0x10000000 #define CBA_DEBUG_INFO 0x10000000
#define CBA_SRCSRV_INFO 0x20000000 #define CBA_SRCSRV_INFO 0x20000000
#define CBA_SRCSRV_EVENT 0x40000000 #define CBA_SRCSRV_EVENT 0x40000000
#define CBA_UPDATE_STATUS_BAR 0x50000000
#define CBA_ENGINE_PRESENT 0x60000000
#define CBA_CHECK_ENGOPT_DISALLOW_NETWORK_PATHS 0x70000000
typedef struct _IMAGEHLP_CBA_READ_MEMORY { typedef struct _IMAGEHLP_CBA_READ_MEMORY {
DWORD64 addr; // address to read from DWORD64 addr; // address to read from
PVOID buf; // buffer to read to PVOID buf; // buffer to read to
DWORD bytes; // amount of bytes to re ad DWORD bytes; // amount of bytes to re ad
DWORD *bytesread; // pointer to store amou nt of bytes read DWORD *bytesread; // pointer to store amou nt of bytes read
} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY; } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
enum { enum {
sevInfo = 0, sevInfo = 0,
skipping to change at line 1777 skipping to change at line 1778
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_L OADW64) DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_L OADW64)
DWORD64 BaseOfImage; // base load address of module DWORD64 BaseOfImage; // base load address of module
DWORD CheckSum; // checksum from the pe header DWORD CheckSum; // checksum from the pe header
DWORD TimeDateStamp; // date/time stamp from pe header DWORD TimeDateStamp; // date/time stamp from pe header
WCHAR FileName[MAX_PATH + 1]; // symbols file or image name WCHAR FileName[MAX_PATH + 1]; // symbols file or image name
BOOLEAN Reparse; // load failure reparse BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passed HANDLE hFile; // file handle, if passed
DWORD Flags; // DWORD Flags; //
} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64; } IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
#define DSLFLAG_MISMATCHED_PDB 0x1 #define DSLFLAG_MISMATCHED_PDB 0x1
#define DSLFLAG_MISMATCHED_DBG 0x2 #define DSLFLAG_MISMATCHED_DBG 0x2
#define FLAG_ENGINE_PRESENT 0x4
#define FLAG_ENGOPT_DISALLOW_NETWORK_PATHS 0x8
#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(IMAGEHLP_DEFERRED_SYMBOL_L OAD) DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_L OAD)
DWORD BaseOfImage; // base load address of module DWORD BaseOfImage; // base load address of module
DWORD CheckSum; // checksum from the pe header DWORD CheckSum; // checksum from the pe header
DWORD TimeDateStamp; // date/time stamp from pe header DWORD TimeDateStamp; // date/time stamp from pe header
skipping to change at line 1819 skipping to change at line 1822
PIMAGEHLP_SYMBOL Symbol; // array of duplicate symbols PIMAGEHLP_SYMBOL Symbol; // array of duplicate symbols
DWORD SelectedSymbol; // symbol selected (-1 to start) DWORD SelectedSymbol; // symbol selected (-1 to 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(
__in HWND hwnd _In_ HWND hwnd
); );
PCHAR PCHAR
IMAGEAPI IMAGEAPI
SymSetHomeDirectory( SymSetHomeDirectory(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in_opt PCSTR dir _In_opt_ PCSTR dir
); );
PWSTR PWSTR
IMAGEAPI IMAGEAPI
SymSetHomeDirectoryW( SymSetHomeDirectoryW(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in_opt PCWSTR dir _In_opt_ PCWSTR dir
); );
PCHAR PCHAR
IMAGEAPI IMAGEAPI
SymGetHomeDirectory( SymGetHomeDirectory(
__in DWORD type, _In_ DWORD type,
__out_ecount(size) PSTR dir, _Out_writes_(size) PSTR dir,
__in size_t size _In_ size_t size
); );
PWSTR PWSTR
IMAGEAPI IMAGEAPI
SymGetHomeDirectoryW( SymGetHomeDirectoryW(
__in DWORD type, _In_ DWORD type,
__out_ecount(size) PWSTR dir, _Out_writes_(size) PWSTR dir,
__in size_t size _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
}; };
typedef struct _OMAP { typedef struct _OMAP {
ULONG rva; ULONG rva;
ULONG rvaTo; ULONG rvaTo;
} OMAP, *POMAP; } OMAP, *POMAP;
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetOmaps( SymGetOmaps(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 BaseOfDll, _In_ DWORD64 BaseOfDll,
__out POMAP *OmapTo, _Out_ POMAP *OmapTo,
__out PDWORD64 cOmapTo, _Out_ PDWORD64 cOmapTo,
__out POMAP *OmapFrom, _Out_ POMAP *OmapFrom,
__out PDWORD64 cOmapFrom _Out_ PDWORD64 cOmapFrom
); );
// //
// options that are set/returned by SymSetOptions() & SymGetOptions() // options that are set/returned by SymSetOptions() & SymGetOptions()
// these are used as a mask // these are used as a mask
// //
#define SYMOPT_CASE_INSENSITIVE 0x00000001 #define SYMOPT_CASE_INSENSITIVE 0x00000001
#define SYMOPT_UNDNAME 0x00000002 #define SYMOPT_UNDNAME 0x00000002
#define SYMOPT_DEFERRED_LOADS 0x00000004 #define SYMOPT_DEFERRED_LOADS 0x00000004
#define SYMOPT_NO_CPP 0x00000008 #define SYMOPT_NO_CPP 0x00000008
skipping to change at line 1905 skipping to change at line 1908
#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_OVERWRITE 0x00100000
#define SYMOPT_IGNORE_IMAGEDIR 0x00200000 #define SYMOPT_IGNORE_IMAGEDIR 0x00200000
#define SYMOPT_FLAT_DIRECTORY 0x00400000 #define SYMOPT_FLAT_DIRECTORY 0x00400000
#define SYMOPT_FAVOR_COMPRESSED 0x00800000 #define SYMOPT_FAVOR_COMPRESSED 0x00800000
#define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000 #define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000 #define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000
#define SYMOPT_READONLY_CACHE 0x04000000
#define SYMOPT_SYMPATH_LAST 0x08000000
#define SYMOPT_DISABLE_FAST_SYMBOLS 0x10000000
#define SYMOPT_DISABLE_SYMSRV_TIMEOUT 0x20000000
#define SYMOPT_DISABLE_SRVSTAR_ON_STARTUP 0x40000000
#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 PCSTR string, _In_ PCSTR string,
__in PCSTR expression, _In_ PCSTR expression,
__in BOOL fCase _In_ BOOL fCase
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymMatchStringA( SymMatchStringA(
__in PCSTR string, _In_ PCSTR string,
__in PCSTR expression, _In_ PCSTR expression,
__in BOOL fCase _In_ BOOL fCase
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymMatchStringW( SymMatchStringW(
__in PCWSTR string, _In_ PCWSTR string,
__in PCWSTR expression, _In_ PCWSTR expression,
__in BOOL fCase _In_ BOOL fCase
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)( (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(
__in PSOURCEFILE pSourceFile, _In_ PSOURCEFILE pSourceFile,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
// for backwards compatibility - don't use this // for backwards compatibility - don't use this
#define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK #define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSourceFiles( SymEnumSourceFiles(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 ModBase, _In_ ULONG64 ModBase,
__in_opt PCSTR Mask, _In_opt_ PCSTR Mask,
__in PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles, _In_ PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)( (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(
__in PSOURCEFILEW pSourceFile, _In_ PSOURCEFILEW pSourceFile,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSourceFilesW( SymEnumSourceFilesW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 ModBase, _In_ ULONG64 ModBase,
__in_opt PCWSTR Mask, _In_opt_ PCWSTR Mask,
__in PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles, _In_ PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateModules64( SymEnumerateModules64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, _In_ PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateModulesW64( SymEnumerateModulesW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, _In_ PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateModules SymEnumerateModules64 #define SymEnumerateModules SymEnumerateModules64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateModules( SymEnumerateModules(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, _In_ PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumerateLoadedModulesEx( EnumerateLoadedModulesEx(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, _In_ PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumerateLoadedModulesExW( EnumerateLoadedModulesExW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, _In_ PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumerateLoadedModules64( EnumerateLoadedModules64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, _In_ PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
EnumerateLoadedModulesW64( EnumerateLoadedModulesW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, _In_ PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext _In_opt_ 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_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#endif #endif
PVOID PVOID
IMAGEAPI IMAGEAPI
SymFunctionTableAccess64( SymFunctionTableAccess64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 AddrBase _In_ DWORD64 AddrBase
);
PVOID
IMAGEAPI
SymFunctionTableAccess64AccessRoutines(
_In_ HANDLE hProcess,
_In_ DWORD64 AddrBase,
_In_opt_ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
_In_opt_ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine
); );
#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(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD AddrBase _In_ DWORD AddrBase
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetUnwindInfo( SymGetUnwindInfo(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 Address, _In_ DWORD64 Address,
__out_bcount_opt(*Size) PVOID Buffer, _Out_writes_bytes_opt_(*Size) PVOID Buffer,
__inout PULONG Size _Inout_ PULONG Size
); );
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 #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
skipping to change at line 2161 skipping to change at line 2177
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
WCHAR Obj[MAX_PATH + 1]; // the object file within the module WCHAR Obj[MAX_PATH + 1]; // the object file within the module
WCHAR FileName[MAX_PATH + 1]; // full filename WCHAR 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
} SRCCODEINFOW, *PSRCCODEINFOW; } SRCCODEINFOW, *PSRCCODEINFOW;
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMLINES_CALLBACK)( (CALLBACK *PSYM_ENUMLINES_CALLBACK)(
__in PSRCCODEINFO LineInfo, _In_ PSRCCODEINFO LineInfo,
__in_opt 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_opt PCSTR Obj, _In_opt_ PCSTR Obj,
__in_opt PCSTR File, _In_opt_ PCSTR File,
__in PSYM_ENUMLINES_CALLBACK EnumLinesCallback, _In_ PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMLINES_CALLBACKW)( (CALLBACK *PSYM_ENUMLINES_CALLBACKW)(
__in PSRCCODEINFOW LineInfo, _In_ PSRCCODEINFOW LineInfo,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumLinesW( SymEnumLinesW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCWSTR Obj, _In_opt_ PCWSTR Obj,
__in_opt PCWSTR File, _In_opt_ PCWSTR File,
__in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, _In_ PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromAddr64( SymGetLineFromAddr64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 qwAddr, _In_ DWORD64 qwAddr,
__out PDWORD pdwDisplacement, _Out_ PDWORD pdwDisplacement,
__out PIMAGEHLP_LINE64 Line64 _Out_ PIMAGEHLP_LINE64 Line64
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromAddrW64( SymGetLineFromAddrW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 dwAddr, _In_ DWORD64 dwAddr,
__out PDWORD pdwDisplacement, _Out_ PDWORD pdwDisplacement,
__out PIMAGEHLP_LINEW64 Line _Out_ PIMAGEHLP_LINEW64 Line
);
BOOL
IMAGEAPI
SymGetLineFromInlineContext(
_In_ HANDLE hProcess,
_In_ DWORD64 qwAddr,
_In_ ULONG InlineContext,
_In_opt_ DWORD64 qwModuleBaseAddress,
_Out_ PDWORD pdwDisplacement,
_Out_ PIMAGEHLP_LINE64 Line64
);
BOOL
IMAGEAPI
SymGetLineFromInlineContextW(
_In_ HANDLE hProcess,
_In_ DWORD64 dwAddr,
_In_ ULONG InlineContext,
_In_opt_ DWORD64 qwModuleBaseAddress,
_Out_ PDWORD pdwDisplacement,
_Out_ PIMAGEHLP_LINEW64 Line
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSourceLines( SymEnumSourceLines(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCSTR Obj, _In_opt_ PCSTR Obj,
__in_opt PCSTR File, _In_opt_ PCSTR File,
__in_opt DWORD Line, _In_opt_ DWORD Line,
__in DWORD Flags, _In_ DWORD Flags,
__in PSYM_ENUMLINES_CALLBACK EnumLinesCallback, _In_ PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSourceLinesW( SymEnumSourceLinesW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCWSTR Obj, _In_opt_ PCWSTR Obj,
__in_opt PCWSTR File, _In_opt_ PCWSTR File,
__in_opt DWORD Line, _In_opt_ DWORD Line,
__in DWORD Flags, _In_ DWORD Flags,
__in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, _In_ PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
);
// Check whether input Address includes "inline stack".
DWORD
IMAGEAPI
SymAddrIncludeInlineTrace(
_In_ HANDLE hProcess,
_In_ DWORD64 Address
);
#define SYM_INLINE_COMP_ERROR 0
#define SYM_INLINE_COMP_IDENTICAL 1
#define SYM_INLINE_COMP_STEPIN 2
#define SYM_INLINE_COMP_STEPOUT 3
#define SYM_INLINE_COMP_STEPOVER 4
#define SYM_INLINE_COMP_DIFFERENT 5
// Compare the "inline stack" from the 2 input addresses and determine whether t
he difference is possibly from
// what execution control operation. The return value would be onr of the litera
ls defined above.
DWORD
IMAGEAPI
SymCompareInlineTrace(
_In_ HANDLE hProcess,
_In_ DWORD64 Address1,
_In_ DWORD InlineContext1,
_In_ DWORD64 RetAddress1,
_In_ DWORD64 Address2,
_In_ DWORD64 RetAddress2
);
BOOL
IMAGEAPI
SymQueryInlineTrace(
_In_ HANDLE hProcess,
_In_ DWORD64 StartAddress,
_In_ DWORD StartContext,
_In_ DWORD64 StartRetAddress,
_In_ DWORD64 CurAddress,
_Out_ LPDWORD CurContext,
_Out_ LPDWORD CurFrameIndex
); );
// flags for SymEnumSourceLines // flags for SymEnumSourceLines
#define ESLFLAG_FULLPATH 0x1 #define ESLFLAG_FULLPATH 0x00000001
#define ESLFLAG_NEAREST 0x2 #define ESLFLAG_NEAREST 0x00000002
#define ESLFLAG_PREV 0x4 #define ESLFLAG_PREV 0x00000004
#define ESLFLAG_NEXT 0x8 #define ESLFLAG_NEXT 0x00000008
#define ESLFLAG_INLINE_SITE 0x00000010
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineFromAddr SymGetLineFromAddr64 #define SymGetLineFromAddr SymGetLineFromAddr64
#define SymGetLineFromAddrW SymGetLineFromAddrW64 #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 BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromAddrW( SymGetLineFromAddrW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD dwAddr, _In_ DWORD dwAddr,
__out PDWORD pdwDisplacement, _Out_ PDWORD pdwDisplacement,
__out PIMAGEHLP_LINEW Line _Out_ PIMAGEHLP_LINEW Line
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromName64( SymGetLineFromName64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR ModuleName, _In_opt_ PCSTR ModuleName,
__in_opt PCSTR FileName, _In_opt_ PCSTR FileName,
__in DWORD dwLineNumber, _In_ DWORD dwLineNumber,
__out PLONG plDisplacement, _Out_ PLONG plDisplacement,
__inout PIMAGEHLP_LINE64 Line _Inout_ PIMAGEHLP_LINE64 Line
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineFromNameW64( SymGetLineFromNameW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR ModuleName, _In_opt_ PCWSTR ModuleName,
__in_opt PCWSTR FileName, _In_opt_ PCWSTR FileName,
__in DWORD dwLineNumber, _In_ DWORD dwLineNumber,
__out PLONG plDisplacement, _Out_ PLONG plDisplacement,
__inout PIMAGEHLP_LINEW64 Line _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_opt PCSTR ModuleName, _In_opt_ PCSTR ModuleName,
__in_opt PCSTR FileName, _In_opt_ PCSTR FileName,
__in DWORD dwLineNumber, _In_ DWORD dwLineNumber,
__out PLONG plDisplacement, _Out_ PLONG plDisplacement,
__inout PIMAGEHLP_LINE Line _Inout_ PIMAGEHLP_LINE Line
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineNext64( SymGetLineNext64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_LINE64 Line _Inout_ PIMAGEHLP_LINE64 Line
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineNextW64( SymGetLineNextW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_LINEW64 Line _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,
__inout PIMAGEHLP_LINE Line _Inout_ PIMAGEHLP_LINE Line
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLineNextW( SymGetLineNextW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_LINEW Line _Inout_ PIMAGEHLP_LINEW Line
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLinePrev64( SymGetLinePrev64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_LINE64 Line _Inout_ PIMAGEHLP_LINE64 Line
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLinePrevW64( SymGetLinePrevW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_LINEW64 Line _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,
__inout PIMAGEHLP_LINE Line _Inout_ PIMAGEHLP_LINE Line
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetLinePrevW( SymGetLinePrevW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_LINEW Line _Inout_ PIMAGEHLP_LINEW Line
); );
#endif #endif
ULONG ULONG
IMAGEAPI IMAGEAPI
SymGetFileLineOffsets64( SymGetFileLineOffsets64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR ModuleName, _In_opt_ PCSTR ModuleName,
__in PCSTR FileName, _In_ PCSTR FileName,
__out_ecount(BufferLines) PDWORD64 Buffer, _Out_writes_(BufferLines) PDWORD64 Buffer,
__in ULONG BufferLines _In_ ULONG BufferLines
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymMatchFileName( SymMatchFileName(
__in PCSTR FileName, _In_ PCSTR FileName,
__in PCSTR Match, _In_ PCSTR Match,
__deref_opt_out PSTR *FileNameStop, _Outptr_opt_ PSTR *FileNameStop,
__deref_opt_out PSTR *MatchStop _Outptr_opt_ PSTR *MatchStop
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymMatchFileNameW( SymMatchFileNameW(
__in PCWSTR FileName, _In_ PCWSTR FileName,
__in PCWSTR Match, _In_ PCWSTR Match,
__deref_opt_out PWSTR *FileNameStop, _Outptr_opt_ PWSTR *FileNameStop,
__deref_opt_out PWSTR *MatchStop _Outptr_opt_ PWSTR *MatchStop
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceFile( SymGetSourceFile(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCSTR Params, _In_opt_ PCSTR Params,
__in PCSTR FileSpec, _In_ PCSTR FileSpec,
__out_ecount(Size) PSTR FilePath, _Out_writes_(Size) PSTR FilePath,
__in DWORD Size _In_ DWORD Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceFileW( SymGetSourceFileW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCWSTR Params, _In_opt_ PCWSTR Params,
__in PCWSTR FileSpec, _In_ PCWSTR FileSpec,
__out_ecount(Size) PWSTR FilePath, _Out_writes_(Size) PWSTR FilePath,
__in DWORD Size _In_ DWORD Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceFileToken( SymGetSourceFileToken(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in PCSTR FileSpec, _In_ PCSTR FileSpec,
__deref_out PVOID *Token, _Outptr_ PVOID *Token,
__out DWORD *Size _Out_ DWORD *Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceFileTokenW( SymGetSourceFileTokenW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in PCWSTR FileSpec, _In_ PCWSTR FileSpec,
__deref_out PVOID *Token, _Outptr_ PVOID *Token,
__out DWORD *Size _Out_ DWORD *Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceFileFromToken( SymGetSourceFileFromToken(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PVOID Token, _In_ PVOID Token,
__in_opt PCSTR Params, _In_opt_ PCSTR Params,
__out_ecount(Size) PSTR FilePath, _Out_writes_(Size) PSTR FilePath,
__in DWORD Size _In_ DWORD Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceFileFromTokenW( SymGetSourceFileFromTokenW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PVOID Token, _In_ PVOID Token,
__in_opt PCWSTR Params, _In_opt_ PCWSTR Params,
__out_ecount(Size) PWSTR FilePath, _Out_writes_(Size) PWSTR FilePath,
__in DWORD Size _In_ DWORD Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceVarFromToken( SymGetSourceVarFromToken(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PVOID Token, _In_ PVOID Token,
__in_opt PCSTR Params, _In_opt_ PCSTR Params,
__in PCSTR VarName, _In_ PCSTR VarName,
__out_ecount(Size) PSTR Value, _Out_writes_(Size) PSTR Value,
__in DWORD Size _In_ DWORD Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSourceVarFromTokenW( SymGetSourceVarFromTokenW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PVOID Token, _In_ PVOID Token,
__in_opt PCWSTR Params, _In_opt_ PCWSTR Params,
__in PCWSTR VarName, _In_ PCWSTR VarName,
__out_ecount(Size) PWSTR Value, _Out_writes_(Size) PWSTR Value,
__in DWORD Size _In_ DWORD Size
); );
typedef BOOL (CALLBACK *PENUMSOURCEFILETOKENSCALLBACK)(__in PVOID token, __in s ize_t size); typedef BOOL (CALLBACK *PENUMSOURCEFILETOKENSCALLBACK)(_In_ PVOID token, _In_ s ize_t size);
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSourceFileTokens( SymEnumSourceFileTokens(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in PENUMSOURCEFILETOKENSCALLBACK Callback _In_ PENUMSOURCEFILETOKENSCALLBACK Callback
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymInitialize( SymInitialize(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR UserSearchPath, _In_opt_ PCSTR UserSearchPath,
__in BOOL fInvadeProcess _In_ BOOL fInvadeProcess
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymInitializeW( SymInitializeW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR UserSearchPath, _In_opt_ PCWSTR UserSearchPath,
__in BOOL fInvadeProcess _In_ BOOL fInvadeProcess
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSearchPath( SymGetSearchPath(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__out_ecount(SearchPathLength) PSTR SearchPath, _Out_writes_(SearchPathLength) PSTR SearchPath,
__in DWORD SearchPathLength _In_ DWORD SearchPathLength
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSearchPathW( SymGetSearchPathW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__out_ecount(SearchPathLength) PWSTR SearchPath, _Out_writes_(SearchPathLength) PWSTR SearchPath,
__in DWORD SearchPathLength _In_ DWORD SearchPathLength
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetSearchPath( SymSetSearchPath(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR SearchPath _In_opt_ PCSTR SearchPath
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetSearchPathW( SymSetSearchPathW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR SearchPath _In_opt_ PCWSTR SearchPath
); );
#define SLMFLAG_VIRTUAL 0x1 #define SLMFLAG_VIRTUAL 0x1
#define SLMFLAG_ALT_INDEX 0x2 #define SLMFLAG_ALT_INDEX 0x2
#define SLMFLAG_NO_SYMBOLS 0x4 #define SLMFLAG_NO_SYMBOLS 0x4
DWORD64 DWORD64
IMAGEAPI IMAGEAPI
SymLoadModuleEx( SymLoadModuleEx(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt HANDLE hFile, _In_opt_ HANDLE hFile,
__in_opt PCSTR ImageName, _In_opt_ PCSTR ImageName,
__in_opt PCSTR ModuleName, _In_opt_ PCSTR ModuleName,
__in DWORD64 BaseOfDll, _In_ DWORD64 BaseOfDll,
__in DWORD DllSize, _In_ DWORD DllSize,
__in_opt PMODLOAD_DATA Data, _In_opt_ PMODLOAD_DATA Data,
__in_opt DWORD Flags _In_opt_ DWORD Flags
); );
DWORD64 DWORD64
IMAGEAPI IMAGEAPI
SymLoadModuleExW( SymLoadModuleExW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt HANDLE hFile, _In_opt_ HANDLE hFile,
__in_opt PCWSTR ImageName, _In_opt_ PCWSTR ImageName,
__in_opt PCWSTR ModuleName, _In_opt_ PCWSTR ModuleName,
__in DWORD64 BaseOfDll, _In_ DWORD64 BaseOfDll,
__in DWORD DllSize, _In_ DWORD DllSize,
__in_opt PMODLOAD_DATA Data, _In_opt_ PMODLOAD_DATA Data,
__in_opt DWORD Flags _In_opt_ DWORD Flags
); );
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_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorat _Out_writes_(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorat
ed name 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_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorat _Out_writes_(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorat
ed name 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 BOOL
IMAGEAPI IMAGEAPI
SymRegisterCallbackW64( SymRegisterCallbackW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, _In_ PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
__in ULONG64 UserContext _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_opt 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_opt 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
skipping to change at line 2726 skipping to change at line 2805
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(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PIMAGEHLP_STACK_FRAME StackFrame, _In_ PIMAGEHLP_STACK_FRAME StackFrame,
__in_opt PIMAGEHLP_CONTEXT Context _In_opt_ PIMAGEHLP_CONTEXT Context
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetScopeFromAddr( SymSetScopeFromAddr(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Address _In_ ULONG64 Address
);
BOOL
IMAGEAPI
SymSetScopeFromInlineContext(
_In_ HANDLE hProcess,
_In_ ULONG64 Address,
_In_ ULONG InlineContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSetScopeFromIndex( SymSetScopeFromIndex(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in DWORD Index _In_ DWORD Index
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMPROCESSES_CALLBACK)( (CALLBACK *PSYM_ENUMPROCESSES_CALLBACK)(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PVOID UserContext _In_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumProcesses( SymEnumProcesses(
__in PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback, _In_ PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback,
__in PVOID UserContext _In_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromAddr( SymFromAddr(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 Address, _In_ DWORD64 Address,
__out_opt PDWORD64 Displacement, _Out_opt_ PDWORD64 Displacement,
__inout PSYMBOL_INFO Symbol _Inout_ PSYMBOL_INFO Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromAddrW( SymFromAddrW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 Address, _In_ DWORD64 Address,
__out_opt PDWORD64 Displacement, _Out_opt_ PDWORD64 Displacement,
__inout PSYMBOL_INFOW Symbol _Inout_ PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymFromInlineContext(
_In_ HANDLE hProcess,
_In_ DWORD64 Address,
_In_ ULONG InlineContext,
_Out_opt_ PDWORD64 Displacement,
_Inout_ PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromInlineContextW(
_In_ HANDLE hProcess,
_In_ DWORD64 Address,
_In_ ULONG InlineContext,
_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,
__inout PSYMBOL_INFO Symbol _Inout_ PSYMBOL_INFO Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromTokenW( SymFromTokenW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 Base, _In_ DWORD64 Base,
__in DWORD Token, _In_ DWORD Token,
__inout PSYMBOL_INFOW Symbol _Inout_ PSYMBOL_INFOW Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymNext( SymNext(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PSYMBOL_INFO si _Inout_ PSYMBOL_INFO si
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymNextW( SymNextW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PSYMBOL_INFOW siw _Inout_ PSYMBOL_INFOW siw
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymPrev( SymPrev(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PSYMBOL_INFO si _Inout_ PSYMBOL_INFO si
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymPrevW( SymPrevW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PSYMBOL_INFOW siw _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 PCSTR Name, _In_ PCSTR Name,
__inout PSYMBOL_INFO Symbol _Inout_ PSYMBOL_INFO Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromNameW( SymFromNameW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in PCWSTR Name, _In_ PCWSTR Name,
__inout PSYMBOL_INFOW Symbol _Inout_ PSYMBOL_INFOW Symbol
); );
#define SYMENUM_OPTIONS_DEFAULT 0x00000001
#define SYMENUM_OPTIONS_INLINE 0x00000002
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)( (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(
__in PSYMBOL_INFO pSymInfo, _In_ PSYMBOL_INFO pSymInfo,
__in ULONG SymbolSize, _In_ ULONG SymbolSize,
__in_opt 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_opt PCSTR Mask, _In_opt_ PCSTR Mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbolsEx(
_In_ HANDLE hProcess,
_In_ ULONG64 BaseOfDll,
_In_opt_ PCSTR Mask,
_In_ PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
_In_opt_ PVOID UserContext,
_In_ DWORD Options
); );
typedef BOOL typedef BOOL
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)( (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(
__in PSYMBOL_INFOW pSymInfo, _In_ PSYMBOL_INFOW pSymInfo,
__in ULONG SymbolSize, _In_ ULONG SymbolSize,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSymbolsW( SymEnumSymbolsW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt PCWSTR Mask, _In_opt_ PCWSTR Mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbolsExW(
_In_ HANDLE hProcess,
_In_ ULONG64 BaseOfDll,
_In_opt_ PCWSTR Mask,
_In_ PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
_In_opt_ PVOID UserContext,
_In_ DWORD Options
); );
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_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumSymbolsForAddrW( SymEnumSymbolsForAddrW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 Address, _In_ DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#define SYMSEARCH_MASKOBJS 0x01 // used internally to implement other AP Is #define SYMSEARCH_MASKOBJS 0x01 // used internally to implement other AP Is
#define SYMSEARCH_RECURSE 0X02 // recurse scopes #define SYMSEARCH_RECURSE 0X02 // recurse scopes
#define SYMSEARCH_GLOBALSONLY 0X04 // search only for global symbols #define SYMSEARCH_GLOBALSONLY 0X04 // search only for global symbols
#define SYMSEARCH_ALLITEMS 0X08 // search for everything in the pdb, not just normal scoped symbols #define SYMSEARCH_ALLITEMS 0X08 // search for everything in the pdb, not just normal scoped symbols
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSearch( SymSearch(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt DWORD Index, _In_opt_ DWORD Index,
__in_opt DWORD SymTag, _In_opt_ DWORD SymTag,
__in_opt PCSTR Mask, _In_opt_ PCSTR Mask,
__in_opt DWORD64 Address, _In_opt_ DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext, _In_opt_ PVOID UserContext,
__in DWORD Options _In_ DWORD Options
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSearchW( SymSearchW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt DWORD Index, _In_opt_ DWORD Index,
__in_opt DWORD SymTag, _In_opt_ DWORD SymTag,
__in_opt PCWSTR Mask, _In_opt_ PCWSTR Mask,
__in_opt DWORD64 Address, _In_opt_ DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext, _In_opt_ PVOID UserContext,
__in DWORD Options _In_ DWORD Options
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetScope( SymGetScope(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in DWORD Index, _In_ DWORD Index,
__inout PSYMBOL_INFO Symbol _Inout_ PSYMBOL_INFO Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetScopeW( SymGetScopeW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in DWORD Index, _In_ DWORD Index,
__inout PSYMBOL_INFOW Symbol _Inout_ PSYMBOL_INFOW Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromIndex( SymFromIndex(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in DWORD Index, _In_ DWORD Index,
__inout PSYMBOL_INFO Symbol _Inout_ PSYMBOL_INFO Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymFromIndexW( SymFromIndexW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in DWORD Index, _In_ DWORD Index,
__inout PSYMBOL_INFOW Symbol _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,
skipping to change at line 3000 skipping to change at line 3132
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_IS_CLOSE_EQUIV_TO,
TI_GTIEX_REQS_VALID, TI_GTIEX_REQS_VALID,
TI_GET_VIRTUALBASEOFFSET, TI_GET_VIRTUALBASEOFFSET,
TI_GET_VIRTUALBASEDISPINDEX, TI_GET_VIRTUALBASEDISPINDEX,
TI_GET_IS_REFERENCE, TI_GET_IS_REFERENCE,
TI_GET_INDIRECTVIRTUALBASECLASS, TI_GET_INDIRECTVIRTUALBASECLASS,
TI_GET_VIRTUALBASETABLETYPE,
IMAGEHLP_SYMBOL_TYPE_INFO_MAX, 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_UNCACHED 0x00000001
#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002 #define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002
typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS { typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS {
IN ULONG SizeOfStruct; IN ULONG SizeOfStruct;
IN ULONG Flags; IN ULONG Flags;
IN ULONG NumIds; IN ULONG NumIds;
IN PULONG TypeIds; IN PULONG TypeIds;
skipping to change at line 3046 skipping to change at line 3179
OUT ULONG EntriesFilled; OUT ULONG EntriesFilled;
OUT ULONG64 TagsFound; OUT ULONG64 TagsFound;
OUT ULONG64 AllReqsValid; OUT ULONG64 AllReqsValid;
IN ULONG NumReqsValid; IN ULONG NumReqsValid;
OUT PULONG64 ReqsValid OPTIONAL; OUT PULONG64 ReqsValid OPTIONAL;
} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS; } IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetTypeInfoEx( SymGetTypeInfoEx(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD64 ModBase, _In_ DWORD64 ModBase,
__inout PIMAGEHLP_GET_TYPE_INFO_PARAMS Params _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_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumTypesW( SymEnumTypesW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumTypesByName( SymEnumTypesByName(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt PCSTR mask, _In_opt_ PCSTR mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumTypesByNameW( SymEnumTypesByNameW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt PCWSTR mask, _In_opt_ PCWSTR mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, _In_ PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetTypeFromName( SymGetTypeFromName(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in PCSTR Name, _In_ PCSTR Name,
__inout PSYMBOL_INFO Symbol _Inout_ PSYMBOL_INFO Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetTypeFromNameW( SymGetTypeFromNameW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in PCWSTR Name, _In_ PCWSTR Name,
__inout PSYMBOL_INFOW Symbol _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 BOOL
IMAGEAPI IMAGEAPI
SymAddSymbolW( SymAddSymbolW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in PCWSTR Name, _In_ PCWSTR Name,
__in DWORD64 Address, _In_ DWORD64 Address,
__in DWORD Size, _In_ DWORD Size,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymDeleteSymbol( SymDeleteSymbol(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt PCSTR Name, _In_opt_ PCSTR Name,
__in DWORD64 Address, _In_ DWORD64 Address,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymDeleteSymbolW( SymDeleteSymbolW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in_opt PCWSTR Name, _In_opt_ PCWSTR Name,
__in DWORD64 Address, _In_ DWORD64 Address,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymRefreshModuleList( SymRefreshModuleList(
__in HANDLE hProcess _In_ HANDLE hProcess
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymAddSourceStream( SymAddSourceStream(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCSTR StreamFile, _In_opt_ PCSTR StreamFile,
__in_bcount_opt(Size) PBYTE Buffer, _In_reads_bytes_opt_(Size) PBYTE Buffer,
__in size_t Size _In_ size_t Size
); );
typedef BOOL (WINAPI *SYMADDSOURCESTREAM)(HANDLE, ULONG64, PCSTR, PBYTE, size_t) ; typedef BOOL (WINAPI *SYMADDSOURCESTREAM)(HANDLE, ULONG64, PCSTR, PBYTE, size_t) ;
BOOL BOOL
IMAGEAPI IMAGEAPI
SymAddSourceStreamA( SymAddSourceStreamA(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCSTR StreamFile, _In_opt_ PCSTR StreamFile,
__in_bcount_opt(Size) PBYTE Buffer, _In_reads_bytes_opt_(Size) PBYTE Buffer,
__in size_t Size _In_ size_t Size
); );
typedef BOOL (WINAPI *SYMADDSOURCESTREAMA)(HANDLE, ULONG64, PCSTR, PBYTE, size_t ); typedef BOOL (WINAPI *SYMADDSOURCESTREAMA)(HANDLE, ULONG64, PCSTR, PBYTE, size_t );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymAddSourceStreamW( SymAddSourceStreamW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 Base, _In_ ULONG64 Base,
__in_opt PCWSTR FileSpec, _In_opt_ PCWSTR FileSpec,
__in_bcount_opt(Size) PBYTE Buffer, _In_reads_bytes_opt_(Size) PBYTE Buffer,
__in size_t Size _In_ size_t Size
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvIsStoreW( SymSrvIsStoreW(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in PCWSTR path _In_ PCWSTR path
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvIsStore( SymSrvIsStore(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in PCSTR path _In_ PCSTR path
); );
PCSTR PCSTR
IMAGEAPI IMAGEAPI
SymSrvDeltaName( SymSrvDeltaName(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR SymPath, _In_opt_ PCSTR SymPath,
__in PCSTR Type, _In_ PCSTR Type,
__in PCSTR File1, _In_ PCSTR File1,
__in PCSTR File2 _In_ PCSTR File2
); );
PCWSTR PCWSTR
IMAGEAPI IMAGEAPI
SymSrvDeltaNameW( SymSrvDeltaNameW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR SymPath, _In_opt_ PCWSTR SymPath,
__in PCWSTR Type, _In_ PCWSTR Type,
__in PCWSTR File1, _In_ PCWSTR File1,
__in PCWSTR File2 _In_ PCWSTR File2
); );
PCSTR PCSTR
IMAGEAPI IMAGEAPI
SymSrvGetSupplement( SymSrvGetSupplement(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR SymPath, _In_opt_ PCSTR SymPath,
__in PCSTR Node, _In_ PCSTR Node,
__in PCSTR File _In_ PCSTR File
); );
PCWSTR PCWSTR
IMAGEAPI IMAGEAPI
SymSrvGetSupplementW( SymSrvGetSupplementW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR SymPath, _In_opt_ PCWSTR SymPath,
__in PCWSTR Node, _In_ PCWSTR Node,
__in PCWSTR File _In_ PCWSTR File
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvGetFileIndexes( SymSrvGetFileIndexes(
__in PCSTR File, _In_ PCSTR File,
__out GUID *Id, _Out_ GUID *Id,
__out PDWORD Val1, _Out_ PDWORD Val1,
__out_opt PDWORD Val2, _Out_opt_ PDWORD Val2,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvGetFileIndexesW( SymSrvGetFileIndexesW(
__in PCWSTR File, _In_ PCWSTR File,
__out GUID *Id, _Out_ GUID *Id,
__out PDWORD Val1, _Out_ PDWORD Val1,
__out_opt PDWORD Val2, _Out_opt_ PDWORD Val2,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvGetFileIndexStringW( SymSrvGetFileIndexStringW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR SrvPath, _In_opt_ PCWSTR SrvPath,
__in PCWSTR File, _In_ PCWSTR File,
__out_ecount(Size) PWSTR Index, _Out_writes_(Size) PWSTR Index,
__in size_t Size, _In_ size_t Size,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvGetFileIndexString( SymSrvGetFileIndexString(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR SrvPath, _In_opt_ PCSTR SrvPath,
__in PCSTR File, _In_ PCSTR File,
__out_ecount(Size) PSTR Index, _Out_writes_(Size) PSTR Index,
__in size_t Size, _In_ size_t Size,
__in DWORD Flags _In_ DWORD Flags
); );
typedef struct { typedef struct {
DWORD sizeofstruct; DWORD sizeofstruct;
char file[MAX_PATH +1]; char file[MAX_PATH +1];
BOOL stripped; BOOL stripped;
DWORD timestamp; DWORD timestamp;
DWORD size; DWORD size;
char dbgfile[MAX_PATH +1]; char dbgfile[MAX_PATH +1];
char pdbfile[MAX_PATH + 1]; char pdbfile[MAX_PATH + 1];
skipping to change at line 3312 skipping to change at line 3445
WCHAR dbgfile[MAX_PATH +1]; WCHAR dbgfile[MAX_PATH +1];
WCHAR pdbfile[MAX_PATH + 1]; WCHAR pdbfile[MAX_PATH + 1];
GUID guid; GUID guid;
DWORD sig; DWORD sig;
DWORD age; DWORD age;
} SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW; } SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW;
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvGetFileIndexInfo( SymSrvGetFileIndexInfo(
__in PCSTR File, _In_ PCSTR File,
__out PSYMSRV_INDEX_INFO Info, _Out_ PSYMSRV_INDEX_INFO Info,
__in DWORD Flags _In_ DWORD Flags
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymSrvGetFileIndexInfoW( SymSrvGetFileIndexInfoW(
__in PCWSTR File, _In_ PCWSTR File,
__out PSYMSRV_INDEX_INFOW Info, _Out_ PSYMSRV_INDEX_INFOW Info,
__in DWORD Flags _In_ DWORD Flags
); );
PCSTR PCSTR
IMAGEAPI IMAGEAPI
SymSrvStoreSupplement( SymSrvStoreSupplement(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR SrvPath, _In_opt_ PCSTR SrvPath,
__in PCSTR Node, _In_ PCSTR Node,
__in PCSTR File, _In_ PCSTR File,
__in DWORD Flags _In_ DWORD Flags
); );
PCWSTR PCWSTR
IMAGEAPI IMAGEAPI
SymSrvStoreSupplementW( SymSrvStoreSupplementW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR SymPath, _In_opt_ PCWSTR SymPath,
__in PCWSTR Node, _In_ PCWSTR Node,
__in PCWSTR File, _In_ PCWSTR File,
__in DWORD Flags _In_ DWORD Flags
); );
PCSTR PCSTR
IMAGEAPI IMAGEAPI
SymSrvStoreFile( SymSrvStoreFile(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCSTR SrvPath, _In_opt_ PCSTR SrvPath,
__in PCSTR File, _In_ PCSTR File,
__in DWORD Flags _In_ DWORD Flags
); );
PCWSTR PCWSTR
IMAGEAPI IMAGEAPI
SymSrvStoreFileW( SymSrvStoreFileW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt PCWSTR SrvPath, _In_opt_ PCWSTR SrvPath,
__in PCWSTR File, _In_ PCWSTR File,
__in DWORD Flags _In_ DWORD Flags
); );
// used by SymGetSymbolFile's "Type" parameter // used by SymGetSymbolFile's "Type" parameter
typedef enum { typedef enum {
sfImage = 0, sfImage = 0,
sfDbg, sfDbg,
sfPdb, sfPdb,
sfMpd, sfMpd,
sfMax sfMax
}; };
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymbolFile( SymGetSymbolFile(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in_opt PCSTR SymPath, _In_opt_ PCSTR SymPath,
__in PCSTR ImageFile, _In_ PCSTR ImageFile,
__in DWORD Type, _In_ DWORD Type,
__out_ecount(cSymbolFile) PSTR SymbolFile, _Out_writes_(cSymbolFile) PSTR SymbolFile,
__in size_t cSymbolFile, _In_ size_t cSymbolFile,
__out_ecount(cDbgFile) PSTR DbgFile, _Out_writes_(cDbgFile) PSTR DbgFile,
__in size_t cDbgFile _In_ size_t cDbgFile
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymbolFileW( SymGetSymbolFileW(
__in_opt HANDLE hProcess, _In_opt_ HANDLE hProcess,
__in_opt PCWSTR SymPath, _In_opt_ PCWSTR SymPath,
__in PCWSTR ImageFile, _In_ PCWSTR ImageFile,
__in DWORD Type, _In_ DWORD Type,
__out_ecount(cSymbolFile) PWSTR SymbolFile, _Out_writes_(cSymbolFile) PWSTR SymbolFile,
__in size_t cSymbolFile, _In_ size_t cSymbolFile,
__out_ecount(cDbgFile) PWSTR DbgFile, _Out_writes_(cDbgFile) PWSTR DbgFile,
__in size_t cDbgFile _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)(
__in DWORD DataType, _In_ DWORD DataType,
__in PVOID* Data, _In_ PVOID* Data,
__out LPDWORD DataLength, _Out_ LPDWORD DataLength,
__in_opt PVOID UserData _In_opt_ PVOID UserData
); );
BOOL BOOL
WINAPI WINAPI
DbgHelpCreateUserDump( DbgHelpCreateUserDump(
__in_opt LPCSTR FileName, _In_opt_ LPCSTR FileName,
__in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback, _In_ PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
__in_opt PVOID UserData _In_opt_ PVOID UserData
); );
BOOL BOOL
WINAPI WINAPI
DbgHelpCreateUserDumpW( DbgHelpCreateUserDumpW(
__in_opt LPCWSTR FileName, _In_opt_ LPCWSTR FileName,
__in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback, _In_ PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
__in_opt 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_opt PDWORD64 pdwDisplacement, _Out_opt_ PDWORD64 pdwDisplacement,
__inout 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_opt PDWORD pdwDisplacement, _Out_opt_ PDWORD pdwDisplacement,
__inout 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 PCSTR Name, _In_ PCSTR Name,
__inout 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 PCSTR Name, _In_ PCSTR Name,
__inout PIMAGEHLP_SYMBOL Symbol _Inout_ PIMAGEHLP_SYMBOL Symbol
); );
#endif #endif
// Symbol server exports // Symbol server exports
// This is the version of the SYMSRV_EXTENDED_OUTPUT_DATA structure.
#define EXT_OUTPUT_VER 1
// This structure indicates the Extended Symsrv.dll output data structure
typedef struct
{
DWORD sizeOfStruct; // size of the structure
DWORD version; // version number (EXT_OUTPUT_VER)
WCHAR filePtrMsg[MAX_PATH + 1]; // File ptr message data buffer
} SYMSRV_EXTENDED_OUTPUT_DATA, *PSYMSRV_EXTENDED_OUTPUT_DATA;
typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR ); typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR );
typedef BOOL (WINAPI *PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PST R); 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 *PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, P WSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROC)(PCSTR, PCSTR, PCSTR, PSTR); typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROC)(PCSTR, PCSTR, PCSTR, PSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCA)(PCSTR, PCSTR, PCSTR, PSTR); typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCA)(PCSTR, PCSTR, PCSTR, PSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCW)(PCWSTR, PCWSTR, PCWSTR, PWSTR); typedef BOOL (WINAPI *PSYMBOLSERVERBYINDEXPROCW)(PCWSTR, PCWSTR, PCWSTR, PWSTR);
typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID); typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID); typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64); typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSWPROC)(UINT_PTR, ULONG64); typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSWPROC)(UINT_PTR, ULONG64);
skipping to change at line 3511 skipping to change at line 3655
typedef BOOL (WINAPI *PSYMBOLSERVERSTORESUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, s ize_t, DWORD); 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 *PSYMBOLSERVERSTORESUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWS TR, size_t, DWORD);
typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRING)(PVOID, DWORD, DWORD, PSTR, si ze_t); typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRING)(PVOID, DWORD, DWORD, PSTR, si ze_t);
typedef BOOL (WINAPI *PSYMBOLSERVERGETINDEXSTRINGW)(PVOID, DWORD, DWORD, PWSTR, size_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 *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 *PSYMBOLSERVERSTOREFILEW)(PCWSTR, PCWSTR, PVOID, DWORD, DWO RD, PWSTR, size_t, DWORD);
typedef BOOL (WINAPI *PSYMBOLSERVERISSTORE)(PCSTR); typedef BOOL (WINAPI *PSYMBOLSERVERISSTORE)(PCSTR);
typedef BOOL (WINAPI *PSYMBOLSERVERISSTOREW)(PCWSTR); typedef BOOL (WINAPI *PSYMBOLSERVERISSTOREW)(PCWSTR);
typedef DWORD (WINAPI *PSYMBOLSERVERVERSION)(); typedef DWORD (WINAPI *PSYMBOLSERVERVERSION)();
typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERMESSAGEPROC)(UINT_PTR action, ULONG6 4 data, ULONG64 context); typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERMESSAGEPROC)(UINT_PTR action, ULONG6 4 data, ULONG64 context);
typedef BOOL (WINAPI *PSYMBOLSERVERWEXPROC)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD,
PWSTR, PSYMSRV_EXTENDED_OUTPUT_DATA);
typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROCWEX)(PCWSTR);
#define SYMSRV_VERSION 2 #define SYMSRV_VERSION 2
#define SSRVOPT_CALLBACK 0x00000001 #define SSRVOPT_CALLBACK 0x00000001
#define SSRVOPT_DWORD 0x00000002 #define SSRVOPT_DWORD 0x00000002
#define SSRVOPT_DWORDPTR 0x00000004 #define SSRVOPT_DWORDPTR 0x00000004
#define SSRVOPT_GUIDPTR 0x00000008 #define SSRVOPT_GUIDPTR 0x00000008
#define SSRVOPT_OLDGUIDPTR 0x00000010 #define SSRVOPT_OLDGUIDPTR 0x00000010
#define SSRVOPT_UNATTENDED 0x00000020 #define SSRVOPT_UNATTENDED 0x00000020
#define SSRVOPT_NOCOPY 0x00000040 #define SSRVOPT_NOCOPY 0x00000040
skipping to change at line 3540 skipping to change at line 3686
#define SSRVOPT_RESETTOU 0x00008000 #define SSRVOPT_RESETTOU 0x00008000
#define SSRVOPT_CALLBACKW 0x00010000 #define SSRVOPT_CALLBACKW 0x00010000
#define SSRVOPT_FLAT_DEFAULT_STORE 0x00020000 #define SSRVOPT_FLAT_DEFAULT_STORE 0x00020000
#define SSRVOPT_PROXYW 0x00040000 #define SSRVOPT_PROXYW 0x00040000
#define SSRVOPT_MESSAGE 0x00080000 #define SSRVOPT_MESSAGE 0x00080000
#define SSRVOPT_SERVICE 0x00100000 // deprecated #define SSRVOPT_SERVICE 0x00100000 // deprecated
#define SSRVOPT_FAVOR_COMPRESSED 0x00200000 #define SSRVOPT_FAVOR_COMPRESSED 0x00200000
#define SSRVOPT_STRING 0x00400000 #define SSRVOPT_STRING 0x00400000
#define SSRVOPT_WINHTTP 0x00800000 #define SSRVOPT_WINHTTP 0x00800000
#define SSRVOPT_WININET 0x01000000 #define SSRVOPT_WININET 0x01000000
#define SSRVOPT_DONT_UNCOMPRESS 0x02000000
#define SSRVOPT_DISABLE_PING_HOST 0x04000000
#define SSRVOPT_DISABLE_TIMEOUT 0x08000000
#define SSRVOPT_ENABLE_COMM_MSG 0x10000000
#define SSRVOPT_MAX 0x0100000 #define SSRVOPT_MAX 0x10000000
#define SSRVOPT_RESET ((ULONG_PTR)-1) #define SSRVOPT_RESET ((ULONG_PTR)-1)
#define NUM_SSRVOPTS 30 #define NUM_SSRVOPTS 30
#define SSRVACTION_TRACE 1 #define SSRVACTION_TRACE 1
#define SSRVACTION_QUERYCANCEL 2 #define SSRVACTION_QUERYCANCEL 2
#define SSRVACTION_EVENT 3 #define SSRVACTION_EVENT 3
#define SSRVACTION_EVENTW 4 #define SSRVACTION_EVENTW 4
#define SSRVACTION_SIZE 5 #define SSRVACTION_SIZE 5
skipping to change at line 3569 skipping to change at line 3719
#define SYMSTOREOPT_PASS_IF_EXISTS 0x40 #define SYMSTOREOPT_PASS_IF_EXISTS 0x40
#ifdef DBGHELP_TRANSLATE_TCHAR #ifdef DBGHELP_TRANSLATE_TCHAR
#define SymInitialize SymInitializeW #define SymInitialize SymInitializeW
#define SymAddSymbol SymAddSymbolW #define SymAddSymbol SymAddSymbolW
#define SymDeleteSymbol SymDeleteSymbolW #define SymDeleteSymbol SymDeleteSymbolW
#define SearchTreeForFile SearchTreeForFileW #define SearchTreeForFile SearchTreeForFileW
#define UnDecorateSymbolName UnDecorateSymbolNameW #define UnDecorateSymbolName UnDecorateSymbolNameW
#define SymGetLineFromName64 SymGetLineFromNameW64 #define SymGetLineFromName64 SymGetLineFromNameW64
#define SymGetLineFromAddr64 SymGetLineFromAddrW64 #define SymGetLineFromAddr64 SymGetLineFromAddrW64
#define SymGetLineFromInlineContext SymGetLineFromInlineContextW
#define SymGetLineNext64 SymGetLineNextW64 #define SymGetLineNext64 SymGetLineNextW64
#define SymGetLinePrev64 SymGetLinePrevW64 #define SymGetLinePrev64 SymGetLinePrevW64
#define SymFromName SymFromNameW #define SymFromName SymFromNameW
#define SymFindExecutableImage SymFindExecutableImageW #define SymFindExecutableImage SymFindExecutableImageW
#define FindExecutableImageEx FindExecutableImageExW #define FindExecutableImageEx FindExecutableImageExW
#define SymSearch SymSearchW #define SymSearch SymSearchW
#define SymEnumLines SymEnumLinesW #define SymEnumLines SymEnumLinesW
#define SymEnumSourceLines SymEnumSourceLinesW #define SymEnumSourceLines SymEnumSourceLinesW
#define SymGetTypeFromName SymGetTypeFromNameW #define SymGetTypeFromName SymGetTypeFromNameW
#define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW #define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW
#define SymFromAddr SymFromAddrW #define SymFromAddr SymFromAddrW
#define SymFromInlineContext SymFromInlineContextW
#define SymMatchString SymMatchStringW #define SymMatchString SymMatchStringW
#define SymEnumSourceFiles SymEnumSourceFilesW #define SymEnumSourceFiles SymEnumSourceFilesW
#define SymEnumSymbols SymEnumSymbolsW #define SymEnumSymbols SymEnumSymbolsW
#define SymEnumSymbolsEx SymEnumSymbolsExW
#define SymLoadModuleEx SymLoadModuleExW #define SymLoadModuleEx SymLoadModuleExW
#define SymSetSearchPath SymSetSearchPathW #define SymSetSearchPath SymSetSearchPathW
#define SymGetSearchPath SymGetSearchPathW #define SymGetSearchPath SymGetSearchPathW
#define EnumDirTree EnumDirTreeW #define EnumDirTree EnumDirTreeW
#define SymFromToken SymFromTokenW #define SymFromToken SymFromTokenW
#define SymFromIndex SymFromIndexW #define SymFromIndex SymFromIndexW
#define SymGetScope SymGetScopeW #define SymGetScope SymGetScopeW
#define SymNext SymNextW #define SymNext SymNextW
#define SymPrev SymPrevW #define SymPrev SymPrevW
#define SymEnumTypes SymEnumTypesW #define SymEnumTypes SymEnumTypesW
skipping to change at line 3612 skipping to change at line 3765
#define SymGetSourceFileToken SymGetSourceFileTokenW #define SymGetSourceFileToken SymGetSourceFileTokenW
#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW #define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW #define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
#define SymGetSourceFileToken SymGetSourceFileTokenW #define SymGetSourceFileToken SymGetSourceFileTokenW
#define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64 #define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64
#define SymFindFileInPath SymFindFileInPathW #define SymFindFileInPath SymFindFileInPathW
#define SymMatchFileName SymMatchFileNameW #define SymMatchFileName SymMatchFileNameW
#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW #define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW #define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
#define SymGetModuleInfo64 SymGetModuleInfoW64 #define SymGetModuleInfo64 SymGetModuleInfoW64
#define SymAddSourceStream SymAddSourceStreamW
#define SymSrvIsStore SymSrvIsStoreW #define SymSrvIsStore SymSrvIsStoreW
#define SymSrvDeltaName SymSrvDeltaNameW #define SymSrvDeltaName SymSrvDeltaNameW
#define SymSrvGetSupplement SymSrvGetSupplementW #define SymSrvGetSupplement SymSrvGetSupplementW
#define SymSrvStoreSupplement SymSrvStoreSupplementW #define SymSrvStoreSupplement SymSrvStoreSupplementW
#define SymSrvGetFileIndexes SymSrvGetFileIndexes #define SymSrvGetFileIndexes SymSrvGetFileIndexes
#define SymSrvGetFileIndexString SymSrvGetFileIndexStringW #define SymSrvGetFileIndexString SymSrvGetFileIndexStringW
#define SymSrvStoreFile SymSrvStoreFileW #define SymSrvStoreFile SymSrvStoreFileW
#define SymGetSymbolFile SymGetSymbolFileW #define SymGetSymbolFile SymGetSymbolFileW
#define EnumerateLoadedModules64 EnumerateLoadedModulesW64 #define EnumerateLoadedModules64 EnumerateLoadedModulesW64
#define EnumerateLoadedModulesEx EnumerateLoadedModulesExW #define EnumerateLoadedModulesEx EnumerateLoadedModulesExW
skipping to change at line 3667 skipping to change at line 3821
// 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(
__in HANDLE hprocess, _In_ HANDLE hprocess,
__in PCSTR SearchPath, _In_ PCSTR SearchPath,
__in PCSTR FileName, _In_ PCSTR FileName,
__in PVOID id, _In_ PVOID id,
__in DWORD two, _In_ DWORD two,
__in DWORD three, _In_ DWORD three,
__in DWORD flags, _In_ DWORD flags,
__out_ecount(MAX_PATH + 1) PSTR FilePath _Out_writes_(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(
__in HANDLE hprocess, _In_ HANDLE hprocess,
__in PCSTR SearchPath, _In_ PCSTR SearchPath,
__in PCSTR FileName, _In_ PCSTR FileName,
__in DWORD one, _In_ DWORD one,
__in DWORD two, _In_ DWORD two,
__in DWORD three, _In_ DWORD three,
__out_ecount(MAX_PATH + 1) PSTR FilePath _Out_writes_(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_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbols64( SymEnumerateSymbols64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback, _In_ PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbolsW64( SymEnumerateSymbolsW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG64 BaseOfDll, _In_ ULONG64 BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback, _In_ PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateSymbols SymEnumerateSymbols64 #define SymEnumerateSymbols SymEnumerateSymbols64
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64 #define SymEnumerateSymbolsW SymEnumerateSymbolsW64
#else #else
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbols( SymEnumerateSymbols(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG BaseOfDll, _In_ ULONG BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, _In_ PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
DBHLP_DEPRECIATED DBHLP_DEPRECIATED
BOOL BOOL
IMAGEAPI IMAGEAPI
SymEnumerateSymbolsW( SymEnumerateSymbolsW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in ULONG BaseOfDll, _In_ ULONG BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback, _In_ PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext _In_opt_ PVOID UserContext
); );
#endif #endif
// use SymLoadModuleEx // use SymLoadModuleEx
DWORD64 DWORD64
IMAGEAPI IMAGEAPI
SymLoadModule64( SymLoadModule64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt HANDLE hFile, _In_opt_ HANDLE hFile,
__in_opt PCSTR ImageName, _In_opt_ PCSTR ImageName,
__in_opt PCSTR ModuleName, _In_opt_ PCSTR ModuleName,
__in DWORD64 BaseOfDll, _In_ DWORD64 BaseOfDll,
__in DWORD SizeOfDll _In_ DWORD SizeOfDll
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymLoadModule SymLoadModule64 #define SymLoadModule SymLoadModule64
#else #else
DWORD DWORD
IMAGEAPI IMAGEAPI
SymLoadModule( SymLoadModule(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in_opt HANDLE hFile, _In_opt_ HANDLE hFile,
__in_opt PCSTR ImageName, _In_opt_ PCSTR ImageName,
__in_opt PCSTR ModuleName, _In_opt_ PCSTR ModuleName,
__in DWORD BaseOfDll, _In_ DWORD BaseOfDll,
__in DWORD SizeOfDll _In_ DWORD SizeOfDll
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymNext64( SymGetSymNext64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL64 Symbol _Inout_ PIMAGEHLP_SYMBOL64 Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymNextW64( SymGetSymNextW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW64 Symbol _Inout_ PIMAGEHLP_SYMBOLW64 Symbol
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymNext SymGetSymNext64 #define SymGetSymNext SymGetSymNext64
#define SymGetSymNextW SymGetSymNextW64 #define SymGetSymNextW SymGetSymNextW64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymNext( SymGetSymNext(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL Symbol _Inout_ PIMAGEHLP_SYMBOL Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymNextW( SymGetSymNextW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW Symbol _Inout_ PIMAGEHLP_SYMBOLW Symbol
); );
#endif #endif
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymPrev64( SymGetSymPrev64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL64 Symbol _Inout_ PIMAGEHLP_SYMBOL64 Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymPrevW64( SymGetSymPrevW64(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW64 Symbol _Inout_ PIMAGEHLP_SYMBOLW64 Symbol
); );
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymPrev SymGetSymPrev64 #define SymGetSymPrev SymGetSymPrev64
#define SymGetSymPrevW SymGetSymPrevW64 #define SymGetSymPrevW SymGetSymPrevW64
#else #else
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymPrev( SymGetSymPrev(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL Symbol _Inout_ PIMAGEHLP_SYMBOL Symbol
); );
BOOL BOOL
IMAGEAPI IMAGEAPI
SymGetSymPrevW( SymGetSymPrevW(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW Symbol _Inout_ PIMAGEHLP_SYMBOLW Symbol
); );
#endif #endif
// This type indicates the call back function type
typedef ULONG (__stdcall *LPCALL_BACK_USER_INTERRUPT_ROUTINE )(VOID);
// Extra data to report for the symbol load summary
typedef struct
{
PCWSTR pBinPathNonExist;
PCWSTR pSymbolPathNonExist;
}DBGHELP_DATA_REPORT_STRUCT, *PDBGHELP_DATA_REPORT_STRUCT;
void
IMAGEAPI
SetCheckUserInterruptShared(
_In_ LPCALL_BACK_USER_INTERRUPT_ROUTINE lpStartAddress
);
LPCALL_BACK_USER_INTERRUPT_ROUTINE
IMAGEAPI
GetCheckUserInterruptShared(
void
);
DWORD
IMAGEAPI
GetSymLoadError(
void
);
void
IMAGEAPI
SetSymLoadError(
_In_ DWORD error
);
BOOL
IMAGEAPI
ReportSymbolLoadSummary(
_In_ HANDLE hProcess,
_In_opt_ PCWSTR pLoadModule,
_In_ PDBGHELP_DATA_REPORT_STRUCT pSymbolData
);
void
IMAGEAPI
RemoveInvalidModuleList(
_In_ HANDLE hProcess
);
// 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
#define SYMF_LOCAL 0x00000080 #define SYMF_LOCAL 0x00000080
skipping to change at line 3875 skipping to change at line 4077
#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL // 0x001 0 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL // 0x001 0
#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL // 0x002 0 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL // 0x002 0
#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER // 0x004 0 #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER // 0x004 0
#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL // 0x008 0 #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL // 0x008 0
#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT // 0x010 0 #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT // 0x010 0
#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION // 0x080 0 #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION // 0x080 0
#define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL // 0x100 0 #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL // 0x100 0
#define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK // 0x200 0 #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK // 0x200 0
#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL // 0x400 0 #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL // 0x400 0
//
// RangeMap APIs.
//
PVOID
IMAGEAPI
RangeMapCreate(
VOID
);
VOID
IMAGEAPI
RangeMapFree(
_In_opt_ PVOID RmapHandle
);
#define IMAGEHLP_RMAP_MAPPED_FLAT 0x00000001
#define IMAGEHLP_RMAP_BIG_ENDIAN 0x00000002
#define IMAGEHLP_RMAP_IGNORE_MISCOMPARE 0x00000004
#define IMAGEHLP_RMAP_LOAD_RW_DATA_SECTIONS 0x20000000
#define IMAGEHLP_RMAP_OMIT_SHARED_RW_DATA_SECTIONS 0x40000000
#define IMAGEHLP_RMAP_FIXUP_IMAGEBASE 0x80000000
BOOL
IMAGEAPI
RangeMapAddPeImageSections(
_In_ PVOID RmapHandle,
_In_opt_ PCWSTR ImageName,
_In_reads_bytes_(MappingBytes) PVOID MappedImage,
_In_ DWORD MappingBytes,
_In_ DWORD64 ImageBase,
_In_ DWORD64 UserTag,
_In_ DWORD MappingFlags
);
BOOL
IMAGEAPI
RangeMapRemove(
_In_ PVOID RmapHandle,
_In_ DWORD64 UserTag
);
BOOL
IMAGEAPI
RangeMapRead(
_In_ PVOID RmapHandle,
_In_ DWORD64 Offset,
_Out_writes_bytes_to_(RequestBytes, *DoneBytes) PVOID Buffer,
_In_ DWORD RequestBytes,
_In_ DWORD Flags,
_Out_opt_ PDWORD DoneBytes
);
BOOL
IMAGEAPI
RangeMapWrite(
_In_ PVOID RmapHandle,
_In_ DWORD64 Offset,
_In_reads_bytes_(RequestBytes) PVOID Buffer,
_In_ DWORD RequestBytes,
_In_ DWORD Flags,
_Out_opt_ PDWORD DoneBytes
);
#include <poppack.h> #include <poppack.h>
#include <pshpack4.h> #include <pshpack4.h>
#if defined(_MSC_VER) #if defined(_MSC_VER)
#if _MSC_VER >= 800 #if _MSC_VER >= 800
#if _MSC_VER >= 1200 #if _MSC_VER >= 1200
#pragma warning(push) #pragma warning(push)
#endif #endif
#pragma warning(disable:4200) /* Zero length array */ #pragma warning(disable:4200) /* Zero length array */
skipping to change at line 3977 skipping to change at line 4243
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, MemoryInfoListStream = 16,
ThreadInfoListStream = 17, ThreadInfoListStream = 17,
HandleOperationListStream = 18, HandleOperationListStream = 18,
TokenStream = 19, TokenStream = 19,
JavaScriptDataStream = 20,
ceStreamNull = 0x8000, ceStreamNull = 0x8000,
ceStreamSystemInfo = 0x8001, ceStreamSystemInfo = 0x8001,
ceStreamException = 0x8002, ceStreamException = 0x8002,
ceStreamModuleList = 0x8003, ceStreamModuleList = 0x8003,
ceStreamProcessList = 0x8004, ceStreamProcessList = 0x8004,
ceStreamThreadList = 0x8005, ceStreamThreadList = 0x8005,
ceStreamThreadContextList = 0x8006, ceStreamThreadContextList = 0x8006,
ceStreamThreadCallStackList = 0x8007, ceStreamThreadCallStackList = 0x8007,
ceStreamMemoryVirtualList = 0x8008, ceStreamMemoryVirtualList = 0x8008,
skipping to change at line 4265 skipping to change at line 4532
// so on. The minidump gives a minidump identifier // so on. The minidump gives a minidump identifier
// to each possible data format for identification // to each possible data format for identification
// purposes but does not control nor describe the actual data. // purposes but does not control nor describe the actual data.
typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE { typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
MiniHandleObjectInformationNone, MiniHandleObjectInformationNone,
MiniThreadInformation1, MiniThreadInformation1,
MiniMutantInformation1, MiniMutantInformation1,
MiniMutantInformation2, MiniMutantInformation2,
MiniProcessInformation1, MiniProcessInformation1,
MiniProcessInformation2, MiniProcessInformation2,
MiniEventInformation1,
MiniSectionInformation1,
MiniHandleObjectInformationTypeMax MiniHandleObjectInformationTypeMax
} MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE; } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION { typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION {
RVA NextInfoRva; RVA NextInfoRva;
ULONG32 InfoType; ULONG32 InfoType;
ULONG32 SizeOfInfo; ULONG32 SizeOfInfo;
// Raw information follows. // Raw information follows.
} MINIDUMP_HANDLE_OBJECT_INFORMATION; } MINIDUMP_HANDLE_OBJECT_INFORMATION;
skipping to change at line 4381 skipping to change at line 4650
// 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 #define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004
#define MINIDUMP_MISC3_PROCESS_INTEGRITY 0x00000010 #define MINIDUMP_MISC3_PROCESS_INTEGRITY 0x00000010
#define MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS 0x00000020 #define MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS 0x00000020
#define MINIDUMP_MISC3_TIMEZONE 0x00000040 #define MINIDUMP_MISC3_TIMEZONE 0x00000040
#define MINIDUMP_MISC3_PROTECTED_PROCESS 0x00000080 #define MINIDUMP_MISC3_PROTECTED_PROCESS 0x00000080
#define MINIDUMP_MISC4_BUILDSTRING 0x00000100
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;
skipping to change at line 4424 skipping to change at line 4694
ULONG32 ProcessorMhzLimit; ULONG32 ProcessorMhzLimit;
ULONG32 ProcessorMaxIdleState; ULONG32 ProcessorMaxIdleState;
ULONG32 ProcessorCurrentIdleState; ULONG32 ProcessorCurrentIdleState;
ULONG32 ProcessIntegrityLevel; ULONG32 ProcessIntegrityLevel;
ULONG32 ProcessExecuteFlags; ULONG32 ProcessExecuteFlags;
ULONG32 ProtectedProcess; ULONG32 ProtectedProcess;
ULONG32 TimeZoneId; ULONG32 TimeZoneId;
TIME_ZONE_INFORMATION TimeZone; TIME_ZONE_INFORMATION TimeZone;
} MINIDUMP_MISC_INFO_3, *PMINIDUMP_MISC_INFO_3; } MINIDUMP_MISC_INFO_3, *PMINIDUMP_MISC_INFO_3;
typedef struct _MINIDUMP_MISC_INFO_4 {
ULONG32 SizeOfInfo;
ULONG32 Flags1;
ULONG32 ProcessId;
ULONG32 ProcessCreateTime;
ULONG32 ProcessUserTime;
ULONG32 ProcessKernelTime;
ULONG32 ProcessorMaxMhz;
ULONG32 ProcessorCurrentMhz;
ULONG32 ProcessorMhzLimit;
ULONG32 ProcessorMaxIdleState;
ULONG32 ProcessorCurrentIdleState;
ULONG32 ProcessIntegrityLevel;
ULONG32 ProcessExecuteFlags;
ULONG32 ProtectedProcess;
ULONG32 TimeZoneId;
TIME_ZONE_INFORMATION TimeZone;
WCHAR BuildString[MAX_PATH];
WCHAR DbgBldStr[40];
} MINIDUMP_MISC_INFO_4, *PMINIDUMP_MISC_INFO_4;
// The latest MINIDUMP_MISC_INFO definition. // The latest MINIDUMP_MISC_INFO definition.
typedef MINIDUMP_MISC_INFO_3 MINIDUMP_MISC_INFO_N; typedef MINIDUMP_MISC_INFO_4 MINIDUMP_MISC_INFO_N;
typedef MINIDUMP_MISC_INFO_N* PMINIDUMP_MISC_INFO_N; typedef MINIDUMP_MISC_INFO_N* PMINIDUMP_MISC_INFO_N;
// //
// The memory information stream contains memory region // The memory information stream contains memory region
// description information. This stream corresponds to // description information. This stream corresponds to
// what VirtualQuery would return for the process the // what VirtualQuery would return for the process the
// dump was created for. // dump was created for.
// //
typedef struct _MINIDUMP_MEMORY_INFO { typedef struct _MINIDUMP_MEMORY_INFO {
skipping to change at line 4545 skipping to change at line 4836
CancelCallback, CancelCallback,
WriteKernelMinidumpCallback, WriteKernelMinidumpCallback,
KernelMinidumpStatusCallback, KernelMinidumpStatusCallback,
RemoveMemoryCallback, RemoveMemoryCallback,
IncludeVmRegionCallback, IncludeVmRegionCallback,
IoStartCallback, IoStartCallback,
IoWriteAllCallback, IoWriteAllCallback,
IoFinishCallback, IoFinishCallback,
ReadMemoryFailureCallback, ReadMemoryFailureCallback,
SecondaryFlagsCallback, SecondaryFlagsCallback,
IsProcessSnapshotCallback,
VmStartCallback,
VmQueryCallback,
VmPreReadCallback,
VmPostReadCallback,
} 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 4623 skipping to change at line 4919
} MINIDUMP_IO_CALLBACK, *PMINIDUMP_IO_CALLBACK; } MINIDUMP_IO_CALLBACK, *PMINIDUMP_IO_CALLBACK;
typedef struct _MINIDUMP_READ_MEMORY_FAILURE_CALLBACK typedef struct _MINIDUMP_READ_MEMORY_FAILURE_CALLBACK
{ {
ULONG64 Offset; ULONG64 Offset;
ULONG Bytes; ULONG Bytes;
HRESULT FailureStatus; HRESULT FailureStatus;
} MINIDUMP_READ_MEMORY_FAILURE_CALLBACK, } MINIDUMP_READ_MEMORY_FAILURE_CALLBACK,
*PMINIDUMP_READ_MEMORY_FAILURE_CALLBACK; *PMINIDUMP_READ_MEMORY_FAILURE_CALLBACK;
typedef struct _MINIDUMP_VM_QUERY_CALLBACK
{
ULONG64 Offset;
} MINIDUMP_VM_QUERY_CALLBACK, *PMINIDUMP_VM_QUERY_CALLBACK;
typedef struct _MINIDUMP_VM_PRE_READ_CALLBACK
{
ULONG64 Offset;
PVOID Buffer;
ULONG Size;
} MINIDUMP_VM_PRE_READ_CALLBACK, *PMINIDUMP_VM_PRE_READ_CALLBACK;
typedef struct _MINIDUMP_VM_POST_READ_CALLBACK
{
ULONG64 Offset;
PVOID Buffer;
ULONG Size;
ULONG Completed;
HRESULT Status;
} MINIDUMP_VM_POST_READ_CALLBACK, *PMINIDUMP_VM_POST_READ_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; 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_IO_CALLBACK Io;
MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure; MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure;
ULONG SecondaryFlags; ULONG SecondaryFlags;
MINIDUMP_VM_QUERY_CALLBACK VmQuery;
MINIDUMP_VM_PRE_READ_CALLBACK VmPreRead;
MINIDUMP_VM_POST_READ_CALLBACK VmPostRead;
}; };
} 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; ULONG SecondaryFlags;
struct { struct {
ULONG64 MemoryBase; ULONG64 MemoryBase;
skipping to change at line 4658 skipping to change at line 4978
}; };
struct { struct {
BOOL CheckCancel; BOOL CheckCancel;
BOOL Cancel; BOOL Cancel;
}; };
HANDLE Handle; HANDLE Handle;
struct { struct {
MINIDUMP_MEMORY_INFO VmRegion; MINIDUMP_MEMORY_INFO VmRegion;
BOOL Continue; BOOL Continue;
}; };
struct {
HRESULT VmQueryStatus;
MINIDUMP_MEMORY_INFO VmQueryResult;
};
struct {
HRESULT VmReadStatus;
ULONG VmReadBytesCompleted;
};
HRESULT Status; 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
skipping to change at line 4758 skipping to change at line 5086
MiniDumpWithPrivateReadWriteMemory = 0x00000200, MiniDumpWithPrivateReadWriteMemory = 0x00000200,
MiniDumpWithoutOptionalData = 0x00000400, MiniDumpWithoutOptionalData = 0x00000400,
MiniDumpWithFullMemoryInfo = 0x00000800, MiniDumpWithFullMemoryInfo = 0x00000800,
MiniDumpWithThreadInfo = 0x00001000, MiniDumpWithThreadInfo = 0x00001000,
MiniDumpWithCodeSegs = 0x00002000, MiniDumpWithCodeSegs = 0x00002000,
MiniDumpWithoutAuxiliaryState = 0x00004000, MiniDumpWithoutAuxiliaryState = 0x00004000,
MiniDumpWithFullAuxiliaryState = 0x00008000, MiniDumpWithFullAuxiliaryState = 0x00008000,
MiniDumpWithPrivateWriteCopyMemory = 0x00010000, MiniDumpWithPrivateWriteCopyMemory = 0x00010000,
MiniDumpIgnoreInaccessibleMemory = 0x00020000, MiniDumpIgnoreInaccessibleMemory = 0x00020000,
MiniDumpWithTokenInformation = 0x00040000, MiniDumpWithTokenInformation = 0x00040000,
MiniDumpValidTypeFlags = 0x0007ffff, MiniDumpWithModuleHeaders = 0x00080000,
MiniDumpFilterTriage = 0x00100000,
MiniDumpValidTypeFlags = 0x001fffff,
} MINIDUMP_TYPE; } MINIDUMP_TYPE;
// //
// In addition to the primary flags provided to // In addition to the primary flags provided to
// MiniDumpWriteDump there are additional, less // MiniDumpWriteDump there are additional, less
// frequently used options queried via the secondary // frequently used options queried via the secondary
// flags callback. // flags callback.
// //
// MiniSecondaryWithoutPowerInfo suppresses the minidump // MiniSecondaryWithoutPowerInfo suppresses the minidump
// query that retrieves processor power information for // query that retrieves processor power information for
skipping to change at line 4787 skipping to change at line 5117
// //
// 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) (
__inout PVOID CallbackParam, _Inout_ PVOID CallbackParam,
__in PMINIDUMP_CALLBACK_INPUT CallbackInput, _In_ PMINIDUMP_CALLBACK_INPUT CallbackInput,
__inout PMINIDUMP_CALLBACK_OUTPUT CallbackOutput _Inout_ PMINIDUMP_CALLBACK_OUTPUT CallbackOutput
); );
typedef struct _MINIDUMP_CALLBACK_INFORMATION { typedef struct _MINIDUMP_CALLBACK_INFORMATION {
MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
PVOID CallbackParam; PVOID CallbackParam;
} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION; } MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
//++ //++
// //
// PVOID // PVOID
skipping to change at line 4827 skipping to change at line 5157
// //
// A pointer to the desired data. // A pointer to the desired data.
// //
//-- //--
#define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva))) #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
BOOL BOOL
WINAPI WINAPI
MiniDumpWriteDump( MiniDumpWriteDump(
__in HANDLE hProcess, _In_ HANDLE hProcess,
__in DWORD ProcessId, _In_ DWORD ProcessId,
__in HANDLE hFile, _In_ HANDLE hFile,
__in MINIDUMP_TYPE DumpType, _In_ MINIDUMP_TYPE DumpType,
__in_opt PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, _In_opt_ PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
__in_opt PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, _In_opt_ PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
__in_opt PMINIDUMP_CALLBACK_INFORMATION CallbackParam _In_opt_ PMINIDUMP_CALLBACK_INFORMATION CallbackParam
); );
BOOL BOOL
WINAPI WINAPI
MiniDumpReadDumpStream( MiniDumpReadDumpStream(
__in PVOID BaseOfDump, _In_ PVOID BaseOfDump,
__in ULONG StreamNumber, _In_ ULONG StreamNumber,
__deref_out_opt PMINIDUMP_DIRECTORY * Dir, _Outptr_result_maybenull_ PMINIDUMP_DIRECTORY * Dir,
__deref_out_opt PVOID * StreamPointer, _Outptr_result_maybenull_ PVOID * StreamPointer,
__out_opt ULONG * StreamSize _Out_opt_ ULONG * StreamSize
); );
#if defined(_MSC_VER) #if defined(_MSC_VER)
#if _MSC_VER >= 800 #if _MSC_VER >= 800
#if _MSC_VER >= 1200 #if _MSC_VER >= 1200
#pragma warning(pop) #pragma warning(pop)
#else #else
#pragma warning(default:4200) /* Zero length array */ #pragma warning(default:4200) /* Zero length array */
#pragma warning(default:4201) /* Nameless struct/union */ #pragma warning(default:4201) /* Nameless struct/union */
#endif #endif
#endif #endif
#endif #endif
#include <poppack.h> #include <poppack.h>
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion
#endif // _IMAGEHLP_ #endif // _IMAGEHLP_
 End of changes. 299 change blocks. 
1088 lines changed or deleted 1426 lines changed or added

This html diff was produced by rfcdiff 1.41.