|
|
//----------------------------------------------------------------------------
//
// Abstraction of processor-specific information.
//
// Copyright (C) Microsoft Corporation, 1999-2001.
//
//----------------------------------------------------------------------------
#ifndef __MACHINE_HPP__
#define __MACHINE_HPP__
// These context information states are intended to be shared among
// processors so they may not all apply to each processor. The important
// thing is that they are ordered from less information to more.
// Each state includes all the information from the states that precede it.
// More states can be inserted anywhere as new processors require them.
#define MCTX_NONE 0 // No context information.
#define MCTX_PC 1 // Program counter.
#define MCTX_DR67_REPORT 2 // X86: DR6,7 control report.
#define MCTX_REPORT 3 // Control report.
#define MCTX_CONTEXT 4 // Kernel protocol context information.
#define MCTX_FULL 5 // All possible information.
#define MCTX_DIRTY 6 // Dirty context, implies full information.
// Constant offset value returned from GetNextOffset to indicate the
// trace flag should be used.
#define OFFSET_TRACE ((ULONG64)(LONG64)-1)
#define OFFSET_TRACE_32 ((ULONG)OFFSET_TRACE)
// Distinguished error code for GetVirtualTranslationPhysicalOffsets
// to indicate that all translations were successful but
// the page was not present. In this case the LastVal value
// will contain the page file offset and PfIndex will contain
// the page file number.
#define HR_PAGE_IN_PAGE_FILE HRESULT_FROM_NT(STATUS_PAGE_FAULT_PAGING_FILE)
// Translation could not complete and a page file location
// for the data could not be determined.
#define HR_PAGE_NOT_AVAILABLE HRESULT_FROM_NT(STATUS_NO_PAGEFILE)
#define MAX_PAGING_FILE_MASK 0xf
//
// Segment register access.
// Processors which do not support segment registers return
// zero for the segment register number.
//
enum{ // Descriptor table pseudo-segments. The GDT does
// not have a specific register number.
// These pseudo-segments should be first so that
// index zero is not used for a normal segreg.
SEGREG_GDT, SEGREG_LDT,
// Generic segments.
SEGREG_CODE, SEGREG_DATA, SEGREG_STACK, // Extended segments.
SEGREG_ES, SEGREG_FS, SEGREG_GS, SEGREG_COUNT};
//
// Segment descriptor values.
// Due to the descriptor caching that x86 processors
// do this may differ from the actual in-memory descriptor and
// may be retrieved in a much different way.
//
// Special flags value that marks a descriptor as invalid.
#define SEGDESC_INVALID 0xffffffff
#define X86_DESC_TYPE(Flags) ((Flags) & 0x1f)
#define X86_DESC_PRIVILEGE_SHIFT 5
#define X86_DESC_PRIVILEGE(Flags) (((Flags) >> X86_DESC_PRIVILEGE_SHIFT) & 3)
#define X86_DESC_PRESENT 0x80
#define X86_DESC_LONG_MODE 0x200
#define X86_DESC_DEFAULT_BIG 0x400
#define X86_DESC_GRANULARITY 0x800
typedef struct _DESCRIPTOR64{ ULONG64 Base; ULONG64 Limit; ULONG Flags;} DESCRIPTOR64, *PDESCRIPTOR64;
#define FORM_VM86 0x00000001
#define FORM_CODE 0x00000002
#define FORM_SEGREG 0x00000004
#define X86_FORM_VM86(Efl) \
(X86_IS_VM86(Efl) ? FORM_VM86 : 0) //----------------------------------------------------------------------------
//
// Abstract interface for machine information. All possible
// machine-specific implementations of this interface exist at
// all times. The effective implementation is selected when
// SetEffMachine is called. For generic access the abstract
// interface should be used. In machine-specific code the
// specific implementation classes can be used.
//
// IMPORTANT: Be very careful when using machine-specific header files
// such as nt<plat>.h. The machine implementation class is
// compiled for all platforms so the nt<plat>.h file will be the
// one for the build platform, not necessarily the platform
// of the machine implementation. ntdbg.h contains many cross-platform
// types and definitions that can be used to avoid problems.
//
//----------------------------------------------------------------------------
extern BOOL g_PrefixSymbols;extern BOOL g_ContextChanged;extern DEBUG_PROCESSOR_IDENTIFICATION_ALL g_InitProcessorId;
struct RegisterGroup{ RegisterGroup* Next; // Counted automatically.
ULONG NumberRegs; // Regs is assumed to be non-NULL in all groups.
// SubRegs and AllExtraDesc may be NULL in any group.
REGDEF* Regs; REGSUBDEF* SubRegs; REGALLDESC* AllExtraDesc;};
// Trace modes used by SetTraceMode/GetTraceMode functions
typedef enum { TRACE_NONE, TRACE_INSTRUCTION, TRACE_TAKEN_BRANCH} TRACEMODE;
// These enumerants are abstract values but currently
// only IA64 actually has different page directories
// so set them up to match the IA64 mapping for convenience.
enum{ PAGE_DIR_USER, PAGE_DIR_SESSION, PAGE_DIR_KERNEL = 7, PAGE_DIR_COUNT};
// For machines which only support a single page directory
// take it from the kernel slot. All will be updated so
// this is an arbitrary choice.
#define PAGE_DIR_SINGLE PAGE_DIR_KERNEL
// All directories bit mask.
#define PAGE_DIR_ALL ((1 << PAGE_DIR_COUNT) - 1)
// Flags for GetPrefixedSymbolOffset.
#define GETPREF_VERBOSE 0x00000001
class MachineInfo{public: // Descriptive information.
PCSTR m_FullName; PCSTR m_AbbrevName; ULONG m_PageSize; ULONG m_PageShift; ULONG m_NumExecTypes; // First ExecTypes entry must be the actual processor type.
PULONG m_ExecTypes; BOOL m_Ptr64; // Automatically counted from regs in base Initialize.
ULONG m_NumberRegs; RegisterGroup* m_Groups; ULONG m_AllMask; // Collected automatically from groups.
ULONG m_AllMaskBits; ULONG m_MaxDataBreakpoints; PCSTR m_SymPrefix; // Computed automatically.
ULONG m_SymPrefixLen;
// Hard-coded type information for machine and platform version.
ULONG m_OffsetPrcbProcessorState; ULONG m_OffsetPrcbNumber; ULONG64 m_TriagePrcbOffset; ULONG m_SizePrcb; ULONG m_OffsetKThreadApcProcess; ULONG m_OffsetKThreadTeb; ULONG m_OffsetKThreadInitialStack; ULONG m_OffsetEprocessPeb; ULONG m_OffsetEprocessDirectoryTableBase; ULONG m_OffsetKThreadNextProcessor; // Size of the native context for the target machine.
ULONG m_SizeTargetContext; // Offset of the flags ULONG in the native context.
ULONG m_OffsetTargetContextFlags; // Control space offset for special registers.
ULONG m_OffsetSpecialRegisters; // Size of the canonical context kept in the MachineInfo.
ULONG m_SizeCanonicalContext; // System version of the canonical context. Can be compared
// against g_SystemVersion to see if the target provides
// canonical contexts or not.
ULONG m_SverCanonicalContext; ULONG m_SizeControlReport; ULONG m_SizeEThread; ULONG m_SizeEProcess; ULONG m_SizeKspecialRegisters; // Size of the debugger's *_THREAD partial structure.
ULONG m_SizePartialKThread; ULONG64 m_SharedUserDataOffset;
// Context could be kept per-thread
// so that several can be around at once for a cache.
// That would also make the save/restore stuff unnecessary.
ULONG m_ContextState; CROSS_PLATFORM_CONTEXT m_Context;
// Segment register descriptors. These will only
// be valid on processors that support them, otherwise
// they will be marked invalid.
DESCRIPTOR64 m_SegRegDesc[SEGREG_COUNT]; DESCRIPTOR64 m_SavedSegRegDesc[SEGREG_COUNT]; // Holds the current page directory offsets.
ULONG64 m_PageDirectories[PAGE_DIR_COUNT]; BOOL m_Translating; BOOL m_ContextIsReadOnly;
// InitializeConstants initializes information which is
// fixed and unaffected by the type of target being debugged.
// InitializeForTarget initializes information which
// varies according to the particular type of target being debugged.
// InitializeForProcessor initializes information which
// varies according to the particular type of processor that's
// present in the target as described by g_InitProcessorId.
// Derived classes should call base Initialize* after
// their own initialization.
virtual HRESULT InitializeConstants(void); virtual HRESULT InitializeForTarget(void); virtual HRESULT InitializeForProcessor(void);
virtual void InitializeContext (ULONG64 Pc, PDBGKD_ANY_CONTROL_REPORT ControlReport) = 0; HRESULT GetContextState(ULONG State); HRESULT SetContext(void); // Base implementations use Get/SetThreadContext for
// any request.
virtual HRESULT UdGetContextState(ULONG State); virtual HRESULT UdSetContext(void); virtual HRESULT KdGetContextState(ULONG State) = 0; virtual HRESULT KdSetContext(void) = 0; // Base implementation sets ContextState to NONE.
virtual void InvalidateContext(void); // Context conversion is version-based rather than size-based
// as the size is ambiguous in certain cases. For example,
// ALPHA_CONTEXT and ALPHA_NT5_CONTEXT are the same size
// so additional information is necessary to distinguish them.
virtual HRESULT ConvertContextFrom(PCROSS_PLATFORM_CONTEXT Context, ULONG FromSver, ULONG FromSize, PVOID From) = 0; virtual HRESULT ConvertContextTo(PCROSS_PLATFORM_CONTEXT Context, ULONG ToSver, ULONG ToSize, PVOID To) = 0; virtual void InitializeContextFlags(PCROSS_PLATFORM_CONTEXT Context, ULONG Version) = 0; virtual HRESULT GetContextFromThreadStack(ULONG64 ThreadBase, PCROSS_PLATFORM_THREAD Thread, PCROSS_PLATFORM_CONTEXT Context, PDEBUG_STACK_FRAME Frame, PULONG RunningOnProc) = 0;
// Base implementations return E_NOTIMPL.
virtual HRESULT GetExdiContext(IUnknown* Exdi, PEXDI_CONTEXT Context); virtual HRESULT SetExdiContext(IUnknown* Exdi, PEXDI_CONTEXT Context); virtual void ConvertExdiContextFromContext(PCROSS_PLATFORM_CONTEXT Context, PEXDI_CONTEXT ExdiContext); virtual void ConvertExdiContextToContext(PEXDI_CONTEXT ExdiContext, PCROSS_PLATFORM_CONTEXT Context); virtual void ConvertExdiContextToSegDescs(PEXDI_CONTEXT ExdiContext, ULONG Start, ULONG Count, PDESCRIPTOR64 Descs); virtual void ConvertExdiContextFromSpecial (PCROSS_PLATFORM_KSPECIAL_REGISTERS Special, PEXDI_CONTEXT ExdiContext); virtual void ConvertExdiContextToSpecial (PEXDI_CONTEXT ExdiContext, PCROSS_PLATFORM_KSPECIAL_REGISTERS Special); // A simple one-deep temporary save stack for CONTEXT information.
// Useful when you want to swap in an arbitrary context for
// some machine operation. This uses the same save area
// as KdSave/RestoreProcessorState so the two should
// not be used together.
void PushContext(PCROSS_PLATFORM_CONTEXT Context) { DBG_ASSERT (!m_ContextIsReadOnly); m_SavedContextState = m_ContextState; m_SavedContext = m_Context; memcpy(m_SavedSegRegDesc, m_SegRegDesc, sizeof(m_SegRegDesc)); m_Context = *Context; m_ContextState = MCTX_FULL; m_ContextIsReadOnly = TRUE; } void PopContext(void) { DBG_ASSERT((m_ContextState != MCTX_DIRTY) && (m_ContextIsReadOnly)); m_Context = m_SavedContext; m_ContextState = m_SavedContextState; memcpy(m_SegRegDesc, m_SavedSegRegDesc, sizeof(m_SegRegDesc)); m_ContextIsReadOnly = FALSE; } virtual int GetType(ULONG index) = 0; virtual BOOL GetVal(ULONG index, REGVAL *val) = 0; virtual BOOL SetVal(ULONG index, REGVAL *val) = 0;
virtual void GetPC(PADDR Address) = 0; virtual void SetPC(PADDR Address) = 0; virtual void GetFP(PADDR Address) = 0; virtual void GetSP(PADDR Address) = 0; virtual ULONG64 GetArgReg(void) = 0; // Base implementations return zero and FALSE.
virtual ULONG GetSegRegNum(ULONG SegReg); virtual HRESULT GetSegRegDescriptor(ULONG SegReg, PDESCRIPTOR64 Desc);
virtual void OutputAll(ULONG Mask, ULONG OutMask) = 0;
virtual TRACEMODE GetTraceMode(void) = 0; virtual void SetTraceMode(TRACEMODE Mode) = 0;
// Returns true if trace mode appropriate to specified execution status
// (e.g. DEBUG_STATUS_STEP_OVER, DEBUG_STATUS_STEP_INTO,
// DEBUG_STATUS_STEP_BRANCH...) supported by the machine.
virtual BOOL IsStepStatusSupported(ULONG Status) = 0;
void QuietSetTraceMode(TRACEMODE Mode) { BOOL ContextChangedOrg = g_ContextChanged; SetTraceMode(Mode); g_ContextChanged = ContextChangedOrg; }
// Base implementation does nothing.
virtual void KdUpdateControlSet (PDBGKD_ANY_CONTROL_SET ControlSet);
// Base implementations save and restore m_Context and m_ContextState.
virtual void KdSaveProcessorState(void); virtual void KdRestoreProcessorState(void);
virtual ULONG ExecutingMachine(void) = 0;
virtual HRESULT SetPageDirectory(ULONG Idx, ULONG64 PageDir, PULONG NextIdx) = 0; HRESULT SetDefaultPageDirectories(ULONG Mask); virtual HRESULT GetVirtualTranslationPhysicalOffsets (ULONG64 Virt, PULONG64 Offsets, ULONG OffsetsSize, PULONG Levels, PULONG PfIndex, PULONG64 LastVal) = 0; virtual HRESULT GetBaseTranslationVirtualOffset(PULONG64 Offset) = 0;
virtual void Assemble(PADDR Addr, PSTR Input) = 0; virtual BOOL Disassemble(PADDR Addr, PSTR Buffer, BOOL EffAddr) = 0;
// Creates new Breakpoint object compatible with specific machine
virtual HRESULT NewBreakpoint(DebugClient* Client, ULONG Type, ULONG Id, Breakpoint** RetBp);
virtual BOOL IsBreakpointInstruction(PADDR Addr) = 0; virtual HRESULT InsertBreakpointInstruction(PUSER_DEBUG_SERVICES Services, ULONG64 Process, ULONG64 Offset, PUCHAR SaveInstr, PULONG64 ChangeStart, PULONG ChangeLen) = 0; virtual HRESULT RemoveBreakpointInstruction(PUSER_DEBUG_SERVICES Services, ULONG64 Process, ULONG64 Offset, PUCHAR SaveInstr, PULONG64 ChangeStart, PULONG ChangeLen) = 0; virtual void AdjustPCPastBreakpointInstruction(PADDR Addr, ULONG BreakType) = 0; // Base implementations do nothing for platforms which
// do not support data breakpoints.
virtual void InsertAllDataBreakpoints(void); virtual void RemoveAllDataBreakpoints(void); // Base implementation returns EXCEPTION_BRAKEPOINT_ANY
// for STATUS_BREAKPOINT.
virtual ULONG IsBreakpointOrStepException(PEXCEPTION_RECORD64 Record, ULONG FirstChance, PADDR BpAddr, PADDR RelAddr);
virtual BOOL IsCallDisasm(PCSTR Disasm) = 0; virtual BOOL IsReturnDisasm(PCSTR Disasm) = 0; virtual BOOL IsSystemCallDisasm(PCSTR Disasm) = 0; virtual BOOL IsDelayInstruction(PADDR Addr) = 0; virtual void GetEffectiveAddr(PADDR Addr) = 0; // Some processors, such as IA64, have instructions which
// switch between instruction sets, thus the machine type
// of the next offset may be different from the current machine.
// If the NextAddr is OFFSET_TRACE the NextMachine is ignored.
virtual void GetNextOffset(BOOL StepOver, PADDR NextAddr, PULONG NextMachine) = 0; // Base implementation returns the value from StackWalk.
virtual void GetRetAddr(PADDR Addr); // Base implementation does nothing for machines which
// do not have symbol prefixing.
virtual BOOL GetPrefixedSymbolOffset(ULONG64 SymOffset, ULONG Flags, PULONG64 PrefixedSymOffset);
virtual void IncrementBySmallestInstruction(PADDR Addr) = 0; virtual void DecrementBySmallestInstruction(PADDR Addr) = 0;
virtual BOOL DisplayTrapFrame(ULONG64 FrameAddress, PCROSS_PLATFORM_CONTEXT Context) = 0; virtual void ValidateCxr(PCROSS_PLATFORM_CONTEXT Context) = 0;
// Output function entry information for the given entry.
virtual void OutputFunctionEntry(PVOID RawEntry) = 0; // Base implementation returns E_UNEXPECTED.
virtual HRESULT ReadDynamicFunctionTable(ULONG64 Table, PULONG64 NextTable, PULONG64 MinAddress, PULONG64 MaxAddress, PULONG64 BaseAddress, PULONG64 TableData, PULONG TableSize, PWSTR OutOfProcessDll, PCROSS_PLATFORM_DYNAMIC_FUNCTION_TABLE RawTable); // Base implementation returns NULL.
virtual PVOID FindDynamicFunctionEntry(PCROSS_PLATFORM_DYNAMIC_FUNCTION_TABLE Table, ULONG64 Address, PVOID TableData, ULONG TableSize);
virtual HRESULT ReadKernelProcessorId (ULONG Processor, PDEBUG_PROCESSOR_IDENTIFICATION_ALL Id) = 0;
// Base implementation discards page directory entries.
virtual void FlushPerExecutionCaches(void); // Stack output functions
virtual void PrintStackFrameAddressesTitle(ULONG Flags); virtual void PrintStackFrameAddresses(ULONG Flags, PDEBUG_STACK_FRAME StackFrame); virtual void PrintStackArgumentsTitle(ULONG Flags); virtual void PrintStackArguments(ULONG Flags, PDEBUG_STACK_FRAME StackFrame); virtual void PrintStackCallSiteTitle(ULONG Flags); virtual void PrintStackCallSite(ULONG Flags, PDEBUG_STACK_FRAME StackFrame, CHAR SymBuf[], DWORD64 Displacement, USHORT StdCallArgs); virtual void PrintStackNonvolatileRegisters(ULONG Flags, PDEBUG_STACK_FRAME StackFrame, PCROSS_PLATFORM_CONTEXT Context, ULONG FrameNum);
//
// IMPORTANT
//
// Helpers for convenient value access. When in machine code
// these helpers are preferred to Get/SetRegVal* because
// they stay in the same machine whereas the generic code
// always uses g_Machine. If a caller makes a direct call
// on a specific machine g_Machine may not match so the
// generic code will not work properly.
//
// Note that the set methods here do not get the register
// type as is done in the generic code. All of these methods
// assume that the proper call is being made for the register.
// The Get/SetReg methods also only operate on real registers, not
// subregisters. Use the Get/SetSubReg methods when dealing
// with subregisters.
//
USHORT GetReg16(ULONG Reg) { REGVAL RegVal; RegVal.i64 = 0; GetVal(Reg, &RegVal); return RegVal.i16; } ULONG GetReg32(ULONG Reg) { REGVAL RegVal; RegVal.i64 = 0; GetVal(Reg, &RegVal); return RegVal.i32; } void SetReg32(ULONG Reg, ULONG Val) { REGVAL RegVal; RegVal.type = REGVAL_INT32; RegVal.i64 = 0; RegVal.i32 = Val; SetVal(Reg, &RegVal); } ULONG64 GetReg64(ULONG Reg) { REGVAL RegVal; RegVal.i64 = 0; GetVal(Reg, &RegVal); return RegVal.i64; } void SetReg64(ULONG Reg, ULONG64 Val) { REGVAL RegVal; RegVal.type = REGVAL_INT64; RegVal.i64 = Val; RegVal.Nat = FALSE; SetVal(Reg, &RegVal); } ULONG GetSubReg32(ULONG SubReg) { REGVAL RegVal; REGSUBDEF* SubDef = RegSubDefFromIndex(SubReg);
if (!SubDef) { return 0; }
RegVal.i64 = 0; GetVal(SubDef->fullreg, &RegVal); return (ULONG)((RegVal.i64 >> SubDef->shift) & SubDef->mask); }
// Helper function to initialize an ADDR given a flat
// offset from a known segment or segment register.
void FormAddr(ULONG SegOrReg, ULONG64 Off, ULONG Flags, PADDR Address);
protected: TRACEMODE m_TraceMode;
// KdSave/Restore state.
ULONG m_SavedContextState; CROSS_PLATFORM_CONTEXT m_SavedContext;
// Common helpers for disassembly.
PCHAR m_Buf, m_BufStart; void BufferHex(ULONG64 Value, ULONG Length, BOOL Signed); void BufferBlanks(ULONG BufferPos); void BufferString(PCSTR String);
void PrintMultiPtrTitle(const CHAR* Title, USHORT PtrNum);};
// Effective machine settings.
extern ULONG g_EffMachine;extern MachineIndex g_EffMachineIndex;extern MachineInfo* g_Machine;
// Target machine settings.
extern MachineInfo* g_TargetMachine;
extern MachineInfo* g_AllMachines[];
HRESULT InitializeMachines(ULONG TargetMachine);MachineIndex MachineTypeIndex(ULONG Machine);
// g_AllMachines has a NULL at MACHIDX_COUNT to handle errors.
#define MachineTypeInfo(Machine) g_AllMachines[MachineTypeIndex(Machine)]
void CacheReportInstructions(ULONG64 Pc, ULONG Count, PUCHAR Stream);void FlushMachinePerExecutionCaches(void);
extern CHAR g_F0[], g_F1[], g_F2[], g_F3[], g_F4[], g_F5[];extern CHAR g_F6[], g_F7[], g_F8[], g_F9[], g_F10[], g_F11[];extern CHAR g_F12[], g_F13[], g_F14[], g_F15[], g_F16[], g_F17[];extern CHAR g_F18[], g_F19[], g_F20[], g_F21[], g_F22[], g_F23[];extern CHAR g_F24[], g_F25[], g_F26[], g_F27[], g_F28[], g_F29[];extern CHAR g_F30[], g_F31[];
extern CHAR g_R0[], g_R1[], g_R2[], g_R3[], g_R4[], g_R5[];extern CHAR g_R6[], g_R7[], g_R8[], g_R9[], g_R10[], g_R11[];extern CHAR g_R12[], g_R13[], g_R14[], g_R15[], g_R16[], g_R17[];extern CHAR g_R18[], g_R19[], g_R20[], g_R21[], g_R22[], g_R23[];extern CHAR g_R24[], g_R25[], g_R26[], g_R27[], g_R28[], g_R29[];extern CHAR g_R30[], g_R31[];
#endif // #ifndef __MACHINE_HPP__
|
