opcodes.c File Reference

#include <windef.h>
#include <debug.h>
#include <fast486.h>
#include "opcodes.h"
#include "opgroups.h"
#include "extraops.h"
#include "common.h"
#include "fpu.h"

Include dependency graph for opcodes.c:

Go to the source code of this file.

Functions
	FAST486_OPCODE_HANDLER (Fast486OpcodeInvalid)
	FAST486_OPCODE_HANDLER (Fast486OpcodePrefix)
	FAST486_OPCODE_HANDLER (Fast486OpcodeIncrement)
	FAST486_OPCODE_HANDLER (Fast486OpcodeDecrement)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushReg)
	FAST486_OPCODE_HANDLER (Fast486OpcodePopReg)
	FAST486_OPCODE_HANDLER (Fast486OpcodeNop)
	FAST486_OPCODE_HANDLER (Fast486OpcodeExchangeEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeShortConditionalJmp)
	FAST486_OPCODE_HANDLER (Fast486OpcodeClearCarry)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSetCarry)
	FAST486_OPCODE_HANDLER (Fast486OpcodeComplCarry)
	FAST486_OPCODE_HANDLER (Fast486OpcodeClearInt)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSetInt)
	FAST486_OPCODE_HANDLER (Fast486OpcodeClearDir)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSetDir)
	FAST486_OPCODE_HANDLER (Fast486OpcodeHalt)
	FAST486_OPCODE_HANDLER (Fast486OpcodeInByte)
	FAST486_OPCODE_HANDLER (Fast486OpcodeIn)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOutByte)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOut)
	FAST486_OPCODE_HANDLER (Fast486OpcodeShortJump)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovRegImm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovByteRegImm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAddByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAddModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAddAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAddEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOrByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOrModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOrAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOrEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAndByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAndModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAndAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAndEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXorByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXorModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXorAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXorEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeTestByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeTestModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeTestAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeTestEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXchgByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXchgModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushEs)
	FAST486_OPCODE_HANDLER (Fast486OpcodePopEs)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushCs)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAdcByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAdcModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAdcAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAdcEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushSs)
	FAST486_OPCODE_HANDLER (Fast486OpcodePopSs)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSbbByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSbbModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSbbAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSbbEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushDs)
	FAST486_OPCODE_HANDLER (Fast486OpcodePopDs)
	FAST486_OPCODE_HANDLER (Fast486OpcodeDaa)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCmpSubByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCmpSubModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCmpSubAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCmpSubEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeDas)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAaa)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAas)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushAll)
	FAST486_OPCODE_HANDLER (Fast486OpcodePopAll)
	FAST486_OPCODE_HANDLER (Fast486OpcodeBound)
	FAST486_OPCODE_HANDLER (Fast486OpcodeArpl)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushImm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeImulModrmImm)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushByteImm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovByteModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovModrm)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovStoreSeg)
	FAST486_OPCODE_HANDLER (Fast486OpcodeLea)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovLoadSeg)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCwde)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCdq)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCallAbs)
	FAST486_OPCODE_HANDLER (Fast486OpcodeWait)
	FAST486_OPCODE_HANDLER (Fast486OpcodePushFlags)
	FAST486_OPCODE_HANDLER (Fast486OpcodePopFlags)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSahf)
	FAST486_OPCODE_HANDLER (Fast486OpcodeLahf)
	FAST486_OPCODE_HANDLER (Fast486OpcodeRet)
	FAST486_OPCODE_HANDLER (Fast486OpcodeLdsLes)
	FAST486_OPCODE_HANDLER (Fast486OpcodeEnter)
	FAST486_OPCODE_HANDLER (Fast486OpcodeLeave)
	FAST486_OPCODE_HANDLER (Fast486OpcodeRetFar)
	FAST486_OPCODE_HANDLER (Fast486OpcodeInt)
	FAST486_OPCODE_HANDLER (Fast486OpcodeIret)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAam)
	FAST486_OPCODE_HANDLER (Fast486OpcodeAad)
	FAST486_OPCODE_HANDLER (Fast486OpcodeXlat)
	FAST486_OPCODE_HANDLER (Fast486OpcodeLoop)
	FAST486_OPCODE_HANDLER (Fast486OpcodeJecxz)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCall)
	FAST486_OPCODE_HANDLER (Fast486OpcodeJmp)
	FAST486_OPCODE_HANDLER (Fast486OpcodeJmpAbs)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovAlOffset)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovEaxOffset)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovOffsetAl)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovOffsetEax)
	FAST486_OPCODE_HANDLER (Fast486OpcodeSalc)
	FAST486_OPCODE_HANDLER (Fast486OpcodeMovs)
	FAST486_OPCODE_HANDLER (Fast486OpcodeCmps)
	FAST486_OPCODE_HANDLER (Fast486OpcodeStos)
	FAST486_OPCODE_HANDLER (Fast486OpcodeLods)
	FAST486_OPCODE_HANDLER (Fast486OpcodeScas)
	FAST486_OPCODE_HANDLER (Fast486OpcodeIns)
	FAST486_OPCODE_HANDLER (Fast486OpcodeOuts)

Variables
FAST486_OPCODE_HANDLER_PROC	Fast486OpcodeHandlers [FAST486_NUM_OPCODE_HANDLERS]

Function Documentation

FAST486_OPCODE_HANDLER() [1/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAaa

)

Definition at line 3150 of file opcodes.c.

{
    UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    /*
     * Check if the value in AL is not a valid BCD digit,
     * or there was a carry from the lowest 4 bits of AL
     */
    if (((Value & 0x0F) > 9) || State->Flags.Af)
    {
        /* Correct it */
        State->GeneralRegs[FAST486_REG_EAX].LowWord += 0x06;
        State->GeneralRegs[FAST486_REG_EAX].HighByte++;
 
        /* Set CF and AF */
        State->Flags.Cf = State->Flags.Af = TRUE;
    }
    else
    {
        /* Clear CF and AF */
        State->Flags.Cf = State->Flags.Af = FALSE;
    }
 
    /* Keep only the lowest 4 bits of AL */
    State->GeneralRegs[FAST486_REG_EAX].LowByte &= 0x0F;
}

FAST486_OPCODE_HANDLER() [2/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAad

)

Definition at line 4734 of file opcodes.c.

{
    UCHAR Base;
    UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    NO_LOCK_PREFIX();
 
    /* Fetch the base */
    if (!Fast486FetchByte(State, &Base))
    {
        /* Exception occurred */
        return;
    }
 
    /* Adjust */
    Value += State->GeneralRegs[FAST486_REG_EAX].HighByte * Base;
    State->GeneralRegs[FAST486_REG_EAX].LowWord = Value;
 
    /* Update flags */
    State->Flags.Af = FALSE;
    State->Flags.Zf = (Value == 0);
    State->Flags.Sf = ((Value & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Value);
}

FAST486_OPCODE_HANDLER() [3/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAam

)

Definition at line 4701 of file opcodes.c.

{
    UCHAR Base;
    UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    NO_LOCK_PREFIX();
 
    /* Fetch the base */
    if (!Fast486FetchByte(State, &Base))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check if the base is zero */
    if (Base == 0)
    {
        /* Divide error */
        Fast486Exception(State, FAST486_EXCEPTION_DE);
        return;
    }
 
    /* Adjust */
    State->GeneralRegs[FAST486_REG_EAX].HighByte = Value / Base;
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Value %= Base;
 
    /* Update flags */
    State->Flags.Af = FALSE;
    State->Flags.Zf = (Value == 0);
    State->Flags.Sf = ((Value & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Value);
}

FAST486_OPCODE_HANDLER() [4/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAas

)

Definition at line 3177 of file opcodes.c.

{
    UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    /*
     * Check if the value in AL is not a valid BCD digit,
     * or there was a borrow from the lowest 4 bits of AL
     */
    if (((Value & 0x0F) > 9) || State->Flags.Af)
    {
        /* Correct it */
        State->GeneralRegs[FAST486_REG_EAX].LowWord -= 0x06;
        State->GeneralRegs[FAST486_REG_EAX].HighByte--;
 
        /* Set CF and AF */
        State->Flags.Cf = State->Flags.Af = TRUE;
    }
    else
    {
        /* Clear CF and AF */
        State->Flags.Cf = State->Flags.Af = FALSE;
    }
 
    /* Keep only the lowest 4 bits of AL */
    State->GeneralRegs[FAST486_REG_EAX].LowByte &= 0x0F;
}

FAST486_OPCODE_HANDLER() [5/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAdcAl

)

Definition at line 2392 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x14);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue + SecondValue + State->Flags.Cf;
 
    /* Special exception for CF */
    State->Flags.Cf = State->Flags.Cf &&
                      ((FirstValue == 0xFF) || (SecondValue == 0xFF));
 
    /* Update the flags */
    State->Flags.Cf = State->Flags.Cf || ((Result < FirstValue) && (Result < SecondValue));
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) == (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
}

FAST486_OPCODE_HANDLER() [6/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAdcByteModrm

)

Definition at line 2248 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x10);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue + SecondValue + State->Flags.Cf;
 
    /* Special exception for CF */
    State->Flags.Cf = State->Flags.Cf
                      && ((FirstValue == 0xFF) || (SecondValue == 0xFF));
 
    /* Update the flags */
    State->Flags.Cf = State->Flags.Cf || ((Result < FirstValue) && (Result < SecondValue));
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) == (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [7/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAdcEax

)

Definition at line 2428 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x15);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue + State->Flags.Cf;
 
        /* Special exception for CF */
        State->Flags.Cf = State->Flags.Cf &&
                          ((FirstValue == 0xFFFFFFFF) || (SecondValue == 0xFFFFFFFF));
 
        /* Update the flags */
        State->Flags.Cf = State->Flags.Cf || ((Result < FirstValue) && (Result < SecondValue));
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) == (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].Long = Result;
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue + State->Flags.Cf;
 
        /* Special exception for CF */
        State->Flags.Cf = State->Flags.Cf &&
                          ((FirstValue == 0xFFFF) || (SecondValue == 0xFFFF));
 
        /* Update the flags */
        State->Flags.Cf = State->Flags.Cf || ((Result < FirstValue) && (Result < SecondValue));
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) == (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Result;
    }
}

FAST486_OPCODE_HANDLER() [8/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAdcModrm

)

Definition at line 2298 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x11);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue + State->Flags.Cf;
 
        /* Special exception for CF */
        State->Flags.Cf = State->Flags.Cf
                          && ((FirstValue == 0xFFFFFFFF) || (SecondValue == 0xFFFFFFFF));
 
        /* Update the flags */
        State->Flags.Cf = State->Flags.Cf || ((Result < FirstValue) && (Result < SecondValue));
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) == (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue + State->Flags.Cf;
 
        /* Special exception for CF */
        State->Flags.Cf = State->Flags.Cf
                          && ((FirstValue == 0xFFFF) || (SecondValue == 0xFFFF));
 
        /* Update the flags */
        State->Flags.Cf = State->Flags.Cf || ((Result < FirstValue) && (Result < SecondValue));
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) == (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
 
}

FAST486_OPCODE_HANDLER() [9/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAddAl

)

Definition at line 1169 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x04);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue + SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = (Result < FirstValue) && (Result < SecondValue);
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) == (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = ((((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) != 0);
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
}

FAST486_OPCODE_HANDLER() [10/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAddByteModrm

)

Definition at line 1038 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x00);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue + SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = (Result < FirstValue) && (Result < SecondValue);
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) == (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = ((((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) != 0);
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [11/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAddEax

)

Definition at line 1201 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x05);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (Result < FirstValue) && (Result < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) == (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = ((((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) != 0);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].Long = Result;
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (Result < FirstValue) && (Result < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) == (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = ((((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) != 0);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Result;
    }
}

FAST486_OPCODE_HANDLER() [12/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAddModrm

)

Definition at line 1084 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x01);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (Result < FirstValue) && (Result < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) == (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = ((((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) != 0);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue + SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (Result < FirstValue) && (Result < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) == (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = ((((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) != 0);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
}

FAST486_OPCODE_HANDLER() [13/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAndAl

)

Definition at line 1605 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x24);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue & SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
}

FAST486_OPCODE_HANDLER() [14/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAndByteModrm

)

Definition at line 1480 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x20);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue & SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [15/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAndEax

)

Definition at line 1635 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x25);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].Long = Result;
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Result;
    }
}

FAST486_OPCODE_HANDLER() [16/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeAndModrm

)

Definition at line 1524 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x21);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
}

FAST486_OPCODE_HANDLER() [17/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeArpl

)

Definition at line 3368 of file opcodes.c.

{
    USHORT FirstValue, SecondValue;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    if (!(State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
        || State->Flags.Vm
        || (State->PrefixFlags & FAST486_PREFIX_LOCK))
    {
        /* Cannot be used in real mode or with a LOCK prefix */
        Fast486Exception(State, FAST486_EXCEPTION_UD);
        return;
    }
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Read the operands */
    if (!Fast486ReadModrmWordOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check if the RPL needs adjusting */
    if ((SecondValue & 3) < (FirstValue & 3))
    {
        /* Adjust the RPL */
        SecondValue &= ~3;
        SecondValue |= FirstValue & 3;
 
        /* Set ZF */
        State->Flags.Zf = TRUE;
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, SecondValue);
    }
    else
    {
        /* Clear ZF */
        State->Flags.Zf = FALSE;
    }
}

FAST486_OPCODE_HANDLER() [18/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeBound

)

Definition at line 3272 of file opcodes.c.

{
    BOOLEAN OperandSize, AddressSize;
    FAST486_MOD_REG_RM ModRegRm;
    FAST486_SEG_REGS Segment = FAST486_REG_DS;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!ModRegRm.Memory)
    {
        /* Invalid */
        Fast486Exception(State, FAST486_EXCEPTION_UD);
        return;
    }
 
    /* Check for the segment override */
    if (State->PrefixFlags & FAST486_PREFIX_SEG)
    {
        /* Use the override segment instead */
        Segment = State->SegmentOverride;
    }
 
    if (OperandSize)
    {
        LONG Index, LowerBound, UpperBound;
 
        /* Read the operands */
        if (!Fast486ReadModrmDwordOperands(State,
                                           &ModRegRm,
                                           (PULONG)&Index,
                                           (PULONG)&LowerBound))
        {
            /* Exception occurred */
            return;
        }
 
        if (!Fast486ReadMemory(State,
                               Segment,
                               ModRegRm.MemoryAddress + sizeof(ULONG),
                               FALSE,
                               &UpperBound,
                               sizeof(ULONG)))
        {
            /* Exception occurred */
            return;
        }
 
        if ((Index < LowerBound) || (Index > UpperBound))
        {
            /* Out of bounds */
            Fast486Exception(State, FAST486_EXCEPTION_BR);
        }
    }
    else
    {
        SHORT Index, LowerBound, UpperBound;
 
        /* Read the operands */
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          (PUSHORT)&Index,
                                          (PUSHORT)&LowerBound))
        {
            /* Exception occurred */
            return;
        }
 
        if (!Fast486ReadMemory(State,
                               Segment,
                               ModRegRm.MemoryAddress + sizeof(USHORT),
                               FALSE,
                               &UpperBound,
                               sizeof(USHORT)))
        {
            /* Exception occurred */
            return;
        }
 
        if ((Index < LowerBound) || (Index > UpperBound))
        {
            /* Out of bounds */
            Fast486Exception(State, FAST486_EXCEPTION_BR);
        }
    }
}

FAST486_OPCODE_HANDLER() [19/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCall

)

Definition at line 4856 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xE8);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Size)
    {
        LONG Offset = 0;
 
        /* Fetch the offset */
        if (!Fast486FetchDword(State, (PULONG)&Offset))
        {
            /* An exception occurred */
            return;
        }
 
        /* Push the current value of the instruction pointer */
        if (!Fast486StackPush(State, State->InstPtr.Long))
        {
            /* Exception occurred */
            return;
        }
 
        /* Move the instruction pointer */
        State->InstPtr.Long += Offset;
    }
    else
    {
        SHORT Offset = 0;
 
        /* Fetch the offset */
        if (!Fast486FetchWord(State, (PUSHORT)&Offset))
        {
            /* An exception occurred */
            return;
        }
 
        /* Push the current value of the instruction pointer */
        if (!Fast486StackPush(State, State->InstPtr.Long))
        {
            /* Exception occurred */
            return;
        }
 
        /* Move the instruction pointer */
        State->InstPtr.LowWord += Offset;
    }
}

FAST486_OPCODE_HANDLER() [20/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCallAbs

)

Definition at line 3910 of file opcodes.c.

{
    USHORT Segment = 0;
    ULONG Offset = 0;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x9A);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Fetch the offset */
    if (Size)
    {
        if (!Fast486FetchDword(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
    }
    else
    {
        if (!Fast486FetchWord(State, (PUSHORT)&Offset))
        {
            /* Exception occurred */
            return;
        }
    }
 
    /* Fetch the segment */
    if (!Fast486FetchWord(State, &Segment))
    {
        /* Exception occurred */
        return;
    }
 
    if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm)
    {
        if (!Fast486ProcessGate(State, Segment, Offset, TRUE))
        {
            /* Gate processed or exception occurred */
            return;
        }
    }
 
    /* Push the current code segment selector */
    if (!Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector))
    {
        /* Exception occurred */
        return;
    }
 
    /* Push the current value of the instruction pointer */
    if (!Fast486StackPush(State, State->InstPtr.Long))
    {
        /* Exception occurred */
        return;
    }
 
    /* Load the new CS */
    if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment))
    {
        /* Exception occurred */
        return;
    }
 
    /* Load new (E)IP */
    if (Size) State->InstPtr.Long = Offset;
    else State->InstPtr.LowWord = LOWORD(Offset);
}

FAST486_OPCODE_HANDLER() [21/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCdq

)

Definition at line 3884 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x99);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Size)
    {
        /* Sign extend EAX to EDX:EAX */
        State->GeneralRegs[FAST486_REG_EDX].Long =
        (State->GeneralRegs[FAST486_REG_EAX].Long & SIGN_FLAG_LONG)
        ? 0xFFFFFFFF : 0x00000000;
    }
    else
    {
        /* Sign extend AX to DX:AX */
        State->GeneralRegs[FAST486_REG_EDX].LowWord =
        (State->GeneralRegs[FAST486_REG_EAX].LowWord & SIGN_FLAG_WORD)
        ? 0xFFFF : 0x0000;
    }
}

FAST486_OPCODE_HANDLER() [22/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeClearCarry

)

Definition at line 633 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xF8);
 
    NO_LOCK_PREFIX();
 
    /* Clear CF and return success */
    State->Flags.Cf = FALSE;
}

FAST486_OPCODE_HANDLER() [23/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeClearDir

)

Definition at line 727 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xFC);
 
    NO_LOCK_PREFIX();
 
    /* Clear DF */
    State->Flags.Df = FALSE;
}

FAST486_OPCODE_HANDLER() [24/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeClearInt

)

Definition at line 667 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xFA);
 
    NO_LOCK_PREFIX();
 
    /* Check for protected mode */
    if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
    {
        /* Check IOPL */
        if (State->Flags.Iopl >= Fast486GetCurrentPrivLevel(State))
        {
            /* Clear the interrupt flag */
            State->Flags.If = FALSE;
        }
        else
        {
            /* General Protection Fault */
            Fast486Exception(State, FAST486_EXCEPTION_GP);
            return;
        }
    }
    else
    {
        /* Just clear the interrupt flag */
        State->Flags.If = FALSE;
    }
}

FAST486_OPCODE_HANDLER() [25/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCmps

)

Definition at line 5368 of file opcodes.c.

{
    ULONG FirstValue = 0, SecondValue = 0, Result;
    ULONG DataSize, DataMask, SignFlag;
    BOOLEAN OperandSize, AddressSize;
    FAST486_SEG_REGS Segment = FAST486_REG_DS;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xA6);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (State->PrefixFlags & FAST486_PREFIX_SEG)
    {
        /* Use the override segment instead of DS */
        Segment = State->SegmentOverride;
    }
 
    if ((State->PrefixFlags & FAST486_PREFIX_REP)
        || (State->PrefixFlags & FAST486_PREFIX_REPNZ))
    {
        if ((AddressSize && (State->GeneralRegs[FAST486_REG_ECX].Long == 0))
            || (!AddressSize && (State->GeneralRegs[FAST486_REG_ECX].LowWord == 0)))
        {
            /* Do nothing */
            return;
        }
    }
 
    /* Calculate the size */
    if (Opcode == 0xA6) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    /* Calculate the mask and sign flag */
    SignFlag = 1 << ((DataSize * 8) - 1);
    DataMask = SignFlag | (SignFlag - 1);
 
    /* Read from the first source operand */
    if (!Fast486ReadMemory(State,
                           Segment,
                           AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long
                                       : State->GeneralRegs[FAST486_REG_ESI].LowWord,
                           FALSE,
                           &FirstValue,
                           DataSize))
    {
        /* Exception occurred */
        return;
    }
 
    /* Read from the second source operand */
    if (!Fast486ReadMemory(State,
                           FAST486_REG_ES,
                           AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                       : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                           FALSE,
                           &SecondValue,
                           DataSize))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    FirstValue &= DataMask;
    SecondValue &= DataMask;
    Result = (FirstValue - SecondValue) & DataMask;
 
    /* Update the flags */
    State->Flags.Cf = (FirstValue < SecondValue);
    State->Flags.Of = ((FirstValue & SignFlag) != (SecondValue & SignFlag))
                      && ((FirstValue & SignFlag) != (Result & SignFlag));
    State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SignFlag) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Increment/decrement ESI and EDI */
    if (AddressSize)
    {
        if (!State->Flags.Df)
        {
            State->GeneralRegs[FAST486_REG_ESI].Long += DataSize;
            State->GeneralRegs[FAST486_REG_EDI].Long += DataSize;
        }
        else
        {
            State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize;
            State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize;
        }
    }
    else
    {
        if (!State->Flags.Df)
        {
            State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize;
            State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize;
        }
        else
        {
            State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize;
            State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize;
        }
    }
 
    // FIXME: This method is slow!
    if ((State->PrefixFlags & FAST486_PREFIX_REP)
        || (State->PrefixFlags & FAST486_PREFIX_REPNZ))
    {
        BOOLEAN Repeat = TRUE;
 
        if (AddressSize)
        {
            if ((--State->GeneralRegs[FAST486_REG_ECX].Long) == 0)
            {
                /* ECX is 0 */
                Repeat = FALSE;
            }
        }
        else
        {
            if ((--State->GeneralRegs[FAST486_REG_ECX].LowWord) == 0)
            {
                /* CX is 0 */
                Repeat = FALSE;
            }
        }
 
        if (((State->PrefixFlags & FAST486_PREFIX_REP) && !State->Flags.Zf)
            || ((State->PrefixFlags & FAST486_PREFIX_REPNZ) && State->Flags.Zf))
        {
            /* REPZ with ZF = 0 or REPNZ with ZF = 1 */
            Repeat = FALSE;
        }
 
        if (Repeat)
        {
            /* Repeat the instruction */
            State->InstPtr = State->SavedInstPtr;
        }
    }
}

FAST486_OPCODE_HANDLER() [26/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCmpSubAl

)

Definition at line 3001 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xEF) == 0x2C);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue - SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = (FirstValue < SecondValue);
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) != (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Check if this is not a CMP */
    if (!(Opcode & 0x10))
    {
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
    }
}

FAST486_OPCODE_HANDLER() [27/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCmpSubByteModrm

)

Definition at line 2837 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xED) == 0x28);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check if this is the instruction that writes to R/M */
    if (!(Opcode & FAST486_OPCODE_WRITE_REG))
    {
        /* Swap the order */
        SWAP(FirstValue, SecondValue);
    }
 
    /* Calculate the result */
    Result = FirstValue - SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = (FirstValue < SecondValue);
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) != (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Check if this is not a CMP */
    if (!(Opcode & 0x10))
    {
        /* Write back the result */
        Fast486WriteModrmByteOperands(State,
                                      &ModRegRm,
                                      Opcode & FAST486_OPCODE_WRITE_REG,
                                      Result);
    }
}

FAST486_OPCODE_HANDLER() [28/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCmpSubEax

)

Definition at line 3037 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xEF) == 0x2D);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) != (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Check if this is not a CMP */
        if (!(Opcode & 0x10))
        {
            /* Write back the result */
            State->GeneralRegs[FAST486_REG_EAX].Long = Result;
        }
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) != (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Check if this is not a CMP */
        if (!(Opcode & 0x10))
        {
            /* Write back the result */
            State->GeneralRegs[FAST486_REG_EAX].LowWord = Result;
        }
    }
}

FAST486_OPCODE_HANDLER() [29/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCmpSubModrm

)

Definition at line 2894 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xED) == 0x29);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Check if this is the instruction that writes to R/M */
        if (!(Opcode & FAST486_OPCODE_WRITE_REG))
        {
            /* Swap the order */
            SWAP(FirstValue, SecondValue);
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) != (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Check if this is not a CMP */
        if (!(Opcode & 0x10))
        {
            /* Write back the result */
            Fast486WriteModrmDwordOperands(State,
                                           &ModRegRm,
                                           Opcode & FAST486_OPCODE_WRITE_REG,
                                           Result);
        }
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Check if this is the instruction that writes to R/M */
        if (!(Opcode & FAST486_OPCODE_WRITE_REG))
        {
            /* Swap the order */
            SWAP(FirstValue, SecondValue);
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) != (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Check if this is not a CMP */
        if (!(Opcode & 0x10))
        {
            /* Write back the result */
            Fast486WriteModrmWordOperands(State,
                                          &ModRegRm,
                                          Opcode & FAST486_OPCODE_WRITE_REG,
                                          Result);
        }
    }
}

FAST486_OPCODE_HANDLER() [30/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeComplCarry

)

Definition at line 655 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xF5);
 
    NO_LOCK_PREFIX();
 
    /* Toggle CF and return success */
    State->Flags.Cf = !State->Flags.Cf;
    return;
}

FAST486_OPCODE_HANDLER() [31/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeCwde

)

Definition at line 3855 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x98);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Size)
    {
        /* Sign extend AX to EAX */
        State->GeneralRegs[FAST486_REG_EAX].Long = MAKELONG
        (
            State->GeneralRegs[FAST486_REG_EAX].LowWord,
            (State->GeneralRegs[FAST486_REG_EAX].LowWord & SIGN_FLAG_WORD)
            ? 0xFFFF : 0x0000
        );
    }
    else
    {
        /* Sign extend AL to AX */
        State->GeneralRegs[FAST486_REG_EAX].HighByte =
        (State->GeneralRegs[FAST486_REG_EAX].LowByte & SIGN_FLAG_BYTE)
        ? 0xFF : 0x00;
    }
}

FAST486_OPCODE_HANDLER() [32/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeDaa

)

Definition at line 2796 of file opcodes.c.

{
    UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    BOOLEAN Carry = State->Flags.Cf;
 
    /* Clear the carry flag */
    State->Flags.Cf = FALSE;
 
    /* Check if the first BCD digit is invalid or there was a carry from it */
    if (((Value & 0x0F) > 9) || State->Flags.Af)
    {
        /* Correct it */
        State->GeneralRegs[FAST486_REG_EAX].LowByte += 0x06;
        if (State->GeneralRegs[FAST486_REG_EAX].LowByte < 0x06)
        {
            /* A carry occurred */
            State->Flags.Cf = TRUE;
        }
 
        /* Set the adjust flag */
        State->Flags.Af = TRUE;
    }
 
    /* Check if the second BCD digit is invalid or there was a carry from it */
    if ((Value > 0x99) || Carry)
    {
        /* Correct it */
        State->GeneralRegs[FAST486_REG_EAX].LowByte += 0x60;
 
        /* There was a carry */
        State->Flags.Cf = TRUE;
    }
 
    Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    /* Update the flags */
    State->Flags.Sf = (Value & SIGN_FLAG_BYTE) != 0;
    State->Flags.Zf = (Value == 0);
    State->Flags.Pf = Fast486CalculateParity(Value);
}

FAST486_OPCODE_HANDLER() [33/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeDas

)

Definition at line 3109 of file opcodes.c.

{
    UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    BOOLEAN Carry = State->Flags.Cf;
 
    /* Clear the carry flag */
    State->Flags.Cf = FALSE;
 
    /* Check if the first BCD digit is invalid or there was a borrow */
    if (((Value & 0x0F) > 9) || State->Flags.Af)
    {
        /* Correct it */
        State->GeneralRegs[FAST486_REG_EAX].LowByte -= 0x06;
        if (State->GeneralRegs[FAST486_REG_EAX].LowByte > 0xFB)
        {
            /* A borrow occurred */
            State->Flags.Cf = TRUE;
        }
 
        /* Set the adjust flag */
        State->Flags.Af = TRUE;
    }
 
    /* Check if the second BCD digit is invalid or there was a borrow */
    if ((Value > 0x99) || Carry)
    {
        /* Correct it */
        State->GeneralRegs[FAST486_REG_EAX].LowByte -= 0x60;
 
        /* There was a borrow */
        State->Flags.Cf = TRUE;
    }
 
    Value = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    /* Update the flags */
    State->Flags.Sf = (Value & SIGN_FLAG_BYTE) != 0;
    State->Flags.Zf = (Value == 0);
    State->Flags.Pf = Fast486CalculateParity(Value);
}

FAST486_OPCODE_HANDLER() [34/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeDecrement

)

Definition at line 442 of file opcodes.c.

{
    ULONG Value;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0x48);
 
    if (Size)
    {
        Value = --State->GeneralRegs[Opcode & 0x07].Long;
 
        State->Flags.Of = (Value == (SIGN_FLAG_LONG - 1));
        State->Flags.Sf = ((Value & SIGN_FLAG_LONG) != 0);
    }
    else
    {
        Value = --State->GeneralRegs[Opcode & 0x07].LowWord;
 
        State->Flags.Of = (Value == (SIGN_FLAG_WORD - 1));
        State->Flags.Sf = ((Value & SIGN_FLAG_WORD) != 0);
    }
 
    State->Flags.Zf = (Value == 0);
    State->Flags.Af = ((Value & 0x0F) == 0x0F);
    State->Flags.Pf = Fast486CalculateParity(LOBYTE(Value));
}

FAST486_OPCODE_HANDLER() [35/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeEnter

)

Definition at line 4209 of file opcodes.c.

{
    INT i;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    USHORT FrameSize;
    UCHAR NestingLevel;
    FAST486_REG FramePointer;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xC8);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (!Fast486FetchWord(State, &FrameSize))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486FetchByte(State, &NestingLevel))
    {
        /* Exception occurred */
        return;
    }
 
    /* Push EBP */
    if (!Fast486StackPush(State, State->GeneralRegs[FAST486_REG_EBP].Long))
    {
        /* Exception occurred */
        return;
    }
 
    /* Save ESP */
    FramePointer = State->GeneralRegs[FAST486_REG_ESP];
 
    /* Set up the nested procedure stacks */
    for (i = 1; i < NestingLevel; i++)
    {
        if (Size)
        {
            State->GeneralRegs[FAST486_REG_EBP].Long -= 4;
            Fast486StackPush(State, State->GeneralRegs[FAST486_REG_EBP].Long);
        }
        else
        {
            State->GeneralRegs[FAST486_REG_EBP].LowWord -= 2;
            Fast486StackPush(State, State->GeneralRegs[FAST486_REG_EBP].LowWord);
        }
    }
 
    if (NestingLevel > 0) Fast486StackPush(State, FramePointer.Long);
 
    /* Set EBP to the frame pointer */
    if (Size) State->GeneralRegs[FAST486_REG_EBP].Long = FramePointer.Long;
    else State->GeneralRegs[FAST486_REG_EBP].LowWord = FramePointer.LowWord;
 
    /* Reserve space for the frame */
    if (State->SegmentRegs[FAST486_REG_SS].Size)
    {
        State->GeneralRegs[FAST486_REG_ESP].Long -= (ULONG)FrameSize;
    }
    else
    {
        State->GeneralRegs[FAST486_REG_ESP].LowWord -= FrameSize;
    }
}

FAST486_OPCODE_HANDLER() [36/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeExchangeEax

)

Definition at line 507 of file opcodes.c.

{
    INT Reg = Opcode & 0x07;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0x90);
 
    /* Exchange the values */
    if (Size)
    {
        ULONG Value;
 
        Value = State->GeneralRegs[Reg].Long;
        State->GeneralRegs[Reg].Long = State->GeneralRegs[FAST486_REG_EAX].Long;
        State->GeneralRegs[FAST486_REG_EAX].Long = Value;
    }
    else
    {
        USHORT Value;
 
        Value = State->GeneralRegs[Reg].LowWord;
        State->GeneralRegs[Reg].LowWord = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Value;
    }
}

FAST486_OPCODE_HANDLER() [37/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeHalt

)

Definition at line 749 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xF4);
 
    NO_LOCK_PREFIX();
 
    /* Privileged instructions can only be executed under CPL = 0 */
    if (Fast486GetCurrentPrivLevel(State) != 0)
    {
        Fast486Exception(State, FAST486_EXCEPTION_GP);
        return;
    }
 
    /* Halt */
    State->Halted = TRUE;
}

FAST486_OPCODE_HANDLER() [38/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeImulModrmImm

)

Definition at line 3460 of file opcodes.c.

{
    BOOLEAN OperandSize, AddressSize;
    FAST486_MOD_REG_RM ModRegRm;
    LONG Multiplier;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x69);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Fetch the parameters */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (Opcode == 0x6B)
    {
        CHAR Byte;
 
        /* Fetch the immediate operand */
        if (!Fast486FetchByte(State, (PUCHAR)&Byte))
        {
            /* Exception occurred */
            return;
        }
 
        Multiplier = (LONG)Byte;
    }
    else
    {
        if (OperandSize)
        {
            LONG Dword;
 
            /* Fetch the immediate operand */
            if (!Fast486FetchDword(State, (PULONG)&Dword))
            {
                /* Exception occurred */
                return;
            }
 
            Multiplier = Dword;
        }
        else
        {
            SHORT Word;
 
            /* Fetch the immediate operand */
            if (!Fast486FetchWord(State, (PUSHORT)&Word))
            {
                /* Exception occurred */
                return;
            }
 
            Multiplier = (LONG)Word;
        }
    }
 
    if (OperandSize)
    {
        LONG RegValue, Multiplicand;
        LONGLONG Product;
 
        /* Read the operands */
        if (!Fast486ReadModrmDwordOperands(State,
                                           &ModRegRm,
                                           (PULONG)&RegValue,
                                           (PULONG)&Multiplicand))
        {
            /* Exception occurred */
            return;
        }
 
        /* Multiply */
        Product = (LONGLONG)Multiplicand * (LONGLONG)Multiplier;
 
        /* Check for carry/overflow */
        State->Flags.Cf = State->Flags.Of = ((Product < FAST486_LONG_MIN)
                                            || (Product > FAST486_LONG_MAX));
 
        /* Write-back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       TRUE,
                                       (ULONG)((LONG)Product));
    }
    else
    {
        SHORT RegValue, Multiplicand;
        LONG Product;
 
        /* Read the operands */
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          (PUSHORT)&RegValue,
                                          (PUSHORT)&Multiplicand))
        {
            /* Exception occurred */
            return;
        }
 
        /* Multiply */
        Product = (LONG)Multiplicand * (LONG)Multiplier;
 
        /* Check for carry/overflow */
        State->Flags.Cf = State->Flags.Of = ((Product < FAST486_SHORT_MIN)
                                            || (Product > FAST486_SHORT_MAX));
 
        /* Write-back the result */
        Fast486WriteModrmWordOperands(State,
                                      &ModRegRm,
                                      TRUE,
                                      (USHORT)((SHORT)Product));
    }
}

FAST486_OPCODE_HANDLER() [39/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeIn

)

Definition at line 802 of file opcodes.c.

{
    ULONG Port;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF7) == 0xE5);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Opcode == 0xE5)
    {
        UCHAR Data;
 
        /* Fetch the parameter */
        if (!Fast486FetchByte(State, &Data))
        {
            /* Exception occurred */
            return;
        }
 
        /* Set the port number to the parameter */
        Port = Data;
    }
    else
    {
        /* The port number is in DX */
        Port = State->GeneralRegs[FAST486_REG_EDX].LowWord;
    }
 
    if (!Fast486IoPrivilegeCheck(State, Port)) return;
 
    if (Size)
    {
        ULONG Data;
 
        /* Read a dword from the I/O port */
        State->IoReadCallback(State, Port, &Data, 1, sizeof(ULONG));
 
        /* Store the value in EAX */
        State->GeneralRegs[FAST486_REG_EAX].Long = Data;
    }
    else
    {
        USHORT Data;
 
        /* Read a word from the I/O port */
        State->IoReadCallback(State, Port, &Data, 1, sizeof(USHORT));
 
        /* Store the value in AX */
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Data;
    }
}

FAST486_OPCODE_HANDLER() [40/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeInByte

)

Definition at line 767 of file opcodes.c.

{
    UCHAR Data;
    ULONG Port;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF7) == 0xE4);
 
    if (Opcode == 0xE4)
    {
        /* Fetch the parameter */
        if (!Fast486FetchByte(State, &Data))
        {
            /* Exception occurred */
            return;
        }
 
        /* Set the port number to the parameter */
        Port = Data;
    }
    else
    {
        /* The port number is in DX */
        Port = State->GeneralRegs[FAST486_REG_EDX].LowWord;
    }
 
    if (!Fast486IoPrivilegeCheck(State, Port)) return;
 
    /* Read a byte from the I/O port */
    State->IoReadCallback(State, Port, &Data, 1, sizeof(UCHAR));
 
    /* Store the result in AL */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Data;
}

FAST486_OPCODE_HANDLER() [41/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeIncrement

)

Definition at line 411 of file opcodes.c.

{
    ULONG Value;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0x40);
 
    if (Size)
    {
        Value = ++State->GeneralRegs[Opcode & 0x07].Long;
 
        State->Flags.Of = (Value == SIGN_FLAG_LONG);
        State->Flags.Sf = ((Value & SIGN_FLAG_LONG) != 0);
    }
    else
    {
        Value = ++State->GeneralRegs[Opcode & 0x07].LowWord;
 
        State->Flags.Of = (Value == SIGN_FLAG_WORD);
        State->Flags.Sf = ((Value & SIGN_FLAG_WORD) != 0);
    }
 
    State->Flags.Zf = (Value == 0);
    State->Flags.Af = ((Value & 0x0F) == 0);
    State->Flags.Pf = Fast486CalculateParity(LOBYTE(Value));
}

FAST486_OPCODE_HANDLER() [42/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeIns

)

Definition at line 5834 of file opcodes.c.

{
    ULONG DataSize;
    BOOLEAN OperandSize, AddressSize;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0x6C);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (!Fast486IoPrivilegeCheck(State, State->GeneralRegs[FAST486_REG_EDX].LowWord)) return;
 
    /* Calculate the size */
    if (Opcode == 0x6C) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    if (State->PrefixFlags & (FAST486_PREFIX_REP | FAST486_PREFIX_REPNZ))
    {
        UCHAR Block[STRING_BLOCK_SIZE];
        ULONG Count = AddressSize ? State->GeneralRegs[FAST486_REG_ECX].Long
                                  : State->GeneralRegs[FAST486_REG_ECX].LowWord;
 
        /* Clear the memory block */
        RtlZeroMemory(Block, sizeof(Block));
 
        /* Transfer until finished */
        while (Count)
        {
            ULONG Processed = min(Count, STRING_BLOCK_SIZE / DataSize);
 
            /* Simulate the 16-bit wrap-around of DI in 16-bit address mode */
            if (!AddressSize)
            {
                ULONG MaxBytes = State->Flags.Df
                                 ? (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord
                                 : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord);
 
                Processed = min(Processed, MaxBytes / DataSize);
                if (Processed == 0) Processed = 1;
            }
 
            /* Read from the I/O port */
            State->IoReadCallback(State,
                                  State->GeneralRegs[FAST486_REG_EDX].LowWord,
                                  Block,
                                  Processed,
                                  DataSize);
 
            if (State->Flags.Df)
            {
                ULONG i, j;
 
                /* Reduce EDI by the number of bytes to transfer */
                if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long -= Processed * DataSize;
                else State->GeneralRegs[FAST486_REG_EDI].LowWord -= Processed * DataSize;
 
                /* Reverse the block data */
                for (i = 0; i < Processed / 2; i++)
                {
                    /* Swap the values */
                    for (j = 0; j < DataSize; j++)
                    {
                        UCHAR Temp = Block[i * DataSize + j];
                        Block[i * DataSize + j] = Block[(Processed - i - 1) * DataSize + j];
                        Block[(Processed - i - 1) * DataSize + j] = Temp;
                    }
                }
            }
 
            /* Write to memory */
            if (!Fast486WriteMemory(State,
                                    FAST486_REG_ES,
                                    AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                                : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                                    Block,
                                    Processed * DataSize))
            {
                /* Set ECX */
                if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count;
                else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count);
 
                /* Exception occurred */
                return;
            }
 
            if (!State->Flags.Df)
            {
                /* Increase EDI by the number of bytes transfered */
                if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long += Processed * DataSize;
                else State->GeneralRegs[FAST486_REG_EDI].LowWord += Processed * DataSize;
            }
 
            /* Reduce the total count by the number processed in this run */
            Count -= Processed;
        }
 
        /* Clear ECX */
        if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0;
        else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0;
    }
    else
    {
        ULONG Data = 0;
 
        /* Read from the I/O port */
        State->IoReadCallback(State,
                              State->GeneralRegs[FAST486_REG_EDX].LowWord,
                              &Data,
                              1,
                              DataSize);
 
        /* Write to the destination operand */
        if (!Fast486WriteMemory(State,
                                FAST486_REG_ES,
                                AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                            : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                                &Data,
                                DataSize))
        {
            /* Exception occurred */
            return;
        }
 
        /* Increment/decrement EDI */
        if (AddressSize)
        {
            if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].Long += DataSize;
            else State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize;
        }
        else
        {
            if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize;
            else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize;
        }
    }
}

FAST486_OPCODE_HANDLER() [43/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeInt

)

Definition at line 4422 of file opcodes.c.

{
    UCHAR IntNum;
 
    /* Check for V86 mode */
    if (State->Flags.Vm && (State->Flags.Iopl != 3))
    {
        /* Call the V86 monitor */
        Fast486Exception(State, FAST486_EXCEPTION_GP);
        return;
    }
 
    switch (Opcode)
    {
        case 0xCC:  // INT 3
        {
            /* This is the INT3 instruction */
            IntNum = 3;
            break;
        }
 
        case 0xCD:  // INT xx
        {
            /* Fetch the interrupt number */
            if (!Fast486FetchByte(State, &IntNum))
            {
                /* Exception occurred */
                return;
            }
 
            break;
        }
 
        case 0xCE:  // INTO
        {
            /* Don't do anything if OF is cleared */
            if (!State->Flags.Of) return;
 
            /* Exception #OF */
            IntNum = FAST486_EXCEPTION_OF;
 
            break;
        }
 
        default:
        {
            /* Should not happen */
            ASSERT(FALSE);
        }
    }
 
    /* Perform the interrupt */
    Fast486PerformInterrupt(State, IntNum);
}

FAST486_OPCODE_HANDLER() [44/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeInvalid

)

Definition at line 301 of file opcodes.c.

{
    /*
     * This is not a valid opcode.
     * Well, not totally: see http://www.rcollins.org/secrets/opcodes/ICEBP.html
     * for more details.
     */
    DPRINT1("FAST486 -- Calling ICEBP opcode\n");
    Fast486Exception(State, FAST486_EXCEPTION_UD);
}

FAST486_OPCODE_HANDLER() [45/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeIret

)

Definition at line 4477 of file opcodes.c.

{
    FAST486_SEG_REGS i;
    ULONG InstPtr, CodeSel, StackPtr, StackSel;
    FAST486_FLAGS_REG NewFlags;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xCF);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    /* Check if this is a nested task return */
    if (State->Flags.Nt && (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE))
    {
        /* Clear the NT flag of the current task */
        State->Flags.Nt = FALSE;
 
        /* Switch to the old task */
        Fast486TaskSwitch(State, FAST486_TASK_RETURN, 0);
        return;
    }
 
    /* Pop EIP */
    if (!Fast486StackPop(State, &InstPtr))
    {
        /* Exception occurred */
        return;
    }
 
    /* Pop CS */
    if (!Fast486StackPop(State, &CodeSel))
    {
        /* Exception occurred */
        return;
    }
 
    /* Pop EFLAGS */
    if (!Fast486StackPop(State, &NewFlags.Long))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check for protected mode */
    if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
    {
        UINT OldCpl = Fast486GetCurrentPrivLevel(State);
 
        if (State->Flags.Vm)
        {
            /* Return from VM86 mode */
 
            /* Check the IOPL */
            if (State->Flags.Iopl == 3)
            {
                /* Set new EIP */
                State->InstPtr.Long = LOWORD(InstPtr);
 
                /* Load new CS */
                if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel))
                {
                    /* Exception occurred */
                    return;
                }
 
                /* Set the new flags */
                if (Size) State->Flags.Long = NewFlags.Long & REAL_MODE_FLAGS_MASK;
                else State->Flags.LowWord = NewFlags.LowWord & REAL_MODE_FLAGS_MASK;
                State->Flags.AlwaysSet = State->Flags.Vm = TRUE;
                State->Flags.Iopl = 3;
            }
            else
            {
                /* Call the VM86 monitor */
                Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0);
                return;
            }
 
            return;
        }
 
        if (NewFlags.Vm)
        {
            /* Return to VM86 mode */
            ULONG Es, Ds, Fs, Gs;
 
            /* Pop ESP, SS, ES, DS, FS, GS */
            if (!Fast486StackPop(State, &StackPtr)) return;
            if (!Fast486StackPop(State, &StackSel)) return;
            if (!Fast486StackPop(State, &Es)) return;
            if (!Fast486StackPop(State, &Ds)) return;
            if (!Fast486StackPop(State, &Fs)) return;
            if (!Fast486StackPop(State, &Gs)) return;
 
            /* Set the new IP */
            State->InstPtr.Long = LOWORD(InstPtr);
 
            /* Set the new SP */
            State->GeneralRegs[FAST486_REG_ESP].Long = StackPtr;
 
            /* Set the new flags */
            if (Size) State->Flags.Long = NewFlags.Long & REAL_MODE_FLAGS_MASK;
            else State->Flags.LowWord = NewFlags.LowWord & REAL_MODE_FLAGS_MASK;
            State->Flags.AlwaysSet = State->Flags.Vm = TRUE;
 
            /* Switch to CPL 3 */
            State->Cpl = 3;
 
            /* Load the new segments */
            if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel)) return;
            if (!Fast486LoadSegment(State, FAST486_REG_SS, StackSel)) return;
            if (!Fast486LoadSegment(State, FAST486_REG_ES, Es)) return;
            if (!Fast486LoadSegment(State, FAST486_REG_DS, Ds)) return;
            if (!Fast486LoadSegment(State, FAST486_REG_FS, Fs)) return;
            if (!Fast486LoadSegment(State, FAST486_REG_GS, Gs)) return;
 
            return;
        }
 
        if (GET_SEGMENT_RPL(CodeSel) > OldCpl)
        {
            /* Pop ESP */
            if (!Fast486StackPop(State, &StackPtr))
            {
                /* Exception */
                return;
            }
 
            /* Pop SS */
            if (!Fast486StackPop(State, &StackSel))
            {
                /* Exception */
                return;
            }
        }
 
        /* Load the new CS */
        if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel))
        {
            /* Exception occurred */
            return;
        }
 
        /* Set EIP */
        if (Size) State->InstPtr.Long = InstPtr;
        else State->InstPtr.LowWord = LOWORD(InstPtr);
 
        /* Update the CPL */
        State->Cpl = GET_SEGMENT_RPL(CodeSel);
 
        /* Set the new flags */
        if (Size)
        {
            State->Flags.Long = (State->Flags.Long & ~PROT_MODE_FLAGS_MASK)
                                | (NewFlags.Long & PROT_MODE_FLAGS_MASK);
        }
        else
        {
            State->Flags.LowWord = (State->Flags.LowWord & ~PROT_MODE_FLAGS_MASK)
                                   | (NewFlags.LowWord & PROT_MODE_FLAGS_MASK);
        }
        State->Flags.AlwaysSet = TRUE;
 
        /* Set additional flags */
        if (OldCpl <= State->Flags.Iopl) State->Flags.If = NewFlags.If;
        if (OldCpl == 0) State->Flags.Iopl = NewFlags.Iopl;
 
        if (State->Cpl > OldCpl)
        {
            /* Load new SS */
            if (!Fast486LoadSegment(State, FAST486_REG_SS, StackSel))
            {
                /* Exception */
                return;
            }
 
            /* Set ESP */
            if (Size) State->GeneralRegs[FAST486_REG_ESP].Long = StackPtr;
            else State->GeneralRegs[FAST486_REG_ESP].LowWord = LOWORD(StackPtr);
 
            /* Check segment security */
            for (i = 0; i < FAST486_NUM_SEG_REGS; i++)
            {
                /* Don't check CS or SS */
                if ((i == FAST486_REG_CS) || (i == FAST486_REG_SS)) continue;
 
                if ((State->Cpl > State->SegmentRegs[i].Dpl)
                    && (!State->SegmentRegs[i].Executable
                    || !State->SegmentRegs[i].DirConf))
                {
                    /* Load the NULL descriptor in the segment */
                    if (!Fast486LoadSegment(State, i, 0)) return;
                }
            }
        }
    }
    else
    {
        if (Size && (InstPtr & 0xFFFF0000))
        {
            /* Invalid */
            Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0);
            return;
        }
 
        /* Set new EIP */
        State->InstPtr.Long = InstPtr;
 
        /* Load new CS */
        if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel))
        {
            /* Exception occurred */
            return;
        }
 
        /* Set the new flags */
        if (Size) State->Flags.Long = NewFlags.Long & REAL_MODE_FLAGS_MASK;
        else State->Flags.LowWord = NewFlags.LowWord & REAL_MODE_FLAGS_MASK;
        State->Flags.AlwaysSet = TRUE;
    }
}

FAST486_OPCODE_HANDLER() [46/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeJecxz

)

Definition at line 4826 of file opcodes.c.

{
    BOOLEAN Condition;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    CHAR Offset = 0;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xE3);
 
    NO_LOCK_PREFIX();
    TOGGLE_ADSIZE(Size);
 
    if (Size) Condition = (State->GeneralRegs[FAST486_REG_ECX].Long == 0);
    else Condition = (State->GeneralRegs[FAST486_REG_ECX].LowWord == 0);
 
    /* Fetch the offset */
    if (!Fast486FetchByte(State, (PUCHAR)&Offset))
    {
        /* An exception occurred */
        return;
    }
 
    if (Condition)
    {
        /* Move the instruction pointer */
        if (Size) State->InstPtr.Long += Offset;
        else State->InstPtr.LowWord += Offset;
    }
}

FAST486_OPCODE_HANDLER() [47/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeJmp

)

Definition at line 4910 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xE9);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Size)
    {
        LONG Offset = 0;
 
        /* Fetch the offset */
        if (!Fast486FetchDword(State, (PULONG)&Offset))
        {
            /* An exception occurred */
            return;
        }
 
        /* Move the instruction pointer */
        State->InstPtr.Long += Offset;
    }
    else
    {
        SHORT Offset = 0;
 
        /* Fetch the offset */
        if (!Fast486FetchWord(State, (PUSHORT)&Offset))
        {
            /* An exception occurred */
            return;
        }
 
        /* Move the instruction pointer */
        State->InstPtr.Long += Offset;
 
        /* Clear the top half of EIP */
        State->InstPtr.Long &= 0xFFFF;
    }
}

FAST486_OPCODE_HANDLER() [48/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeJmpAbs

)

Definition at line 4953 of file opcodes.c.

{
    USHORT Segment = 0;
    ULONG Offset = 0;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xEA);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Fetch the offset */
    if (Size)
    {
        if (!Fast486FetchDword(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
    }
    else
    {
        if (!Fast486FetchWord(State, (PUSHORT)&Offset))
        {
            /* Exception occurred */
            return;
        }
    }
 
    /* Fetch the segment */
    if (!Fast486FetchWord(State, &Segment))
    {
        /* Exception occurred */
        return;
    }
 
    if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm)
    {
        if (!Fast486ProcessGate(State, Segment, Offset, FALSE))
        {
            /* Gate processed or exception occurred */
            return;
        }
    }
 
    /* Load the new CS */
    if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment))
    {
        /* Exception occurred */
        return;
    }
 
    /* Load new EIP */
    State->InstPtr.Long = Offset;
}

FAST486_OPCODE_HANDLER() [49/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeLahf

)

Definition at line 4062 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x9F);
 
    /* Set AH to the low-order byte of FLAGS */
    State->GeneralRegs[FAST486_REG_EAX].HighByte = LOBYTE(State->Flags.Long);
}

FAST486_OPCODE_HANDLER() [50/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeLdsLes

)

Definition at line 4105 of file opcodes.c.

{
    UCHAR FarPointer[6];
    BOOLEAN OperandSize, AddressSize;
    FAST486_MOD_REG_RM ModRegRm;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xC4);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!ModRegRm.Memory)
    {
        /* Check if this is a BOP and the host supports BOPs */
        if ((Opcode == 0xC4)
            && (ModRegRm.Register == FAST486_REG_EAX)
            && (ModRegRm.SecondRegister == FAST486_REG_ESP)
            && (State->BopCallback != NULL))
        {
            UCHAR BopCode;
 
            /* Fetch the BOP code */
            if (!Fast486FetchByte(State, &BopCode))
            {
                /* Exception occurred */
                return;
            }
 
#ifndef FAST486_NO_PREFETCH
            /* Invalidate the prefetch since BOP handlers can alter the memory */
            State->PrefetchValid = FALSE;
#endif
 
            /* Call the BOP handler */
            State->BopCallback(State, BopCode);
 
            /*
             * If an interrupt should occur at this time, delay it.
             * We must do this because if an interrupt begins and the BOP callback
             * changes the CS:IP, the interrupt handler won't execute and the
             * stack pointer will never be restored.
             */
            State->DoNotInterrupt = TRUE;
 
            return;
        }
 
        /* Invalid */
        Fast486Exception(State, FAST486_EXCEPTION_UD);
        return;
    }
 
    if (!Fast486ReadMemory(State,
                           (State->PrefixFlags & FAST486_PREFIX_SEG)
                           ? State->SegmentOverride : FAST486_REG_DS,
                           ModRegRm.MemoryAddress,
                           FALSE,
                           FarPointer,
                           OperandSize ? 6 : 4))
    {
        /* Exception occurred */
        return;
    }
 
    if (OperandSize)
    {
        ULONG Offset = *((PULONG)FarPointer);
        USHORT Segment = *((PUSHORT)&FarPointer[sizeof(ULONG)]);
 
        /* Set the register to the offset */
        State->GeneralRegs[ModRegRm.Register].Long = Offset;
 
        /* Load the segment */
        Fast486LoadSegment(State,
                           (Opcode == 0xC4)
                           ? FAST486_REG_ES : FAST486_REG_DS,
                           Segment);
    }
    else
    {
        USHORT Offset = *((PUSHORT)FarPointer);
        USHORT Segment = *((PUSHORT)&FarPointer[sizeof(USHORT)]);
 
        /* Set the register to the offset */
        State->GeneralRegs[ModRegRm.Register].LowWord = Offset;
 
        /* Load the segment */
        Fast486LoadSegment(State,
                           (Opcode == 0xC4)
                           ? FAST486_REG_ES : FAST486_REG_DS,
                           Segment);
    }
}

FAST486_OPCODE_HANDLER() [51/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeLea

)

Definition at line 3764 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x8D);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* The second operand must be memory */
    if (!ModRegRm.Memory)
    {
        /* Invalid */
        Fast486Exception(State, FAST486_EXCEPTION_UD);
        return;
    }
 
    /* Write the address to the register */
    if (OperandSize)
    {
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       TRUE,
                                       ModRegRm.MemoryAddress);
    }
    else
    {
        Fast486WriteModrmWordOperands(State,
                                      &ModRegRm,
                                      TRUE,
                                      ModRegRm.MemoryAddress);
 
    }
}

FAST486_OPCODE_HANDLER() [52/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeLeave

)

Definition at line 4277 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    ULONG Value;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xC9);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (State->SegmentRegs[FAST486_REG_SS].Size)
    {
        /* Set the stack pointer (ESP) to the base pointer (EBP) */
        State->GeneralRegs[FAST486_REG_ESP].Long = State->GeneralRegs[FAST486_REG_EBP].Long;
    }
    else
    {
        /* Set the stack pointer (SP) to the base pointer (BP) */
        State->GeneralRegs[FAST486_REG_ESP].LowWord = State->GeneralRegs[FAST486_REG_EBP].LowWord;
    }
 
    /* Pop the saved base pointer from the stack */
    if (Fast486StackPop(State, &Value))
    {
        if (Size) State->GeneralRegs[FAST486_REG_EBP].Long = Value;
        else State->GeneralRegs[FAST486_REG_EBP].LowWord = LOWORD(Value);
    }
}

FAST486_OPCODE_HANDLER() [53/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeLods

)

Definition at line 5647 of file opcodes.c.

{
    ULONG DataSize;
    BOOLEAN OperandSize, AddressSize;
    FAST486_SEG_REGS Segment = FAST486_REG_DS;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xAC);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (State->PrefixFlags & FAST486_PREFIX_SEG)
    {
        /* Use the override segment instead of DS */
        Segment = State->SegmentOverride;
    }
 
    /* Calculate the size */
    if (Opcode == 0xAC) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    if (State->PrefixFlags & (FAST486_PREFIX_REP | FAST486_PREFIX_REPNZ))
    {
        ULONG Count = AddressSize ? State->GeneralRegs[FAST486_REG_ECX].Long
                                  : State->GeneralRegs[FAST486_REG_ECX].LowWord;
 
        /* If the count is 0, do nothing */
        if (Count == 0) return;
 
        /* Only the last entry will be loaded */
        if (!State->Flags.Df)
        {
            if (AddressSize) State->GeneralRegs[FAST486_REG_ESI].Long += (Count - 1) * DataSize;
            else State->GeneralRegs[FAST486_REG_ESI].LowWord += (Count - 1) * DataSize;
        }
        else
        {
            if (AddressSize) State->GeneralRegs[FAST486_REG_ESI].Long -= (Count - 1) * DataSize;
            else State->GeneralRegs[FAST486_REG_ESI].LowWord -= (Count - 1) * DataSize;
        }
 
        /* Clear ECX */
        if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0;
        else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0;
    }
 
    /* Read from the source operand */
    if (!Fast486ReadMemory(State,
                           Segment,
                           AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long
                                       : State->GeneralRegs[FAST486_REG_ESI].LowWord,
                           FALSE,
                           &State->GeneralRegs[FAST486_REG_EAX].Long,
                           DataSize))
    {
        /* Exception occurred */
        return;
    }
 
    /* Increment/decrement ESI */
    if (AddressSize)
    {
        if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].Long += DataSize;
        else State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize;
    }
    else
    {
        if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize;
        else State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize;
    }
}

FAST486_OPCODE_HANDLER() [54/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeLoop

)

Definition at line 4785 of file opcodes.c.

{
    BOOLEAN Condition;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    CHAR Offset = 0;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode >= 0xE0) && (Opcode <= 0xE2));
 
    NO_LOCK_PREFIX();
    TOGGLE_ADSIZE(Size);
 
    if (Size) Condition = ((--State->GeneralRegs[FAST486_REG_ECX].Long) != 0);
    else Condition = ((--State->GeneralRegs[FAST486_REG_ECX].LowWord) != 0);
 
    if (Opcode == 0xE0)
    {
        /* Additional rule for LOOPNZ */
        if (State->Flags.Zf) Condition = FALSE;
    }
    else if (Opcode == 0xE1)
    {
        /* Additional rule for LOOPZ */
        if (!State->Flags.Zf) Condition = FALSE;
    }
 
    /* Fetch the offset */
    if (!Fast486FetchByte(State, (PUCHAR)&Offset))
    {
        /* An exception occurred */
        return;
    }
 
    if (Condition)
    {
        /* Move the instruction pointer */
        if (Size) State->InstPtr.Long += Offset;
        else State->InstPtr.LowWord += Offset;
    }
}

FAST486_OPCODE_HANDLER() [55/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovAlOffset

)

Definition at line 5010 of file opcodes.c.

{
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
    ULONG Offset;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xA0);
 
    TOGGLE_ADSIZE(AddressSize);
 
    if (AddressSize)
    {
        if (!Fast486FetchDword(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
    }
    else
    {
        USHORT WordOffset;
 
        if (!Fast486FetchWord(State, &WordOffset))
        {
            /* Exception occurred */
            return;
        }
 
        Offset = (ULONG)WordOffset;
    }
 
    /* Read from memory */
    Fast486ReadMemory(State,
                      (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                      State->SegmentOverride : FAST486_REG_DS,
                      Offset,
                      FALSE,
                      &State->GeneralRegs[FAST486_REG_EAX].LowByte,
                      sizeof(UCHAR));
}

FAST486_OPCODE_HANDLER() [56/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovByteModrm

)

Definition at line 3599 of file opcodes.c.

{
    UCHAR Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x88);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (Opcode & FAST486_OPCODE_WRITE_REG)
    {
        if (!Fast486ReadModrmByteOperands(State, &ModRegRm, NULL, &Result))
        {
            /* Exception occurred */
            return;
        }
    }
    else
    {
        if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Result, NULL))
        {
            /* Exception occurred */
            return;
        }
    }
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [57/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovByteRegImm

)

Definition at line 1010 of file opcodes.c.

{
    UCHAR Value;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0xB0);
 
    NO_LOCK_PREFIX();
 
    /* Fetch the byte */
    if (!Fast486FetchByte(State, &Value))
    {
        /* Exception occurred */
        return;
    }
 
    if (Opcode & 0x04)
    {
        /* AH, CH, DH or BH */
        State->GeneralRegs[Opcode & 0x03].HighByte = Value;
    }
    else
    {
        /* AL, CL, DL or BL */
        State->GeneralRegs[Opcode & 0x03].LowByte = Value;
    }
}

FAST486_OPCODE_HANDLER() [58/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovEaxOffset

)

Definition at line 5051 of file opcodes.c.

{
    BOOLEAN OperandSize, AddressSize;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xA1);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (AddressSize)
    {
        ULONG Offset;
 
        if (!Fast486FetchDword(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
 
        /* Read from memory */
        if (OperandSize)
        {
            Fast486ReadMemory(State,
                              (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                              State->SegmentOverride : FAST486_REG_DS,
                              Offset,
                              FALSE,
                              &State->GeneralRegs[FAST486_REG_EAX].Long,
                              sizeof(ULONG));
        }
        else
        {
            Fast486ReadMemory(State,
                              (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                              State->SegmentOverride : FAST486_REG_DS,
                              Offset,
                              FALSE,
                              &State->GeneralRegs[FAST486_REG_EAX].LowWord,
                              sizeof(USHORT));
        }
    }
    else
    {
        USHORT Offset;
 
        if (!Fast486FetchWord(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
 
        /* Read from memory */
        if (OperandSize)
        {
            Fast486ReadMemory(State,
                              (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                              State->SegmentOverride : FAST486_REG_DS,
                              Offset,
                              FALSE,
                              &State->GeneralRegs[FAST486_REG_EAX].Long,
                              sizeof(ULONG));
        }
        else
        {
            Fast486ReadMemory(State,
                              (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                              State->SegmentOverride : FAST486_REG_DS,
                              Offset,
                              FALSE,
                              &State->GeneralRegs[FAST486_REG_EAX].LowWord,
                              sizeof(USHORT));
        }
    }
}

FAST486_OPCODE_HANDLER() [59/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovLoadSeg

)

Definition at line 3810 of file opcodes.c.

{
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
    FAST486_MOD_REG_RM ModRegRm;
    USHORT Selector;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x8E);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if ((ModRegRm.Register >= FAST486_NUM_SEG_REGS)
        || ((FAST486_SEG_REGS)ModRegRm.Register == FAST486_REG_CS))
    {
        /* Invalid */
        Fast486Exception(State, FAST486_EXCEPTION_UD);
        return;
    }
 
    if (!Fast486ReadModrmWordOperands(State, &ModRegRm, NULL, &Selector))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486LoadSegment(State, ModRegRm.Register, Selector))
    {
        /* Exception occurred */
        return;
    }
 
    if ((INT)ModRegRm.Register == FAST486_REG_SS)
    {
        /* Inhibit all interrupts until the next instruction */
        State->DoNotInterrupt = TRUE;
    }
}

FAST486_OPCODE_HANDLER() [60/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovModrm

)

Definition at line 3641 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x89);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG Result;
 
 
 
        if (Opcode & FAST486_OPCODE_WRITE_REG)
        {
            if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, NULL, &Result))
            {
                /* Exception occurred */
                return;
            }
        }
        else
        {
            if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Result, NULL))
            {
                /* Exception occurred */
                return;
            }
        }
 
        /* Write back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
    else
    {
        USHORT Result;
 
        if (Opcode & FAST486_OPCODE_WRITE_REG)
        {
            if (!Fast486ReadModrmWordOperands(State, &ModRegRm, NULL, &Result))
            {
                /* Exception occurred */
                return;
            }
        }
        else
        {
            if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Result, NULL))
            {
                /* Exception occurred */
                return;
            }
        }
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State,
                                      &ModRegRm,
                                      Opcode & FAST486_OPCODE_WRITE_REG,
                                      Result);
    }
}

FAST486_OPCODE_HANDLER() [61/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovOffsetAl

)

Definition at line 5129 of file opcodes.c.

{
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
    ULONG Offset;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xA2);
 
    TOGGLE_ADSIZE(AddressSize);
 
    if (AddressSize)
    {
        if (!Fast486FetchDword(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
    }
    else
    {
        USHORT WordOffset;
 
        if (!Fast486FetchWord(State, &WordOffset))
        {
            /* Exception occurred */
            return;
        }
 
        Offset = (ULONG)WordOffset;
    }
 
    /* Write to memory */
    Fast486WriteMemory(State,
                      (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                      State->SegmentOverride : FAST486_REG_DS,
                      Offset,
                      &State->GeneralRegs[FAST486_REG_EAX].LowByte,
                      sizeof(UCHAR));
}

FAST486_OPCODE_HANDLER() [62/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovOffsetEax

)

Definition at line 5169 of file opcodes.c.

{
    BOOLEAN OperandSize, AddressSize;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xA3);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (AddressSize)
    {
        ULONG Offset;
 
        if (!Fast486FetchDword(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write to memory */
        if (OperandSize)
        {
            Fast486WriteMemory(State,
                               (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                               State->SegmentOverride : FAST486_REG_DS,
                               Offset,
                               &State->GeneralRegs[FAST486_REG_EAX].Long,
                               sizeof(ULONG));
        }
        else
        {
            Fast486WriteMemory(State,
                               (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                               State->SegmentOverride : FAST486_REG_DS,
                               Offset,
                               &State->GeneralRegs[FAST486_REG_EAX].LowWord,
                               sizeof(USHORT));
        }
    }
    else
    {
        USHORT Offset;
 
        if (!Fast486FetchWord(State, &Offset))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write to memory */
        if (OperandSize)
        {
            Fast486WriteMemory(State,
                               (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                               State->SegmentOverride : FAST486_REG_DS,
                               Offset,
                               &State->GeneralRegs[FAST486_REG_EAX].Long,
                               sizeof(ULONG));
        }
        else
        {
            Fast486WriteMemory(State,
                               (State->PrefixFlags & FAST486_PREFIX_SEG) ?
                               State->SegmentOverride : FAST486_REG_DS,
                               Offset,
                               &State->GeneralRegs[FAST486_REG_EAX].LowWord,
                               sizeof(USHORT));
        }
    }
}

FAST486_OPCODE_HANDLER() [63/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovRegImm

)

Definition at line 970 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0xB8);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Size)
    {
        ULONG Value;
 
        /* Fetch the dword */
        if (!Fast486FetchDword(State, &Value))
        {
            /* Exception occurred */
            return;
        }
 
        /* Store the value in the register */
        State->GeneralRegs[Opcode & 0x07].Long = Value;
    }
    else
    {
        USHORT Value;
 
        /* Fetch the word */
        if (!Fast486FetchWord(State, &Value))
        {
            /* Exception occurred */
            return;
        }
 
        /* Store the value in the register */
        State->GeneralRegs[Opcode & 0x07].LowWord = Value;
    }
}

FAST486_OPCODE_HANDLER() [64/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovs

)

Definition at line 5259 of file opcodes.c.

{
    ULONG Data, DataSize;
    BOOLEAN OperandSize, AddressSize;
    FAST486_SEG_REGS Segment = FAST486_REG_DS;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xA4);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (State->PrefixFlags & FAST486_PREFIX_SEG)
    {
        /* Use the override segment instead of DS */
        Segment = State->SegmentOverride;
    }
 
    if (State->PrefixFlags & (FAST486_PREFIX_REP | FAST486_PREFIX_REPNZ))
    {
        if ((AddressSize && (State->GeneralRegs[FAST486_REG_ECX].Long == 0))
            || (!AddressSize && (State->GeneralRegs[FAST486_REG_ECX].LowWord == 0)))
        {
            /* Do nothing */
            return;
        }
    }
 
    /* Calculate the size */
    if (Opcode == 0xA4) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    /* Read from the source operand */
    if (!Fast486ReadMemory(State,
                           Segment,
                           AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long
                                       : State->GeneralRegs[FAST486_REG_ESI].LowWord,
                           FALSE,
                           &Data,
                           DataSize))
    {
        /* Exception occurred */
        return;
    }
 
    /* Write to the destination operand */
    if (!Fast486WriteMemory(State,
                            FAST486_REG_ES,
                            AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                        : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                            &Data,
                            DataSize))
    {
        /* Exception occurred */
        return;
    }
 
    /* Increment/decrement ESI and EDI */
    if (AddressSize)
    {
        if (!State->Flags.Df)
        {
            State->GeneralRegs[FAST486_REG_ESI].Long += DataSize;
            State->GeneralRegs[FAST486_REG_EDI].Long += DataSize;
        }
        else
        {
            State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize;
            State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize;
        }
    }
    else
    {
        if (!State->Flags.Df)
        {
            State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize;
            State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize;
        }
        else
        {
            State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize;
            State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize;
        }
    }
 
    // FIXME: This method is slow!
    if (State->PrefixFlags & (FAST486_PREFIX_REP | FAST486_PREFIX_REPNZ))
    {
        if (AddressSize)
        {
            if (--State->GeneralRegs[FAST486_REG_ECX].Long)
            {
                /* Repeat the instruction */
                State->InstPtr = State->SavedInstPtr;
            }
        }
        else
        {
            if (--State->GeneralRegs[FAST486_REG_ECX].LowWord)
            {
                /* Repeat the instruction */
                State->InstPtr = State->SavedInstPtr;
            }
        }
    }
}

FAST486_OPCODE_HANDLER() [65/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeMovStoreSeg

)

Definition at line 3720 of file opcodes.c.

{
    BOOLEAN OperandSize, AddressSize;
    FAST486_MOD_REG_RM ModRegRm;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x8C);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (ModRegRm.Register >= FAST486_NUM_SEG_REGS)
    {
        /* Invalid */
        Fast486Exception(State, FAST486_EXCEPTION_UD);
        return;
    }
 
    /* When the other operand is a memory location, always use 16-bit */
    if (OperandSize && !ModRegRm.Memory)
    {
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       FALSE,
                                       State->SegmentRegs[ModRegRm.Register].Selector);
    }
    else
    {
        Fast486WriteModrmWordOperands(State,
                                      &ModRegRm,
                                      FALSE,
                                      State->SegmentRegs[ModRegRm.Register].Selector);
    }
}

FAST486_OPCODE_HANDLER() [66/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeNop

)

Definition at line 503 of file opcodes.c.

{
}

FAST486_OPCODE_HANDLER() [67/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOrAl

)

Definition at line 1390 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x0C);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue | SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
}

FAST486_OPCODE_HANDLER() [68/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOrByteModrm

)

Definition at line 1265 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x08);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue | SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [69/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOrEax

)

Definition at line 1420 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x0D);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue | SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].Long = Result;
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue | SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Result;
    }
}

FAST486_OPCODE_HANDLER() [70/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOrModrm

)

Definition at line 1309 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x09);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue | SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue | SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
}

FAST486_OPCODE_HANDLER() [71/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOut

)

Definition at line 892 of file opcodes.c.

{
    ULONG Port;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF7) == 0xE7);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Opcode == 0xE7)
    {
        UCHAR Data;
 
        /* Fetch the parameter */
        if (!Fast486FetchByte(State, &Data))
        {
            /* Exception occurred */
            return;
        }
 
        /* Set the port number to the parameter */
        Port = Data;
    }
    else
    {
        /* The port number is in DX */
        Port = State->GeneralRegs[FAST486_REG_EDX].LowWord;
    }
 
    if (!Fast486IoPrivilegeCheck(State, Port)) return;
 
    if (Size)
    {
        /* Get the value from EAX */
        ULONG Data = State->GeneralRegs[FAST486_REG_EAX].Long;
 
        /* Write a dword to the I/O port */
        State->IoWriteCallback(State, Port, &Data, 1, sizeof(ULONG));
    }
    else
    {
        /* Get the value from AX */
        USHORT Data = State->GeneralRegs[FAST486_REG_EAX].LowWord;
 
        /* Write a word to the I/O port */
        State->IoWriteCallback(State, Port, &Data, 1, sizeof(USHORT));
    }
}

FAST486_OPCODE_HANDLER() [72/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOutByte

)

Definition at line 857 of file opcodes.c.

{
    UCHAR Data;
    ULONG Port;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF7) == 0xE6);
 
    if (Opcode == 0xE6)
    {
        /* Fetch the parameter */
        if (!Fast486FetchByte(State, &Data))
        {
            /* Exception occurred */
            return;
        }
 
        /* Set the port number to the parameter */
        Port = Data;
    }
    else
    {
        /* The port number is in DX */
        Port = State->GeneralRegs[FAST486_REG_EDX].LowWord;
    }
 
    if (!Fast486IoPrivilegeCheck(State, Port)) return;
 
    /* Read the value from AL */
    Data = State->GeneralRegs[FAST486_REG_EAX].LowByte;
 
    /* Write the byte to the I/O port */
    State->IoWriteCallback(State, Port, &Data, 1, sizeof(UCHAR));
}

FAST486_OPCODE_HANDLER() [73/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeOuts

)

Definition at line 5974 of file opcodes.c.

{
    ULONG DataSize;
    BOOLEAN OperandSize, AddressSize;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0x6E);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if (!Fast486IoPrivilegeCheck(State, State->GeneralRegs[FAST486_REG_EDX].LowWord)) return;
 
    /* Calculate the size */
    if (Opcode == 0x6E) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    if (State->PrefixFlags & (FAST486_PREFIX_REP | FAST486_PREFIX_REPNZ))
    {
        UCHAR Block[STRING_BLOCK_SIZE];
        ULONG Count = AddressSize ? State->GeneralRegs[FAST486_REG_ECX].Long
                                  : State->GeneralRegs[FAST486_REG_ECX].LowWord;
 
        /* Clear the memory block */
        RtlZeroMemory(Block, sizeof(Block));
 
        /* Transfer until finished */
        while (Count)
        {
            ULONG Processed = min(Count, STRING_BLOCK_SIZE / DataSize);
 
            /* Simulate the 16-bit wrap-around of DI in 16-bit address mode */
            if (!AddressSize)
            {
                ULONG MaxBytes = State->Flags.Df
                                 ? (ULONG)State->GeneralRegs[FAST486_REG_ESI].LowWord
                                 : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_ESI].LowWord);
 
                Processed = min(Processed, MaxBytes / DataSize);
                if (Processed == 0) Processed = 1;
            }
 
            /* Read from memory */
            if (!Fast486ReadMemory(State,
                                   (State->PrefixFlags & FAST486_PREFIX_SEG)
                                   ? State->SegmentOverride : FAST486_REG_DS,
                                   AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long
                                               : State->GeneralRegs[FAST486_REG_ESI].LowWord,
                                   FALSE,
                                   Block,
                                   Processed * DataSize))
            {
                /* Set ECX */
                if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count;
                else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count);
 
                /* Exception occurred */
                return;
            }
 
            if (State->Flags.Df)
            {
                ULONG i, j;
 
                /* Reduce ESI by the number of bytes to transfer */
                if (AddressSize) State->GeneralRegs[FAST486_REG_ESI].Long -= Processed * DataSize;
                else State->GeneralRegs[FAST486_REG_ESI].LowWord -= Processed * DataSize;
 
                /* Reverse the block data */
                for (i = 0; i < Processed / 2; i++)
                {
                    /* Swap the values */
                    for (j = 0; j < DataSize; j++)
                    {
                        UCHAR Temp = Block[i * DataSize + j];
                        Block[i * DataSize + j] = Block[(Processed - i - 1) * DataSize + j];
                        Block[(Processed - i - 1) * DataSize + j] = Temp;
                    }
                }
            }
 
            /* Write to the I/O port */
            State->IoWriteCallback(State,
                                   State->GeneralRegs[FAST486_REG_EDX].LowWord,
                                   Block,
                                   Processed,
                                   DataSize);
 
            if (!State->Flags.Df)
            {
                /* Increase ESI by the number of bytes transfered */
                if (AddressSize) State->GeneralRegs[FAST486_REG_ESI].Long += Processed * DataSize;
                else State->GeneralRegs[FAST486_REG_ESI].LowWord += Processed * DataSize;
            }
 
            /* Reduce the total count by the number processed in this run */
            Count -= Processed;
        }
 
        /* Clear ECX */
        if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0;
        else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0;
    }
    else
    {
        ULONG Data = 0;
 
        /* Read from the source operand */
        if (!Fast486ReadMemory(State,
                               (State->PrefixFlags & FAST486_PREFIX_SEG)
                               ? State->SegmentOverride : FAST486_REG_DS,
                               AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long
                                           : State->GeneralRegs[FAST486_REG_ESI].LowWord,
                               FALSE,
                               &Data,
                               DataSize))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write to the I/O port */
        State->IoWriteCallback(State,
                               State->GeneralRegs[FAST486_REG_EDX].LowWord,
                               &Data,
                               1,
                               DataSize);
 
        /* Increment/decrement ESI */
        if (AddressSize)
        {
            if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].Long += DataSize;
            else State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize;
        }
        else
        {
            if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize;
            else State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize;
        }
    }
}

FAST486_OPCODE_HANDLER() [74/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePopAll

)

Definition at line 3241 of file opcodes.c.

{
    INT i;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    ULONG Value;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x61);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Pop all the registers in reverse order */
    for (i = FAST486_NUM_GEN_REGS - 1; i >= 0; i--)
    {
        /* Pop the value */
        if (!Fast486StackPop(State, &Value))
        {
            /* Exception occurred */
            return;
        }
 
        /* Don't modify ESP */
        if (i != FAST486_REG_ESP)
        {
            if (Size) State->GeneralRegs[i].Long = Value;
            else State->GeneralRegs[i].LowWord = LOWORD(Value);
        }
    }
}

FAST486_OPCODE_HANDLER() [75/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePopDs

)

Definition at line 2782 of file opcodes.c.

{
    ULONG NewSelector;
 
    if (!Fast486StackPop(State, &NewSelector))
    {
        /* Exception occurred */
        return;
    }
 
    /* Call the internal API */
    Fast486LoadSegment(State, FAST486_REG_DS, LOWORD(NewSelector));
}

FAST486_OPCODE_HANDLER() [76/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePopEs

)

Definition at line 2228 of file opcodes.c.

{
    ULONG NewSelector;
 
    if (!Fast486StackPop(State, &NewSelector))
    {
        /* Exception occurred */
        return;
    }
 
    /* Call the internal API */
    Fast486LoadSegment(State, FAST486_REG_ES, LOWORD(NewSelector));
}

FAST486_OPCODE_HANDLER() [77/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePopFlags

)

Definition at line 4009 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    UINT Cpl = Fast486GetCurrentPrivLevel(State);
    FAST486_FLAGS_REG NewFlags;
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    /* Pop the new flags */
    if (!Fast486StackPop(State, &NewFlags.Long))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check for VM86 mode when IOPL is not 3 */
    if (State->Flags.Vm && (State->Flags.Iopl != 3))
    {
        /* Call the VM86 monitor */
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0);
        return;
    }
 
    State->Flags.Cf = NewFlags.Cf;
    State->Flags.Pf = NewFlags.Pf;
    State->Flags.Af = NewFlags.Af;
    State->Flags.Zf = NewFlags.Zf;
    State->Flags.Sf = NewFlags.Sf;
    State->Flags.Tf = NewFlags.Tf;
    State->Flags.Df = NewFlags.Df;
    State->Flags.Of = NewFlags.Of;
    State->Flags.Nt = NewFlags.Nt;
    State->Flags.Ac = NewFlags.Ac;
 
    if (Cpl == 0) State->Flags.Iopl = NewFlags.Iopl;
    if (Cpl <= State->Flags.Iopl) State->Flags.If = NewFlags.If;
}

FAST486_OPCODE_HANDLER() [78/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePopReg

)

Definition at line 484 of file opcodes.c.

{
    ULONG Value;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0x58);
 
    /* Call the internal function */
    if (!Fast486StackPop(State, &Value)) return;
 
    /* Store the value */
    if (Size) State->GeneralRegs[Opcode & 0x07].Long = Value;
    else State->GeneralRegs[Opcode & 0x07].LowWord = Value;
}

FAST486_OPCODE_HANDLER() [79/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePopSs

)

Definition at line 2506 of file opcodes.c.

{
    ULONG NewSelector;
 
    if (!Fast486StackPop(State, &NewSelector))
    {
        /* Exception occurred */
        return;
    }
 
    /* Call the internal API */
    if (Fast486LoadSegment(State, FAST486_REG_SS, LOWORD(NewSelector)))
    {
        /* Inhibit all interrupts until the next instruction */
        State->DoNotInterrupt = TRUE;
    }
}

FAST486_OPCODE_HANDLER() [80/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePrefix

)

Definition at line 312 of file opcodes.c.

{
    switch (Opcode)
    {
        /* ES: */
        case 0x26:
        {
            State->PrefixFlags |= FAST486_PREFIX_SEG;
            State->SegmentOverride = FAST486_REG_ES;
            break;
        }
 
        /* CS: */
        case 0x2E:
        {
            State->PrefixFlags |= FAST486_PREFIX_SEG;
            State->SegmentOverride = FAST486_REG_CS;
            break;
        }
 
        /* SS: */
        case 0x36:
        {
            State->PrefixFlags |= FAST486_PREFIX_SEG;
            State->SegmentOverride = FAST486_REG_SS;
            break;
        }
 
        /* DS: */
        case 0x3E:
        {
            State->PrefixFlags |= FAST486_PREFIX_SEG;
            State->SegmentOverride = FAST486_REG_DS;
            break;
        }
 
        /* FS: */
        case 0x64:
        {
            State->PrefixFlags |= FAST486_PREFIX_SEG;
            State->SegmentOverride = FAST486_REG_FS;
            break;
        }
 
        /* GS: */
        case 0x65:
        {
            State->PrefixFlags |= FAST486_PREFIX_SEG;
            State->SegmentOverride = FAST486_REG_GS;
            break;
        }
 
        /* OPSIZE */
        case 0x66:
        {
            State->PrefixFlags |= FAST486_PREFIX_OPSIZE;
            break;
        }
 
        /* ADSIZE */
        case 0x67:
        {
            State->PrefixFlags |= FAST486_PREFIX_ADSIZE;
            break;
        }
 
        /* LOCK */
        case 0xF0:
        {
            State->PrefixFlags |= FAST486_PREFIX_LOCK;
            break;
        }
 
        /* REPNZ */
        case 0xF2:
        {
            /* Mutually exclusive with REP */
            State->PrefixFlags |= FAST486_PREFIX_REPNZ;
            State->PrefixFlags &= ~FAST486_PREFIX_REP;
            break;
        }
 
        /* REP / REPZ */
        case 0xF3:
        {
            /* Mutually exclusive with REPNZ */
            State->PrefixFlags |= FAST486_PREFIX_REP;
            State->PrefixFlags &= ~FAST486_PREFIX_REPNZ;
            break;
        }
 
        default:
        {
            /* Shouldn't happen */
            ASSERT(FALSE);
        }
    }
}

FAST486_OPCODE_HANDLER() [81/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushAll

)

Definition at line 3204 of file opcodes.c.

{
    INT i;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    FAST486_REG SavedEsp = State->GeneralRegs[FAST486_REG_ESP];
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x60);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    /* Push all the registers in order */
    for (i = 0; i < FAST486_NUM_GEN_REGS; i++)
    {
        if (i == FAST486_REG_ESP)
        {
            /* Use the saved ESP instead */
            if (!Fast486StackPush(State, Size ? SavedEsp.Long : SavedEsp.LowWord))
            {
                /* Exception occurred */
                return;
            }
        }
        else
        {
            /* Push the register */
            if (!Fast486StackPush(State, Size ? State->GeneralRegs[i].Long
                                              : State->GeneralRegs[i].LowWord))
            {
                /* Exception occurred */
                return;
            }
        }
    }
}

FAST486_OPCODE_HANDLER() [82/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushByteImm

)

Definition at line 3582 of file opcodes.c.

{
    CHAR Data;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x6A);
 
    if (!Fast486FetchByte(State, (PUCHAR)&Data))
    {
        /* Exception occurred */
        return;
    }
 
    /* Call the internal API */
    Fast486StackPush(State, Data);
}

FAST486_OPCODE_HANDLER() [83/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushCs

)

Definition at line 2242 of file opcodes.c.

{
    /* Call the internal API */
    Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector);
}

FAST486_OPCODE_HANDLER() [84/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushDs

)

Definition at line 2776 of file opcodes.c.

{
    /* Call the internal API */
    Fast486StackPush(State, State->SegmentRegs[FAST486_REG_DS].Selector);
}

FAST486_OPCODE_HANDLER() [85/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushEs

)

Definition at line 2222 of file opcodes.c.

{
    /* Call the internal API */
    Fast486StackPush(State, State->SegmentRegs[FAST486_REG_ES].Selector);
}

FAST486_OPCODE_HANDLER() [86/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushFlags

)

Definition at line 3989 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    /* Check for VM86 mode when IOPL is not 3 */
    if (State->Flags.Vm && (State->Flags.Iopl != 3))
    {
        /* Call the VM86 monitor */
        Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0);
        return;
    }
 
    /* Push the flags */
    if (Size) Fast486StackPush(State, State->Flags.Long);
    else Fast486StackPush(State, LOWORD(State->Flags.Long));
}

FAST486_OPCODE_HANDLER() [87/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushImm

)

Definition at line 3422 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x68);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG Data;
 
        if (!Fast486FetchDword(State, &Data))
        {
            /* Exception occurred */
            return;
        }
 
        /* Call the internal API */
        Fast486StackPush(State, Data);
    }
    else
    {
        SHORT Data;
 
        if (!Fast486FetchWord(State, (PUSHORT)&Data))
        {
            /* Exception occurred */
            return;
        }
 
        /* Call the internal API */
        Fast486StackPush(State, Data);
    }
}

FAST486_OPCODE_HANDLER() [88/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushReg

)

Definition at line 473 of file opcodes.c.

{
    NO_LOCK_PREFIX();
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF8) == 0x50);
 
    /* Call the internal function */
    Fast486StackPush(State, State->GeneralRegs[Opcode & 0x07].Long);
}

FAST486_OPCODE_HANDLER() [89/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodePushSs

)

Definition at line 2500 of file opcodes.c.

{
    /* Call the internal API */
    Fast486StackPush(State, State->SegmentRegs[FAST486_REG_SS].Selector);
}

FAST486_OPCODE_HANDLER() [90/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeRet

)

Definition at line 4071 of file opcodes.c.

{
    ULONG ReturnAddress;
    USHORT BytesToPop = 0;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xC2);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Opcode == 0xC2)
    {
        /* Fetch the number of bytes to pop after the return */
        if (!Fast486FetchWord(State, &BytesToPop)) return;
    }
 
    /* Pop the return address */
    if (!Fast486StackPop(State, &ReturnAddress)) return;
 
    /* Return to the calling procedure, and if necessary, pop the parameters */
    if (Size)
    {
        State->InstPtr.Long = ReturnAddress;
        State->GeneralRegs[FAST486_REG_ESP].Long += BytesToPop;
    }
    else
    {
        State->InstPtr.LowWord = LOWORD(ReturnAddress);
        State->GeneralRegs[FAST486_REG_ESP].LowWord += BytesToPop;
    }
}

FAST486_OPCODE_HANDLER() [91/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeRetFar

)

Definition at line 4307 of file opcodes.c.

{
    ULONG Segment = 0;
    ULONG Offset = 0;
    USHORT BytesToPop = 0;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    ULONG StackPtr;
    ULONG StackSel;
    UCHAR OldCpl = Fast486GetCurrentPrivLevel(State);
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xCA);
 
    TOGGLE_OPSIZE(Size);
    NO_LOCK_PREFIX();
 
    if (Opcode == 0xCA)
    {
        /* Fetch the number of bytes to pop after the return */
        if (!Fast486FetchWord(State, &BytesToPop)) return;
    }
 
    /* Pop the offset */
    if (!Fast486StackPop(State, &Offset))
    {
        /* Exception occurred */
        return;
    }
 
    /* Pop the segment */
    if (!Fast486StackPop(State, &Segment))
    {
        /* Exception occurred */
        return;
    }
 
    /* Pop the parameters */
    if (State->SegmentRegs[FAST486_REG_SS].Size)
    {
        State->GeneralRegs[FAST486_REG_ESP].Long += BytesToPop;
    }
    else
    {
        State->GeneralRegs[FAST486_REG_ESP].LowWord += BytesToPop;
    }
 
    if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm)
    {
        if (GET_SEGMENT_RPL(Segment) > OldCpl)
        {
            /* Pop ESP */
            if (!Fast486StackPop(State, &StackPtr))
            {
                /* Exception */
                return;
            }
 
            /* Pop SS */
            if (!Fast486StackPop(State, &StackSel))
            {
                /* Exception */
                return;
            }
        }
    }
 
    /* Load the new CS */
    if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment))
    {
        /* Exception occurred */
        return;
    }
 
    /* Load new (E)IP */
    if (Size) State->InstPtr.Long = Offset;
    else State->InstPtr.LowWord = LOWORD(Offset);
 
    if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm)
    {
        UINT i;
 
        /* Update the CPL */
        State->Cpl = GET_SEGMENT_RPL(Segment);
 
        if (State->Cpl > OldCpl)
        {
            /* Load new SS */
            if (!Fast486LoadSegment(State, FAST486_REG_SS, StackSel))
            {
                /* Exception */
                return;
            }
 
            /* Set ESP */
            if (Size) State->GeneralRegs[FAST486_REG_ESP].Long = StackPtr;
            else State->GeneralRegs[FAST486_REG_ESP].LowWord = LOWORD(StackPtr);
 
            /* Check segment security */
            for (i = 0; i < FAST486_NUM_SEG_REGS; i++)
            {
                /* Don't check CS or SS */
                if ((i == FAST486_REG_CS) || (i == FAST486_REG_SS)) continue;
 
                if ((State->Cpl > State->SegmentRegs[i].Dpl)
                    && (!State->SegmentRegs[i].Executable
                    || !State->SegmentRegs[i].DirConf))
                {
                    /* Load the NULL descriptor in the segment */
                    if (!Fast486LoadSegment(State, i, 0)) return;
                }
            }
        }
    }
}

FAST486_OPCODE_HANDLER() [92/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSahf

)

Definition at line 4048 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x9E);
 
    /* Set the low-order byte of FLAGS to AH */
    State->Flags.Long &= 0xFFFFFF00;
    State->Flags.Long |= State->GeneralRegs[FAST486_REG_EAX].HighByte;
 
    /* Restore the reserved bits of FLAGS */
    State->Flags.AlwaysSet = TRUE;
    State->Flags.Reserved0 = State->Flags.Reserved1 = FALSE;
}

FAST486_OPCODE_HANDLER() [93/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSalc

)

Definition at line 5243 of file opcodes.c.

{
    /*
     * See: http://www.rcollins.org/secrets/opcodes/SALC.html
     * for more information.
     */
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xD6);
 
    NO_LOCK_PREFIX();
 
    /* Set all the bits of AL to CF */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = State->Flags.Cf ? 0xFF : 0x00;
}

FAST486_OPCODE_HANDLER() [94/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSbbAl

)

Definition at line 2678 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
    INT Carry = State->Flags.Cf ? 1 : 0;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x1C);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue - SecondValue - Carry;
 
    /* Update the flags */
    State->Flags.Cf = Carry ? (FirstValue <= SecondValue) : (FirstValue < SecondValue);
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) != (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
}

FAST486_OPCODE_HANDLER() [95/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSbbByteModrm

)

Definition at line 2524 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
    INT Carry = State->Flags.Cf ? 1 : 0;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x18);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check if this is the instruction that writes to R/M */
    if (!(Opcode & FAST486_OPCODE_WRITE_REG))
    {
        /* Swap the order */
        SWAP(FirstValue, SecondValue);
    }
 
    /* Calculate the result */
    Result = FirstValue - SecondValue - Carry;
 
    /* Update the flags */
    State->Flags.Cf = Carry ? (FirstValue <= SecondValue) : (FirstValue < SecondValue);
    State->Flags.Of = ((FirstValue & SIGN_FLAG_BYTE) != (SecondValue & SIGN_FLAG_BYTE))
                      && ((FirstValue & SIGN_FLAG_BYTE) != (Result & SIGN_FLAG_BYTE));
    State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [96/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSbbEax

)

Definition at line 2711 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
    INT Carry = State->Flags.Cf ? 1 : 0;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x1D);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue - Carry;
 
        /* Update the flags */
        State->Flags.Cf = Carry ? (FirstValue <= SecondValue) : (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) != (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].Long = Result;
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue - Carry;
 
        /* Update the flags */
        State->Flags.Cf = Carry ? (FirstValue <= SecondValue) : (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) != (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        State->GeneralRegs[FAST486_REG_EAX].LowWord = Result;
    }
}

FAST486_OPCODE_HANDLER() [97/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSbbModrm

)

Definition at line 2578 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
    INT Carry = State->Flags.Cf ? 1 : 0;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x19);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                           &ModRegRm,
                                           &FirstValue,
                                           &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Check if this is the instruction that writes to R/M */
        if (!(Opcode & FAST486_OPCODE_WRITE_REG))
        {
            /* Swap the order */
            SWAP(FirstValue, SecondValue);
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue - Carry;
 
        /* Update the flags */
        State->Flags.Cf = Carry ? (FirstValue <= SecondValue) : (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_LONG) != (SecondValue & SIGN_FLAG_LONG))
                          && ((FirstValue & SIGN_FLAG_LONG) != (Result & SIGN_FLAG_LONG));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       Opcode & FAST486_OPCODE_WRITE_REG,
                                       Result);
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Check if this is the instruction that writes to R/M */
        if (!(Opcode & FAST486_OPCODE_WRITE_REG))
        {
            /* Swap the order */
            SWAP(FirstValue, SecondValue);
        }
 
        /* Calculate the result */
        Result = FirstValue - SecondValue - Carry;
 
        /* Update the flags */
        State->Flags.Cf = Carry ? (FirstValue <= SecondValue) : (FirstValue < SecondValue);
        State->Flags.Of = ((FirstValue & SIGN_FLAG_WORD) != (SecondValue & SIGN_FLAG_WORD))
                          && ((FirstValue & SIGN_FLAG_WORD) != (Result & SIGN_FLAG_WORD));
        State->Flags.Af = ((FirstValue ^ SecondValue ^ Result) & 0x10) != 0;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
 
        /* Write back the result */
        Fast486WriteModrmWordOperands(State,
                                      &ModRegRm,
                                      Opcode & FAST486_OPCODE_WRITE_REG,
                                      Result);
    }
}

FAST486_OPCODE_HANDLER() [98/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeScas

)

Definition at line 5722 of file opcodes.c.

{
    ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
    ULONG SecondValue = 0;
    ULONG Result;
    ULONG DataSize, DataMask, SignFlag;
    BOOLEAN OperandSize, AddressSize;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xAE);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    if ((State->PrefixFlags & FAST486_PREFIX_REP)
        || (State->PrefixFlags & FAST486_PREFIX_REPNZ))
    {
        if ((AddressSize && (State->GeneralRegs[FAST486_REG_ECX].Long == 0))
            || (!AddressSize && (State->GeneralRegs[FAST486_REG_ECX].LowWord == 0)))
        {
            /* Do nothing */
            return;
        }
    }
 
    /* Calculate the size */
    if (Opcode == 0xAE) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    /* Calculate the mask and sign flag */
    SignFlag = 1 << ((DataSize * 8) - 1);
    DataMask = SignFlag | (SignFlag - 1);
 
    /* Read from the source operand */
    if (!Fast486ReadMemory(State,
                           FAST486_REG_ES,
                           AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                       : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                           FALSE,
                           &SecondValue,
                           DataSize))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    FirstValue &= DataMask;
    SecondValue &= DataMask;
    Result = (FirstValue - SecondValue) & DataMask;
 
    /* Update the flags */
    State->Flags.Cf = (FirstValue < SecondValue);
    State->Flags.Of = ((FirstValue & SignFlag) != (SecondValue & SignFlag))
                      && ((FirstValue & SignFlag) != (Result & SignFlag));
    State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F);
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SignFlag) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Increment/decrement EDI */
    if (AddressSize)
    {
        if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].Long += DataSize;
        else State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize;
    }
    else
    {
        if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize;
        else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize;
    }
 
    // FIXME: This method is slow!
    if ((State->PrefixFlags & FAST486_PREFIX_REP)
        || (State->PrefixFlags & FAST486_PREFIX_REPNZ))
    {
        BOOLEAN Repeat = TRUE;
 
        if (AddressSize)
        {
            if ((--State->GeneralRegs[FAST486_REG_ECX].Long) == 0)
            {
                /* ECX is 0 */
                Repeat = FALSE;
            }
        }
        else
        {
            if ((--State->GeneralRegs[FAST486_REG_ECX].LowWord) == 0)
            {
                /* CX is 0 */
                Repeat = FALSE;
            }
        }
 
        if (((State->PrefixFlags & FAST486_PREFIX_REP) && !State->Flags.Zf)
            || ((State->PrefixFlags & FAST486_PREFIX_REPNZ) && State->Flags.Zf))
        {
            /* REPZ with ZF = 0 or REPNZ with ZF = 1 */
            Repeat = FALSE;
        }
 
        if (Repeat)
        {
            /* Repeat the instruction */
            State->InstPtr = State->SavedInstPtr;
        }
    }
}

FAST486_OPCODE_HANDLER() [99/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSetCarry

)

Definition at line 644 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xF9);
 
    NO_LOCK_PREFIX();
 
    /* Set CF and return success*/
    State->Flags.Cf = TRUE;
}

FAST486_OPCODE_HANDLER() [100/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSetDir

)

Definition at line 738 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xFD);
 
    NO_LOCK_PREFIX();
 
    /* Set DF */
    State->Flags.Df = TRUE;
}

FAST486_OPCODE_HANDLER() [101/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeSetInt

)

Definition at line 697 of file opcodes.c.

{
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xFB);
 
    NO_LOCK_PREFIX();
 
    /* Check for protected mode */
    if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)
    {
        /* Check IOPL */
        if (State->Flags.Iopl >= Fast486GetCurrentPrivLevel(State))
        {
            /* Set the interrupt flag */
            State->Flags.If = TRUE;
        }
        else
        {
            /* General Protection Fault */
            Fast486Exception(State, FAST486_EXCEPTION_GP);
            return;
        }
    }
    else
    {
        /* Just set the interrupt flag */
        State->Flags.If = TRUE;
    }
}

FAST486_OPCODE_HANDLER() [102/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeShortConditionalJmp

)

Definition at line 537 of file opcodes.c.

{
    BOOLEAN Jump = FALSE;
    CHAR Offset = 0;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xF0) == 0x70);
 
    TOGGLE_OPSIZE(Size);
 
    /* Fetch the offset */
    if (!Fast486FetchByte(State, (PUCHAR)&Offset))
    {
        /* An exception occurred */
        return;
    }
 
    switch ((Opcode & 0x0F) >> 1)
    {
        /* JO / JNO */
        case 0:
        {
            Jump = State->Flags.Of;
            break;
        }
 
        /* JC / JNC */
        case 1:
        {
            Jump = State->Flags.Cf;
            break;
        }
 
        /* JZ / JNZ */
        case 2:
        {
            Jump = State->Flags.Zf;
            break;
        }
 
        /* JBE / JNBE */
        case 3:
        {
            Jump = State->Flags.Cf || State->Flags.Zf;
            break;
        }
 
        /* JS / JNS */
        case 4:
        {
            Jump = State->Flags.Sf;
            break;
        }
 
        /* JP / JNP */
        case 5:
        {
            Jump = State->Flags.Pf;
            break;
        }
 
        /* JL / JNL */
        case 6:
        {
            Jump = State->Flags.Sf != State->Flags.Of;
            break;
        }
 
        /* JLE / JNLE */
        case 7:
        {
            Jump = (State->Flags.Sf != State->Flags.Of) || State->Flags.Zf;
            break;
        }
    }
 
    if (Opcode & 1)
    {
        /* Invert the result */
        Jump = !Jump;
    }
 
    if (Jump)
    {
        /* Move the instruction pointer */
        State->InstPtr.Long += Offset;
 
        if (!Size)
        {
            /* Clear the top half of EIP */
            State->InstPtr.Long &= 0xFFFF;
        }
    }
}

FAST486_OPCODE_HANDLER() [103/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeShortJump

)

Definition at line 943 of file opcodes.c.

{
    CHAR Offset = 0;
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_OPSIZE(Size);
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xEB);
 
    /* Fetch the offset */
    if (!Fast486FetchByte(State, (PUCHAR)&Offset))
    {
        /* An exception occurred */
        return;
    }
 
    /* Move the instruction pointer */
    State->InstPtr.Long += Offset;
 
    if (!Size)
    {
        /* Clear the top half of EIP */
        State->InstPtr.Long &= 0xFFFF;
    }
}

FAST486_OPCODE_HANDLER() [104/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeStos

)

Definition at line 5514 of file opcodes.c.

{
    ULONG DataSize;
    BOOLEAN OperandSize, AddressSize;
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFE) == 0xAA);
 
    TOGGLE_OPSIZE(OperandSize);
    TOGGLE_ADSIZE(AddressSize);
 
    /* Calculate the size */
    if (Opcode == 0xAA) DataSize = sizeof(UCHAR);
    else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT);
 
    if (State->PrefixFlags & (FAST486_PREFIX_REP | FAST486_PREFIX_REPNZ))
    {
        UCHAR Block[STRING_BLOCK_SIZE];
        ULONG Count = AddressSize ? State->GeneralRegs[FAST486_REG_ECX].Long
                                  : State->GeneralRegs[FAST486_REG_ECX].LowWord;
 
        /* Fill the memory block with the data */
        if (DataSize == sizeof(UCHAR))
        {
            RtlFillMemory(Block, sizeof(Block), State->GeneralRegs[FAST486_REG_EAX].LowByte);
        }
        else
        {
            ULONG i;
 
            for (i = 0; i < STRING_BLOCK_SIZE / DataSize; i++)
            {
                if (DataSize == sizeof(USHORT))
                {
                    ((PUSHORT)Block)[i] = State->GeneralRegs[FAST486_REG_EAX].LowWord;
                }
                else
                {
                    ((PULONG)Block)[i] = State->GeneralRegs[FAST486_REG_EAX].Long;
                }
            }
        }
 
        /* Transfer until finished */
        while (Count)
        {
            ULONG Processed = min(Count, STRING_BLOCK_SIZE / DataSize);
 
            /* Simulate the 16-bit wrap-around of DI in 16-bit address mode */
            if (!AddressSize)
            {
                ULONG MaxBytes = State->Flags.Df
                                 ? (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord
                                 : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord);
 
                Processed = min(Processed, MaxBytes / DataSize);
                if (Processed == 0) Processed = 1;
            }
 
            if (State->Flags.Df)
            {
                /* Set EDI to the starting location */
                if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long -= (Processed - 1) * DataSize;
                else State->GeneralRegs[FAST486_REG_EDI].LowWord -= (Processed - 1) * DataSize;
            }
 
            /* Write to memory */
            if (!Fast486WriteMemory(State,
                                    FAST486_REG_ES,
                                    AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                                : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                                    Block,
                                    Processed * DataSize))
            {
                /* Set ECX */
                if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count;
                else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count);
 
                /* Exception occurred */
                return;
            }
 
            if (!State->Flags.Df)
            {
                /* Increase EDI by the number of bytes transfered */
                if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long += Processed * DataSize;
                else State->GeneralRegs[FAST486_REG_EDI].LowWord += Processed * DataSize;
            }
            else
            {
                /* Reduce EDI */
                if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize;
                else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize;
            }
 
            /* Reduce the total count by the number processed in this run */
            Count -= Processed;
        }
 
        /* Clear ECX */
        if (AddressSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0;
        else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0;
    }
    else
    {
        /* Write to the destination operand */
        if (!Fast486WriteMemory(State,
                                FAST486_REG_ES,
                                AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long
                                            : State->GeneralRegs[FAST486_REG_EDI].LowWord,
                                &State->GeneralRegs[FAST486_REG_EAX].Long,
                                DataSize))
        {
            /* Exception occurred */
            return;
        }
 
        /* Increment/decrement EDI */
        if (AddressSize)
        {
            if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].Long += DataSize;
            else State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize;
        }
        else
        {
            if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize;
            else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize;
        }
    }
}

FAST486_OPCODE_HANDLER() [105/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeTestAl

)

Definition at line 2016 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xA8);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue & SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
}

FAST486_OPCODE_HANDLER() [106/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeTestByteModrm

)

Definition at line 1910 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x84);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
    /* Calculate the result */
    Result = FirstValue & SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
}

FAST486_OPCODE_HANDLER() [107/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeTestEax

)

Definition at line 2043 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0xA9);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
    }
    else
    {
        USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord;
        USHORT SecondValue, Result;
 
        if (!Fast486FetchWord(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
    }
}

FAST486_OPCODE_HANDLER() [108/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeTestModrm

)

Definition at line 1947 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x85);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_LONG) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
    }
    else
    {
        USHORT FirstValue, SecondValue, Result;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue & SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State->Flags.Zf = (Result == 0);
        State->Flags.Sf = ((Result & SIGN_FLAG_WORD) != 0);
        State->Flags.Pf = Fast486CalculateParity(Result);
    }
}

FAST486_OPCODE_HANDLER() [109/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeWait

)

Definition at line 3982 of file opcodes.c.

{
#ifndef FAST486_NO_FPU
    Fast486FpuExceptionCheck(State);
#endif
}

FAST486_OPCODE_HANDLER() [110/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeXchgByteModrm

)

Definition at line 2097 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x86);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Write the value from the register to the R/M */
    if (!Fast486WriteModrmByteOperands(State,
                                       &ModRegRm,
                                       FALSE,
                                       FirstValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Write the value from the R/M to the register */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  TRUE,
                                  SecondValue);
}

FAST486_OPCODE_HANDLER() [111/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeXchgModrm

)

Definition at line 2141 of file opcodes.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x87);
 
    OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
    TOGGLE_OPSIZE(OperandSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    /* Check the operand size */
    if (OperandSize)
    {
        ULONG FirstValue, SecondValue;
 
        if (!Fast486ReadModrmDwordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write the value from the register to the R/M */
        if (!Fast486WriteModrmDwordOperands(State,
                                            &ModRegRm,
                                            FALSE,
                                            FirstValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write the value from the R/M to the register */
        Fast486WriteModrmDwordOperands(State,
                                       &ModRegRm,
                                       TRUE,
                                       SecondValue);
    }
    else
    {
        USHORT FirstValue, SecondValue;
 
        if (!Fast486ReadModrmWordOperands(State,
                                          &ModRegRm,
                                          &FirstValue,
                                          &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write the value from the register to the R/M */
        if (!Fast486WriteModrmWordOperands(State,
                                           &ModRegRm,
                                           FALSE,
                                           FirstValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Write the value from the R/M to the register */
        Fast486WriteModrmWordOperands(State,
                                      &ModRegRm,
                                      TRUE,
                                      SecondValue);
    }
}

FAST486_OPCODE_HANDLER() [112/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeXlat

)

Definition at line 4759 of file opcodes.c.

{
    UCHAR Value;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Read a byte from DS:[(E)BX + AL] */
    if (!Fast486ReadMemory(State,
                           (State->PrefixFlags & FAST486_PREFIX_SEG)
                           ? State->SegmentOverride : FAST486_REG_DS,
                           (AddressSize ? State->GeneralRegs[FAST486_REG_EBX].Long
                                        : State->GeneralRegs[FAST486_REG_EBX].LowWord)
                           + State->GeneralRegs[FAST486_REG_EAX].LowByte,
                           FALSE,
                           &Value,
                           sizeof(UCHAR)))
    {
        /* Exception occurred */
        return;
    }
 
    /* Set AL to the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Value;
}

FAST486_OPCODE_HANDLER() [113/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeXorAl

)

Definition at line 1820 of file opcodes.c.

{
    UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte;
    UCHAR SecondValue, Result;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x34);
 
    NO_LOCK_PREFIX();
 
    if (!Fast486FetchByte(State, &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue ^ SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    State->GeneralRegs[FAST486_REG_EAX].LowByte = Result;
}

FAST486_OPCODE_HANDLER() [114/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeXorByteModrm

)

Definition at line 1695 of file opcodes.c.

{
    UCHAR FirstValue, SecondValue, Result;
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT((Opcode & 0xFD) == 0x30);
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    if (!Fast486ReadModrmByteOperands(State,
                                      &ModRegRm,
                                      &FirstValue,
                                      &SecondValue))
    {
        /* Exception occurred */
        return;
    }
 
    /* Calculate the result */
    Result = FirstValue ^ SecondValue;
 
    /* Update the flags */
    State->Flags.Cf = FALSE;
    State->Flags.Of = FALSE;
    State->Flags.Zf = (Result == 0);
    State->Flags.Sf = ((Result & SIGN_FLAG_BYTE) != 0);
    State->Flags.Pf = Fast486CalculateParity(Result);
 
    /* Write back the result */
    Fast486WriteModrmByteOperands(State,
                                  &ModRegRm,
                                  Opcode & FAST486_OPCODE_WRITE_REG,
                                  Result);
}

FAST486_OPCODE_HANDLER() [115/116]

FAST486_OPCODE_HANDLER

(

Fast486OpcodeXorEax

)

Definition at line 1850 of file opcodes.c.

{
    BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size;
 
    /* Make sure this is the right instruction */
    ASSERT(Opcode == 0x35);
 
    NO_LOCK_PREFIX();
    TOGGLE_OPSIZE(Size);
 
    if (Size)
    {
        ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long;
        ULONG SecondValue, Result;
 
        if (!Fast486FetchDword(State, &SecondValue))
        {
            /* Exception occurred */
            return;
        }
 
        /* Calculate the result */
        Result = FirstValue ^ SecondValue;
 
        /* Update the flags */
        State->Flags.Cf = FALSE;
        State->Flags.Of = FALSE;
        State-&