/*++



Copyright (c) 1995  Digital Equipment Corporation



Module Name:



    byteem.c



Abstract:



    This module implements the code necessary to emulate the new set of Alpha

    byte and word instructions defined by ECO 81.



    N.B. This file must be compiled without the use of byte/word instructions

         to avoid fatal recursive exceptions.



Author:



    Wim Colgate (colgate) 18-May-1995

    Thomas Van Baak (tvb) 18-May-1995



Environment:



    Kernel mode only.



Revision History:



--*/



#include "ki.h"



//

// Define function prototypes for emulation routines written in assembler.

//



VOID

KiInterlockedStoreByte (

   IN PUCHAR Address,

   IN UCHAR Data

   );



VOID

KiInterlockedStoreWord (

   IN PUSHORT Address,

   IN USHORT Data

   );



BOOLEAN

KiEmulateByteWord (

    IN OUT PEXCEPTION_RECORD ExceptionRecord,

    IN OUT PKEXCEPTION_FRAME  ExceptionFrame,

    IN OUT PKTRAP_FRAME TrapFrame

    )



/*++



Routine Description:



    This routine emulates Alpha instructions defined by ECO 81. This includes

    the load byte unsigned, store byte, load word unsigned, store word, sign

    extend byte, and sign extend word instructions.



    If a misaligned word access is detected the illegal instruction exception

    record is converted into data misalignment exception record, no emulation

    is performed, and a value of FALSE is returned. It is expected that the

    call to this function is followed by a check for a data misalignment

    exception and a call to the data misalignment emulation function if

    appropriate.



Arguments:



    ExceptionRecord - Supplies a pointer to the exception record.



    ExceptionFrame - Supplies a pointer to an exception frame.



    TrapFrame - Supplies a pointer to a trap frame.



Return Value:



    A value of TRUE is returned if the instruction is successfully emulated,

    otherwise a value of FALSE is returned.



--*/



{

    ULONGLONG Data;

    ULONGLONG EffectiveAddress;

    PVOID ExceptionAddress;

    ALPHA_INSTRUCTION Instruction;

    KIRQL OldIrql;

    KPROCESSOR_MODE PreviousMode;



    //

    // Save original exception address in case another exception occurs.

    //



    ExceptionAddress = ExceptionRecord->ExceptionAddress;



    //

    // Any exception that occurs during the attempted emulation will cause

    // the emulation to be aborted. The new exception code and information

    // will be copied to the original exception record and FALSE will be

    // returned. If the memory access was not from kernel mode then probe

    // the effective address before performing the emulation.

    //



    //

    // Capture previous mode from trap frame not current thread.

    //



    PreviousMode = (KPROCESSOR_MODE)(((PSR *)(&TrapFrame->Psr))->MODE);



    try {



        //

        // Get faulting instruction and case on instruction type.

        //



        if (PreviousMode != KernelMode) {

            ProbeForRead(ExceptionAddress,

                         sizeof(ALPHA_INSTRUCTION),

                         sizeof(ALPHA_INSTRUCTION));

        }

        Instruction = *((PALPHA_INSTRUCTION)ExceptionAddress);

        switch (Instruction.Memory.Opcode) {



        //

        // Load/store operations.

        //



        case LDBU_OP :

        case LDWU_OP :

        case STB_OP :

        case STW_OP :





            //

            // Compute effective address and if the address is non-canonical

            // then change the exception code to STATUS_ACCESS_VIOLATION and

            // return FALSE.

            //



            EffectiveAddress = (ULONGLONG)Instruction.Memory.MemDisp +

                               KiGetRegisterValue(Instruction.Memory.Rb,

                                                  ExceptionFrame,

                                                  TrapFrame);



            if (EffectiveAddress != (ULONGLONG)(PVOID)EffectiveAddress) {

                ExceptionRecord->ExceptionCode = STATUS_ACCESS_VIOLATION;

                ExceptionRecord->NumberParameters = 0;

                return FALSE;

            }



            //

            // Case on individual load/store instruction type.

            //



            switch (Instruction.Memory.Opcode) {



            //

            // Load byte unsigned.

            //



            case LDBU_OP :

                if (PreviousMode != KernelMode) {

                    ProbeForRead(EffectiveAddress,

                                 sizeof(UCHAR),

                                 sizeof(UCHAR));

                }

                Data = (ULONGLONG)*(PUCHAR)EffectiveAddress;

                KiSetRegisterValue(Instruction.Memory.Ra,

                                   Data,

                                   ExceptionFrame,

                                   TrapFrame);

                break;



            //

            // Load word unsigned.

            //



            case LDWU_OP :

                if (EffectiveAddress & 0x1) {

                    goto AlignmentFault;

                }

                if (PreviousMode != KernelMode) {

                    ProbeForRead((PUSHORT)EffectiveAddress,

                                 sizeof(USHORT),

                                 sizeof(UCHAR));

                }

                Data = (ULONGLONG)*(PUSHORT)EffectiveAddress;

                KiSetRegisterValue(Instruction.Memory.Ra,

                                   Data,

                                   ExceptionFrame,

                                   TrapFrame);

                break;



            //

            // Store byte.

            //



            case STB_OP :

                if (PreviousMode != KernelMode) {

                    ProbeForWrite((PUCHAR)EffectiveAddress,

                                  sizeof(UCHAR),

                                  sizeof(UCHAR));

                }

                Data = KiGetRegisterValue(Instruction.Memory.Ra,

                                          ExceptionFrame,

                                          TrapFrame);

                KiInterlockedStoreByte((PUCHAR)EffectiveAddress,

                                       (UCHAR)Data);

                break;



            //

            // Store word.

            //



            case STW_OP :

                if (EffectiveAddress & 0x1) {

                    goto AlignmentFault;

                }

                if (PreviousMode != KernelMode) {

                    ProbeForWrite((PUSHORT)EffectiveAddress,

                                  sizeof(USHORT),

                                  sizeof(UCHAR));

                }

                Data = KiGetRegisterValue(Instruction.Memory.Ra,

                                          ExceptionFrame,

                                          TrapFrame);

                KiInterlockedStoreWord((PUSHORT)EffectiveAddress,

                                       (USHORT)Data);

                break;

            }



            break;



        //

        // Sign extend operations.

        //



        case SEXT_OP :

            switch (Instruction.OpReg.Function) {



            //

            // Sign extend byte.

            //



            case SEXTB_FUNC :

                Data = KiGetRegisterValue(Instruction.OpReg.Rb,

                                          ExceptionFrame,

                                          TrapFrame);

                KiSetRegisterValue(Instruction.OpReg.Rc,

                                   (ULONGLONG)(CHAR)Data,

                                   ExceptionFrame,

                                   TrapFrame);

                break;



            //

            // Sign extend word.

            //



            case SEXTW_FUNC :

                Data = KiGetRegisterValue(Instruction.OpReg.Rb,

                                          ExceptionFrame,

                                          TrapFrame);

                KiSetRegisterValue(Instruction.OpReg.Rc,

                                   (ULONGLONG)(SHORT)Data,

                                   ExceptionFrame,

                                   TrapFrame);

                break;



            //

            // All other functions are not emulated.

            //



            default :

                return FALSE;

            }



            break;



        //

        // All other instructions are not emulated.

        //



        default :

            return FALSE;

        }



#if 0

        //

        // Call out to profile interrupt if byte/word emulation profiling is

        // active.

        //



        if (KiProfileByteWordEmulation != FALSE) {

            if (++KiProfileByteWordEmulationCount >=

                KiProfileByteWordEmulationInterval) {



                KeRaiseIrql(PROFILE_LEVEL, &OldIrql);

                KiProfileByteWordEmulationCount = 0;

                KeProfileInterruptWithSource(TrapFrame,

                                             ProfileByteWordEmulation);

                KeLowerIrql(OldIrql);

            }

        }

#endif



        TrapFrame->Fir += 4;



        return TRUE;



    } except (KiCopyInformation(ExceptionRecord,

                                (GetExceptionInformation())->ExceptionRecord)) {



        //

        // Preserve the original exception address.

        //



        ExceptionRecord->ExceptionAddress = ExceptionAddress;



        return FALSE;

    }



AlignmentFault :



    //

    // A misaligned word access has been encountered. Change the illegal

    // instruction exception record into data misalignment exception record

    // (the format is defined by PALcode) and return FALSE.

    //



    ExceptionRecord->ExceptionCode = STATUS_DATATYPE_MISALIGNMENT;

    ExceptionRecord->NumberParameters = 3;

    ExceptionRecord->ExceptionInformation[0] = Instruction.Memory.Opcode;

    ExceptionRecord->ExceptionInformation[1] = Instruction.Memory.Ra;

    ExceptionRecord->ExceptionInformation[2] = (ULONG)EffectiveAddress;



    return FALSE;

}