700 lines
20 KiB
C
700 lines
20 KiB
C
#ifdef ALPHA_FW_KDHOOKS
|
||
|
||
/*++
|
||
|
||
Copyright (c) 1990 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
fwkd.c
|
||
|
||
Abstract:
|
||
|
||
This module implements the code to interface the firware exception
|
||
path with the kernel debugger stub.
|
||
|
||
Author:
|
||
|
||
Joe Notarangelo 31-Mar-93
|
||
|
||
Environment:
|
||
|
||
Firmware.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "fwp.h"
|
||
#include "fwpexcpt.h"
|
||
#include "ntosdef.h"
|
||
|
||
VOID
|
||
FwFrameToKdFrames(
|
||
PFW_EXCEPTION_FRAME FirmwareFrame,
|
||
PKTRAP_FRAME TrapFrame,
|
||
PCONTEXT Context
|
||
);
|
||
|
||
VOID
|
||
FwFrameFromKdFrames(
|
||
PFW_EXCEPTION_FRAME FirmwareFrame,
|
||
PKTRAP_FRAME TrapFrame,
|
||
PCONTEXT Context
|
||
);
|
||
|
||
VOID
|
||
KeContextFromKframes (
|
||
IN PKTRAP_FRAME TrapFrame,
|
||
IN PKEXCEPTION_FRAME ExceptionFrame,
|
||
IN OUT PCONTEXT ContextFrame
|
||
);
|
||
|
||
VOID
|
||
KeContextToKframes (
|
||
IN OUT PKTRAP_FRAME TrapFrame,
|
||
IN OUT PKEXCEPTION_FRAME ExceptionFrame,
|
||
IN PCONTEXT ContextFrame,
|
||
IN ULONG ContextFlags,
|
||
IN KPROCESSOR_MODE PreviousMode
|
||
);
|
||
|
||
|
||
BOOLEAN
|
||
FwKdProcessBreakpoint(
|
||
PFW_EXCEPTION_FRAME FirmwareExceptionFrame
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function implements the glue logic between the firmware
|
||
exception path and the kernel debugger stub. It must translate
|
||
the firmware exception frame to a kernel trap and context frame.
|
||
|
||
Arguments:
|
||
|
||
FirmwareExceptionFrame - supplies a pointer to the firmware exception
|
||
frame.
|
||
|
||
Return Value:
|
||
|
||
The value TRUE is returned if the breakpoint is processed by the
|
||
kernel debugger stub, FALSE is returned otherwise.
|
||
|
||
--*/
|
||
{
|
||
KTRAP_FRAME TrapFrame;
|
||
CONTEXT Context;
|
||
PEXCEPTION_RECORD ExceptionRecord;
|
||
|
||
|
||
//
|
||
// Translate the firmware exception frame to the frames expected
|
||
// by the kernel debugger stub.
|
||
//
|
||
|
||
FwFrameToKdFrames( FirmwareExceptionFrame, &TrapFrame, &Context );
|
||
|
||
|
||
ExceptionRecord = (PEXCEPTION_RECORD)&TrapFrame.ExceptionRecord;
|
||
|
||
//
|
||
// Determine if this is a kernel debugger breakpoint, if it is not
|
||
// return FALSE to indicate that the breakpoint was not handled.
|
||
//
|
||
|
||
if( !KdIsThisAKdTrap(ExceptionRecord,
|
||
&Context,
|
||
KernelMode) ) {
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Call the kernel debugger to handle the breakpoint.
|
||
//
|
||
|
||
(VOID)KdpTrap( &TrapFrame,
|
||
ExceptionRecord,
|
||
&Context,
|
||
KernelMode,
|
||
FALSE );
|
||
|
||
//
|
||
// Transfer the kernel frames back into the firmware frame.
|
||
//
|
||
|
||
FwFrameFromKdFrames( FirmwareExceptionFrame, &TrapFrame, &Context );
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
VOID
|
||
FwFrameToKdFrames(
|
||
PFW_EXCEPTION_FRAME FirmwareFrame,
|
||
PKTRAP_FRAME TrapFrame,
|
||
PCONTEXT Context
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert the firmware exception frame to the kernel frames format.
|
||
|
||
Arguments:
|
||
|
||
FirmwareFrame - supplies a pointer to the firmware exception frame.
|
||
|
||
TrapFrame - supplies a pointer to the kernel trap frame.
|
||
|
||
Context - supplies a pointer to the kernel context
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
{
|
||
|
||
PEXCEPTION_RECORD ExceptionRecord;
|
||
KEXCEPTION_FRAME ExceptionFrame;
|
||
|
||
//
|
||
// Build the kernel trap frame.
|
||
//
|
||
|
||
//
|
||
// Volatile floating registers.
|
||
//
|
||
|
||
TrapFrame->FltF0 = FirmwareFrame->ExceptionF0;
|
||
TrapFrame->Fpcr = 0; //not saved by firmware
|
||
TrapFrame->FltF1 = FirmwareFrame->ExceptionF1;
|
||
|
||
TrapFrame->FltF10 = FirmwareFrame->ExceptionF10;
|
||
TrapFrame->FltF11 = FirmwareFrame->ExceptionF11;
|
||
TrapFrame->FltF12 = FirmwareFrame->ExceptionF12;
|
||
TrapFrame->FltF13 = FirmwareFrame->ExceptionF13;
|
||
TrapFrame->FltF14 = FirmwareFrame->ExceptionF14;
|
||
TrapFrame->FltF15 = FirmwareFrame->ExceptionF15;
|
||
TrapFrame->FltF16 = FirmwareFrame->ExceptionF16;
|
||
TrapFrame->FltF17 = FirmwareFrame->ExceptionF17;
|
||
TrapFrame->FltF18 = FirmwareFrame->ExceptionF18;
|
||
TrapFrame->FltF19 = FirmwareFrame->ExceptionF19;
|
||
TrapFrame->FltF20 = FirmwareFrame->ExceptionF20;
|
||
TrapFrame->FltF21 = FirmwareFrame->ExceptionF21;
|
||
TrapFrame->FltF22 = FirmwareFrame->ExceptionF22;
|
||
TrapFrame->FltF23 = FirmwareFrame->ExceptionF23;
|
||
TrapFrame->FltF24 = FirmwareFrame->ExceptionF24;
|
||
TrapFrame->FltF25 = FirmwareFrame->ExceptionF25;
|
||
TrapFrame->FltF26 = FirmwareFrame->ExceptionF26;
|
||
TrapFrame->FltF27 = FirmwareFrame->ExceptionF27;
|
||
TrapFrame->FltF28 = FirmwareFrame->ExceptionF28;
|
||
TrapFrame->FltF29 = FirmwareFrame->ExceptionF29;
|
||
TrapFrame->FltF30 = FirmwareFrame->ExceptionF30;
|
||
|
||
//
|
||
// Volatile integer registers.
|
||
//
|
||
|
||
TrapFrame->IntV0 = FirmwareFrame->ExceptionV0;
|
||
TrapFrame->IntT0 = FirmwareFrame->ExceptionT0;
|
||
TrapFrame->IntT1 = FirmwareFrame->ExceptionT1;
|
||
TrapFrame->IntT2 = FirmwareFrame->ExceptionT2;
|
||
TrapFrame->IntT3 = FirmwareFrame->ExceptionT3;
|
||
TrapFrame->IntT4 = FirmwareFrame->ExceptionT4;
|
||
TrapFrame->IntT5 = FirmwareFrame->ExceptionT5;
|
||
TrapFrame->IntT6 = FirmwareFrame->ExceptionT6;
|
||
TrapFrame->IntT7 = FirmwareFrame->ExceptionT7;
|
||
|
||
TrapFrame->IntFp = FirmwareFrame->ExceptionFp;
|
||
|
||
TrapFrame->IntA0 = FirmwareFrame->ExceptionA0;
|
||
TrapFrame->IntA1 = FirmwareFrame->ExceptionA1;
|
||
TrapFrame->IntA2 = FirmwareFrame->ExceptionA2;
|
||
TrapFrame->IntA3 = FirmwareFrame->ExceptionA3;
|
||
|
||
TrapFrame->IntA4 = FirmwareFrame->ExceptionA4;
|
||
TrapFrame->IntA5 = FirmwareFrame->ExceptionA5;
|
||
TrapFrame->IntT8 = FirmwareFrame->ExceptionT8;
|
||
TrapFrame->IntT9 = FirmwareFrame->ExceptionT9;
|
||
TrapFrame->IntT10 = FirmwareFrame->ExceptionT10;
|
||
TrapFrame->IntT11 = FirmwareFrame->ExceptionT11;
|
||
|
||
TrapFrame->IntRa = FirmwareFrame->ExceptionRa;
|
||
TrapFrame->IntT12 = FirmwareFrame->ExceptionT12;
|
||
TrapFrame->IntAt = FirmwareFrame->ExceptionAt;
|
||
TrapFrame->IntGp = FirmwareFrame->ExceptionGp;
|
||
TrapFrame->IntSp = FirmwareFrame->ExceptionSp;
|
||
|
||
//
|
||
// Exception Record.
|
||
//
|
||
|
||
ExceptionRecord = (PEXCEPTION_RECORD)&TrapFrame->ExceptionRecord;
|
||
|
||
ExceptionRecord->ExceptionCode = STATUS_BREAKPOINT;
|
||
ExceptionRecord->ExceptionAddress = (PVOID)(LONG)
|
||
FirmwareFrame->ExceptionFaultingInstructionAddress;
|
||
ExceptionRecord->ExceptionInformation[0] =
|
||
FirmwareFrame->ExceptionParameter1;
|
||
ExceptionRecord->ExceptionFlags = 0;
|
||
ExceptionRecord->ExceptionAddress = NULL;
|
||
ExceptionRecord->NumberParameters = 0;
|
||
|
||
//
|
||
// Control data.
|
||
//
|
||
|
||
TrapFrame->Fir = FirmwareFrame->ExceptionFaultingInstructionAddress;
|
||
TrapFrame->Psr = 0;
|
||
TrapFrame->OldIrql = 0;
|
||
TrapFrame->PreviousMode = 0;
|
||
|
||
//
|
||
// Build the Context Frame, using the standard kernel routines to
|
||
// transfer kernel frames to a context frame. This strategy requires
|
||
// building a local exception frame to pass in to the common routine.
|
||
//
|
||
|
||
ExceptionFrame.IntS0 = FirmwareFrame->ExceptionS0;
|
||
ExceptionFrame.IntS1 = FirmwareFrame->ExceptionS1;
|
||
ExceptionFrame.IntS2 = FirmwareFrame->ExceptionS2;
|
||
ExceptionFrame.IntS3 = FirmwareFrame->ExceptionS3;
|
||
ExceptionFrame.IntS4 = FirmwareFrame->ExceptionS4;
|
||
ExceptionFrame.IntS5 = FirmwareFrame->ExceptionS5;
|
||
|
||
ExceptionFrame.FltF2 = FirmwareFrame->ExceptionF2;
|
||
ExceptionFrame.FltF3 = FirmwareFrame->ExceptionF3;
|
||
ExceptionFrame.FltF4 = FirmwareFrame->ExceptionF4;
|
||
ExceptionFrame.FltF5 = FirmwareFrame->ExceptionF5;
|
||
ExceptionFrame.FltF6 = FirmwareFrame->ExceptionF6;
|
||
ExceptionFrame.FltF7 = FirmwareFrame->ExceptionF7;
|
||
ExceptionFrame.FltF8 = FirmwareFrame->ExceptionF8;
|
||
ExceptionFrame.FltF9 = FirmwareFrame->ExceptionF9;
|
||
|
||
Context->ContextFlags = CONTEXT_FULL;
|
||
KeContextFromKframes( TrapFrame, &ExceptionFrame, Context );
|
||
|
||
}
|
||
|
||
VOID
|
||
FwFrameFromKdFrames(
|
||
PFW_EXCEPTION_FRAME FirmwareFrame,
|
||
PKTRAP_FRAME TrapFrame,
|
||
PCONTEXT Context
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert the firmware exception frame to the kernel frames format.
|
||
|
||
Arguments:
|
||
|
||
FirmwareFrame - supplies a pointer to the firmware exception frame.
|
||
|
||
TrapFrame - supplies a pointer to the kernel trap frame.
|
||
|
||
Context - supplies a pointer to the kernel context
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
{
|
||
|
||
KEXCEPTION_FRAME ExceptionFrame;
|
||
|
||
//
|
||
// Build the kernel frames (trap and exception) from the
|
||
// context frame using the standard kernel routines.
|
||
//
|
||
|
||
KeContextToKframes( TrapFrame,
|
||
&ExceptionFrame,
|
||
Context,
|
||
CONTEXT_FULL,
|
||
KernelMode );
|
||
|
||
//
|
||
// Extract the non-volatile register state from the ExceptionFrame
|
||
// and re-populate the firmware frame.
|
||
//
|
||
|
||
FirmwareFrame->ExceptionS0 = ExceptionFrame.IntS0;
|
||
FirmwareFrame->ExceptionS1 = ExceptionFrame.IntS1;
|
||
FirmwareFrame->ExceptionS2 = ExceptionFrame.IntS2;
|
||
FirmwareFrame->ExceptionS3 = ExceptionFrame.IntS3;
|
||
FirmwareFrame->ExceptionS4 = ExceptionFrame.IntS4;
|
||
FirmwareFrame->ExceptionS5 = ExceptionFrame.IntS5;
|
||
|
||
FirmwareFrame->ExceptionF2 = ExceptionFrame.FltF2;
|
||
FirmwareFrame->ExceptionF3 = ExceptionFrame.FltF3;
|
||
FirmwareFrame->ExceptionF4 = ExceptionFrame.FltF4;
|
||
FirmwareFrame->ExceptionF5 = ExceptionFrame.FltF5;
|
||
FirmwareFrame->ExceptionF6 = ExceptionFrame.FltF6;
|
||
FirmwareFrame->ExceptionF7 = ExceptionFrame.FltF7;
|
||
FirmwareFrame->ExceptionF8 = ExceptionFrame.FltF8;
|
||
FirmwareFrame->ExceptionF9 = ExceptionFrame.FltF9;
|
||
|
||
//
|
||
// Extract the volatile register state from the TrapFrame and
|
||
// re-populate the firmware frame.
|
||
//
|
||
|
||
//
|
||
// Volatile floating registers.
|
||
//
|
||
|
||
FirmwareFrame->ExceptionF0 = TrapFrame->FltF0;
|
||
FirmwareFrame->ExceptionF1 = TrapFrame->FltF1;
|
||
|
||
FirmwareFrame->ExceptionF10 = TrapFrame->FltF10;
|
||
FirmwareFrame->ExceptionF11 = TrapFrame->FltF11;
|
||
FirmwareFrame->ExceptionF12 = TrapFrame->FltF12;
|
||
FirmwareFrame->ExceptionF13 = TrapFrame->FltF13;
|
||
FirmwareFrame->ExceptionF14 = TrapFrame->FltF14;
|
||
FirmwareFrame->ExceptionF15 = TrapFrame->FltF15;
|
||
FirmwareFrame->ExceptionF16 = TrapFrame->FltF16;
|
||
FirmwareFrame->ExceptionF17 = TrapFrame->FltF17;
|
||
FirmwareFrame->ExceptionF18 = TrapFrame->FltF18;
|
||
FirmwareFrame->ExceptionF19 = TrapFrame->FltF19;
|
||
FirmwareFrame->ExceptionF20 = TrapFrame->FltF20;
|
||
FirmwareFrame->ExceptionF21 = TrapFrame->FltF21;
|
||
FirmwareFrame->ExceptionF22 = TrapFrame->FltF22;
|
||
FirmwareFrame->ExceptionF23 = TrapFrame->FltF23;
|
||
FirmwareFrame->ExceptionF24 = TrapFrame->FltF24;
|
||
FirmwareFrame->ExceptionF25 = TrapFrame->FltF25;
|
||
FirmwareFrame->ExceptionF26 = TrapFrame->FltF26;
|
||
FirmwareFrame->ExceptionF27 = TrapFrame->FltF27;
|
||
FirmwareFrame->ExceptionF28 = TrapFrame->FltF28;
|
||
FirmwareFrame->ExceptionF29 = TrapFrame->FltF29;
|
||
FirmwareFrame->ExceptionF30 = TrapFrame->FltF30;
|
||
|
||
//
|
||
// Volatile integer registers.
|
||
//
|
||
|
||
FirmwareFrame->ExceptionV0 = TrapFrame->IntV0;
|
||
FirmwareFrame->ExceptionT0 = TrapFrame->IntT0;
|
||
FirmwareFrame->ExceptionT1 = TrapFrame->IntT1;
|
||
FirmwareFrame->ExceptionT2 = TrapFrame->IntT2;
|
||
FirmwareFrame->ExceptionT3 = TrapFrame->IntT3;
|
||
FirmwareFrame->ExceptionT4 = TrapFrame->IntT4;
|
||
FirmwareFrame->ExceptionT5 = TrapFrame->IntT5;
|
||
FirmwareFrame->ExceptionT6 = TrapFrame->IntT6;
|
||
FirmwareFrame->ExceptionT7 = TrapFrame->IntT7;
|
||
|
||
FirmwareFrame->ExceptionFp = TrapFrame->IntFp;
|
||
|
||
FirmwareFrame->ExceptionA0 = TrapFrame->IntA0;
|
||
FirmwareFrame->ExceptionA1 = TrapFrame->IntA1;
|
||
FirmwareFrame->ExceptionA2 = TrapFrame->IntA2;
|
||
FirmwareFrame->ExceptionA3 = TrapFrame->IntA3;
|
||
|
||
FirmwareFrame->ExceptionA4 = TrapFrame->IntA4;
|
||
FirmwareFrame->ExceptionA5 = TrapFrame->IntA5;
|
||
FirmwareFrame->ExceptionT8 = TrapFrame->IntT8;
|
||
FirmwareFrame->ExceptionT9 = TrapFrame->IntT9;
|
||
FirmwareFrame->ExceptionT10 = TrapFrame->IntT10;
|
||
FirmwareFrame->ExceptionT11 = TrapFrame->IntT11;
|
||
|
||
FirmwareFrame->ExceptionRa = TrapFrame->IntRa;
|
||
FirmwareFrame->ExceptionT12 = TrapFrame->IntT12;
|
||
FirmwareFrame->ExceptionAt = TrapFrame->IntAt;
|
||
FirmwareFrame->ExceptionGp = TrapFrame->IntGp;
|
||
FirmwareFrame->ExceptionSp = TrapFrame->IntSp;
|
||
|
||
|
||
//
|
||
// Control data.
|
||
//
|
||
|
||
FirmwareFrame->ExceptionFaultingInstructionAddress = TrapFrame->Fir;
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
VOID
|
||
KeContextFromKframes (
|
||
IN PKTRAP_FRAME TrapFrame,
|
||
IN PKEXCEPTION_FRAME ExceptionFrame,
|
||
IN OUT PCONTEXT ContextFrame
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine moves the selected contents of the specified trap and exception
|
||
frames into the specified context frame according to the specified context
|
||
flags.
|
||
|
||
Arguments:
|
||
|
||
TrapFrame - Supplies a pointer to a trap frame from which volatile context
|
||
should be copied into the context record.
|
||
|
||
ExceptionFrame - Supplies a pointer to an exception frame from which
|
||
context should be copied into the context record.
|
||
|
||
ContextFrame - Supplies a pointer to the context frame that receives the
|
||
context copied from the trap and exception frames.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Implementation Notes:
|
||
|
||
The mix of structure element assignments and memory copies in the code
|
||
below is completely dependent on the layout of the context structure.
|
||
|
||
Since this code is not executed often, it is optimized for minimum size
|
||
(memory copies), rather than maximum speed (individual assignments).
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
//
|
||
// Set control information if specified.
|
||
//
|
||
|
||
if ((ContextFrame->ContextFlags & CONTEXT_CONTROL) == CONTEXT_CONTROL) {
|
||
|
||
//
|
||
// Set integer register gp, ra, sp, FIR, and PSR from trap frame.
|
||
//
|
||
|
||
ContextFrame->IntGp = TrapFrame->IntGp;
|
||
ContextFrame->IntSp = TrapFrame->IntSp;
|
||
ContextFrame->IntRa = TrapFrame->IntRa;
|
||
ContextFrame->Fir = TrapFrame->Fir;
|
||
ContextFrame->Psr = TrapFrame->Psr;
|
||
}
|
||
|
||
//
|
||
// Set integer register contents if specified.
|
||
//
|
||
|
||
if ((ContextFrame->ContextFlags & CONTEXT_INTEGER) == CONTEXT_INTEGER) {
|
||
|
||
//
|
||
// Set volatile integer registers v0 and t0 - t7 from trap frame.
|
||
//
|
||
|
||
RtlMoveMemory(&ContextFrame->IntV0, &TrapFrame->IntV0,
|
||
sizeof(ULONGLONG) * 9);
|
||
|
||
//
|
||
// Set nonvolatile integer registers s0 - s5 from exception frame.
|
||
//
|
||
|
||
RtlMoveMemory(&ContextFrame->IntS0, &ExceptionFrame->IntS0,
|
||
sizeof(ULONGLONG) * 6);
|
||
|
||
//
|
||
// Set volatile integer registers a0 - a3, a4 - a5, and t8 - t11
|
||
// from trap frame.
|
||
//
|
||
|
||
RtlMoveMemory(&ContextFrame->IntA0, &TrapFrame->IntA0,
|
||
sizeof(ULONGLONG) * 4);
|
||
ContextFrame->IntA4 = TrapFrame->IntA4;
|
||
ContextFrame->IntA5 = TrapFrame->IntA5;
|
||
RtlMoveMemory(&ContextFrame->IntT8, &TrapFrame->IntT8,
|
||
sizeof(ULONGLONG) * 4);
|
||
|
||
//
|
||
// Set volatile integer registers fp, t12 and at from trap frame.
|
||
// Set integer register zero.
|
||
//
|
||
|
||
ContextFrame->IntFp = TrapFrame->IntFp;
|
||
ContextFrame->IntT12 = TrapFrame->IntT12;
|
||
ContextFrame->IntAt = TrapFrame->IntAt;
|
||
ContextFrame->IntZero = 0;
|
||
}
|
||
|
||
//
|
||
// Set floating register contents if specified.
|
||
//
|
||
|
||
if ((ContextFrame->ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT) {
|
||
|
||
//
|
||
// Set volatile floating registers f0 - f1 from trap frame.
|
||
// Set volatile floating registers f10 - f30 from trap frame.
|
||
// Set floating zero register f31 to 0.
|
||
//
|
||
|
||
ContextFrame->FltF0 = TrapFrame->FltF0;
|
||
ContextFrame->FltF1 = TrapFrame->FltF1;
|
||
RtlMoveMemory(&ContextFrame->FltF10, &TrapFrame->FltF10,
|
||
sizeof(ULONGLONG) * 21);
|
||
ContextFrame->FltF31 = 0;
|
||
|
||
//
|
||
// Set nonvolatile floating registers f2 - f9 from exception frame.
|
||
//
|
||
|
||
RtlMoveMemory(&ContextFrame->FltF2, &ExceptionFrame->FltF2,
|
||
sizeof(ULONGLONG) * 8);
|
||
|
||
//
|
||
// Set floating point control register from trap frame.
|
||
//
|
||
|
||
ContextFrame->Fpcr = TrapFrame->Fpcr;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
VOID
|
||
KeContextToKframes (
|
||
IN OUT PKTRAP_FRAME TrapFrame,
|
||
IN OUT PKEXCEPTION_FRAME ExceptionFrame,
|
||
IN PCONTEXT ContextFrame,
|
||
IN ULONG ContextFlags,
|
||
IN KPROCESSOR_MODE PreviousMode
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine moves the selected contents of the specified context frame
|
||
into the specified trap and exception frames according to the specified
|
||
context flags.
|
||
|
||
Arguments:
|
||
|
||
TrapFrame - Supplies a pointer to a trap frame that receives the volatile
|
||
context from the context record.
|
||
|
||
ExceptionFrame - Supplies a pointer to an exception frame that receives
|
||
the nonvolatile context from the context record.
|
||
|
||
ContextFrame - Supplies a pointer to a context frame that contains the
|
||
context that is to be copied into the trap and exception frames.
|
||
|
||
ContextFlags - Supplies the set of flags that specify which parts of the
|
||
context frame are to be copied into the trap and exception frames.
|
||
|
||
PreviousMode - Supplies the processor mode for which the trap and exception
|
||
frames are being built.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Implementation Notes:
|
||
|
||
The mix of structure element assignments and memory copies in the code
|
||
below is completely dependent on the layout of the context structure.
|
||
|
||
Since this code is not executed often, it is optimized for minimum size
|
||
(memory copies), rather than maximum speed (individual assignments).
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
//
|
||
// Set control information if specified.
|
||
//
|
||
|
||
if ((ContextFlags & CONTEXT_CONTROL) == CONTEXT_CONTROL) {
|
||
|
||
//
|
||
// Set integer register gp, sp, ra, FIR, and PSR in trap frame.
|
||
//
|
||
|
||
TrapFrame->IntGp = ContextFrame->IntGp;
|
||
TrapFrame->IntSp = ContextFrame->IntSp;
|
||
TrapFrame->IntRa = ContextFrame->IntRa;
|
||
TrapFrame->Fir = ContextFrame->Fir;
|
||
TrapFrame->Psr = SANITIZE_PSR(ContextFrame->Psr, PreviousMode);
|
||
}
|
||
|
||
//
|
||
// Set integer register contents if specified.
|
||
//
|
||
|
||
if ((ContextFlags & CONTEXT_INTEGER) == CONTEXT_INTEGER) {
|
||
|
||
//
|
||
// Set volatile integer registers v0 and t0 - t7 in trap frame.
|
||
//
|
||
|
||
RtlMoveMemory(&TrapFrame->IntV0, &ContextFrame->IntV0,
|
||
sizeof(ULONGLONG) * 9);
|
||
|
||
//
|
||
// Set nonvolatile integer registers s0 - s5 in exception frame.
|
||
//
|
||
|
||
RtlMoveMemory(&ExceptionFrame->IntS0, &ContextFrame->IntS0,
|
||
sizeof(ULONGLONG) * 6);
|
||
|
||
//
|
||
// Set volatile integer registers a0 - a3, a4 - a5, and t8 - t11
|
||
// in trap frame.
|
||
//
|
||
|
||
RtlMoveMemory(&TrapFrame->IntA0, &ContextFrame->IntA0,
|
||
sizeof(ULONGLONG) * 4);
|
||
TrapFrame->IntA4 = ContextFrame->IntA4;
|
||
TrapFrame->IntA5 = ContextFrame->IntA5;
|
||
RtlMoveMemory(&TrapFrame->IntT8, &ContextFrame->IntT8,
|
||
sizeof(ULONGLONG) * 4);
|
||
|
||
//
|
||
// Set volatile integer registers fp, t12 and at in trap frame.
|
||
//
|
||
|
||
TrapFrame->IntFp = ContextFrame->IntFp;
|
||
TrapFrame->IntT12 = ContextFrame->IntT12;
|
||
TrapFrame->IntAt = ContextFrame->IntAt;
|
||
}
|
||
|
||
//
|
||
// Set floating register contents if specified.
|
||
//
|
||
|
||
if ((ContextFlags & CONTEXT_FLOATING_POINT) == CONTEXT_FLOATING_POINT) {
|
||
|
||
//
|
||
// Set volatile floating registers f0 - f1 in trap frame.
|
||
// Set volatile floating registers f10 - f30 in trap frame.
|
||
//
|
||
|
||
TrapFrame->FltF0 = ContextFrame->FltF0;
|
||
TrapFrame->FltF1 = ContextFrame->FltF1;
|
||
RtlMoveMemory(&TrapFrame->FltF10, &ContextFrame->FltF10,
|
||
sizeof(ULONGLONG) * 21);
|
||
|
||
//
|
||
// Set nonvolatile floating registers f2 - f9 in exception frame.
|
||
//
|
||
|
||
RtlMoveMemory(&ExceptionFrame->FltF2, &ContextFrame->FltF2,
|
||
sizeof(ULONGLONG) * 8);
|
||
|
||
//
|
||
// Set floating point control register in trap frame.
|
||
//
|
||
|
||
TrapFrame->Fpcr = SANITIZE_FPCR(ContextFrame->Fpcr, PreviousMode);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
#endif
|