EOR

snes-core/src/cpu/instructions.rs

@@ -215,7 +215,22 @@ impl CPU {
             let (result, affected_flags) = alu::and(target as u8, value);
             self.registers.set_low_a(result);
             self.registers.set_flags(&affected_flags);
+        }
+        self.increment_cycles_bitwise(addressing_mode);
+    }
 
+    fn eor(&mut self, bus: &Bus, addressing_mode: AddressingMode) {
+        let target = self.registers.a;
+        if self.registers.is_16bit_mode() {
+            let value = self.get_16bit_from_address(bus, addressing_mode);
+            let (result, affected_flags) = alu::eor(target, value);
+            self.registers.a = result;
+            self.registers.set_flags(&affected_flags);
+        } else {
+            let value = self.get_8bit_from_address(bus, addressing_mode);
+            let (result, affected_flags) = alu::eor(target as u8, value);
+            self.registers.set_low_a(result);
+            self.registers.set_flags(&affected_flags);
         }
         self.increment_cycles_bitwise(addressing_mode);
     }
@@ -512,6 +527,22 @@ impl CPU {
             0xCA => self.dex(),
             // DEY
             0x88 => self.dey(),
+            // EOR
+            0x49 => self.eor(bus, A::Immediate),
+            0x4D => self.eor(bus, A::Absolute),
+            0x4F => self.eor(bus, A::AbsoluteLong),
+            0x45 => self.eor(bus, A::DirectPage),
+            0x52 => self.eor(bus, A::DirectPageIndirect),
+            0x47 => self.eor(bus, A::DirectPageIndirectLong),
+            0x5D => self.eor(bus, A::AbsoluteIndexed(I::X)),
+            0x5F => self.eor(bus, A::AbsoluteLongIndexed(I::X)),
+            0x59 => self.eor(bus, A::AbsoluteIndexed(I::Y)),
+            0x55 => self.eor(bus, A::DirectPageIndexed(I::X)),
+            0x41 => self.eor(bus, A::DirectPageIndexedIndirect(I::X)),
+            0x51 => self.eor(bus, A::DirectPageIndirectIndexed(I::Y)),
+            0x57 => self.eor(bus, A::DirectPageIndirectLongIndexed(I::Y)),
+            0x43 => self.eor(bus, A::StackRelative),
+            0x53 => self.eor(bus, A::StackRelativeIndirectIndexed(I::Y)),
             _ => println!("Invalid opcode: {:02X}", opcode),
         }
     }
@@ -537,6 +568,23 @@ mod cpu_instructions_tests {
         assert!(!cpu.registers.get_carry_flag());
     }
 
+    #[test]
+    fn test_eor() {
+        let mut cpu = CPU::new();
+        let mut bus = Bus::new();
+        cpu.registers.a   = 0x0F;
+        cpu.registers.pbr = 0x00;
+        cpu.registers.pc  = 0x0000;
+        cpu.registers.set_16bit_mode(false);
+        bus.write(0x000001, 0xF0);
+        cpu.eor(&bus, AddressingMode::Immediate);
+        assert_eq!(cpu.registers.a, 0xFF);
+        assert_eq!(cpu.registers.pc, 0x02);
+        assert_eq!(cpu.cycles, 2);
+        assert!(cpu.registers.get_negative_flag());
+        assert!(!cpu.registers.get_zero_flag());
+    }
+
     #[test]
     fn test_sbc() {
         let mut cpu = CPU::new();

snes-core/src/utils/alu.rs

@@ -109,7 +109,7 @@ pub fn asl<T: SnesNum>(target: T) -> (T, [Flags; 3]) {
     ])
 }
 
-pub fn xor<T: SnesNum>(target: T, value: T) -> (T, [Flags; 2]) {
+pub fn eor<T: SnesNum>(target: T, value: T) -> (T, [Flags; 2]) {
     let result = target.xor(value);
     (result, [
         Negative(result.is_negative()),
@@ -328,20 +328,20 @@ mod alu_tests {
     #[test]
     fn test_xor() {
         // 8 bit
-        let (result, affected_flags) = xor(0b0101_0101_u8, 0b0101_0101_u8);
+        let (result, affected_flags) = eor(0b0101_0101_u8, 0b0101_0101_u8);
         assert_eq!(result, 0);
         assert_eq!(affected_flags, [Negative(false), Zero(true)]);
 
-        let (result, affected_flags) = xor(0b1000_0000_u8, 0b0000_0000_u8);
+        let (result, affected_flags) = eor(0b1000_0000_u8, 0b0000_0000_u8);
         assert_eq!(result, 0b1000_0000);
         assert_eq!(affected_flags, [Negative(true), Zero(false)]);
 
         // 16 bit
-        let (result, affected_flags) = xor(0b01010101_00000000_u16, 0b01010101_00000000_u16);
+        let (result, affected_flags) = eor(0b01010101_00000000_u16, 0b01010101_00000000_u16);
         assert_eq!(result, 0);
         assert_eq!(affected_flags, [Negative(false), Zero(true)]);
 
-        let (result, affected_flags) = xor(0b10000000_00000000_u16, 0b00000000_00000000_u16);
+        let (result, affected_flags) = eor(0b10000000_00000000_u16, 0b00000000_00000000_u16);
         assert_eq!(result, 0b10000000_00000000);
         assert_eq!(affected_flags, [Negative(true), Zero(false)]);
     }