OS_Develop/WindowsXP
OS_Develop/WindowsXP
1
0
Fork 0
Code Pull Requests Activity
350cc3dbe1
WindowsXP/Source/XPSP1/NT/public/sdk/inc/ntppc.h

675 lines
18 KiB
C
Raw Normal View History

Initial commit
2024-08-03 16:30:48 +02:00
/*++
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 __cplusplus
extern "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;
typedef
VOID
(*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 )
#else
void __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.
//
VOID
RtlCaptureContext (
OUT PCONTEXT ContextRecord
);
PRUNTIME_FUNCTION
RtlLookupFunctionEntry (
IN ULONG ControlPc
);
ULONG
RtlVirtualUnwind (
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;
typedef
LONG
(*EXCEPTION_FILTER) (
struct _EXCEPTION_POINTERS *ExceptionPointers
);
typedef
VOID
(*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_
Copy Permalink