From 3daca0e5dbe912531b0fbb52e1c0693beb852d55 Mon Sep 17 00:00:00 2001 From: Lauchmelder Date: Thu, 25 Aug 2022 00:40:30 +0200 Subject: [PATCH] yet more instructions --- src/cpu.rs | 22 ++++++- src/instructions.rs | 151 ++++++++++++++++++++++++++++++++++++++------ 2 files changed, 154 insertions(+), 19 deletions(-) diff --git a/src/cpu.rs b/src/cpu.rs index 2f98aa3..f25cfc3 100644 --- a/src/cpu.rs +++ b/src/cpu.rs @@ -74,6 +74,7 @@ impl CPU instr_set[0x30] = instr!(bmi, rel, 2, 2); instr_set[0x38] = instr!(sec, imp, 2, 1); + instr_set[0x40] = instr!(rti, imp, 6, 1); instr_set[0x48] = instr!(pha, imp, 3, 1); instr_set[0x49] = instr!(eor, imm, 2, 2); instr_set[0x4C] = instr!(jmp, abs, 3, 3); @@ -82,26 +83,45 @@ impl CPU instr_set[0x60] = instr!(rts, imp, 6, 1); instr_set[0x68] = instr!(pla, imp, 4, 1); - + instr_set[0x69] = instr!(adc, imm, 2, 2); + instr_set[0x70] = instr!(bvs, rel, 2, 2); instr_set[0x78] = instr!(sei, imp, 2, 1); + instr_set[0x84] = instr!(sty, zpg, 3, 2); instr_set[0x85] = instr!(sta, zpg, 3, 2); instr_set[0x86] = instr!(stx, zpg, 3, 2); + instr_set[0x88] = instr!(dey, imp, 2, 1); + instr_set[0x8A] = instr!(txa, imp, 2, 1); + instr_set[0x8E] = instr!(stx, abs, 4, 3); instr_set[0x90] = instr!(bcc, rel, 2, 2); + instr_set[0x98] = instr!(tya, imp, 2, 1); + instr_set[0x9A] = instr!(txs, imp, 2, 1); + instr_set[0xA0] = instr!(ldy, imm, 2, 2); instr_set[0xA2] = instr!(ldx, imm, 2, 2); + instr_set[0xA8] = instr!(tay, imp, 2, 1); instr_set[0xA9] = instr!(lda, imm, 2, 2); + instr_set[0xAA] = instr!(tax, imp, 2, 1); + instr_set[0xAD] = instr!(lda, abs, 4, 3); + instr_set[0xAE] = instr!(ldx, abs, 4, 3); instr_set[0xB0] = instr!(bcs, rel, 2, 2); instr_set[0xB8] = instr!(clv, imp, 2, 1); + instr_set[0xBA] = instr!(tsx, imp, 2, 1); + instr_set[0xC0] = instr!(cpy, imm, 2, 2); + instr_set[0xC8] = instr!(iny, imp, 2, 1); instr_set[0xC9] = instr!(cmp, imm, 2, 2); + instr_set[0xCA] = instr!(dex, imp, 2, 1); instr_set[0xD0] = instr!(bne, rel, 2, 2); instr_set[0xD8] = instr!(cld, imp, 2, 1); + instr_set[0xE0] = instr!(cpx, imm, 2, 2); + instr_set[0xE8] = instr!(inx, imp, 2, 1); + instr_set[0xE9] = instr!(sbc, imm, 2, 2); instr_set[0xEA] = instr!(nop, imp, 2, 1); instr_set[0xF0] = instr!(beq, rel, 2, 2); diff --git a/src/instructions.rs b/src/instructions.rs index b6c20ed..9897a24 100644 --- a/src/instructions.rs +++ b/src/instructions.rs @@ -132,6 +132,64 @@ macro_rules! store_fn }; } +macro_rules! transfer_fn +{ + ($name: ident, $from: ident, $to: ident) => + { + pub fn $name(&mut self) + { + self.$to = self.$from; + + match stringify!($to) + { + "sp" => {}, + _ => { + set_flag_to!(self.p, Bit::Negative, (self.$to >> 7) == 0x01); + set_flag_to!(self.p, Bit::Zero, self.$to == 0); + } + }; + } + } +} + +macro_rules! inc_dec_fn +{ + ($name: ident, $register: ident, $increment: literal) => + { + pub fn $name(&mut self) + { + match $increment + { + false => self.$register = self.$register.wrapping_sub(1), + true => self.$register = self.$register.wrapping_add(1) + } + + set_flag_to!(self.p, Bit::Negative, (self.$register >> 7) == 1); + set_flag_to!(self.p, Bit::Zero, self.$register == 0); + } + }; + + ($name: ident, $increment: literal) => + { + pub fn $name(&mut self) + { + let bus = self.bus.upgrade().unwrap(); + let mut value = self.fetch(); + + match $increment + { + false => value = value.wrapping_sub(1), + true => value = value.wrapping_add(1) + } + + set_flag_to!(self.p, Bit::Negative, (value >> 7) == 1); + set_flag_to!(self.p, Bit::Zero, value == 0); + + bus.borrow_mut().write_cpu(self.absolute_addr, value); + } + }; +} + macro_rules! cmp_fn { ($name: ident, $register: ident) => @@ -143,7 +201,7 @@ macro_rules! cmp_fn set_flag_to!(self.p, Bit::Zero, self.$register == value); set_flag_to!(self.p, Bit::Carry, self.$register >= value); - set_flag_to!(self.p, Bit::Negative, (value >> 7) != 0); + set_flag_to!(self.p, Bit::Negative, (result >> 7) != 0); } } } @@ -156,22 +214,22 @@ impl CPU return bus.borrow().read_cpu(self.absolute_addr); } - branch_on_fn!(bcc, Bit::Carry, false); - branch_on_fn!(bcs, Bit::Carry, true); - branch_on_fn!(bne, Bit::Zero, false); - branch_on_fn!(beq, Bit::Zero, true); - branch_on_fn!(bpl, Bit::Negative, false); - branch_on_fn!(bmi, Bit::Negative, true); - branch_on_fn!(bvc, Bit::Overflow, false); - branch_on_fn!(bvs, Bit::Overflow, true); + branch_on_fn!(bcc, Bit::Carry, false); + branch_on_fn!(bcs, Bit::Carry, true); + branch_on_fn!(bne, Bit::Zero, false); + branch_on_fn!(beq, Bit::Zero, true); + branch_on_fn!(bpl, Bit::Negative, false); + branch_on_fn!(bmi, Bit::Negative, true); + branch_on_fn!(bvc, Bit::Overflow, false); + branch_on_fn!(bvs, Bit::Overflow, true); - set_flag_fn!(clc, Bit::Carry, false); - set_flag_fn!(sec, Bit::Carry, true); - set_flag_fn!(sei, Bit::Interrupt, true); - set_flag_fn!(cli, Bit::Interrupt, false); - set_flag_fn!(sed, Bit::Decimal, true); - set_flag_fn!(cld, Bit::Decimal, false); - set_flag_fn!(clv, Bit::Overflow, false); + set_flag_fn!(clc, Bit::Carry, false); + set_flag_fn!(sec, Bit::Carry, true); + set_flag_fn!(sei, Bit::Interrupt, true); + set_flag_fn!(cli, Bit::Interrupt, false); + set_flag_fn!(sed, Bit::Decimal, true); + set_flag_fn!(cld, Bit::Decimal, false); + set_flag_fn!(clv, Bit::Overflow, false); load_fn!(lda, acc); load_fn!(ldx, x); @@ -181,10 +239,52 @@ impl CPU store_fn!(stx, x); store_fn!(sty, y); + transfer_fn!(tax, acc, x); + transfer_fn!(tay, acc, y); + transfer_fn!(tsx, sp, x); + transfer_fn!(txa, x, acc); + transfer_fn!(tya, y, acc); + transfer_fn!(txs, x, sp); + cmp_fn!(cmp, acc); cmp_fn!(cpx, x); cmp_fn!(cpy, y); + inc_dec_fn!(inc, true); + inc_dec_fn!(inx, x, true); + inc_dec_fn!(iny, y, true); + + inc_dec_fn!(dec, false); + inc_dec_fn!(dex, x, false); + inc_dec_fn!(dey, y, false); + + + pub fn adc(&mut self) + { + let value = self.fetch() as u16; + let result = (self.acc as u16) + value + (test_flag!(self.p, Bit::Carry) as u16); + + set_flag_to!(self.p, Bit::Carry, (result & 0xFF00) != 0x0000); + set_flag_to!(self.p, Bit::Negative, ((result >> 7) & 0x0001) == 0x0001); + set_flag_to!(self.p, Bit::Zero, (result & 0x00FF) == 0x0000); + set_flag_to!(self.p, Bit::Overflow, ((result ^ value) & (result ^ self.acc as u16) & 0x80) == 0x80); + + self.acc = result as u8; + } + + pub fn sbc(&mut self) + { + let value = !(self.fetch() as u16); + let result = (self.acc as u16).wrapping_add(value).wrapping_add(test_flag!(self.p, Bit::Carry) as u16); + + set_flag_to!(self.p, Bit::Carry, (result & 0xFF00) == 0x0000); + set_flag_to!(self.p, Bit::Negative, ((result >> 7) & 0x0001) == 0x0001); + set_flag_to!(self.p, Bit::Zero, (result & 0x00FF) == 0x0000); + set_flag_to!(self.p, Bit::Overflow, ((result ^ value) & (result ^ self.acc as u16) & 0x80) == 0x80); + + self.acc = result as u8; + } + pub fn and(&mut self) { let val = self.fetch(); @@ -259,7 +359,6 @@ impl CPU set_flag_to!(self.p, Bit::Zero, self.acc == 0); } - pub fn php(&mut self) { let bus = self.bus.upgrade().unwrap(); @@ -276,12 +375,28 @@ impl CPU let bus = self.bus.upgrade().unwrap(); let flag: u8 = pop(bus.borrow(), &mut self.sp); - let mask: u8 = 0b1100111; + let mask: u8 = 0b11001111; self.p &= !mask; self.p |= flag & mask; } + pub fn rti(&mut self) + { + let bus = self.bus.upgrade().unwrap(); + + let flag: u8 = pop(bus.borrow(), &mut self.sp); + let mask: u8 = 0b11001111; + + self.p &= !mask; + self.p |= flag & mask; + + let lo = pop(bus.borrow(), &mut self.sp) as u16; + let hi = pop(bus.borrow(), &mut self.sp) as u16; + + self.pc = (hi << 8) | lo; + } + pub fn rts(&mut self) { let bus = self.bus.upgrade().unwrap();