/*++

Copyright (c) 1994  Microsoft Corporation

Module Name:

    addops.c

Abstract:

    This module implements the code to emulate the add, sub, adc, sbb,
    inc, dec, and neg opcodes.

Author:

    David N. Cutler (davec) 2-Sep-1994

Environment:

    Kernel mode only.

Revision History:

--*/

#include "nthal.h"
#include "emulate.h"

//
// Define forward referenced prototypes.
//

VOID
XmAddOperands (
    IN PRXM_CONTEXT P,
    IN ULONG Carry
    );

VOID
XmSubOperands (
    IN PRXM_CONTEXT P,
    IN ULONG Borrow
    );

VOID
XmAddOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates an add opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    //
    // Add operands and store result.
    //

    XmAddOperands(P, 0);
    return;
}

VOID
XmAdcOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates an add with carry opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    //
    // Add operands with carry and store result.
    //

    XmAddOperands(P, P->Eflags.CF);
    return;
}

VOID
XmSbbOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates a subtract with borrow opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    ULONG Source;

    //
    // Subtract operands with borrow and store result.
    //

    XmSubOperands(P, P->Eflags.CF);
    return;
}

VOID
XmSubOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates a subtract opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    //
    // Subtract operands and store result.
    //

    XmSubOperands(P, 0);
    return;
}

VOID
XmCmpOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates a cmp opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    //
    // Subtract operands to perform comparison operation.
    //

    XmSubOperands(P, 0);
    return;
}

VOID
XmCmpxchgOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates a cmpxchg opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    ULONG Accumulator;
    ULONG Destination;

    //
    // Compare the destination with the accumulator. If the destination
    // operand is equal to the accumulator, then set ZF and store the
    // source operand value in the destination opperand. Otherwise, clear
    // ZF and store the destination operand in the accumlator.
    //

    Destination = P->DstValue.Long;
    if (P->DataType == BYTE_DATA) {
        Accumulator = P->Gpr[AL].Xl;

    } else if (P->DataType == LONG_DATA) {
        Accumulator = P->Gpr[EAX].Exx;

    } else {
        Accumulator = P->Gpr[AX].Xx;
    }

    if (Destination == Accumulator) {
        P->Eflags.ZF = 1;
        XmStoreResult(P, P->SrcValue.Long);

    } else {
        P->Eflags.ZF = 0;
        P->DstLong = (ULONG UNALIGNED *)(&P->Gpr[EAX].Exx);
        XmStoreResult(P, P->DstValue.Long);
    }

    //
    // Subtract operands to perform comparison operation.
    //

    P->SrcValue.Long = P->DstValue.Long;
    P->DstValue.Long = Accumulator;
    XmSubOperands(P, 0);
    return;
}

VOID
XmDecOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates a decrement opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    //
    // Subtract operands and store result.
    //
    //

    P->SrcValue.Long = 1;
    XmSubOperands(P, 0);
    return;
}

VOID
XmIncOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates an increment opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    //
    // Add operands and store result.
    //

    P->SrcValue.Long = 1;
    XmAddOperands(P, 0);
    return;
}

VOID
XmNegOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates a neg opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{


    //
    // Subtract operand from zero and store result.
    //

    P->SrcValue.Long = P->DstValue.Long;
    P->DstValue.Long = 0;
    XmSubOperands(P, 0);
    return;
}

VOID
XmXaddOp (
    IN PRXM_CONTEXT P
    )

/*++

Routine Description:

    This function emulates an xadd opcode.

Arguments:

    P - Supplies a pointer to the emulation context structure.

Return Value:

    None.

--*/

{

    ULONG Destination;

    //
    // Exchange add operands and store result.
    //

    Destination = P->DstValue.Long;
    XmAddOperands(P, 0);
    P->DstLong = P->SrcLong;
    XmStoreResult(P, Destination);
    return;
}

VOID
XmAddOperands (
    IN PRXM_CONTEXT P,
    IN ULONG Carry
    )

/*++

Routine Description:

    This function adds two operands and computes the resulting condition
    codes.

Arguments:

    P - Supplies a pointer to the emulation context structure.

    Carry - Supplies the carry value.

Return Value:

    None.

--*/

{

    ULONG CarryFlag;
    ULONG Shift;
    union {
        UCHAR ResultByte;
        ULONG ResultLong;
        USHORT ResultWord;
    } u;

    u.ResultLong = 0;
    if (P->DataType == BYTE_DATA) {
        u.ResultByte = P->SrcValue.Byte + (UCHAR)Carry;
        CarryFlag = u.ResultByte < (UCHAR)Carry;
        u.ResultByte += P->DstValue.Byte;
        CarryFlag |= (u.ResultByte < P->DstValue.Byte);
        Shift = 7;

    } else if (P->DataType == LONG_DATA) {
        u.ResultLong = P->SrcValue.Long + Carry;
        CarryFlag = (u.ResultLong < Carry);
        u.ResultLong += P->DstValue.Long;
        CarryFlag |= (u.ResultLong < P->DstValue.Long);
        Shift = 31;

    } else {
        u.ResultWord = P->SrcValue.Word + (USHORT)Carry;
        CarryFlag = (u.ResultWord < (USHORT)Carry);
        u.ResultWord += P->DstValue.Word;
        CarryFlag |= (u.ResultWord < P->DstValue.Word);
        Shift = 15;
    }

    //
    // Store the result.
    //

    XmStoreResult(P, u.ResultLong);

    //
    // If the function is not an increment, then store the carry flag.
    //

    if (P->FunctionIndex != X86_INC_OP) {
        P->Eflags.CF = CarryFlag;
    }

    //
    // Compute and store the parity and auxiliary carry flags.
    //

    P->Eflags.PF = XmComputeParity(u.ResultLong);
    P->Eflags.AF = ((P->DstValue.Byte & 0xf) +
                                        (P->SrcValue.Long & 0xf) + Carry) >> 4;

    //
    // Compute and store the zero and sign flags.
    //

    P->Eflags.ZF = (u.ResultLong == 0);
    P->Eflags.SF = u.ResultLong >> Shift;

    //
    // The overflow flag is computed as the carry into the sign bit
    // compared with the carry out of the sign bit.
    //

    P->Eflags.OF = (((P->SrcValue.Long ^ P->DstValue.Long) ^
                                        u.ResultLong) >> Shift) ^ CarryFlag;

    return;
}

VOID
XmSubOperands (
    IN PRXM_CONTEXT P,
    IN ULONG Borrow
    )

/*++

Routine Description:

    This function adds to operands and computes the resulting condition
    codes.

Arguments:

    P - Supplies a pointer to the emulation context structure.

    Borrow - Supplies the boorow value.

Return Value:

    None.

--*/

{

    ULONG CarryFlag;
    ULONG Shift;
    union {
        UCHAR ResultByte;
        ULONG ResultLong;
        USHORT ResultWord;
    } u;

    u.ResultLong = 0;
    if (P->DataType == BYTE_DATA) {
        CarryFlag = (P->DstValue.Byte < (UCHAR)Borrow);
        u.ResultByte = P->DstValue.Byte - (UCHAR)Borrow;
        CarryFlag |= (u.ResultByte < P->SrcValue.Byte);
        u.ResultByte -= P->SrcValue.Byte;
        Shift = 7;

    } else if (P->DataType == LONG_DATA) {
        CarryFlag = (P->DstValue.Long < Borrow);
        u.ResultLong = P->DstValue.Long - Borrow;
        CarryFlag |= (u.ResultLong < P->SrcValue.Long);
        u.ResultLong -= P->SrcValue.Long;
        Shift = 31;

    } else {
        CarryFlag = (P->DstValue.Word < (USHORT)Borrow);
        u.ResultWord = P->DstValue.Word - (USHORT)Borrow;
        CarryFlag |= (u.ResultWord < P->SrcValue.Word);
        u.ResultWord -= P->SrcValue.Word;
        Shift = 15;
    }

    //
    // If the fucntion is not a compare or a compare and swap, then store
    // result.
    //

    if ((P->FunctionIndex != X86_CMP_OP) && (P->FunctionIndex != X86_CMPXCHG_OP)) {
        XmStoreResult(P, u.ResultLong);
    }

    //
    // If the function is not a decrement, then store the carry flag.
    //

    if (P->FunctionIndex != X86_DEC_OP) {
        P->Eflags.CF = CarryFlag;
    }

    //
    // Compute and store the parity and auxiliary carry flags.
    //

    P->Eflags.PF = XmComputeParity(u.ResultLong);
    P->Eflags.AF = ((P->DstValue.Byte & 0xf) -
                                        (P->SrcValue.Byte & 0xf) - Borrow) >> 4;

    //
    // If the function is not a compare and swap, then compute the zero flag.
    //

    if (P->FunctionIndex != X86_CMPXCHG_OP) {
        P->Eflags.ZF = (u.ResultLong == 0);
    }

    //
    // Compute and store the sign flag.
    //

    P->Eflags.SF = u.ResultLong >> Shift;

    //
    // The overflow flag is computed as the borrow from the sign bit
    // compared with the borrow into the sign bit.
    //

    P->Eflags.OF = (((P->SrcValue.Long ^ P->DstValue.Long) ^ u.ResultLong) >> Shift) ^ CarryFlag;
    return;
}