fpu.h File Reference

#include "opcodes.h"

Include dependency graph for fpu.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FPU_CHECK()
#define	FPU_INDEX(i)   ((State->FpuStatus.Top + (i)) % FAST486_NUM_FPU_REGS)
#define	FPU_ST(i)   State->FpuRegisters[FPU_INDEX(i)]
#define	FPU_GET_TAG(i)   ((State->FpuTag >> (FPU_INDEX(i) * 2)) & 3)
#define	FPU_SET_TAG(i, t)
#define	FPU_UPDATE_TAG(i)   FPU_SET_TAG((i), Fast486FpuGetValueTag(&FPU_ST(i)))
#define	FPU_SAVE_LAST_INST()
#define	FPU_SAVE_LAST_OPERAND()
#define	FPU_REAL4_BIAS   0x7F
#define	FPU_REAL8_BIAS   0x3FF
#define	FPU_REAL10_BIAS   0x3FFF
#define	FPU_MAX_EXPONENT   0x7FFE
#define	FPU_MANTISSA_HIGH_BIT   0x8000000000000000ULL
#define	FPU_INDEFINITE_MANTISSA   0xC000000000000000ULL
#define	FPU_REAL4_INFINITY   0x7F800000
#define	FPU_REAL4_INDEFINITE   0xFFC00000
#define	FPU_REAL8_INFINITY   0x7FF0000000000000ULL
#define	FPU_REAL8_INDEFINITE   0xFFF8000000000000ULL
#define	FPU_IS_NORMALIZED(x)   (FPU_IS_ZERO(x) || (((x)->Mantissa & FPU_MANTISSA_HIGH_BIT) != 0ULL))
#define	FPU_IS_ZERO(x)   ((x)->Mantissa == 0ULL)
#define	FPU_IS_NAN(x)   ((x)->Exponent == (FPU_MAX_EXPONENT + 1))
#define	FPU_IS_INFINITY(x)   (FPU_IS_NAN(x) && ((x)->Mantissa == FPU_MANTISSA_HIGH_BIT))
#define	FPU_IS_POS_INF(x)   (FPU_IS_INFINITY(x) && !(x)->Sign)
#define	FPU_IS_NEG_INF(x)   (FPU_IS_INFINITY(x) && (x)->Sign)
#define	FPU_IS_INDEFINITE(x)   (FPU_IS_NAN(x) && !FPU_IS_INFINITY(x))
#define	INVERSE_NUMBERS_COUNT   50

Enumerations
enum	{ FPU_SINGLE_PRECISION = 0 , FPU_DOUBLE_PRECISION = 2 , FPU_DOUBLE_EXT_PRECISION = 3 }
enum	{ FPU_TAG_VALID = 0 , FPU_TAG_ZERO = 1 , FPU_TAG_SPECIAL = 2 , FPU_TAG_EMPTY = 3 }
enum	{ FPU_ROUND_NEAREST = 0 , FPU_ROUND_DOWN = 1 , FPU_ROUND_UP = 2 , FPU_ROUND_TRUNCATE = 3 }

Functions
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeD8)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeD9)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeDA)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeDB)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeDC)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeDD)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeDE)
	FAST486_OPCODE_HANDLER (Fast486FpuOpcodeDF)

Macro Definition Documentation

FPU_CHECK

#define FPU_CHECK

(

)

Value:

                    if (State->ControlRegisters[FAST486_REG_CR0] & (FAST486_CR0_EM | FAST486_CR0_TS)) \
                    { \
                        Fast486Exception(State, FAST486_EXCEPTION_NM); \
                        return; \
                    }

Definition at line 31 of file fpu.h.

FPU_GET_TAG

#define FPU_GET_TAG

(

i

)

((State->FpuTag >> (FPU_INDEX(i) * 2)) & 3)

Definition at line 39 of file fpu.h.

FPU_INDEFINITE_MANTISSA

#define FPU_INDEFINITE_MANTISSA   0xC000000000000000ULL

Definition at line 60 of file fpu.h.

FPU_INDEX

#define FPU_INDEX

(

i

)

((State->FpuStatus.Top + (i)) % FAST486_NUM_FPU_REGS)

Definition at line 36 of file fpu.h.

FPU_IS_INDEFINITE

#define FPU_IS_INDEFINITE

(

x

)

(FPU_IS_NAN(x) && !FPU_IS_INFINITY(x))

Definition at line 72 of file fpu.h.

FPU_IS_INFINITY

#define FPU_IS_INFINITY

(

x

)

(FPU_IS_NAN(x) && ((x)->Mantissa == FPU_MANTISSA_HIGH_BIT))

Definition at line 69 of file fpu.h.

FPU_IS_NAN

#define FPU_IS_NAN

(

x

)

((x)->Exponent == (FPU_MAX_EXPONENT + 1))

Definition at line 68 of file fpu.h.

FPU_IS_NEG_INF

#define FPU_IS_NEG_INF

(

x

)

(FPU_IS_INFINITY(x) && (x)->Sign)

Definition at line 71 of file fpu.h.

FPU_IS_NORMALIZED

#define FPU_IS_NORMALIZED

(

x

)

(FPU_IS_ZERO(x) || (((x)->Mantissa & FPU_MANTISSA_HIGH_BIT) != 0ULL))

Definition at line 66 of file fpu.h.

FPU_IS_POS_INF

#define FPU_IS_POS_INF

(

x

)

(FPU_IS_INFINITY(x) && !(x)->Sign)

Definition at line 70 of file fpu.h.

FPU_IS_ZERO

#define FPU_IS_ZERO

(

x

)

((x)->Mantissa == 0ULL)

Definition at line 67 of file fpu.h.

FPU_MANTISSA_HIGH_BIT

#define FPU_MANTISSA_HIGH_BIT   0x8000000000000000ULL

Definition at line 59 of file fpu.h.

FPU_MAX_EXPONENT

#define FPU_MAX_EXPONENT   0x7FFE

Definition at line 58 of file fpu.h.

FPU_REAL10_BIAS

#define FPU_REAL10_BIAS   0x3FFF

Definition at line 57 of file fpu.h.

FPU_REAL4_BIAS

#define FPU_REAL4_BIAS   0x7F

Definition at line 55 of file fpu.h.

FPU_REAL4_INDEFINITE

#define FPU_REAL4_INDEFINITE   0xFFC00000

Definition at line 62 of file fpu.h.

FPU_REAL4_INFINITY

#define FPU_REAL4_INFINITY   0x7F800000

Definition at line 61 of file fpu.h.

FPU_REAL8_BIAS

#define FPU_REAL8_BIAS   0x3FF

Definition at line 56 of file fpu.h.

FPU_REAL8_INDEFINITE

#define FPU_REAL8_INDEFINITE   0xFFF8000000000000ULL

Definition at line 64 of file fpu.h.

FPU_REAL8_INFINITY

#define FPU_REAL8_INFINITY   0x7FF0000000000000ULL

Definition at line 63 of file fpu.h.

FPU_SAVE_LAST_INST

#define FPU_SAVE_LAST_INST

(

)

Value:

                                    { \
                                    State->FpuLastInstPtr = State->SavedInstPtr; \
                                    State->FpuLastCodeSel = State->SegmentRegs[FAST486_REG_CS].Selector; \
                                }

Definition at line 45 of file fpu.h.

FPU_SAVE_LAST_OPERAND

#define FPU_SAVE_LAST_OPERAND

(

)

Value:

                                    { \
                                    State->FpuLastOpPtr.Long = ModRegRm.MemoryAddress; \
                                    State->FpuLastDataSel = (State->PrefixFlags & FAST486_PREFIX_SEG) \
                                                            ? State->SegmentOverride : FAST486_REG_DS; \
                                }

Definition at line 49 of file fpu.h.

FPU_SET_TAG

#define FPU_SET_TAG	(		i,
			t
	)

Value:

                                { \
                                State->FpuTag &= ~((1 << (FPU_INDEX(i) * 2)) | (1 << ((FPU_INDEX(i) * 2) + 1))); \
                                State->FpuTag |= ((t) & 3) << (FPU_INDEX(i) * 2); \
                            }

Definition at line 40 of file fpu.h.

FPU_ST

#define FPU_ST

(

i

)

State->FpuRegisters[FPU_INDEX(i)]

Definition at line 37 of file fpu.h.

FPU_UPDATE_TAG

#define FPU_UPDATE_TAG

(

i

)

FPU_SET_TAG((i), Fast486FpuGetValueTag(&FPU_ST(i)))

Definition at line 44 of file fpu.h.

INVERSE_NUMBERS_COUNT

#define INVERSE_NUMBERS_COUNT   50

Definition at line 74 of file fpu.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
FPU_SINGLE_PRECISION
FPU_DOUBLE_PRECISION
FPU_DOUBLE_EXT_PRECISION

Definition at line 76 of file fpu.h.

{
    FPU_SINGLE_PRECISION = 0,
    FPU_DOUBLE_PRECISION = 2,
    FPU_DOUBLE_EXT_PRECISION = 3
};

anonymous enum

anonymous enum

Enumerator
FPU_TAG_VALID
FPU_TAG_ZERO
FPU_TAG_SPECIAL
FPU_TAG_EMPTY

Definition at line 83 of file fpu.h.

{
    FPU_TAG_VALID = 0,
    FPU_TAG_ZERO = 1,
    FPU_TAG_SPECIAL = 2,
    FPU_TAG_EMPTY = 3
};

anonymous enum

anonymous enum

Enumerator
FPU_ROUND_NEAREST
FPU_ROUND_DOWN
FPU_ROUND_UP
FPU_ROUND_TRUNCATE

Definition at line 91 of file fpu.h.

{
    FPU_ROUND_NEAREST = 0,
    FPU_ROUND_DOWN = 1,
    FPU_ROUND_UP = 2,
    FPU_ROUND_TRUNCATE = 3
};

Function Documentation

FAST486_OPCODE_HANDLER() [1/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeD8

)

Definition at line 1808 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
#ifndef FAST486_NO_FPU
    PFAST486_FPU_DATA_REG Operand;
    FAST486_FPU_DATA_REG MemoryData;
#endif
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    Fast486FpuExceptionCheck(State);
    FPU_SAVE_LAST_INST();
 
    if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
    {
        /* Raise the invalid operation exception */
        State->FpuStatus.Ie = TRUE;
 
        if (State->FpuControl.Im)
        {
            /* Return the indefinite NaN */
            FPU_ST(0).Sign = TRUE;
            FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
            FPU_ST(0).Mantissa = FPU_INDEFINITE_MANTISSA;
 
            FPU_SET_TAG(0, FPU_TAG_SPECIAL);
        }
 
        return;
    }
 
    if (ModRegRm.Memory)
    {
        /* Load the source operand from memory */
        ULONG Value;
 
        if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, NULL, &Value))
        {
            /* Exception occurred */
            return;
        }
 
        Fast486FpuFromSingleReal(State, Value, &MemoryData);
        Operand = &MemoryData;
 
        FPU_SAVE_LAST_OPERAND();
    }
    else
    {
        if (FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY)
        {
            /* Raise the invalid operation exception */
            State->FpuStatus.Ie = TRUE;
 
            if (State->FpuControl.Im)
            {
                /* Return the indefinite NaN */
                FPU_ST(0).Sign = TRUE;
                FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
                FPU_ST(0).Mantissa = FPU_INDEFINITE_MANTISSA;
 
                FPU_SET_TAG(0, FPU_TAG_SPECIAL);
            }
 
            return;
        }
 
        /* Load the source operand from an FPU register */
        Operand = &FPU_ST(ModRegRm.SecondRegister);
    }
 
    /* Perform the requested operation */
    Fast486FpuArithmeticOperation(State, ModRegRm.Register, Operand, TRUE);
 
#endif
}

FAST486_OPCODE_HANDLER() [2/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeD9

)

Definition at line 1897 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    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;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    if (ModRegRm.Memory)
    {
        switch (ModRegRm.Register)
        {
            /* FLD */
            case 0:
            {
                ULONG Value;
                FAST486_FPU_DATA_REG MemoryData;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
                FPU_SAVE_LAST_OPERAND();
 
                if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, NULL, &Value))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuFromSingleReal(State, Value, &MemoryData);
                Fast486FpuPush(State, &MemoryData);
 
                break;
            }
 
            /* FST */
            case 2:
            /* FSTP */
            case 3:
            {
                ULONG Value = FPU_REAL4_INDEFINITE;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
                FPU_SAVE_LAST_OPERAND();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
                else if (!Fast486FpuToSingleReal(State, &FPU_ST(0), &Value))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (!Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (ModRegRm.Register == 3) Fast486FpuPop(State);
                break;
            }
 
            /* FLDENV */
            case 4:
            {
                Fast486FpuLoadEnvironment(State,
                                          (State->PrefixFlags & FAST486_PREFIX_SEG)
                                          ? State->SegmentOverride : FAST486_REG_DS,
                                          ModRegRm.MemoryAddress,
                                          OperandSize);
                break;
            }
 
            /* FLDCW */
            case 5:
            {
                Fast486ReadModrmWordOperands(State, &ModRegRm, NULL, &State->FpuControl.Value);
                break;
            }
 
            /* FSTENV */
            case 6:
            {
                Fast486FpuSaveEnvironment(State,
                                          (State->PrefixFlags & FAST486_PREFIX_SEG)
                                          ? State->SegmentOverride : FAST486_REG_DS,
                                          ModRegRm.MemoryAddress,
                                          OperandSize);
                break;
            }
 
            /* FSTCW */
            case 7:
            {
                Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, State->FpuControl.Value);
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
                return;
            }
        }
    }
    else
    {
        switch ((ModRegRm.Register << 3) | ModRegRm.SecondRegister)
        {
            /* FLD */
            case 0x00:
            case 0x01:
            case 0x02:
            case 0x03:
            case 0x04:
            case 0x05:
            case 0x06:
            case 0x07:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY)
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
 
                Fast486FpuPush(State, &FPU_ST(ModRegRm.SecondRegister));
                break;
            }
 
            /* FXCH */
            case 0x08:
            case 0x09:
            case 0x0A:
            case 0x0B:
            case 0x0C:
            case 0x0D:
            case 0x0E:
            case 0x0F:
            {
                FAST486_FPU_DATA_REG Temp;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                    || FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                /* Exchange */
                Temp = FPU_ST(0);
                FPU_ST(0) = FPU_ST(ModRegRm.SecondRegister);
                FPU_ST(ModRegRm.SecondRegister) = Temp;
 
                FPU_UPDATE_TAG(0);
                FPU_UPDATE_TAG(ModRegRm.SecondRegister);
 
                break;
            }
 
            /* FNOP */
            case 0x10:
            {
                /* Do nothing */
                break;
            }
 
            /* FSTP */
            case 0x18:
            case 0x19:
            case 0x1A:
            case 0x1B:
            case 0x1C:
            case 0x1D:
            case 0x1E:
            case 0x1F:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                FPU_ST(ModRegRm.SecondRegister) = FPU_ST(0);
                FPU_UPDATE_TAG(ModRegRm.SecondRegister);
 
                Fast486FpuPop(State);
                break;
            }
 
            /* FCHS */
            case 0x20:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                /* Invert the sign */
                FPU_ST(0).Sign = !FPU_ST(0).Sign;
 
                break;
            }
 
            /* FABS */
            case 0x21:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                /* Set the sign to positive */
                FPU_ST(0).Sign = FALSE;
 
                break;
            }
 
            /* FTST */
            case 0x24:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                Fast486FpuCompare(State, &FPU_ST(0), &FpuZero);
                break;
            }
 
            /* FXAM */
            case 0x25:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                /* The sign bit goes in C1, even if the register's empty */
                State->FpuStatus.Code1 = FPU_ST(0).Sign;
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Code0 = 1;
                    State->FpuStatus.Code2 = 0;
                    State->FpuStatus.Code3 = 1;
                }
                else if (FPU_GET_TAG(0) == FPU_TAG_SPECIAL)
                {
                    if (FPU_IS_INFINITY(&FPU_ST(0)))
                    {
                        State->FpuStatus.Code0 = 1;
                        State->FpuStatus.Code2 = 1;
                        State->FpuStatus.Code3 = 0;
                    }
                    else
                    {
                        State->FpuStatus.Code0 = 1;
                        State->FpuStatus.Code2 = 0;
                        State->FpuStatus.Code3 = 0;
                    }
                }
                else if (FPU_GET_TAG(0) == FPU_TAG_ZERO)
                {
                    State->FpuStatus.Code0 = 0;
                    State->FpuStatus.Code2 = 0;
                    State->FpuStatus.Code3 = 1;
                }
                else
                {
                    if (FPU_IS_NORMALIZED(&FPU_ST(0)))
                    {
                        State->FpuStatus.Code0 = 0;
                        State->FpuStatus.Code2 = 1;
                        State->FpuStatus.Code3 = 0;
                    }
                    else
                    {
                        State->FpuStatus.Code0 = 0;
                        State->FpuStatus.Code2 = 1;
                        State->FpuStatus.Code3 = 1;
                    }
                }
 
                break;
            }
 
            /* FLD1 */
            case 0x28:
            /* FLDL2T */
            case 0x29:
            /* FLDL2E */
            case 0x2A:
            /* FLDPI */
            case 0x2B:
            /* FLDLG2 */
            case 0x2C:
            /* FLDLN2 */
            case 0x2D:
            /* FLDZ */
            case 0x2E:
            {
                PCFAST486_FPU_DATA_REG Constants[] =
                {
                    &FpuOne,
                    &FpuL2Ten,
                    &FpuL2E,
                    &FpuPi,
                    &FpuLgTwo,
                    &FpuLnTwo,
                    &FpuZero
                };
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                Fast486FpuPush(State, Constants[ModRegRm.SecondRegister]);
                break;
            }
 
            /* F2XM1 */
            case 0x30:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!FPU_IS_NORMALIZED(&FPU_ST(0)))
                {
                    State->FpuStatus.De = TRUE;
 
                    if (!State->FpuControl.Dm)
                    {
                        break;
                    }
                }
 
                Fast486FpuCalculateTwoPowerMinusOne(State, &FPU_ST(0), &FPU_ST(0));
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* FYL2X */
            case 0x31:
            {
                FAST486_FPU_DATA_REG Logarithm;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY || FPU_GET_TAG(1) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!Fast486FpuCalculateLogBase2(State, &FPU_ST(0), &Logarithm))
                {
                    /* Exception occurred */
                    break;
                }
 
                if (!Fast486FpuMultiply(State, &Logarithm, &FPU_ST(1), &FPU_ST(1)))
                {
                    /* Exception occurred */
                    break;
                }
 
                /* Pop the stack so that the result ends up in ST0 */
                Fast486FpuPop(State);
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* FPTAN */
            case 0x32:
            {
                FAST486_FPU_DATA_REG Sine;
                FAST486_FPU_DATA_REG Cosine;
                ULONGLONG Quadrant;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                /* Compute the sine */
                if (!Fast486FpuCalculateSine(State, &FPU_ST(0), &Sine)) break;
 
                /* Normalize the angle */
                if (!Fast486FpuRemainder(State,
                                         &FPU_ST(0),
                                         &FpuHalfPi,
                                         FALSE,
                                         NULL,
                                         (PLONGLONG)&Quadrant))
                {
                    break;
                }
 
                /* Normalize the quadrant number */
                Quadrant &= 3;
 
                /* Find the cosine by calculating sqrt(1 - sin(x) ^ 2) */
                if (!Fast486FpuMultiply(State, &Sine, &Sine, &Cosine)) break;
                if (!Fast486FpuSubtract(State, &FpuOne, &Cosine, &Cosine)) break;
                if (!Fast486FpuCalculateSquareRoot(State, &Cosine, &Cosine)) break;
 
                /* Adjust the sign of the cosine */
                if (Quadrant == 1 || Quadrant == 2) Cosine.Sign = TRUE;
 
                /* Divide the sine by the cosine to get the tangent */
                if (!Fast486FpuDivide(State, &Sine, &Cosine, &FPU_ST(0))) break;
                FPU_UPDATE_TAG(0);
 
                /* Push 1.00 */
                Fast486FpuPush(State, &FpuOne);
                break;
            }
 
            /* FPATAN */
            case 0x33:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (!Fast486FpuCalculateArcTangent(State,
                                                   &FPU_ST(1),
                                                   &FPU_ST(0),
                                                   &FPU_ST(1)))
                {
                    break;
                }
 
                FPU_UPDATE_TAG(1);
 
                Fast486FpuPop(State);
                break;
            }
 
            /* FXTRACT */
            case 0x34:
            {
                FAST486_FPU_DATA_REG Value = FPU_ST(0);
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY) || FPU_IS_INDEFINITE(&Value))
                {
                    State->FpuStatus.Ie = TRUE;
                    if (FPU_GET_TAG(0) == FPU_TAG_EMPTY) State->FpuStatus.Sf = TRUE;
                    break;
                }
 
                if (FPU_IS_ZERO(&Value))
                {
                    /* The exponent of zero is negative infinity */
                    FPU_ST(0).Sign = TRUE;
                    FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
                    FPU_ST(0).Mantissa = FPU_MANTISSA_HIGH_BIT;
                }
                else if (FPU_IS_INFINITY(&Value))
                {
                    /* The exponent of infinity is positive infinity */
                    FPU_ST(0).Sign = FALSE;
                    FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
                    FPU_ST(0).Mantissa = FPU_MANTISSA_HIGH_BIT;
                }
                else
                {
                    /* Store the unbiased exponent in ST0 */
                    Fast486FpuFromInteger(State,
                                          (LONGLONG)Value.Exponent - (LONGLONG)FPU_REAL10_BIAS,
                                          &FPU_ST(0));
                }
 
                /* Now push the mantissa as a real number, with the original sign */
                Value.Exponent = FPU_REAL10_BIAS;
                Fast486FpuPush(State, &Value);
 
                break;
            }
 
            /* FPREM1 */
            case 0x35:
            /* FPREM */
            case 0x38:
            {
                LONGLONG Quotient;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY || FPU_GET_TAG(1) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (Fast486FpuRemainder(State,
                                        &FPU_ST(0),
                                        &FPU_ST(1),
                                        ModRegRm.Register == 6, /* TRUE if it's FPREM1 */
                                        &FPU_ST(0),
                                        &Quotient))
                {
                    FPU_UPDATE_TAG(0);
 
                    /* Return the lowest 3 bits of the quotient in C1, C3, C0 */
                    State->FpuStatus.Code1 = Quotient & 1;
                    State->FpuStatus.Code3 = (Quotient >> 1) & 1;
                    State->FpuStatus.Code0 = (Quotient >> 2) & 1;
                }
 
                break;
            }
 
            /* FDECSTP */
            case 0x36:
            {
                State->FpuStatus.Top--;
                break;
            }
 
            /* FINCSTP */
            case 0x37:
            {
                State->FpuStatus.Top++;
                break;
            }
 
            /* FYL2XP1 */
            case 0x39:
            {
                FAST486_FPU_DATA_REG Value, Logarithm;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY || FPU_GET_TAG(1) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!Fast486FpuAdd(State, &FPU_ST(0), &FpuOne, &Value))
                {
                    /* Exception occurred */
                    break;
                }
 
                if (!Fast486FpuCalculateLogBase2(State, &Value, &Logarithm))
                {
                    /* Exception occurred */
                    break;
                }
 
                if (!Fast486FpuMultiply(State, &Logarithm, &FPU_ST(1), &FPU_ST(1)))
                {
                    /* Exception occurred */
                    break;
                }
 
                /* Pop the stack so that the result ends up in ST0 */
                Fast486FpuPop(State);
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* FSQRT */
            case 0x3A:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                Fast486FpuCalculateSquareRoot(State, &FPU_ST(0), &FPU_ST(0));
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* FSINCOS */
            case 0x3B:
            {
                FAST486_FPU_DATA_REG Number = FPU_ST(0);
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!FPU_IS_NORMALIZED(&FPU_ST(0)))
                {
                    State->FpuStatus.De = TRUE;
 
                    if (!State->FpuControl.Dm)
                    {
                        break;
                    }
                }
 
                /* Replace FP0 with the sine */
                if (!Fast486FpuCalculateSine(State, &Number, &FPU_ST(0))) break;
                FPU_UPDATE_TAG(0);
 
                /* Push the cosine */
                if (!Fast486FpuCalculateCosine(State, &Number, &Number)) break;
                Fast486FpuPush(State, &Number);
 
                break;
            }
 
            /* FRNDINT */
            case 0x3C:
            {
                LONGLONG Result = 0LL;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!FPU_IS_NORMALIZED(&FPU_ST(0)))
                {
                    State->FpuStatus.De = TRUE;
 
                    if (!State->FpuControl.Dm)
                    {
                        break;
                    }
                }
 
                /* Do nothing if it's too big to not be an integer */
                if (FPU_ST(0).Exponent >= FPU_REAL10_BIAS + 63) break;
 
                /* Perform the rounding */
                Fast486FpuToInteger(State, &FPU_ST(0), &Result);
                Fast486FpuFromInteger(State, Result, &FPU_ST(0));
 
                State->FpuStatus.Pe = TRUE;
                break;
            }
 
            /* FSCALE */
            case 0x3D:
            {
                LONGLONG Scale;
                LONGLONG UnbiasedExp = (LONGLONG)((SHORT)FPU_ST(0).Exponent) - FPU_REAL10_BIAS;
                INT OldRoundingMode = State->FpuControl.Rc;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY || FPU_GET_TAG(1) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!FPU_IS_NORMALIZED(&FPU_ST(0)))
                {
                    State->FpuStatus.De = TRUE;
 
                    if (!State->FpuControl.Dm)
                    {
                        break;
                    }
                }
 
                State->FpuControl.Rc = FPU_ROUND_TRUNCATE;
 
                if (!Fast486FpuToInteger(State, &FPU_ST(1), &Scale))
                {
                    /* Exception occurred */
                    State->FpuControl.Rc = OldRoundingMode;
                    break;
                }
 
                State->FpuControl.Rc = OldRoundingMode;
 
                /* Adjust the unbiased exponent */
                UnbiasedExp += Scale;
 
                /* Check for underflow */
                if (UnbiasedExp < -1023)
                {
                    /* Raise the underflow exception */
                    State->FpuStatus.Ue = TRUE;
 
                    if (State->FpuControl.Um)
                    {
                        /* Make the result zero */
                        FPU_ST(0) = FpuZero;
                        FPU_UPDATE_TAG(0);
                    }
 
                    break;
                }
 
                /* Check for overflow */
                if (UnbiasedExp > 1023)
                {
                    /* Raise the overflow exception */
                    State->FpuStatus.Oe = TRUE;
 
                    if (State->FpuControl.Om)
                    {
                        /* Make the result infinity */
                        FPU_ST(0).Mantissa = FPU_MANTISSA_HIGH_BIT;
                        FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
                        FPU_UPDATE_TAG(0);
                    }
 
                    break;
                }
 
                FPU_ST(0).Exponent = (USHORT)(UnbiasedExp + FPU_REAL10_BIAS);
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* FSIN */
            case 0x3E:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!FPU_IS_NORMALIZED(&FPU_ST(0)))
                {
                    State->FpuStatus.De = TRUE;
 
                    if (!State->FpuControl.Dm)
                    {
                        break;
                    }
                }
 
                Fast486FpuCalculateSine(State, &FPU_ST(0), &FPU_ST(0));
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* FCOS */
            case 0x3F:
            {
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                if (!FPU_IS_NORMALIZED(&FPU_ST(0)))
                {
                    State->FpuStatus.De = TRUE;
 
                    if (!State->FpuControl.Dm)
                    {
                        break;
                    }
                }
 
                Fast486FpuCalculateCosine(State, &FPU_ST(0), &FPU_ST(0));
                FPU_UPDATE_TAG(0);
 
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
                return;
            }
        }
    }
 
#endif
}

FAST486_OPCODE_HANDLER() [3/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeDA

)

Definition at line 2735 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
#ifndef FAST486_NO_FPU
    LONG Value;
    FAST486_FPU_DATA_REG MemoryData;
#endif
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    Fast486FpuExceptionCheck(State);
    FPU_SAVE_LAST_INST();
 
    if (!ModRegRm.Memory)
    {
        /* The only valid opcode in this case is FUCOMPP (0xDA 0xE9) */
        if ((ModRegRm.Register != 5) && (ModRegRm.SecondRegister != 1))
        {
            Fast486Exception(State, FAST486_EXCEPTION_UD);
            return;
        }
 
        if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY) || (FPU_GET_TAG(1) == FPU_TAG_EMPTY))
        {
            /* Raise the invalid operation exception*/
            State->FpuStatus.Ie = TRUE;
            return;
        }
 
        /* Compare */
        Fast486FpuCompare(State, &FPU_ST(0), &FPU_ST(1));
 
        /* Pop twice */
        Fast486FpuPop(State);
        Fast486FpuPop(State);
 
        return;
    }
 
    FPU_SAVE_LAST_OPERAND();
 
    /* Load the source operand from memory */
    if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, NULL, (PULONG)&Value))
    {
        /* Exception occurred */
        return;
    }
 
    if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
    {
        /* Raise the invalid operation exception */
        State->FpuStatus.Ie = TRUE;
 
        if (State->FpuControl.Im)
        {
            /* Return the indefinite NaN */
            FPU_ST(0).Sign = TRUE;
            FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
            FPU_ST(0).Mantissa = FPU_INDEFINITE_MANTISSA;
 
            FPU_SET_TAG(0, FPU_TAG_SPECIAL);
        }
 
        return;
    }
 
    Fast486FpuFromInteger(State, (LONGLONG)Value, &MemoryData);
 
    /* Perform the requested operation */
    Fast486FpuArithmeticOperation(State, ModRegRm.Register, &MemoryData, TRUE);
 
#endif
}

FAST486_OPCODE_HANDLER() [4/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeDB

)

Definition at line 2821 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    if (ModRegRm.Memory)
    {
        Fast486FpuExceptionCheck(State);
        FPU_SAVE_LAST_INST();
        FPU_SAVE_LAST_OPERAND();
 
        switch (ModRegRm.Register)
        {
            /* FILD */
            case 0:
            {
                LONG Value;
                FAST486_FPU_DATA_REG Temp;
 
                if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, NULL, (PULONG)&Value))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuFromInteger(State, (LONGLONG)Value, &Temp);
                Fast486FpuPush(State, &Temp);
 
                break;
            }
 
            /* FIST */
            case 2:
            /* FISTP */
            case 3:
            {
                LONGLONG Temp = 0;
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY) || (FPU_GET_TAG(0) == FPU_TAG_SPECIAL))
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
 
                if (!Fast486FpuToInteger(State, &FPU_ST(0), &Temp))
                {
                    /* Exception occurred */
                    return;
                }
 
                /* Check if it can fit in a signed 32-bit integer */
                if ((LONGLONG)((LONG)Temp) != Temp)
                {
                    State->FpuStatus.Ie = TRUE;
 
                    if (State->FpuControl.Im)
                    {
                        Temp = 0x80000000LL;
                    }
                    else
                    {
                        return;
                    }
                }
 
                if (!Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, (ULONG)((LONG)Temp)))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (ModRegRm.Register == 3)
                {
                    /* Pop the FPU stack too */
                    Fast486FpuPop(State);
                }
 
                break;
            }
 
            /* FLD */
            case 5:
            {
                FAST486_FPU_DATA_REG Value;
                UCHAR Buffer[10];
 
                if (!Fast486ReadMemory(State,
                                       (State->PrefixFlags & FAST486_PREFIX_SEG)
                                       ? State->SegmentOverride : FAST486_REG_DS,
                                       ModRegRm.MemoryAddress,
                                       FALSE,
                                       Buffer,
                                       sizeof(Buffer)))
                {
                    /* Exception occurred */
                    return;
                }
 
                Value.Mantissa = *((PULONGLONG)Buffer);
                Value.Exponent = *((PUSHORT)&Buffer[8]) & (FPU_MAX_EXPONENT + 1);
                Value.Sign = *((PUCHAR)&Buffer[9]) >> 7;
 
                Fast486FpuPush(State, &Value);
                break;
            }
 
            /* FSTP */
            case 7:
            {
                UCHAR Buffer[10];
 
                if (FPU_GET_TAG(0) != FPU_TAG_EMPTY)
                {
                    *((PULONGLONG)Buffer) = FPU_ST(0).Mantissa;
                    *((PUSHORT)&Buffer[sizeof(ULONGLONG)]) = FPU_ST(0).Exponent
                                                             | (FPU_ST(0).Sign ? 0x8000 : 0);
                }
                else
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (State->FpuControl.Im)
                    {
                        *((PULONGLONG)Buffer) = FPU_INDEFINITE_MANTISSA;
                        *((PUSHORT)&Buffer[sizeof(ULONGLONG)]) = 0x8000 | (FPU_MAX_EXPONENT + 1);
                    }
                    else
                    {
                        return;
                    }
                }
 
                if (!Fast486WriteMemory(State,
                                        (State->PrefixFlags & FAST486_PREFIX_SEG)
                                        ? State->SegmentOverride : FAST486_REG_DS,
                                        ModRegRm.MemoryAddress,
                                        Buffer,
                                        sizeof(Buffer)))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuPop(State);
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
                return;
            }
        }
    }
    else
    {
        /* Only a few of these instructions have any meaning on a 487 */
        switch ((ModRegRm.Register << 3) | ModRegRm.SecondRegister)
        {
            /* FCLEX */
            case 0x22:
            {
                /* Clear exception data */
                State->FpuStatus.Ie =
                State->FpuStatus.De =
                State->FpuStatus.Ze =
                State->FpuStatus.Oe =
                State->FpuStatus.Ue =
                State->FpuStatus.Pe =
                State->FpuStatus.Sf =
                State->FpuStatus.Es =
                State->FpuStatus.Busy = FALSE;
 
                break;
            }
 
            /* FINIT */
            case 0x23:
            {
                /* Restore the state */
                State->FpuControl.Value = FAST486_FPU_DEFAULT_CONTROL;
                State->FpuStatus.Value = 0;
                State->FpuTag = 0xFFFF;
 
                break;
            }
 
            /* FENI */
            case 0x20:
            /* FDISI */
            case 0x21:
            /* FSETPM */
            case 0x24:
            /* FRSTPM */
            case 0x25:
            {
                /* These do nothing */
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
                return;
            }
        }
    }
 
#endif
}

FAST486_OPCODE_HANDLER() [5/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeDC

)

Definition at line 3053 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
#ifndef FAST486_NO_FPU
    PFAST486_FPU_DATA_REG Operand;
    FAST486_FPU_DATA_REG MemoryData;
#endif
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    Fast486FpuExceptionCheck(State);
    FPU_SAVE_LAST_INST();
 
    if (ModRegRm.Memory)
    {
        ULONGLONG Value;
 
        if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
        {
            /* Raise the invalid operation exception */
            State->FpuStatus.Ie = TRUE;
 
            if (State->FpuControl.Im)
            {
                /* Return the indefinite NaN */
                FPU_ST(0).Sign = TRUE;
                FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
                FPU_ST(0).Mantissa = FPU_INDEFINITE_MANTISSA;
 
                FPU_SET_TAG(0, FPU_TAG_SPECIAL);
            }
 
            return;
        }
 
        /* Load the source operand from memory */
        if (!Fast486ReadMemory(State,
                               (State->PrefixFlags & FAST486_PREFIX_SEG)
                               ? State->SegmentOverride : FAST486_REG_DS,
                               ModRegRm.MemoryAddress,
                               FALSE,
                               &Value,
                               sizeof(ULONGLONG)))
        {
            /* Exception occurred */
            return;
        }
 
        Fast486FpuFromDoubleReal(State, Value, &MemoryData);
        Operand = &MemoryData;
 
        FPU_SAVE_LAST_OPERAND();
    }
    else
    {
        /* Load the destination operand from an FPU register */
        Operand = &FPU_ST(ModRegRm.SecondRegister);
 
        if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY)
            || (FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY))
        {
            /* Raise the invalid operation exception */
            State->FpuStatus.Ie = TRUE;
 
            if (State->FpuControl.Im)
            {
                /* Return the indefinite NaN */
                Operand->Sign = TRUE;
                Operand->Exponent = FPU_MAX_EXPONENT + 1;
                Operand->Mantissa = FPU_INDEFINITE_MANTISSA;
 
                FPU_SET_TAG(ModRegRm.SecondRegister, FPU_TAG_SPECIAL);
            }
 
            return;
        }
    }
 
    /* Perform the requested operation */
    Fast486FpuArithmeticOperation(State, ModRegRm.Register, Operand, ModRegRm.Memory);
 
#endif
}

FAST486_OPCODE_HANDLER() [6/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeDD

)

Definition at line 3149 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN OperandSize, AddressSize;
 
    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;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    if (ModRegRm.Memory)
    {
        switch (ModRegRm.Register)
        {
            /* FLD */
            case 0:
            {
                ULONGLONG Value;
                FAST486_FPU_DATA_REG MemoryData;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
                FPU_SAVE_LAST_OPERAND();
 
                if (!Fast486ReadMemory(State,
                                       (State->PrefixFlags & FAST486_PREFIX_SEG)
                                       ? State->SegmentOverride : FAST486_REG_DS,
                                       ModRegRm.MemoryAddress,
                                       FALSE,
                                       &Value,
                                       sizeof(ULONGLONG)))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuFromDoubleReal(State, Value, &MemoryData);
                Fast486FpuPush(State, &MemoryData);
 
                break;
            }
 
            /* FST */
            case 2:
            /* FSTP */
            case 3:
            {
                ULONGLONG Value = FPU_REAL8_INDEFINITE;
 
                Fast486FpuExceptionCheck(State);
                FPU_SAVE_LAST_INST();
                FPU_SAVE_LAST_OPERAND();
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
                else if (!Fast486FpuToDoubleReal(State, &FPU_ST(0), &Value))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (!Fast486WriteMemory(State,
                                        (State->PrefixFlags & FAST486_PREFIX_SEG)
                                        ? State->SegmentOverride : FAST486_REG_DS,
                                        ModRegRm.MemoryAddress,
                                        &Value,
                                        sizeof(ULONGLONG)))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (ModRegRm.Register == 3) Fast486FpuPop(State);
                break;
            }
 
            /* FRSTOR */
            case 4:
            {
                INT i;
                UCHAR AllRegs[80];
 
                /* Save the environment */
                if (!Fast486FpuLoadEnvironment(State,
                                               (State->PrefixFlags & FAST486_PREFIX_SEG)
                                               ? State->SegmentOverride : FAST486_REG_DS,
                                               ModRegRm.MemoryAddress,
                                               OperandSize))
                {
                    /* Exception occurred */
                    return;
                }
 
                /* Load the registers */
                if (!Fast486ReadMemory(State,
                                       (State->PrefixFlags & FAST486_PREFIX_SEG)
                                       ? State->SegmentOverride : FAST486_REG_DS,
                                       ModRegRm.MemoryAddress + (OperandSize + 1) * 14,
                                       FALSE,
                                       AllRegs,
                                       sizeof(AllRegs)))
                {
                    /* Exception occurred */
                    return;
                }
 
                for (i = 0; i < FAST486_NUM_FPU_REGS; i++)
                {
                    State->FpuRegisters[i].Mantissa = *((PULONGLONG)&AllRegs[i * 10]);
                    State->FpuRegisters[i].Exponent = *((PUSHORT)&AllRegs[(i * 10) + sizeof(ULONGLONG)]) & 0x7FFF;
 
                    if (*((PUSHORT)&AllRegs[(i * 10) + sizeof(ULONGLONG)]) & 0x8000)
                    {
                        State->FpuRegisters[i].Sign = TRUE;
                    }
                    else
                    {
                        State->FpuRegisters[i].Sign = FALSE;
                    }
                }
 
                break;
            }
 
            /* FSAVE */
            case 6:
            {
                INT i;
                UCHAR AllRegs[80];
 
                /* Save the environment */
                if (!Fast486FpuSaveEnvironment(State,
                                               (State->PrefixFlags & FAST486_PREFIX_SEG)
                                               ? State->SegmentOverride : FAST486_REG_DS,
                                               ModRegRm.MemoryAddress,
                                               OperandSize))
                {
                    /* Exception occurred */
                    return;
                }
 
                /* Save the registers */
                for (i = 0; i < FAST486_NUM_FPU_REGS; i++)
                {
                    *((PULONGLONG)&AllRegs[i * 10]) = State->FpuRegisters[i].Mantissa;
                    *((PUSHORT)&AllRegs[(i * 10) + sizeof(ULONGLONG)]) = State->FpuRegisters[i].Exponent;
 
                    if (State->FpuRegisters[i].Sign)
                    {
                        *((PUSHORT)&AllRegs[(i * 10) + sizeof(ULONGLONG)]) |= 0x8000;
                    }
                }
 
                Fast486WriteMemory(State,
                                   (State->PrefixFlags & FAST486_PREFIX_SEG)
                                   ? State->SegmentOverride : FAST486_REG_DS,
                                   ModRegRm.MemoryAddress + (OperandSize + 1) * 14,
                                   AllRegs,
                                   sizeof(AllRegs));
 
                break;
            }
 
            /* FSTSW */
            case 7:
            {
                Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, State->FpuStatus.Value);
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
            }
        }
    }
    else
    {
        switch (ModRegRm.Register)
        {
            /* FFREE */
            case 0:
            {
                FPU_SET_TAG(ModRegRm.SecondRegister, FPU_TAG_EMPTY);
                break;
            }
 
            /* FXCH */
            case 1:
            {
                FAST486_FPU_DATA_REG Temp;
 
                FPU_SAVE_LAST_INST();
                Fast486FpuExceptionCheck(State);
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                    || FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                /* Exchange */
                Temp = FPU_ST(0);
                FPU_ST(0) = FPU_ST(ModRegRm.SecondRegister);
                FPU_ST(ModRegRm.SecondRegister) = Temp;
 
                FPU_UPDATE_TAG(0);
                FPU_UPDATE_TAG(ModRegRm.SecondRegister);
 
                break;
            }
 
            /* FST */
            case 2:
            /* FSTP */
            case 3:
            {
                FPU_SAVE_LAST_INST();
                Fast486FpuExceptionCheck(State);
 
                FPU_ST(ModRegRm.SecondRegister) = FPU_ST(0);
                FPU_UPDATE_TAG(ModRegRm.SecondRegister);
 
                if (ModRegRm.Register == 3) Fast486FpuPop(State);
                break;
            }
 
            /* FUCOM */
            case 4:
            /* FUCOMP */
            case 5:
            {
                FPU_SAVE_LAST_INST();
                Fast486FpuExceptionCheck(State);
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                    || (FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY))
                {
                    State->FpuStatus.Ie = TRUE;
                    return;
                }
 
                Fast486FpuCompare(State, &FPU_ST(0), &FPU_ST(ModRegRm.SecondRegister));
                if (ModRegRm.Register == 5) Fast486FpuPop(State);
 
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
            }
        }
    }
 
#endif
}

FAST486_OPCODE_HANDLER() [7/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeDE

)

Definition at line 3428 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
#ifndef FAST486_NO_FPU
    PFAST486_FPU_DATA_REG Operand;
    FAST486_FPU_DATA_REG MemoryData;
#endif
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    FPU_SAVE_LAST_INST();
    Fast486FpuExceptionCheck(State);
 
    if (ModRegRm.Memory)
    {
        SHORT Value;
 
        if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
        {
            /* Raise the invalid operation exception */
            State->FpuStatus.Ie = TRUE;
 
            if (State->FpuControl.Im)
            {
                /* Return the indefinite NaN */
                FPU_ST(0).Sign = TRUE;
                FPU_ST(0).Exponent = FPU_MAX_EXPONENT + 1;
                FPU_ST(0).Mantissa = FPU_INDEFINITE_MANTISSA;
 
                FPU_SET_TAG(0, FPU_TAG_SPECIAL);
            }
 
            return;
        }
 
        /* Load the source operand from memory */
        if (!Fast486ReadModrmWordOperands(State, &ModRegRm, NULL, (PUSHORT)&Value))
        {
            /* Exception occurred */
            return;
        }
 
        Fast486FpuFromInteger(State, (LONGLONG)Value, &MemoryData);
        Operand = &MemoryData;
 
        FPU_SAVE_LAST_OPERAND();
    }
    else
    {
        /* FCOMPP check */
        if ((ModRegRm.Register == 3) && (ModRegRm.SecondRegister != 1))
        {
            /* Invalid */
            Fast486Exception(State, FAST486_EXCEPTION_UD);
            return;
        }
 
        /* Load the destination operand from a register */
        Operand = &FPU_ST(ModRegRm.SecondRegister);
 
        if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY)
            || (FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY))
        {
            /* Raise the invalid operation exception, if unmasked */
            State->FpuStatus.Ie = TRUE;
            return;
        }
    }
 
    /* Perform the requested operation */
    Fast486FpuArithmeticOperation(State, ModRegRm.Register, Operand, ModRegRm.Memory);
    if (!ModRegRm.Memory) Fast486FpuPop(State);
 
#endif
}

FAST486_OPCODE_HANDLER() [8/8]

FAST486_OPCODE_HANDLER

(

Fast486FpuOpcodeDF

)

Definition at line 3516 of file fpu.c.

{
    FAST486_MOD_REG_RM ModRegRm;
    BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size;
 
    TOGGLE_ADSIZE(AddressSize);
 
    /* Get the operands */
    if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm))
    {
        /* Exception occurred */
        return;
    }
 
    FPU_CHECK();
 
#ifndef FAST486_NO_FPU
 
    FPU_SAVE_LAST_INST();
    Fast486FpuExceptionCheck(State);
 
    if (ModRegRm.Memory)
    {
        FPU_SAVE_LAST_OPERAND();
 
        switch (ModRegRm.Register)
        {
            /* FILD */
            case 0:
            {
                SHORT Value;
                FAST486_FPU_DATA_REG Temp;
 
                if (!Fast486ReadModrmWordOperands(State, &ModRegRm, NULL, (PUSHORT)&Value))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuFromInteger(State, (LONGLONG)Value, &Temp);
                Fast486FpuPush(State, &Temp);
 
                break;
            }
 
            /* FIST */
            case 2:
            /* FISTP */
            case 3:
            {
                LONGLONG Temp = 0LL;
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY) || (FPU_GET_TAG(0) == FPU_TAG_SPECIAL))
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
 
                if (!Fast486FpuToInteger(State, &FPU_ST(0), &Temp))
                {
                    /* Exception occurred */
                    return;
                }
 
                /* Check if it can fit in a signed 16-bit integer */
                if ((LONGLONG)((SHORT)Temp) != Temp)
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (State->FpuControl.Im)
                    {
                        Temp = 0x8000LL;
                    }
                    else
                    {
                        return;
                    }
                }
 
                if (!Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, (USHORT)((SHORT)Temp)))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (ModRegRm.Register == 3)
                {
                    /* Pop the FPU stack too */
                    Fast486FpuPop(State);
                }
 
                break;
            }
 
            /* FBLD */
            case 4:
            {
                FAST486_FPU_DATA_REG Value;
                UCHAR Buffer[10];
 
                if (!Fast486ReadMemory(State,
                                       (State->PrefixFlags & FAST486_PREFIX_SEG)
                                       ? State->SegmentOverride : FAST486_REG_DS,
                                       ModRegRm.MemoryAddress,
                                       FALSE,
                                       Buffer,
                                       sizeof(Buffer)))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuFromPackedBcd(State, Buffer, &Value);
                Fast486FpuPush(State, &Value);
 
                break;
            }
 
            /* FILD (64-bit int) */
            case 5:
            {
                LONGLONG Value;
                FAST486_FPU_DATA_REG Temp;
 
                if (!Fast486ReadMemory(State,
                                       (State->PrefixFlags & FAST486_PREFIX_SEG)
                                       ? State->SegmentOverride : FAST486_REG_DS,
                                       ModRegRm.MemoryAddress,
                                       FALSE,
                                       &Value,
                                       sizeof(LONGLONG)))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuFromInteger(State, (LONGLONG)Value, &Temp);
                Fast486FpuPush(State, &Temp);
 
                break;
            }
 
            /* FBSTP */
            case 6:
            {
                UCHAR Buffer[10] = {0};
 
                if (FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
                else if (!Fast486FpuToPackedBcd(State, &FPU_ST(0), Buffer))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (!Fast486WriteMemory(State,
                                        (State->PrefixFlags & FAST486_PREFIX_SEG)
                                        ? State->SegmentOverride : FAST486_REG_DS,
                                        ModRegRm.MemoryAddress,
                                        Buffer,
                                        sizeof(Buffer)))
                {
                    /* Exception occurred */
                    return;
                }
 
                Fast486FpuPop(State);
                break;
            }
 
            /* FISTP (64-bit int) */
            case 7:
            {
                LONGLONG Temp = 0LL;
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY) || (FPU_GET_TAG(0) == FPU_TAG_SPECIAL))
                {
                    /* Raise the invalid operation exception */
                    State->FpuStatus.Ie = TRUE;
 
                    if (!State->FpuControl.Im)
                    {
                        return;
                    }
                }
 
                if (!Fast486FpuToInteger(State, &FPU_ST(0), &Temp))
                {
                    /* Exception occurred */
                    return;
                }
 
                if (!Fast486WriteMemory(State,
                                        (State->PrefixFlags & FAST486_PREFIX_SEG)
                                        ? State->SegmentOverride : FAST486_REG_DS,
                                        ModRegRm.MemoryAddress,
                                        &Temp,
                                        sizeof(LONGLONG)))
                {
                    /* Exception occurred */
                    return;
                }
 
                /* Pop the FPU stack too */
                Fast486FpuPop(State);
 
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
            }
        }
    }
    else
    {
        switch (ModRegRm.Register)
        {
            /* FFREEP */
            case 0:
            {
                FPU_SET_TAG(ModRegRm.SecondRegister, FPU_TAG_EMPTY);
                Fast486FpuPop(State);
 
                break;
            }
 
            /* FXCH */
            case 1:
            {
                FAST486_FPU_DATA_REG Temp;
 
                if ((FPU_GET_TAG(0) == FPU_TAG_EMPTY)
                    || FPU_GET_TAG(ModRegRm.SecondRegister) == FPU_TAG_EMPTY)
                {
                    State->FpuStatus.Ie = TRUE;
                    break;
                }
 
                /* Exchange */
                Temp = FPU_ST(0);
                FPU_ST(0) = FPU_ST(ModRegRm.SecondRegister);
                FPU_ST(ModRegRm.SecondRegister) = Temp;
 
                FPU_UPDATE_TAG(0);
                FPU_UPDATE_TAG(ModRegRm.SecondRegister);
 
                break;
            }
 
            /* FSTP */
            case 2:
            case 3:
            {
                FPU_ST(ModRegRm.SecondRegister) = FPU_ST(0);
                FPU_UPDATE_TAG(ModRegRm.SecondRegister);
                Fast486FpuPop(State);
 
                break;
            }
 
            /* FSTSW */
            case 4:
            {
                if (ModRegRm.SecondRegister != 0)
                {
                    /* Invalid */
                    Fast486Exception(State, FAST486_EXCEPTION_UD);
                    return;
                }
 
                /* Store the status word in AX */
                State->GeneralRegs[FAST486_REG_EAX].LowWord = State->FpuStatus.Value;
 
                break;
            }
 
            /* Invalid */
            default:
            {
                Fast486Exception(State, FAST486_EXCEPTION_UD);
                return;
            }
        }
    }
 
#endif
}