diff options
Diffstat (limited to '')
| -rw-r--r-- | public/sdk/inc/ntalpha.h | 888 |
1 files changed, 888 insertions, 0 deletions
diff --git a/public/sdk/inc/ntalpha.h b/public/sdk/inc/ntalpha.h new file mode 100644 index 000000000..7472500cb --- /dev/null +++ b/public/sdk/inc/ntalpha.h @@ -0,0 +1,888 @@ +/*++ BUILD Version: 0011 // Increment this if a change has global effects + +Copyright (c) 1992 Digital Equipment Corporation + +Module Name: + + ntalpha.h + +Abstract: + + User-mode visible Alpha specific structures and constants + +Author: + + Joe Notarangelo 27-March-1992 (based on ntmips.h by Dave Cutler) + +Revision History: + + Miche Baker-Harvey 28-Jan-1993 Add 32-bit API for context structure + + Jeff McLeman 22-Jul-1992 Add SystemTime struct + + Jeff McLeman 10-July-1992 Add Stall entries in the PCR + + Steve Jenness 08-July-1992 Add NtCurrentTeb definition. + + John DeRosa 30-June-1992 + + Added volatile qualifier to the address arguments of the I/O + space function prototypes. + + Put back in sections of the PCR, and a typedef, that were deleted. + + Rod Gamache 15-May-1992 Add EISA access routines prototypes + + Thomas Van Baak (tvb) 9-Jul-1992 + + Created proper Alpha CONTEXT structure definitions. + +--*/ + +#ifndef _NTALPHA_ +#define _NTALPHA_ + +// begin_ntddk begin_nthal + +#if defined(_ALPHA_) + +// +// Define system time structure. +// + +typedef ULONGLONG KSYSTEM_TIME; +typedef KSYSTEM_TIME *PKSYSTEM_TIME; + +#endif + +// end_ntddk end_nthal + +#ifdef _ALPHA_ // ntddk nthal + +// +// Cfront doesn't support the volatile attribute and complains about +// it loudly. This disables volatile when compiling C++ code, but it +// isn't clear the semantics are correct. It all comes down to the fact +// that cfront is bogus. +// + +#ifdef _CFRONT +#define VOLATILE +#else +#define VOLATILE volatile +#endif + +// begin_windbgkd +#ifdef _ALPHA_ + +// +// Define Alpha specific kernel debugger information. +// +// The following structure contains machine specific data passed to +// the host system kernel debugger in a wait state change message. +// + +#define DBGKD_MAXSTREAM 16 + +typedef struct _DBGKD_CONTROL_REPORT { + ULONG InstructionCount; + UCHAR InstructionStream[DBGKD_MAXSTREAM]; +} DBGKD_CONTROL_REPORT, *PDBGKD_CONTROL_REPORT; + +// +// The following structure contains information that the host system +// kernel debugger wants to set on every continue operation and avoids +// the need to send extra packets of information. +// + +typedef ULONG DBGKD_CONTROL_SET, *PDBGKD_CONTROL_SET; + +#endif // _ALPHA_ +// end_windbgkd + +// +// Define breakpoint codes. +// + +#define USER_BREAKPOINT 0 // user breakpoint +#define KERNEL_BREAKPOINT 1 // kernel 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 BREAKIN_BREAKPOINT 25 // breakin breakpoint + +// +// Define Alpha specific read control space commands for the +// Kernel Debugger. These definitions are for values that must be +// accessed via defined interfaces (PAL on MP systems). +// + +#define DEBUG_CONTROL_SPACE_PCR 1 +#define DEBUG_CONTROL_SPACE_THREAD 2 +#define DEBUG_CONTROL_SPACE_PRCB 3 +#define DEBUG_CONTROL_SPACE_PSR 4 +#define DEBUG_CONTROL_SPACE_DPCACTIVE 5 +#define DEBUG_CONTROL_SPACE_TEB 6 +#define DEBUG_CONTROL_SPACE_IPRSTATE 7 +#define DEBUG_CONTROL_SPACE_COUNTERS 8 + +// +// Define Alpha GENTRAP codes. +// + +#define GENTRAP_INTEGER_OVERFLOW (-1) +#define GENTRAP_INTEGER_DIVIDE_BY_ZERO (-2) +#define GENTRAP_FLOATING_OVERFLOW (-3) +#define GENTRAP_FLOATING_DIVIDE_BY_ZERO (-4) +#define GENTRAP_FLOATING_UNDERFLOW (-5) +#define GENTRAP_FLOATING_INVALID_OPERAND (-6) +#define GENTRAP_FLOATING_INEXACT_RESULT (-7) + +// +// Define special fast path even pair client/server system service codes. +// +// N.B. These codes are VERY special. The high bit signifies a fast path +// event pair service and the low bit signifies what type. +// + +#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. +// + +#define KERNEL_STACK_SIZE 0x4000 + +// +// Define size of large kernel mode stack for callbacks. +// + +#define KERNEL_LARGE_STACK_SIZE 65536 + +// +// Define number of pages to initialize in a large kernel stack. +// + +#define KERNEL_LARGE_STACK_COMMIT 16384 + +// end_ntddk end_nthal + +// +// Define address of data shared between user and kernel mode. +// + +#define MM_SHARED_USER_DATA_VA 0x7FFE0000 + +#define USER_SHARED_DATA ((KUSER_SHARED_DATA * const)MM_SHARED_USER_DATA_VA) + +// begin_winnt + +#ifdef _ALPHA_ // winnt +void *_rdteb(void); // winnt +#if defined(_M_ALPHA) // winnt +#pragma intrinsic(_rdteb) // winnt +#endif // winnt +#endif // winnt + +#if defined(_M_ALPHA) +#define NtCurrentTeb() ((struct _TEB *)_rdteb()) +#else +struct _TEB * +NtCurrentTeb(void); +#endif + +// +// Define function to return the current Thread Environment Block +// + +#ifdef _ALPHA_ + + + +// +// 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_PORTABLE_32BIT 0x00100000 +#define CONTEXT_ALPHA 0x00020000 + +#define CONTEXT_CONTROL (CONTEXT_ALPHA | 0x00000001L) +#define CONTEXT_FLOATING_POINT (CONTEXT_ALPHA | 0x00000002L) +#define CONTEXT_INTEGER (CONTEXT_ALPHA | 0x00000004L) + +#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER) + +#endif + +#ifndef _PORTABLE_32BIT_CONTEXT + +// +// Context Frame +// +// This frame has a several purposes: 1) it is used as an argument to +// NtContinue, 2) it is used to construct a call frame for APC delivery, +// 3) it is used to construct a call frame for exception dispatching +// in user mode, 4) it is used in the user level thread creation +// routines, and 5) it is used to to pass thread state to debuggers. +// +// N.B. Because this record is used as a call frame, it must be EXACTLY +// a multiple of 16 bytes in length. +// +// There are two variations of the context structure. This is the real one. +// + +typedef struct _CONTEXT { + + // + // This section is specified/returned if the ContextFlags word contains + // the flag CONTEXT_FLOATING_POINT. + // + + ULONGLONG FltF0; + ULONGLONG FltF1; + ULONGLONG FltF2; + ULONGLONG FltF3; + ULONGLONG FltF4; + ULONGLONG FltF5; + ULONGLONG FltF6; + ULONGLONG FltF7; + ULONGLONG FltF8; + ULONGLONG FltF9; + ULONGLONG FltF10; + ULONGLONG FltF11; + ULONGLONG FltF12; + ULONGLONG FltF13; + ULONGLONG FltF14; + ULONGLONG FltF15; + ULONGLONG FltF16; + ULONGLONG FltF17; + ULONGLONG FltF18; + ULONGLONG FltF19; + ULONGLONG FltF20; + ULONGLONG FltF21; + ULONGLONG FltF22; + ULONGLONG FltF23; + ULONGLONG FltF24; + ULONGLONG FltF25; + ULONGLONG FltF26; + ULONGLONG FltF27; + ULONGLONG FltF28; + ULONGLONG FltF29; + ULONGLONG FltF30; + ULONGLONG FltF31; + + // + // This section is specified/returned if the ContextFlags word contains + // the flag CONTEXT_INTEGER. + // + // N.B. The registers gp, sp, and ra are defined in this section, but are + // considered part of the control context rather than part of the integer + // context. + // + + ULONGLONG IntV0; // $0: return value register, v0 + ULONGLONG IntT0; // $1: temporary registers, t0 - t7 + ULONGLONG IntT1; // $2: + ULONGLONG IntT2; // $3: + ULONGLONG IntT3; // $4: + ULONGLONG IntT4; // $5: + ULONGLONG IntT5; // $6: + ULONGLONG IntT6; // $7: + ULONGLONG IntT7; // $8: + ULONGLONG IntS0; // $9: nonvolatile registers, s0 - s5 + ULONGLONG IntS1; // $10: + ULONGLONG IntS2; // $11: + ULONGLONG IntS3; // $12: + ULONGLONG IntS4; // $13: + ULONGLONG IntS5; // $14: + ULONGLONG IntFp; // $15: frame pointer register, fp/s6 + ULONGLONG IntA0; // $16: argument registers, a0 - a5 + ULONGLONG IntA1; // $17: + ULONGLONG IntA2; // $18: + ULONGLONG IntA3; // $19: + ULONGLONG IntA4; // $20: + ULONGLONG IntA5; // $21: + ULONGLONG IntT8; // $22: temporary registers, t8 - t11 + ULONGLONG IntT9; // $23: + ULONGLONG IntT10; // $24: + ULONGLONG IntT11; // $25: + ULONGLONG IntRa; // $26: return address register, ra + ULONGLONG IntT12; // $27: temporary register, t12 + ULONGLONG IntAt; // $28: assembler temp register, at + ULONGLONG IntGp; // $29: global pointer register, gp + ULONGLONG IntSp; // $30: stack pointer register, sp + ULONGLONG IntZero; // $31: zero register, zero + + // + // This section is specified/returned if the ContextFlags word contains + // the flag CONTEXT_FLOATING_POINT. + // + + ULONGLONG Fpcr; // floating point control register + ULONGLONG SoftFpcr; // software extension to FPCR + + // + // This section is specified/returned if the ContextFlags word contains + // the flag CONTEXT_CONTROL. + // + // N.B. The registers gp, sp, and ra are defined in the integer section, + // but are considered part of the control context rather than part of + // the integer context. + // + + ULONGLONG Fir; // (fault instruction) continuation address + ULONG Psr; // processor status + + // + // 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[4]; // padding for 16-byte stack frame alignment + +} CONTEXT, *PCONTEXT; + +#else + +// +// 32-bit Context Frame +// +// This alternate version of the Alpha context structure parallels that +// of MIPS and IX86 in style for the first 64 entries: 32-bit machines +// can operate on the fields, and a value declared as a pointer to an +// array of int's can be used to index into the fields. This makes life +// with windbg and ntsd vastly easier. +// +// There are two parts: the first contains the lower 32-bits of each +// element in the 64-bit definition above. The second part contains +// the upper 32-bits of each 64-bit element above. +// +// The names in the first part are identical to the 64-bit names. +// The second part names are prefixed with "High". +// +// 1st half: at 32 bits each, (containing the low parts of 64-bit values) +// 32 floats, 32 ints, fpcrs, fir, psr, contextflags +// 2nd half: at 32 bits each +// 32 floats, 32 ints, fpcrs, fir, fill +// +// There is no external support for the 32-bit version of the context +// structure. It is only used internally by windbg and ntsd. +// +// This structure must be the same size as the 64-bit version above. +// + +typedef struct _CONTEXT { + + ULONG FltF0; + ULONG FltF1; + ULONG FltF2; + ULONG FltF3; + ULONG FltF4; + ULONG FltF5; + ULONG FltF6; + ULONG FltF7; + ULONG FltF8; + ULONG FltF9; + ULONG FltF10; + ULONG FltF11; + ULONG FltF12; + ULONG FltF13; + ULONG FltF14; + ULONG FltF15; + ULONG FltF16; + ULONG FltF17; + ULONG FltF18; + ULONG FltF19; + ULONG FltF20; + ULONG FltF21; + ULONG FltF22; + ULONG FltF23; + ULONG FltF24; + ULONG FltF25; + ULONG FltF26; + ULONG FltF27; + ULONG FltF28; + ULONG FltF29; + ULONG FltF30; + ULONG FltF31; + + ULONG IntV0; // $0: return value register, v0 + ULONG IntT0; // $1: temporary registers, t0 - t7 + ULONG IntT1; // $2: + ULONG IntT2; // $3: + ULONG IntT3; // $4: + ULONG IntT4; // $5: + ULONG IntT5; // $6: + ULONG IntT6; // $7: + ULONG IntT7; // $8: + ULONG IntS0; // $9: nonvolatile registers, s0 - s5 + ULONG IntS1; // $10: + ULONG IntS2; // $11: + ULONG IntS3; // $12: + ULONG IntS4; // $13: + ULONG IntS5; // $14: + ULONG IntFp; // $15: frame pointer register, fp/s6 + ULONG IntA0; // $16: argument registers, a0 - a5 + ULONG IntA1; // $17: + ULONG IntA2; // $18: + ULONG IntA3; // $19: + ULONG IntA4; // $20: + ULONG IntA5; // $21: + ULONG IntT8; // $22: temporary registers, t8 - t11 + ULONG IntT9; // $23: + ULONG IntT10; // $24: + ULONG IntT11; // $25: + ULONG IntRa; // $26: return address register, ra + ULONG IntT12; // $27: temporary register, t12 + ULONG IntAt; // $28: assembler temp register, at + ULONG IntGp; // $29: global pointer register, gp + ULONG IntSp; // $30: stack pointer register, sp + ULONG IntZero; // $31: zero register, zero + + ULONG Fpcr; // floating point control register + ULONG SoftFpcr; // software extension to FPCR + + ULONG Fir; // (fault instruction) continuation address + + ULONG Psr; // processor status + ULONG ContextFlags; + + // + // Beginning of the "second half". + // The name "High" parallels the HighPart of a LargeInteger. + // + + ULONG HighFltF0; + ULONG HighFltF1; + ULONG HighFltF2; + ULONG HighFltF3; + ULONG HighFltF4; + ULONG HighFltF5; + ULONG HighFltF6; + ULONG HighFltF7; + ULONG HighFltF8; + ULONG HighFltF9; + ULONG HighFltF10; + ULONG HighFltF11; + ULONG HighFltF12; + ULONG HighFltF13; + ULONG HighFltF14; + ULONG HighFltF15; + ULONG HighFltF16; + ULONG HighFltF17; + ULONG HighFltF18; + ULONG HighFltF19; + ULONG HighFltF20; + ULONG HighFltF21; + ULONG HighFltF22; + ULONG HighFltF23; + ULONG HighFltF24; + ULONG HighFltF25; + ULONG HighFltF26; + ULONG HighFltF27; + ULONG HighFltF28; + ULONG HighFltF29; + ULONG HighFltF30; + ULONG HighFltF31; + + ULONG HighIntV0; // $0: return value register, v0 + ULONG HighIntT0; // $1: temporary registers, t0 - t7 + ULONG HighIntT1; // $2: + ULONG HighIntT2; // $3: + ULONG HighIntT3; // $4: + ULONG HighIntT4; // $5: + ULONG HighIntT5; // $6: + ULONG HighIntT6; // $7: + ULONG HighIntT7; // $8: + ULONG HighIntS0; // $9: nonvolatile registers, s0 - s5 + ULONG HighIntS1; // $10: + ULONG HighIntS2; // $11: + ULONG HighIntS3; // $12: + ULONG HighIntS4; // $13: + ULONG HighIntS5; // $14: + ULONG HighIntFp; // $15: frame pointer register, fp/s6 + ULONG HighIntA0; // $16: argument registers, a0 - a5 + ULONG HighIntA1; // $17: + ULONG HighIntA2; // $18: + ULONG HighIntA3; // $19: + ULONG HighIntA4; // $20: + ULONG HighIntA5; // $21: + ULONG HighIntT8; // $22: temporary registers, t8 - t11 + ULONG HighIntT9; // $23: + ULONG HighIntT10; // $24: + ULONG HighIntT11; // $25: + ULONG HighIntRa; // $26: return address register, ra + ULONG HighIntT12; // $27: temporary register, t12 + ULONG HighIntAt; // $28: assembler temp register, at + ULONG HighIntGp; // $29: global pointer register, gp + ULONG HighIntSp; // $30: stack pointer register, sp + ULONG HighIntZero; // $31: zero register, zero + + ULONG HighFpcr; // floating point control register + ULONG HighSoftFpcr; // software extension to FPCR + ULONG HighFir; // processor status + + double DoNotUseThisField; // to force quadword structure alignment + ULONG HighFill[2]; // padding for 16-byte stack frame alignment + +} CONTEXT, *PCONTEXT; + +// +// These should name the fields in the _PORTABLE_32BIT structure +// that overlay the Psr and ContextFlags in the normal structure. +// + +#define _QUAD_PSR_OFFSET HighSoftFpcr +#define _QUAD_FLAGS_OFFSET HighFir + +#endif // _PORTABLE_32BIT_CONTEXT + +// end_ntddk end_nthal + +#endif // _ALPHA_ + +// end_winnt + +#define CONTEXT_TO_PROGRAM_COUNTER(Context) ((Context)->Fir) + +#define CONTEXT_LENGTH (sizeof(CONTEXT)) +#define CONTEXT_ALIGN (sizeof(ULONG)) +#define CONTEXT_ROUND (CONTEXT_ALIGN - 1) + +// +// Nonvolatile context pointer record. +// + +typedef struct _KNONVOLATILE_CONTEXT_POINTERS { + + PULONGLONG FloatingContext[1]; + PULONGLONG FltF1; + // Nonvolatile floating point registers start here. + PULONGLONG FltF2; + PULONGLONG FltF3; + PULONGLONG FltF4; + PULONGLONG FltF5; + PULONGLONG FltF6; + PULONGLONG FltF7; + PULONGLONG FltF8; + PULONGLONG FltF9; + PULONGLONG FltF10; + PULONGLONG FltF11; + PULONGLONG FltF12; + PULONGLONG FltF13; + PULONGLONG FltF14; + PULONGLONG FltF15; + PULONGLONG FltF16; + PULONGLONG FltF17; + PULONGLONG FltF18; + PULONGLONG FltF19; + PULONGLONG FltF20; + PULONGLONG FltF21; + PULONGLONG FltF22; + PULONGLONG FltF23; + PULONGLONG FltF24; + PULONGLONG FltF25; + PULONGLONG FltF26; + PULONGLONG FltF27; + PULONGLONG FltF28; + PULONGLONG FltF29; + PULONGLONG FltF30; + PULONGLONG FltF31; + + PULONGLONG IntegerContext[1]; + PULONGLONG IntT0; + PULONGLONG IntT1; + PULONGLONG IntT2; + PULONGLONG IntT3; + PULONGLONG IntT4; + PULONGLONG IntT5; + PULONGLONG IntT6; + PULONGLONG IntT7; + // Nonvolatile integer registers start here. + PULONGLONG IntS0; + PULONGLONG IntS1; + PULONGLONG IntS2; + PULONGLONG IntS3; + PULONGLONG IntS4; + PULONGLONG IntS5; + PULONGLONG IntFp; + PULONGLONG IntA0; + PULONGLONG IntA1; + PULONGLONG IntA2; + PULONGLONG IntA3; + PULONGLONG IntA4; + PULONGLONG IntA5; + PULONGLONG IntT8; + PULONGLONG IntT9; + PULONGLONG IntT10; + PULONGLONG IntT11; + PULONGLONG IntRa; + PULONGLONG IntT12; + PULONGLONG IntAt; + PULONGLONG IntGp; + PULONGLONG IntSp; + PULONGLONG IntZero; + +} KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS; + +// +// Define Exception Summary Register for arithmetic exceptions. +// + +typedef struct _EXC_SUM { + + ULONG SoftwareCompletion : 1; + ULONG InvalidOperation : 1; + ULONG DivisionByZero : 1; + ULONG Overflow : 1; + ULONG Underflow : 1; + ULONG InexactResult : 1; + ULONG IntegerOverflow : 1; + ULONG Fill : 25; + +} EXC_SUM, *PEXC_SUM; + +// +// Define hardware Floating Point Control Register. +// + +typedef struct _FPCR { + + ULONG LowPart; + ULONG Fill : 17; + ULONG DisableInvalid : 1; + ULONG DisableDivisionByZero : 1; + ULONG DisableOverflow : 1; + ULONG InvalidOperation : 1; + ULONG DivisionByZero : 1; + ULONG Overflow : 1; + ULONG Underflow : 1; + ULONG InexactResult : 1; + ULONG IntegerOverflow : 1; + ULONG DynamicRoundingMode : 2; + ULONG UnderflowToZeroEnable : 1; + ULONG DisableUnderflow : 1; + ULONG DisableInexact : 1; + ULONG SummaryBit : 1; + +} FPCR, *PFPCR; + +// +// Define software Floating Point Control and Status Register. +// +// N.B. The five IEEE trap enable bits are in the same position as the bits +// in the exception summary register. The five IEEE status bits are in +// the same order and 16 bits left of the IEEE enable bits. +// +// N.B. The ArithmeticTrapIgnore bit will supress all arithmetic traps (and +// leave unpredictable results in the destination register of floating +// point instructions that trap) when the /S qualifier is not used. +// +// The Software FPCR defaults to zero. +// + +typedef struct _SW_FPCR { + + ULONG ArithmeticTrapIgnore : 1; + + ULONG EnableInvalid : 1; + ULONG EnableDivisionByZero : 1; + ULONG EnableOverflow : 1; + ULONG EnableUnderflow : 1; + ULONG EnableInexact : 1; + ULONG FillA : 6; + + ULONG DenormalResultEnable : 1; + ULONG NoSoftwareEmulation : 1; // tvb debug + ULONG UnderflowToZeroEnable : 1; // bit 14 not used + ULONG ThreadInheritEnable : 1; // bit 15 not used + + ULONG EmulationOccurred : 1; + + ULONG StatusInvalid : 1; + ULONG StatusDivisionByZero : 1; + ULONG StatusOverflow : 1; + ULONG StatusUnderflow : 1; + ULONG StatusInexact : 1; + ULONG FillB : 10; + +} SW_FPCR, *PSW_FPCR; + +// begin_nthal +// +// Define address space layout as defined by Alpha 32-bit super-page +// memory management. +// + +#define KUSEG_BASE 0x0 // base of user segment +#define KSEG0_BASE 0x80000000 // base of cached kernel physical +#define KSEG2_BASE 0xc0000000 // base of cached kernel virtual +// end_nthal + +// +// Define Alpha exception handling structures and function prototypes. +// + +// +// 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 - for acc. +// +// One table entry is created by the acc C compiler for each try-except or +// try-finally scope. Nested scopes are ordered from inner to outer scope. +// Current scope is passively maintained by PC-mapping (function tables). +// + +typedef struct _SCOPE_TABLE { + ULONG Count; + struct + { + ULONG BeginAddress; + ULONG EndAddress; + ULONG HandlerAddress; + ULONG JumpTarget; + } ScopeRecord[1]; +} SCOPE_TABLE, *PSCOPE_TABLE; + +// +// Scope structure definition - for GEM. +// +// One descriptor is created by the GEM C compiler for each try-except or +// try-finally scope. Nested scopes are linked from inner to outer scope. +// Current scope is actively maintained by a dynamic scope context structure. +// + +typedef struct _SEH_BLOCK { + ULONG HandlerAddress; + ULONG JumpTarget; + struct _SEH_BLOCK *ParentSeb; +} SEH_BLOCK, *PSEH_BLOCK; + +// +// Dynamic SEH context definition for GEM. +// +// For GEM generated C code, dynamic SEH scope for a procedure is maintained +// with a pointer to the current SEB (or NULL when not in any SEH scope). The +// SEB pointer, as well as except handler linkage variables, is contained in +// a structure located at a known offset within the stack frame. +// + +typedef struct _SEH_CONTEXT { + PSEH_BLOCK CurrentSeb; + ULONG ExceptionCode; + ULONG RealFramePointer; +} SEH_CONTEXT, *PSEH_CONTEXT; + +// +// Runtime Library function prototypes. +// + +VOID +RtlCaptureContext ( + OUT PCONTEXT ContextRecord + ); + +PRUNTIME_FUNCTION +RtlLookupFunctionEntry ( + IN ULONG ControlPc + ); + +typedef struct _FRAME_POINTERS { + ULONG VirtualFramePointer; + ULONG RealFramePointer; +} FRAME_POINTERS, *PFRAME_POINTERS; + +ULONG +RtlVirtualUnwind ( + IN ULONG ControlPc, + IN PRUNTIME_FUNCTION FunctionEntry, + IN OUT PCONTEXT ContextRecord, + OUT PBOOLEAN InFunction, + OUT PFRAME_POINTERS EstablisherFrame, + IN OUT PKNONVOLATILE_CONTEXT_POINTERS ContextPointers OPTIONAL + ); + +// +// 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 + ); + +// begin_winnt + +#ifdef _ALPHA_ + +VOID +__jump_unwind ( + PVOID VirtualFramePointer, + PVOID TargetPc + ); + +#endif // _ALPHA_ + +// end_winnt + + + +#endif // _ALPHA_ // ntddk nthal + +#endif // _NTALPHA_ |