cpuops.cpp

SFC游戏模拟器 snes9x 1.43 的原代码

}

static void OpCFM0 (void)
{
    AbsoluteLong (READ);
    CMP16 ();
}

static void OpDFM1 (void)
{
    AbsoluteLongIndexedX (READ);
    CMP8 ();
}

static void OpDFM0 (void)
{
    AbsoluteLongIndexedX (READ);
    CMP16 ();
}

static void OpC3M1 (void)
{
    StackRelative (READ);
    CMP8 ();
}

static void OpC3M0 (void)
{
    StackRelative (READ);
    CMP16 ();
}

static void OpD3M1 (void)
{
    StackRelativeIndirectIndexed (READ);
    CMP8 ();
}

static void OpD3M0 (void)
{
    StackRelativeIndirectIndexed (READ);
    CMP16 ();
}

/**********************************************************************************************/

/* CMX *************************************************************************************** */
static void OpE0X1 (void)
{
    Int32 = (int) Registers.XL - (int) *CPU.PC++;
    ICPU._Carry = Int32 >= 0;
    SetZN8 ((uint8) Int32);
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeed;
#endif
}

static void OpE0X0 (void)
{
#ifdef FAST_LSB_WORD_ACCESS    
    Int32 = (long) Registers.X.W - (long) *(uint16 *) CPU.PC;
#else
    Int32 = (long) Registers.X.W -
	    (long) (*CPU.PC + (*(CPU.PC + 1) << 8));
#endif
    ICPU._Carry = Int32 >= 0;
    SetZN16 ((uint16) Int32);
    CPU.PC += 2;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeedx2;
#endif
}

static void OpE4X1 (void)
{
    Direct (READ);
    CMX8 ();
}

static void OpE4X0 (void)
{
    Direct (READ);
    CMX16 ();
}

static void OpECX1 (void)
{
    Absolute (READ);
    CMX8 ();
}

static void OpECX0 (void)
{
    Absolute (READ);
    CMX16 ();
}

/**********************************************************************************************/

/* CMY *************************************************************************************** */
static void OpC0X1 (void)
{
    Int32 = (int) Registers.YL - (int) *CPU.PC++;
    ICPU._Carry = Int32 >= 0;
    SetZN8 ((uint8) Int32);
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeed;
#endif
}

static void OpC0X0 (void)
{
#ifdef FAST_LSB_WORD_ACCESS    
    Int32 = (long) Registers.Y.W - (long) *(uint16 *) CPU.PC;
#else
    Int32 = (long) Registers.Y.W -
	    (long) (*CPU.PC + (*(CPU.PC + 1) << 8));
#endif
    ICPU._Carry = Int32 >= 0;
    SetZN16 ((uint16) Int32);
    CPU.PC += 2;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeedx2;
#endif
}

static void OpC4X1 (void)
{
    Direct (READ);
    CMY8 ();
}

static void OpC4X0 (void)
{
    Direct (READ);
    CMY16 ();
}

static void OpCCX1 (void)
{
    Absolute (READ);
    CMY8 ();
}

static void OpCCX0 (void)
{
    Absolute (READ);
    CMY16 ();
}

/**********************************************************************************************/

/* DEC *************************************************************************************** */
static void Op3AM1 (void)
{
    A_DEC8 ();
}

static void Op3AM0 (void)
{
    A_DEC16 ();
}

static void OpC6M1 (void)
{
    Direct (MODIFY);
    DEC8 ();
}

static void OpC6M0 (void)
{
    Direct (MODIFY);
    DEC16 ();
}

static void OpD6M1 (void)
{
    DirectIndexedX (MODIFY);
    DEC8 ();
}

static void OpD6M0 (void)
{
    DirectIndexedX (MODIFY);
    DEC16 ();
}

static void OpCEM1 (void)
{
    Absolute (MODIFY);
    DEC8 ();
}

static void OpCEM0 (void)
{
    Absolute (MODIFY);
    DEC16 ();
}

static void OpDEM1 (void)
{
    AbsoluteIndexedX (MODIFY);
    DEC8 ();
}

static void OpDEM0 (void)
{
    AbsoluteIndexedX (MODIFY);
    DEC16 ();
}

/**********************************************************************************************/

/* EOR *************************************************************************************** */
static void Op49M1 (void)
{
    Registers.AL ^= *CPU.PC++;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeed;
#endif
    SetZN8 (Registers.AL);
}

static void Op49M0 (void)
{
#ifdef FAST_LSB_WORD_ACCESS
    Registers.A.W ^= *(uint16 *) CPU.PC;
#else
    Registers.A.W ^= *CPU.PC + (*(CPU.PC + 1) << 8);
#endif
    CPU.PC += 2;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeedx2;
#endif
    SetZN16 (Registers.A.W);
}

static void Op45M1 (void)
{
    Direct (READ);
    EOR8 ();
}

static void Op45M0 (void)
{
    Direct (READ);
    EOR16 ();
}

static void Op55M1 (void)
{
    DirectIndexedX (READ);
    EOR8 ();
}

static void Op55M0 (void)
{
    DirectIndexedX (READ);
    EOR16 ();
}

static void Op52M1 (void)
{
    DirectIndirect (READ);
    EOR8 ();
}

static void Op52M0 (void)
{
    DirectIndirect (READ);
    EOR16 ();
}

static void Op41M1 (void)
{
    DirectIndexedIndirect (READ);
    EOR8 ();
}

static void Op41M0 (void)
{
    DirectIndexedIndirect (READ);
    EOR16 ();
}

static void Op51M1 (void)
{
    DirectIndirectIndexed (READ);
    EOR8 ();
}

static void Op51M0 (void)
{
    DirectIndirectIndexed (READ);
    EOR16 ();
}

static void Op47M1 (void)
{
    DirectIndirectLong (READ);
    EOR8 ();
}

static void Op47M0 (void)
{
    DirectIndirectLong (READ);
    EOR16 ();
}

static void Op57M1 (void)
{
    DirectIndirectIndexedLong (READ);
    EOR8 ();
}

static void Op57M0 (void)
{
    DirectIndirectIndexedLong (READ);
    EOR16 ();
}

static void Op4DM1 (void)
{
    Absolute (READ);
    EOR8 ();
}

static void Op4DM0 (void)
{
    Absolute (READ);
    EOR16 ();
}

static void Op5DM1 (void)
{
    AbsoluteIndexedX (READ);
    EOR8 ();
}

static void Op5DM0 (void)
{
    AbsoluteIndexedX (READ);
    EOR16 ();
}

static void Op59M1 (void)
{
    AbsoluteIndexedY (READ);
    EOR8 ();
}

static void Op59M0 (void)
{
    AbsoluteIndexedY (READ);
    EOR16 ();
}

static void Op4FM1 (void)
{
    AbsoluteLong (READ);
    EOR8 ();
}

static void Op4FM0 (void)
{
    AbsoluteLong (READ);
    EOR16 ();
}

static void Op5FM1 (void)
{
    AbsoluteLongIndexedX (READ);
    EOR8 ();
}

static void Op5FM0 (void)
{
    AbsoluteLongIndexedX (READ);
    EOR16 ();
}

static void Op43M1 (void)
{
    StackRelative (READ);
    EOR8 ();
}

static void Op43M0 (void)
{
    StackRelative (READ);
    EOR16 ();
}

static void Op53M1 (void)
{
    StackRelativeIndirectIndexed (READ);
    EOR8 ();
}

static void Op53M0 (void)
{
    StackRelativeIndirectIndexed (READ);
    EOR16 ();
}

/**********************************************************************************************/

/* INC *************************************************************************************** */
static void Op1AM1 (void)
{
    A_INC8 ();
}

static void Op1AM0 (void)
{
    A_INC16 ();
}

static void OpE6M1 (void)
{
    Direct (MODIFY);
    INC8 ();
}

static void OpE6M0 (void)
{
    Direct (MODIFY);
    INC16 ();
}

static void OpF6M1 (void)
{
    DirectIndexedX (MODIFY);
    INC8 ();
}

static void OpF6M0 (void)
{
    DirectIndexedX (MODIFY);
    INC16 ();
}

static void OpEEM1 (void)
{
    Absolute (MODIFY);
    INC8 ();
}

static void OpEEM0 (void)
{
    Absolute (MODIFY);
    INC16 ();
}

static void OpFEM1 (void)
{
    AbsoluteIndexedX (MODIFY);
    INC8 ();
}

static void OpFEM0 (void)
{
    AbsoluteIndexedX (MODIFY);
    INC16 ();
}

/**********************************************************************************************/
/* LDA *************************************************************************************** */
static void OpA9M1 (void)
{
    Registers.AL = *CPU.PC++;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeed;
#endif
    SetZN8 (Registers.AL);
}

static void OpA9M0 (void)
{
#ifdef FAST_LSB_WORD_ACCESS
    Registers.A.W = *(uint16 *) CPU.PC;
#else
    Registers.A.W = *CPU.PC + (*(CPU.PC + 1) << 8);
#endif

    CPU.PC += 2;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeedx2;
#endif
    SetZN16 (Registers.A.W);
}

static void OpA5M1 (void)
{
    Direct (READ);
    LDA8 ();
}

static void OpA5M0 (void)
{
    Direct (READ);
    LDA16 ();
}

static void OpB5M1 (void)
{
    DirectIndexedX (READ);
    LDA8 ();
}

static void OpB5M0 (void)
{
    DirectIndexedX (READ);
    LDA16 ();
}

static void OpB2M1 (void)
{
    DirectIndirect (READ);
    LDA8 ();
}

static void OpB2M0 (void)
{
    DirectIndirect (READ);
    LDA16 ();
}

static void OpA1M1 (void)
{
    DirectIndexedIndirect (READ);
    LDA8 ();
}

static void OpA1M0 (void)
{
    DirectIndexedIndirect (READ);
    LDA16 ();
}

static void OpB1M1 (void)
{
    DirectIndirectIndexed (READ);
    LDA8 ();
}

static void OpB1M0 (void)
{
    DirectIndirectIndexed (READ);
    LDA16 ();
}

static void OpA7M1 (void)
{
    DirectIndirectLong (READ);
    LDA8 ();
}

static void OpA7M0 (void)
{
    DirectIndirectLong (READ);
    LDA16 ();
}

static void OpB7M1 (void)
{
    DirectIndirectIndexedLong (READ);
    LDA8 ();
}

static void OpB7M0 (void)
{
    DirectIndirectIndexedLong (READ);
    LDA16 ();
}

static void OpADM1 (void)
{
    Absolute (READ);
    LDA8 ();
}

static void OpADM0 (void)
{
    Absolute (READ);
    LDA16 ();
}

static void OpBDM1 (void)
{
    AbsoluteIndexedX (READ);
    LDA8 ();
}

static void OpBDM0 (void)
{
    AbsoluteIndexedX (READ);
    LDA16 ();
}

static void OpB9M1 (void)
{
    AbsoluteIndexedY (READ);
    LDA8 ();
}

static void OpB9M0 (void)
{
    AbsoluteIndexedY (READ);
    LDA16 ();
}

static void OpAFM1 (void)
{
    AbsoluteLong (READ);
    LDA8 ();
}

static void OpAFM0 (void)
{
    AbsoluteLong (READ);
    LDA16 ();
}

static void OpBFM1 (void)
{
    AbsoluteLongIndexedX (READ);
    LDA8 ();
}

static void OpBFM0 (void)
{
    AbsoluteLongIndexedX (READ);
    LDA16 ();
}

static void OpA3M1 (void)
{
    StackRelative (READ);
    LDA8 ();
}

static void OpA3M0 (void)
{
    StackRelative (READ);
    LDA16 ();
}

static void OpB3M1 (void)
{
    StackRelativeIndirectIndexed (READ);
    LDA8 ();
}

static void OpB3M0 (void)
{
    StackRelativeIndirectIndexed (READ);
    LDA16 ();
}

/**********************************************************************************************/

/* LDX *************************************************************************************** */
static void OpA2X1 (void)
{
    Registers.XL = *CPU.PC++;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeed;
#endif
    SetZN8 (Registers.XL);
}

static void OpA2X0 (void)
{
#ifdef FAST_LSB_WORD_ACCESS
    Registers.X.W = *(uint16 *) CPU.PC;
#else
    Registers.X.W = *CPU.PC + (*(CPU.PC + 1) << 8);
#endif
    CPU.PC += 2;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeedx2;
#endif
    SetZN16 (Registers.X.W);
}

static void OpA6X1 (void)
{
    Direct (READ);
    LDX8 ();
}

static void OpA6X0 (void)
{
    Direct (READ);
    LDX16 ();
}

static void OpB6X1 (void)
{
    DirectIndexedY (READ);
    LDX8 ();
}

static void OpB6X0 (void)
{
    DirectIndexedY (READ);
    LDX16 ();
}

static void OpAEX1 (void)
{
    Absolute (READ);
    LDX8 ();
}

static void OpAEX0 (void)
{
    Absolute (READ);
    LDX16 ();
}

static void OpBEX1 (void)
{
    AbsoluteIndexedY (READ);
    LDX8 ();
}

static void OpBEX0 (void)
{
    AbsoluteIndexedY (READ);
    LDX16 ();
}
/**********************************************************************************************/

/* LDY *************************************************************************************** */
static void OpA0X1 (void)
{
    Registers.YL = *CPU.PC++;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeed;
#endif
    SetZN8 (Registers.YL);
}

static void OpA0X0 (void)
{
#ifdef FAST_LSB_WORD_ACCESS
    Registers.Y.W = *(uint16 *) CPU.PC;
#else
    Registers.Y.W = *CPU.PC + (*(CPU.PC + 1) << 8);
#endif

    CPU.PC += 2;
#ifndef SA1_OPCODES
    CPU.Cycles += CPU.MemSpeedx2;
#endif
    SetZN16 (Registers.Y.W);
}

static void OpA4X1 (void)
{
    Direct (READ);
    LDY8 ();
}

static void OpA4X0 (void)
{
    Direct (READ);
    LDY16 ();
}

static void OpB4X1 (void)
{
    DirectIndexedX (READ);
    LDY8 ();
}

static void OpB4X0 (void)
{