other testing complete, rti not tested due to needing further implementation support; first version of cpu

Author: derzz

src/cpu.rs

@@ -7,6 +7,7 @@ mod branch_test;
 mod group1_test;
 mod group2_test;
 mod group3_test;
+mod other_test;
 mod op;
 mod sb1_test;
 mod sb2_test;
@@ -875,7 +876,7 @@ impl CPU {
     fn brk(&mut self) {
         println!("brk: Initalized");
         println!("brk: pc is {}", self.pc);
-        self.stack_push_u16(self.pc + 2 - 1);
+        self.stack_push_u16(self.pc.wrapping_add(2));
         self.stack_push(self.flags.bits());
         self.flags.insert(CpuFlags::INTERRUPT_DISABLE);
         self.pc = self.mem_read_u16(0xFFFE);
@@ -884,18 +885,27 @@ impl CPU {
 
     fn jsr(&mut self) {
         // Pushes the 16 bit value after self.pc
-        self.stack_push_u16(self.pc + 2 - 1);
-        self.pc = self.mem_read_u16(self.pc);
+        // Note that self.pc is already on the memory value so we just need to push this part + 1
+        // Eg. JSR 0xAA 0xBB, we would be pushing the memory address of 0xBB
+        // When rts is called, pc will add 1 automatically so it returns from the next function
+        println!("jsr: Initalized! The instruction's address is {:#x}", self.pc);
+        self.stack_push_u16(self.pc.wrapping_add(2));
+        // Need to subtract one at the end as run() will add one automatically
+        self.pc = self.mem_read_u16(self.pc.wrapping_add(1)).wrapping_sub(1);
     }
 
     fn rti(&mut self) {
+        // Most likely coming from a BRK(software IRQ)- BRK is treated as a 2 byte instruction with an unused immediate
         self.flags = CpuFlags::from_bits_truncate(self.stack_pop());
         self.pc = self.stack_pop_u16();
+        // Need to subtract one pc to balance out with the end of run(), which adds one to pc
+        self.pc = self.pc.wrapping_sub(1);
     }
 
     fn rts(&mut self) {
         self.pc = self.stack_pop_u16();
-        self.pc += 1;
+        println!("rts: Finished. The pc before finishing run is {:#x}", self.pc);
+        // self.pc does not need to be added as at the end of run, the pc will be added by 1 automatically
     }
 
     fn group_three(&mut self, aaa: u8, bbb: u8, _cc: u8) {

src/cpu/op.rs

@@ -114,3 +114,10 @@ pub mod branch_op {
     pub const BNE: u8 = 0xD0; // Branch on Not Equal (Z=0)
     pub const BEQ: u8 = 0xF0; // Branch on Equal (Z=1)
 }
+
+#[cfg(test)]
+pub mod other_op{
+    pub const JSR:u8 = 0x20;
+    pub const RTI: u8 = 0x40;
+    pub const RTS: u8 = 0x60;
+}

src/cpu/other_test.rs

@@ -0,0 +1,24 @@
+
+#[cfg(test)]
+mod branch_test {
+    use crate::cpu::op::*;
+    use crate::cpu::CpuFlags;
+    use crate::cpu::CPU;
+
+    // BRK is not tested as every other test hinges on BRK working...
+
+    // JSR and RTS are tested together to see if INX is called
+    // 0x8000 is for jsr, 8001 + 8002 is to store address
+    // One test for jumping to a forward subroutine, another test for jumping to a previous subroutine
+    #[test]
+    fn test_jsr_rts(){
+        let mut cpu = CPU::new();
+        cpu.load_and_run(vec![other_op::JSR, 0x05, 0x80, op::INY, 0x00, op::INX, other_op::RTS]);
+        assert!(cpu.x == 1 && cpu.y == 1, "JSR and RTS test failed! cpu.x is {}, cpu.y is {}", cpu.x, cpu.y);
+    }
+
+
+    // JSR, PHP are done for RTI testing
+    // Check if custom flags are the same from the stack AND if INX is called
+    // in fffe link to address, run programs in ram from 0x0000 to 0x8000, 
+}