diff --git a/README b/README index b629a67..afbe900 100644 --- a/README +++ b/README @@ -55,10 +55,10 @@ ACIAs. More functionality may be considered as time goes on. o Indirect [used only by JMP] o Zero Page, X-indexed o Zero Page, Y-indexed + o Absolute, X-indexed INCOMPLETE ADDRESSING MODES: o Relative - o Absolute, X-indexed o Absolute, Y-indexed o Indexed Indirect [ (Indirect ,X) ] o Indirect Indexed [ (Indirect),Y ] diff --git a/src/main/java/com/loomcom/symon/Cpu.java b/src/main/java/com/loomcom/symon/Cpu.java index be17e5b..e2f89b1 100644 --- a/src/main/java/com/loomcom/symon/Cpu.java +++ b/src/main/java/com/loomcom/symon/Cpu.java @@ -207,9 +207,16 @@ public class Cpu implements InstructionTable { break; case 0x19: // TODO: implement break; - case 0x1d: // TODO: implement + case 0x1d: // ORA - Logical Inclusive OR - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + a |= j; + setArithmeticFlags(a); break; - case 0x1e: // TODO: implement + case 0x1e: // ASL - Arithmetic Shift Left - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + k = asl(j); + bus.write(xAddress(operands[0], operands[1]), k); + setArithmeticFlags(k); break; case 0x20: // JSR - Jump to Subroutine - $20 @@ -226,7 +233,7 @@ public class Cpu implements InstructionTable { setNegativeFlag((k & 0x80) != 0); setOverflowFlag((k & 0x40) != 0); break; - case 0x25: // AND - Logical And - Zero Page + case 0x25: // AND - Logical AND - Zero Page j = bus.read(operands[0]); a &= j; setArithmeticFlags(a); @@ -240,7 +247,7 @@ public class Cpu implements InstructionTable { case 0x28: // PLP - Pull Processor Status - Implied setProcessorStatus(stackPop()); break; - case 0x29: // AND - Logical And - Immediate + case 0x29: // AND - Logical AND - Immediate a &= operands[0]; setArithmeticFlags(a); break; @@ -255,12 +262,12 @@ public class Cpu implements InstructionTable { setNegativeFlag((k & 0x80) != 0); setOverflowFlag((k & 0x40) != 0); break; - case 0x2d: // AND - Logical And - Absolute + case 0x2d: // AND - Logical AND - Absolute j = bus.read(address(operands[0], operands[1])); a &= j; setArithmeticFlags(a); break; - case 0x2e: // ROL - Rotate Shift Left - Absolute + case 0x2e: // ROL - Rotate Left - Absolute j = bus.read(address(operands[0], operands[1])); k = rol(j); bus.write(address(operands[0], operands[1]), k); @@ -271,7 +278,7 @@ public class Cpu implements InstructionTable { break; case 0x31: // TODO: implement break; - case 0x35: // AND - Logical And - Zero Page,X + case 0x35: // AND - Logical AND - Zero Page,X j = bus.read(zpxAddress(operands[0])); a &= j; setArithmeticFlags(a); @@ -287,9 +294,16 @@ public class Cpu implements InstructionTable { break; case 0x39: // TODO: implement break; - case 0x3d: // TODO: implement + case 0x3d: // AND - Logical AND - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + a &= j; + setArithmeticFlags(a); break; - case 0x3e: // TODO: implement + case 0x3e: // ROL - Rotate Left - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + k = rol(j); + bus.write(xAddress(operands[0], operands[1]), k); + setArithmeticFlags(k); break; case 0x40: // RTI - Return from Interrupt - Implied @@ -355,9 +369,15 @@ public class Cpu implements InstructionTable { break; case 0x59: // TODO: implement break; - case 0x5d: // TODO: implement + case 0x5d: // EOR - Exclusive OR - Absolute,X + a ^= bus.read(xAddress(operands[0], operands[1])); + setArithmeticFlags(a); break; - case 0x5e: // TODO: implement + case 0x5e: // LSR - Logical Shift Right - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + k = lsr(j); + bus.write(xAddress(operands[0], operands[1]), k); + setArithmeticFlags(k); break; case 0x60: // RTS - Return from Subroutine - Implied @@ -454,9 +474,19 @@ public class Cpu implements InstructionTable { break; case 0x79: // TODO: implement break; - case 0x7d: // TODO: implement + case 0x7d: // ADC - Add with Carry - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + if (decimalModeFlag) { + a = adcDecimal(a, j); + } else { + a = adc(a, j); + } break; - case 0x7e: // TODO: implement + case 0x7e: // ROR - Rotate Right - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + k = ror(j); + bus.write(xAddress(operands[0], operands[1]), k); + setArithmeticFlags(k); break; case 0x81: // TODO: implement @@ -519,7 +549,9 @@ public class Cpu implements InstructionTable { case 0x9a: // TXS - Transfer X to Stack Pointer - Implied setStackPointer(x); break; - case 0x9d: // TODO: implement + case 0x9d: // STA - Store Accumulator - Absolute,X + bus.write(xAddress(operands[0], operands[1]), a); + setArithmeticFlags(a); break; case 0xa0: // LDY - Load Y Register - Immediate @@ -556,7 +588,9 @@ public class Cpu implements InstructionTable { x = a; setArithmeticFlags(x); break; - case 0xac: // TODO: implement + case 0xac: // LDY - Load Y Register - Absolute + y = bus.read(address(operands[0], operands[1])); + setArithmeticFlags(y); break; case 0xad: // LDA - Load Accumulator - Absolute a = bus.read(address(operands[0], operands[1])); @@ -592,11 +626,13 @@ public class Cpu implements InstructionTable { x = getStackPointer(); setArithmeticFlags(x); break; - case 0xbc: // LDY - Load Y Register - Absolute - y = bus.read(address(operands[0], operands[1])); + case 0xbc: // LDY - Load Y Register - Absolute,X + y = bus.read(xAddress(operands[0], operands[1])); setArithmeticFlags(y); break; - case 0xbd: // TODO: implement + case 0xbd: // LDA - Load Accumulator - Absolute,X + a = bus.read(xAddress(operands[0], operands[1])); + setArithmeticFlags(a); break; case 0xbe: // TODO: implement break; @@ -660,9 +696,14 @@ public class Cpu implements InstructionTable { break; case 0xd9: // TODO: implement break; - case 0xdd: // TODO: implement + case 0xdd: // CMP - Compare Accumulator - Absolute,X + cmp(a, bus.read(xAddress(operands[0], operands[1]))); break; - case 0xde: // TODO: implement + case 0xde: // DEC - Decrement Memory - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + k = --j & 0xff; + bus.write(xAddress(operands[0], operands[1]), k); + setArithmeticFlags(k); break; case 0xe0: // CPX - Compare X Register - Immediate @@ -742,9 +783,19 @@ public class Cpu implements InstructionTable { break; case 0xf9: // TODO: implement break; - case 0xfd: // TODO: implement + case 0xfd: // SBC - Subtract with Carry - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + if (decimalModeFlag) { + a = sbcDecimal(a, j); + } else { + a = sbc(a, j); + } break; - case 0xfe: // TODO: implement + case 0xfe: // INC - Increment Memory Location - Absolute,X + j = bus.read(xAddress(operands[0], operands[1])); + k = ++j & 0xff; + bus.write(xAddress(operands[0], operands[1]), k); + setArithmeticFlags(k); break; /* Unimplemented Instructions */ @@ -1461,6 +1512,22 @@ public class Cpu implements InstructionTable { return ((hiByte<<8)|lowByte); } + /** + * Given a hi byte and a low byte, return the Absolute,X + * offset address. + */ + int xAddress(int lowByte, int hiByte) { + return (address(lowByte, hiByte)+getXRegister()) & 0xffff; + } + + /** + * Given a hi byte and a low byte, return the Absolute,Y + * offset address. + */ + int yAddress(int lowByte, int hiByte) { + return (address(lowByte, hiByte)+getYRegister()) & 0xffff; + } + /** * Given a single byte, compute the Zero Page,X offset address. */ diff --git a/src/test/java/com/loomcom/symon/CpuAbsoluteXModeTest.java b/src/test/java/com/loomcom/symon/CpuAbsoluteXModeTest.java new file mode 100644 index 0000000..8717ab3 --- /dev/null +++ b/src/test/java/com/loomcom/symon/CpuAbsoluteXModeTest.java @@ -0,0 +1,1050 @@ +package com.loomcom.symon; + +import com.loomcom.symon.devices.Memory; +import com.loomcom.symon.exceptions.MemoryRangeException; +import junit.framework.TestCase; + +public class CpuAbsoluteXModeTest extends TestCase { + + protected Cpu cpu; + protected Bus bus; + protected Memory mem; + + protected void setUp() throws Exception { + this.cpu = new Cpu(); + this.bus = new Bus(0x0000, 0xffff); + this.mem = new Memory(0x0000, 0x10000); + bus.addCpu(cpu); + bus.addDevice(mem); + + // Load the reset vector. + bus.write(0xfffc, Cpu.DEFAULT_BASE_ADDRESS & 0x00ff); + bus.write(0xfffd, (Cpu.DEFAULT_BASE_ADDRESS & 0xff00)>>>8); + + cpu.reset(); + // Assert initial state + assertEquals(0, cpu.getAccumulator()); + assertEquals(0, cpu.getXRegister()); + assertEquals(0, cpu.getYRegister()); + assertEquals(0x200, cpu.getProgramCounter()); + assertEquals(0xff, cpu.getStackPointer()); + assertEquals(0x20, cpu.getProcessorStatus()); + } + + /* + * The following opcodes are tested for correctness in this file: + * + * ORA - $1d + * ASL - $1e + * AND - $3d + * ROL - $3e + * EOR - $5d + * LSR - $5e + * ADC - $7d + * ROR - $7e + * STA - $9d + * LDY - $bc + * LDA - $bd + * CMP - $dd + * DEC - $de + * SBC - $fd + * INC - $fe + */ + + /* ORA - Logical Inclusive OR - $1d */ + + public void test_ORA() { + // Set some initial values in memory + bus.write(0x2c30, 0x00); + bus.write(0x2c32, 0x11); + bus.write(0x2c34, 0x22); + bus.write(0x2c38, 0x44); + bus.write(0x2c40, 0x88); + + // Set offset in X register. + cpu.setXRegister(0x30); + + bus.loadProgram(0x1d, 0x00, 0x2c, // ORA $2c00,X + 0x1d, 0x02, 0x2c, // ORA $2c02,X + 0x1d, 0x04, 0x2c, // ORA $2c04,X + 0x1d, 0x08, 0x2c, // ORA $2c08,X + 0x1d, 0x10, 0x2c); // ORA $2c10,X + + cpu.step(); + assertEquals(0x00, cpu.getAccumulator()); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x11, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x33, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x77, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0xff, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + + } + + /* ASL - Arithmetic Shift Left - $1e */ + + public void test_ASL() { + bus.write(0x2c30, 0x00); + bus.write(0x2c31, 0x01); + bus.write(0x2c32, 0x02); + bus.write(0x2c33, 0x44); + bus.write(0x2c34, 0x80); + + // Set offset in X register. + cpu.setXRegister(0x30); + + bus.loadProgram(0x1e, 0x00, 0x2c, // ASL $2c00,X + 0x1e, 0x01, 0x2c, // ASL $2c01,X + 0x1e, 0x02, 0x2c, // ASL $2c02,X + 0x1e, 0x03, 0x2c, // ASL $2c03,X + 0x1e, 0x04, 0x2c); // ASL $2c04,X + + cpu.step(); + assertEquals(0x00, bus.read(0x2c30)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x02, bus.read(0x2c31)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x04, bus.read(0x2c32)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x88, bus.read(0x2c33)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x00, bus.read(0x2c34)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getCarryFlag()); + } + + /* AND - Logical AND - $3d */ + + public void test_AND() { + bus.write(0x1a30, 0x00); + bus.write(0x1a31, 0x11); + bus.write(0x1a32, 0xff); + bus.write(0x1a33, 0x99); + bus.write(0x1a34, 0x11); + bus.write(0x1a35, 0x0f); + bus.write(0x1a02, 0x11); + + // Set offset in X register. + cpu.setXRegister(0x30); + + bus.loadProgram(0x3d, 0x00, 0x1a, // AND $1a00,X + 0x3d, 0x01, 0x1a, // AND $1a01,X + 0xa9, 0xaa, // LDA #$aa + 0x3d, 0x02, 0x1a, // AND $1a02,X + 0x3d, 0x03, 0x1a, // AND $1a03,X + 0x3d, 0x04, 0x1a, // AND $1a04,X + 0xa9, 0xff, // LDA #$ff + 0x3d, 0x05, 0x1a, // AND $1a05,X + 0xa9, 0x01, // LDA #$01 + 0x3d, 0xd2, 0x1a); // AND $1ad2,X + cpu.step(); + assertEquals(0x00, cpu.getAccumulator()); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x00, cpu.getAccumulator()); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(2); + assertEquals(0xaa, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x88, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x00, cpu.getAccumulator()); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(2); + assertEquals(0x0f, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(2); + assertEquals(0x01, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + } + + /* ROL - Rotate Shift Left - $3e */ + + public void test_ROL() { + + bus.write(0x1070, 0x00); + bus.write(0x1071, 0x01); + + // Set offset in X register + cpu.setXRegister(0x70); + + bus.loadProgram(0x3e, 0x00, 0x10, // ROL $1000,X (m=%00000000, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%00000010, c=0) + 0x38, // SEC (m=%00000010, c=1) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%00000101, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%00001010, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%00010100, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%00101000, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%01010000, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%10100000, c=0) + 0x3e, 0x01, 0x10, // ROL $1001,X (m=%01000000, c=1) + 0x3e, 0x01, 0x10); // ROL $1001,X (m=%10000001, c=0) + + cpu.step(); + assertEquals(0x00, bus.read(0x1070)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x02, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(2); + assertEquals(0x05, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x0a, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x14, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x28, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x50, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0xa0, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x40, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x81, bus.read(0x1071)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + } + + /* EOR - Exclusive OR - $5d */ + + public void test_EOR() { + bus.write(0xab40, 0x00); + bus.write(0xab41, 0xff); + bus.write(0xab42, 0x33); + bus.write(0xab43, 0x44); + + cpu.setXRegister(0x30); + + bus.loadProgram(0xa9, 0x88, // LDA #$88 + 0x5d, 0x10, 0xab, // EOR $ab10,X + 0x5d, 0x11, 0xab, // EOR $ab11,X + 0x5d, 0x12, 0xab, // EOR $ab12,X + 0x5d, 0x13, 0xab); // EOR $ab13,X + cpu.step(2); + assertEquals(0x88, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getZeroFlag()); + + cpu.step(); + assertEquals(0x77, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getZeroFlag()); + + cpu.step(); + assertEquals(0x44, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getZeroFlag()); + + cpu.step(); + assertEquals(0x00, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getZeroFlag()); + } + + /* LSR - Logical Shift Right - $5e */ + + public void test_LSR() { + bus.write(0xab30, 0x00); + bus.write(0xab31, 0x01); + bus.write(0xab32, 0x02); + bus.write(0xab33, 0x44); + bus.write(0xab34, 0x80); + bus.write(0xab35, 0x02); + + cpu.setXRegister(0x30); + + bus.loadProgram(0x5e, 0x00, 0xab, // LSR $ab00,X + 0x5e, 0x01, 0xab, // LSR $ab01,X + 0x5e, 0x02, 0xab, // LSR $ab02,X + 0x5e, 0x03, 0xab, // LSR $ab03,X + 0x5e, 0x04, 0xab, // LSR $ab04,X + 0x38, // SEC + 0x5e, 0x05, 0xab); // LSR $ab05,X + + cpu.step(); + assertEquals(0x00, bus.read(0xab30)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x00, bus.read(0xab31)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x01, bus.read(0xab32)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x22, bus.read(0xab33)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x40, bus.read(0xab34)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + // Setting Carry should not affect the result. + cpu.step(2); + assertEquals(0x01, bus.read(0xab35)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + } + + /* ADC - Add with Carry - $7d */ + + public void test_ADC() { + bus.write(0xab40, 0x01); + bus.write(0xab41, 0xff); + + cpu.setXRegister(0x30); + + bus.loadProgram(0xa9, 0x00, // LDA #$00 + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(2); + assertEquals(0x01, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x7f, // LDA #$7f + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(2); + assertEquals(0x80, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertTrue(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x80, // LDA #$80 + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(2); + assertEquals(0x81, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0xff, // LDA #$ff + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(2); + assertEquals(0x00, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertTrue(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x00, // LDA #$00 + 0x7d, 0x11, 0xab); // ADC $ab11,X + cpu.step(2); + assertEquals(0xff, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x7f, // LDA #$7f + 0x7d, 0x11, 0xab); // ADC $ab11,X + cpu.step(2); + assertEquals(0x7e, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x80, // LDA #$80 + 0x7d, 0x11, 0xab); // ADC $ab11,X + cpu.step(2); + assertEquals(0x7f, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0xff, // LDA #$ff + 0x7d, 0x11, 0xab); // ADC $ab11,X + cpu.step(2); + assertEquals(0xfe, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + } + + public void test_ADC_IncludesCarry() { + bus.write(0xab40, 0x01); + + bus.loadProgram(0xa9, 0x00, // LDA #$00 + 0x38, // SEC + 0x7d, 0x10, 0xab); // ADC $ab10,X + + cpu.setXRegister(0x30); + + cpu.step(3); + assertEquals(0x02, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + } + + public void test_ADC_DecimalMode() { + bus.write(0xab40, 0x01); + bus.write(0xab41, 0x99); + + bus.loadProgram(0xf8, // SED + 0xa9, 0x01, // LDA #$01 + 0x7d, 0x10, 0xab); // ADC $ab10,X + + cpu.setXRegister(0x30); + + cpu.step(3); + assertEquals(0x02, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xf8, // SED + 0xa9, 0x49, // LDA #$49 + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(3); + assertEquals(0x50, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xf8, // SED + 0xa9, 0x50, // LDA #$50 + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(3); + assertEquals(0x51, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xf8, // SED + 0xa9, 0x99, // LDA #$99 + 0x7d, 0x10, 0xab); // ADC $ab10,X + cpu.step(3); + assertEquals(0x00, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertTrue(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xf8, // SED + 0xa9, 0x00, // LDA #$00 + 0x7d, 0x11, 0xab); // ADC $ab10,X + cpu.step(3); + assertEquals(0x99, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xf8, // SED + 0xa9, 0x49, // LDA #$49 + 0x7d, 0x11, 0xab); // ADC $ab11,X + cpu.step(3); + assertEquals(0x48, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xf8, // SED + 0xa9, 0x50, // LDA #$59 + 0x7d, 0x11, 0xab); // ADC $ab11,X + cpu.step(3); + assertEquals(0x49, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + } + + /* ROR - Rotate Right - $7e */ + + public void test_ROR() { + + bus.write(0xab40, 0x00); + bus.write(0xab41, 0x10); + + bus.loadProgram(0x7e, 0x10, 0xab, // ROR $ab10 (m=%00000000, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%00001000, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%00000100, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%00000010, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%00000001, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%00000000, c=1) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%10000000, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%01000000, c=0) + 0x7e, 0x11, 0xab, // ROR $ab11 (m=%00100000, c=0) + 0x7e, 0x11, 0xab); // ROR $ab11 (m=%00010000, c=0) + + cpu.setXRegister(0x30); + + cpu.step(); + assertEquals(0x00, bus.read(0xab40)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x08, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x04, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x02, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x01, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x00, bus.read(0xab41)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x80, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x40, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x20, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.step(); + assertEquals(0x10, bus.read(0xab41)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getCarryFlag()); + } + + /* STA - Store Accumulator - $9d */ + + public void test_STA() { + cpu.setXRegister(0x30); + + cpu.setAccumulator(0x00); + bus.loadProgram(0x9d, 0x10, 0xab); // STA $ab10,X + cpu.step(); + assertEquals(0x00, bus.read(0xab40)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.reset(); + + cpu.setAccumulator(0x0f); + bus.loadProgram(0x9d, 0x10, 0xab); // STA $ab10,X + cpu.step(); + assertEquals(0x0f, bus.read(0xab40)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.reset(); + + cpu.setAccumulator(0x80); + bus.loadProgram(0x9d, 0x10, 0xab); // STA $ab10,X + cpu.step(); + assertEquals(0x80, bus.read(0xab40)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + } + + /* LDY - Load Y Register - $bc */ + + public void test_LDY() { + bus.write(0xab45, 0x00); + bus.write(0xab46, 0x0f); + bus.write(0xab47, 0x80); + + bus.loadProgram(0xbc, 0x10, 0xab, // LDY $ab10,X + 0xbc, 0x11, 0xab, // LDY $ab11,X + 0xbc, 0x12, 0xab); // LDY $ab12,X + + cpu.setXRegister(0x35); + + cpu.step(); + assertEquals(0x00, cpu.getYRegister()); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x0f, cpu.getYRegister()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x80, cpu.getYRegister()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + } + + /* LDA - Load Accumulator - $bd */ + + public void test_LDA() { + bus.write(0xab42, 0x00); + bus.write(0xab43, 0x0f); + bus.write(0xab44, 0x80); + + bus.loadProgram(0xbd, 0x10, 0xab, // LDA $ab10,X + 0xbd, 0x11, 0xab, // LDA $ab11,X + 0xbd, 0x12, 0xab); // LDA $ab12,X + + cpu.setXRegister(0x32); + + cpu.step(); + assertEquals(0x00, cpu.getAccumulator()); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x0f, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x80, cpu.getAccumulator()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + } + + /* CMP - Compare Accumulator - $dd */ + + public void test_CMP() { + bus.write(0xab40, 0x00); + bus.write(0xab41, 0x80); + bus.write(0xab42, 0xff); + + cpu.setAccumulator(0x80); + + bus.loadProgram(0xdd, 0x10, 0xab, // CMP $ab10,X + 0xdd, 0x11, 0xab, // CMP $ab11,X + 0xdd, 0x12, 0xab); // CMP $ab12,X + + cpu.setXRegister(0x30); + + cpu.step(); + assertTrue(cpu.getCarryFlag()); // m > y + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); // m - y < 0 + + cpu.step(); + assertTrue(cpu.getCarryFlag()); // m = y + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); // m - y == 0 + + cpu.step(); + assertFalse(cpu.getCarryFlag()); // m < y + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); // m - y > 0 + } + + /* DEC - Decrement Memory Location - $de */ + + public void test_DEC() { + bus.write(0xab40, 0x00); + bus.write(0xab41, 0x01); + bus.write(0xab42, 0x80); + bus.write(0xab43, 0xff); + + bus.loadProgram(0xde, 0x10, 0xab, // DEC $ab10,X + 0xde, 0x11, 0xab, // DEC $ab11,X + 0xde, 0x12, 0xab, // DEC $ab12,X + 0xde, 0x13, 0xab); // DEC $ab13,X + + cpu.setXRegister(0x30); + + cpu.step(); + assertEquals(0xff, bus.read(0xab40)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x00, bus.read(0xab41)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x7f, bus.read(0xab42)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0xfe, bus.read(0xab43)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + } + + /* SBC - Subtract with Carry - $fd */ + + public void test_SBC() { + bus.write(0xab40, 0x01); + + bus.loadProgram(0xa9, 0x00, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(2); + assertEquals(0xfe, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x7f, // LDA #$7f + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(2); + assertEquals(0x7d, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x80, // LDA #$80 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(2); + assertEquals(0x7e, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertTrue(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0xff, // LDA #$ff + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(2); + assertEquals(0xfd, cpu.getAccumulator()); + assertTrue(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + bus.loadProgram(0xa9, 0x02, // LDA #$02 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(2); + assertEquals(0x00, cpu.getAccumulator()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertTrue(cpu.getZeroFlag()); + assertTrue(cpu.getCarryFlag()); + } + + public void test_SBC_IncludesNotOfCarry() { + bus.write(0xab40, 0x01); + + // Subtrace with Carry Flag cleared + bus.loadProgram(0x18, // CLC + 0xa9, 0x05, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x03, cpu.getAccumulator()); + + cpu.reset(); + + // Subtrace with Carry Flag cleared + bus.loadProgram(0x18, // CLC + 0xa9, 0x00, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0xfe, cpu.getAccumulator()); + + cpu.reset(); + + // Subtract with Carry Flag set + bus.loadProgram(0x38, // SEC + 0xa9, 0x05, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x04, cpu.getAccumulator()); + assertTrue(cpu.getCarryFlag()); + + cpu.reset(); + + // Subtract with Carry Flag set + bus.loadProgram(0x38, // SEC + 0xa9, 0x00, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0xff, cpu.getAccumulator()); + assertFalse(cpu.getCarryFlag()); + + } + + public void test_SBC_DecimalMode() { + bus.write(0xab40, 0x01); + bus.write(0xab50, 0x11); + + bus.loadProgram(0xf8, // SED + 0xa9, 0x00, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x98, cpu.getAccumulator()); + assertFalse(cpu.getCarryFlag()); // borrow = set flag + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + + cpu.reset(); + + bus.loadProgram(0xf8, // SED + 0xa9, 0x99, // LDA #$99 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x97, cpu.getAccumulator()); + assertTrue(cpu.getCarryFlag()); // No borrow = clear flag + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + + cpu.reset(); + + bus.loadProgram(0xf8, // SED + 0xa9, 0x50, // LDA #$50 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x48, cpu.getAccumulator()); + assertTrue(cpu.getCarryFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + + + cpu.reset(); + + bus.loadProgram(0xf8, // SED + 0xa9, 0x02, // LDA #$02 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x00, cpu.getAccumulator()); + assertTrue(cpu.getCarryFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertTrue(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + + cpu.reset(); + + bus.loadProgram(0xf8, // SED + 0xa9, 0x10, // LDA #$10 + 0xfd, 0x20, 0xab); // SBC $ab20,X + cpu.setXRegister(0x30); + cpu.step(3); + assertEquals(0x98, cpu.getAccumulator()); + assertFalse(cpu.getCarryFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + + cpu.reset(); + + bus.loadProgram(0x38, // SEC + 0xf8, // SED + 0xa9, 0x05, // LDA #$05 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(4); + assertEquals(0x04, cpu.getAccumulator()); + assertTrue(cpu.getCarryFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + + cpu.reset(); + + bus.loadProgram(0x38, // SEC + 0xf8, // SED + 0xa9, 0x00, // LDA #$00 + 0xfd, 0x10, 0xab); // SBC $ab10,X + cpu.setXRegister(0x30); + cpu.step(4); + assertEquals(0x99, cpu.getAccumulator()); + assertFalse(cpu.getCarryFlag()); + assertFalse(cpu.getNegativeFlag()); + assertFalse(cpu.getOverflowFlag()); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getDecimalModeFlag()); + } + + /* INC - Increment Memory Location - $fe */ + + public void test_INC() { + bus.write(0xab30, 0x00); + bus.write(0xab31, 0x7f); + bus.write(0xab32, 0xff); + + cpu.setXRegister(0x20); + + bus.loadProgram(0xfe, 0x10, 0xab, // INC $ab10,X + 0xfe, 0x11, 0xab, // INC $ab11,X + 0xfe, 0x12, 0xab); // INC $ab12,X + + cpu.step(); + assertEquals(0x01, bus.read(0xab30)); + assertFalse(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x80, bus.read(0xab31)); + assertFalse(cpu.getZeroFlag()); + assertTrue(cpu.getNegativeFlag()); + + cpu.step(); + assertEquals(0x00, bus.read(0xab32)); + assertTrue(cpu.getZeroFlag()); + assertFalse(cpu.getNegativeFlag()); + } + +}