|
|
/*++
Copyright (c) 1993 IBM Corporation
Module Name:
ntppc.h
Abstract:
User-mode visible PowerPC specific structures and constants
Author:
Rick Simpson 9-July-1993
Based on ntmips.h, by David N. Cutler (davec) 31-Mar-1990
Revision History:
Chuck Bauman 3-August-1993 (Integrate NT product source) KPCR modifications need to be integrated because it was removed from ntppc.h. No changes required otherwise.
--*/
#ifndef _NTPPC_#define _NTPPC_#if _MSC_VER > 1000#pragma once#endif
#include "ppcinst.h" #ifdef __cplusplusextern "C" {#endif
// begin_ntddk begin_wdm begin_nthal begin_winnt
#if defined(_PPC_)
// end_winnt
//// Define system time structure.//
typedef struct _KSYSTEM_TIME { ULONG LowPart; LONG High1Time; LONG High2Time;} KSYSTEM_TIME, *PKSYSTEM_TIME;
//// Define unsupported "keywords".//
#define _cdecl
// end_ntddk end_wdm end_nthal
//// Define breakpoint codes.//// **FINISH** Use MIPS codes unless there's a reason not to//
#define USER_BREAKPOINT 0 // user breakpoint#define KERNEL_BREAKPOINT 1 // kernel breakpoint#define BREAKIN_BREAKPOINT 2 // break into kernel debugger#define BRANCH_TAKEN_BREAKPOINT 3 // branch taken breakpoint#define BRANCH_NOT_TAKEN_BREAKPOINT 4 // branch not taken breakpoint#define SINGLE_STEP_BREAKPOINT 5 // single step breakpoint#define DIVIDE_OVERFLOW_BREAKPOINT 6 // divide overflow breakpoint#define DIVIDE_BY_ZERO_BREAKPOINT 7 // divide by zero breakpoint#define RANGE_CHECK_BREAKPOINT 8 // range check breakpoint#define STACK_OVERFLOW_BREAKPOINT 9 // MIPS code#define MULTIPLY_OVERFLOW_BREAKPOINT 10 // multiply overflow breakpoint
#define DEBUG_PRINT_BREAKPOINT 20 // debug print breakpoint#define DEBUG_PROMPT_BREAKPOINT 21 // debug prompt breakpoint#define DEBUG_STOP_BREAKPOINT 22 // debug stop breakpoint#define DEBUG_LOAD_SYMBOLS_BREAKPOINT 23 // load symbols breakpoint#define DEBUG_UNLOAD_SYMBOLS_BREAKPOINT 24 // unload symbols breakpoint#define DEBUG_COMMAND_STRING_BREAKPOINT 25 // command string breakpoint
//// Define PowerPC specific read control space commands for the// Kernel Debugger. These definitions are for values that must be// accessed via defined interfaces (Fast path System Call).//
#define DEBUG_CONTROL_SPACE_PCR 1
//// Define special fast path system service codes.//// N.B. These codes are VERY special. The high bit signifies a fast path// and the low bits signify what type.//
#define RETRIEVE_TEB_PTR -3 // fetch address of TEB
#define SET_LOW_WAIT_HIGH -2 // fast path event pair service#define SET_HIGH_WAIT_LOW -1 // fast path event pair service
// begin_ntddk begin_nthal//
//// Define size of kernel mode stack.//// **FINISH** This may not be the appropriate value for PowerPC
#define KERNEL_STACK_SIZE 16384
//// Define size of large kernel mode stack for callbacks.//
#define KERNEL_LARGE_STACK_SIZE 61440
//// Define number of pages to initialize in a large kernel stack.//
#define KERNEL_LARGE_STACK_COMMIT 16384
// begin_wdm//// Define bus error routine type.//
struct _EXCEPTION_RECORD;struct _KEXCEPTION_FRAME;struct _KTRAP_FRAME;
typedefVOID(*PKBUS_ERROR_ROUTINE) ( IN struct _EXCEPTION_RECORD *ExceptionRecord, IN struct _KEXCEPTION_FRAME *ExceptionFrame, IN struct _KTRAP_FRAME *TrapFrame, IN PVOID VirtualAddress, IN PHYSICAL_ADDRESS PhysicalAddress );
//// Macros to emit eieio, sync, and isync instructions.//
#if defined(_M_PPC) && defined(_MSC_VER) && (_MSC_VER>=1000)void __emit( unsigned const __int32 );#define __builtin_eieio() __emit( 0x7C0006AC )#define __builtin_sync() __emit( 0x7C0004AC )#define __builtin_isync() __emit( 0x4C00012C )#elsevoid __builtin_eieio(void);void __builtin_sync(void);void __builtin_isync(void);#endif
// end_ntddk end_wdm end_nthal - Added to replace comment in the KPCR from ntmips.h
//// Define address of data shared between user and kernel mode.//
#define USER_SHARED_DATA ((KUSER_SHARED_DATA * const)0xFFFFE000)
// begin_winnt
//// The address of the TEB is placed into GPR 13 at context switch time// and should never be destroyed. To get the address of the TEB use// the compiler intrinsic to access it directly from GPR 13.//
#if defined(_M_PPC) && defined(_MSC_VER) && (_MSC_VER>=1000)unsigned __gregister_get( unsigned const regnum );#define NtCurrentTeb() ((struct _TEB *)__gregister_get(13))#elif defined(_M_PPC)struct _TEB * __builtin_get_gpr13(VOID);#define NtCurrentTeb() ((struct _TEB *)__builtin_get_gpr13())#endif
//// Define functions to get the address of the current fiber and the// current fiber data.//
#define GetCurrentFiber() (((PNT_TIB)NtCurrentTeb())->FiberData)#define GetFiberData() (*(PVOID *)(GetCurrentFiber()))
// begin_ntddk begin_nthal//// The following flags control the contents of the CONTEXT structure.//
#if !defined(RC_INVOKED)
#define CONTEXT_CONTROL 0x00000001L#define CONTEXT_FLOATING_POINT 0x00000002L#define CONTEXT_INTEGER 0x00000004L#define CONTEXT_DEBUG_REGISTERS 0x00000008L
#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
#endif
//// Context Frame//// N.B. This frame must be exactly a multiple of 16 bytes in length.//// This frame has a several purposes: 1) it is used as an argument to// NtContinue, 2) it is used to constuct a call frame for APC delivery,// 3) it is used to construct a call frame for exception dispatching// in user mode, and 4) it is used in the user level thread creation// routines.//// Requires at least 8-byte alignment (double)//
typedef struct _CONTEXT {
// // This section is specified/returned if the ContextFlags word contains // the flag CONTEXT_FLOATING_POINT. //
double Fpr0; // Floating registers 0..31 double Fpr1; double Fpr2; double Fpr3; double Fpr4; double Fpr5; double Fpr6; double Fpr7; double Fpr8; double Fpr9; double Fpr10; double Fpr11; double Fpr12; double Fpr13; double Fpr14; double Fpr15; double Fpr16; double Fpr17; double Fpr18; double Fpr19; double Fpr20; double Fpr21; double Fpr22; double Fpr23; double Fpr24; double Fpr25; double Fpr26; double Fpr27; double Fpr28; double Fpr29; double Fpr30; double Fpr31; double Fpscr; // Floating point status/control reg
// // This section is specified/returned if the ContextFlags word contains // the flag CONTEXT_INTEGER. //
ULONG Gpr0; // General registers 0..31 ULONG Gpr1; ULONG Gpr2; ULONG Gpr3; ULONG Gpr4; ULONG Gpr5; ULONG Gpr6; ULONG Gpr7; ULONG Gpr8; ULONG Gpr9; ULONG Gpr10; ULONG Gpr11; ULONG Gpr12; ULONG Gpr13; ULONG Gpr14; ULONG Gpr15; ULONG Gpr16; ULONG Gpr17; ULONG Gpr18; ULONG Gpr19; ULONG Gpr20; ULONG Gpr21; ULONG Gpr22; ULONG Gpr23; ULONG Gpr24; ULONG Gpr25; ULONG Gpr26; ULONG Gpr27; ULONG Gpr28; ULONG Gpr29; ULONG Gpr30; ULONG Gpr31;
ULONG Cr; // Condition register ULONG Xer; // Fixed point exception register
// // This section is specified/returned if the ContextFlags word contains // the flag CONTEXT_CONTROL. //
ULONG Msr; // Machine status register ULONG Iar; // Instruction address register ULONG Lr; // Link register ULONG Ctr; // Count register
// // The flags values within this flag control the contents of // a CONTEXT record. // // If the context record is used as an input parameter, then // for each portion of the context record controlled by a flag // whose value is set, it is assumed that that portion of the // context record contains valid context. If the context record // is being used to modify a thread's context, then only that // portion of the threads context will be modified. // // If the context record is used as an IN OUT parameter to capture // the context of a thread, then only those portions of the thread's // context corresponding to set flags will be returned. // // The context record is never used as an OUT only parameter. //
ULONG ContextFlags;
ULONG Fill[3]; // Pad out to multiple of 16 bytes
// // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is // set in ContextFlags. Note that CONTEXT_DEBUG_REGISTERS is NOT // included in CONTEXT_FULL. // ULONG Dr0; // Breakpoint Register 1 ULONG Dr1; // Breakpoint Register 2 ULONG Dr2; // Breakpoint Register 3 ULONG Dr3; // Breakpoint Register 4 ULONG Dr4; // Breakpoint Register 5 ULONG Dr5; // Breakpoint Register 6 ULONG Dr6; // Debug Status Register ULONG Dr7; // Debug Control Register
} CONTEXT, *PCONTEXT;
// end_ntddk end_nthal
//// Stack frame header//// Order of appearance in stack frame:// Header (six words)// Parameters (at least eight words)// Local variables// Saved GPRs// Saved FPRs//// Minimum alignment is 8 bytes
typedef struct _STACK_FRAME_HEADER { // GPR 1 points here ULONG BackChain; // Addr of previous frame ULONG GlueSaved1; // Used by glue code ULONG GlueSaved2; ULONG Reserved1; // Reserved ULONG Spare1; // Used by tracing, profiling, ... ULONG Spare2;
ULONG Parameter0; // First 8 parameter words are ULONG Parameter1; // always present ULONG Parameter2; ULONG Parameter3; ULONG Parameter4; ULONG Parameter5; ULONG Parameter6; ULONG Parameter7;
} STACK_FRAME_HEADER,*PSTACK_FRAME_HEADER;
// end_winnt
#define CONTEXT_TO_PROGRAM_COUNTER(Context) ((Context)->Iar)
#define CONTEXT_LENGTH (sizeof(CONTEXT))#define CONTEXT_ALIGN (sizeof(double))#define CONTEXT_ROUND (CONTEXT_ALIGN - 1)
//// Nonvolatile context pointer record.//
typedef struct _KNONVOLATILE_CONTEXT_POINTERS { DOUBLE *FloatingContext[32]; PULONG FpscrContext; PULONG IntegerContext[32]; PULONG CrContext; PULONG XerContext; PULONG MsrContext; PULONG IarContext; PULONG LrContext; PULONG CtrContext;} KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS; // begin_nthal//// PowerPC special-purpose registers//
//// Define Machine Status Register (MSR) fields//
typedef struct _MSR { ULONG LE : 1; // 31 Little-Endian execution mode ULONG RI : 1; // 30 Recoverable Interrupt ULONG Rsv1 : 2; // 29..28 reserved ULONG DR : 1; // 27 Data Relocate ULONG IR : 1; // 26 Instruction Relocate ULONG IP : 1; // 25 Interrupt Prefix ULONG Rsv2 : 1; // 24 reserved ULONG FE1 : 1; // 23 Floating point Exception mode 1 ULONG BE : 1; // 22 Branch trace Enable ULONG SE : 1; // 21 Single-step trace Enable ULONG FE0 : 1; // 20 Floating point Exception mode 0 ULONG ME : 1; // 19 Machine check Enable ULONG FP : 1; // 18 Floating Point available ULONG PR : 1; // 17 Problem state ULONG EE : 1; // 16 External interrupt Enable ULONG ILE : 1; // 15 Interrupt Little-Endian mode ULONG IMPL : 1; // 14 Implementation dependent ULONG POW : 1; // 13 Power management enable ULONG Rsv3 : 13; // 12..0 reserved} MSR, *PMSR;
//// Define Processor Version Register (PVR) fields//
typedef struct _PVR { ULONG Revision : 16; ULONG Version : 16;} PVR, *PPVR;
// end_nthal // begin_nthal
//// Define Condition Register (CR) fields//// We name the structure CondR rather than CR, so that a pointer// to a condition register structure is PCondR rather than PCR.// (PCR is an NT data structure, the Processor Control Region.)
typedef struct _CondR { ULONG CR7 : 4; // Eight 4-bit fields; machine numbers ULONG CR6 : 4; // them in Big-Endian order ULONG CR5 : 4; ULONG CR4 : 4; ULONG CR3 : 4; ULONG CR2 : 4; ULONG CR1 : 4; ULONG CR0 : 4;} CondR, *PCondR;
//// Define Fixed Point Exception Register (XER) fields//
typedef struct _XER { ULONG Rsv : 29; // 31..3 Reserved ULONG CA : 1; // 2 Carry ULONG OV : 1; // 1 Overflow ULONG SO : 1; // 0 Summary Overflow} XER, *PXER;
//// Define Floating Point Status/Control Register (FPSCR) fields//
typedef struct _FPSCR { ULONG RN : 2; // 31..30 Rounding control ULONG NI : 1; // 29 Non-IEEE mode ULONG XE : 1; // 28 Inexact exception Enable ULONG ZE : 1; // 27 Zero divide exception Enable ULONG UE : 1; // 26 Underflow exception Enable ULONG OE : 1; // 25 Overflow exception Enable ULONG VE : 1; // 24 Invalid operation exception Enable ULONG VXCVI : 1; // 23 Invalid op exception (integer convert) ULONG VXSQRT : 1; // 22 Invalid op exception (square root) ULONG VXSOFT : 1; // 21 Invalid op exception (software request) ULONG Res1 : 1; // 20 reserved ULONG FU : 1; // 19 Result Unordered or NaN ULONG FE : 1; // 18 Result Equal or zero ULONG FG : 1; // 17 Result Greater than or positive ULONG FL : 1; // 16 Result Less than or negative ULONG C : 1; // 15 Result Class descriptor ULONG FI : 1; // 14 Fraction Inexact ULONG FR : 1; // 13 Fraction Rounded ULONG VXVC : 1; // 12 Invalid op exception (compare) ULONG VXIMZ : 1; // 11 Invalid op exception (infinity * 0) ULONG VXZDZ : 1; // 10 Invalid op exception (0 / 0) ULONG VXIDI : 1; // 9 Invalid op exception (infinity / infinity) ULONG VXISI : 1; // 8 Invalid op exception (infinity - infinity) ULONG VXSNAN : 1; // 7 Invalid op exception (signalling NaN) ULONG XX : 1; // 6 Inexact exception ULONG ZX : 1; // 5 Zero divide exception ULONG UX : 1; // 4 Underflow exception ULONG OX : 1; // 3 Overflow exception ULONG VX : 1; // 2 Invalid operation exception summary ULONG FEX : 1; // 1 Enabled Exception summary ULONG FX : 1; // 0 Exception summary} FPSCR, *PFPSCR;
// end_nthal // begin_nthal//// Define address space layout as defined by PowerPC memory management.//// The names come from MIPS hardwired virtual to first 512MB real.// We use these values to define the size of the PowerPC kernel BAT.// Must coordinate with values in ../private/mm/ppc/mippc.h.// This is 8MB on the PowerPC 601; may be larger for other models.////
#define KUSEG_BASE 0x0 // base of user segment#define KSEG0_BASE 0x80000000 // base of kernel BAT#define KSEG1_BASE PCR->Kseg0Top // end of kernel BAT#define KSEG2_BASE KSEG1_BASE // end of kernel BAT
//// A valid Page Table Entry has the following definition//
typedef struct _HARDWARE_PTE { ULONG Dirty : 2; ULONG Valid : 1; // software ULONG GuardedStorage : 1; ULONG MemoryCoherence : 1; ULONG CacheDisable : 1; ULONG WriteThrough : 1; ULONG Change : 1; ULONG Reference : 1; ULONG Write : 1; // software ULONG CopyOnWrite : 1; // software ULONG rsvd1 : 1; ULONG PageFrameNumber : 20;} HARDWARE_PTE, *PHARDWARE_PTE;
#define HARDWARE_PTE_DIRTY_MASK 0x3
// end_nthal
//// Define PowerPC exception handling structures and function prototypes.//// These are adopted without change from the MIPS implementation.//
//// Function table entry structure definition.//
typedef struct _RUNTIME_FUNCTION { ULONG BeginAddress; ULONG EndAddress; PEXCEPTION_ROUTINE ExceptionHandler; PVOID HandlerData; ULONG PrologEndAddress;} RUNTIME_FUNCTION, *PRUNTIME_FUNCTION;
//// Scope table structure definition.//
typedef struct _SCOPE_TABLE { ULONG Count; struct { ULONG BeginAddress; ULONG EndAddress; ULONG HandlerAddress; ULONG JumpTarget; } ScopeRecord[1];} SCOPE_TABLE, *PSCOPE_TABLE;
//// Runtime Library function prototypes.//
VOIDRtlCaptureContext ( OUT PCONTEXT ContextRecord );
PRUNTIME_FUNCTIONRtlLookupFunctionEntry ( IN ULONG ControlPc );
ULONGRtlVirtualUnwind ( IN ULONG ControlPc, IN PRUNTIME_FUNCTION FunctionEntry, IN OUT PCONTEXT ContextRecord, OUT PBOOLEAN InFunction, OUT PULONG EstablisherFrame, IN OUT PKNONVOLATILE_CONTEXT_POINTERS ContextPointers OPTIONAL, IN ULONG LowStackLimit, IN ULONG HighStackLimit );
//// Define C structured exception handing function prototypes.//
typedef struct _DISPATCHER_CONTEXT { ULONG ControlPc; PRUNTIME_FUNCTION FunctionEntry; ULONG EstablisherFrame; PCONTEXT ContextRecord;} DISPATCHER_CONTEXT, *PDISPATCHER_CONTEXT;
struct _EXCEPTION_POINTERS;
typedefLONG(*EXCEPTION_FILTER) ( struct _EXCEPTION_POINTERS *ExceptionPointers );
typedefVOID(*TERMINATION_HANDLER) ( BOOLEAN is_abnormal );
// **FINISH** This may need alteration for PowerPC// begin_winnt
VOID__jump_unwind ( PVOID Fp, PVOID TargetPc );
// end_winnt
// begin_ntddk begin_wdm begin_nthal begin_winnt#endif // defined(_PPC_)// end_ntddk end_wdm end_nthal end_winnt
#ifdef __cplusplus}#endif
#endif // _NTPPC_
|
