mirror of
https://github.com/mre/mos6502.git
synced 2025-02-17 17:30:43 +00:00
Starting on implementing different variants (#88)
* start on separating 6502 variants from cpu itself * add a single variant: the NMOS one * get examples & tests running again * Add the Revision A variant, one that has no ROR * disable failing lint in build-time dependencies * Variant with no decimal mode * Revert "disable failing lint in build-time dependencies" This reverts commit c87975e9374e99b593ab20e6f87d7c01cc7ffd03. * some doc comments * specify the variant in unit test now the API has changed --------- Co-authored-by: Sam M W <you@example.com>
This commit is contained in:
parent
b52e47bbb5
commit
11499b6bc8
@ -23,6 +23,7 @@ Source: [Wikipedia](https://en.wikipedia.org/wiki/MOS_Technology_6502)
|
||||
```rust
|
||||
use mos6502::memory::Bus;
|
||||
use mos6502::memory::Memory;
|
||||
use mos6502::instruction::Nmos6502;
|
||||
use mos6502::cpu;
|
||||
|
||||
fn main() {
|
||||
@ -52,7 +53,7 @@ fn main() {
|
||||
0x4c, 0x10, 0x00, // Jump to .algo
|
||||
];
|
||||
|
||||
let mut cpu = cpu::CPU::new(Memory::new());
|
||||
let mut cpu = cpu::CPU::new(Memory::new(), Nmos6502);
|
||||
|
||||
cpu.memory.set_bytes(0x00, &zero_page_data);
|
||||
cpu.memory.set_bytes(0x10, &program);
|
||||
@ -86,6 +87,7 @@ This will create a binary file `euclid.bin` that you can load into the emulator:
|
||||
```rust
|
||||
use mos6502::memory::Bus;
|
||||
use mos6502::memory::Memory;
|
||||
use mos6502::instruction::Nmos6502;
|
||||
use mos6502::cpu;
|
||||
use std::fs::read;
|
||||
|
||||
@ -103,7 +105,7 @@ fn main() {
|
||||
}
|
||||
};
|
||||
|
||||
let mut cpu = cpu::CPU::new(Memory::new());
|
||||
let mut cpu = cpu::CPU::new(Memory::new(), Nmos6502);
|
||||
|
||||
cpu.memory.set_bytes(0x00, &zero_page_data);
|
||||
cpu.memory.set_bytes(0x10, &program);
|
||||
|
@ -1,4 +1,5 @@
|
||||
use mos6502::cpu;
|
||||
use mos6502::instruction::Nmos6502;
|
||||
use mos6502::memory::Bus;
|
||||
use mos6502::memory::Memory;
|
||||
use std::fs::read;
|
||||
@ -22,7 +23,7 @@ fn main() {
|
||||
}
|
||||
};
|
||||
|
||||
let mut cpu = cpu::CPU::new(Memory::new());
|
||||
let mut cpu = cpu::CPU::new(Memory::new(), Nmos6502);
|
||||
|
||||
cpu.memory.set_bytes(0x00, &zero_page_data);
|
||||
cpu.memory.set_bytes(0x10, &program);
|
||||
|
@ -1,6 +1,7 @@
|
||||
extern crate mos6502;
|
||||
|
||||
use mos6502::cpu;
|
||||
use mos6502::instruction::Nmos6502;
|
||||
use mos6502::memory::Bus;
|
||||
use mos6502::memory::Memory;
|
||||
|
||||
@ -35,7 +36,7 @@ fn main() {
|
||||
0x4c, 0x10, 0x00, // Jump to .algo
|
||||
];
|
||||
|
||||
let mut cpu = cpu::CPU::new(Memory::new());
|
||||
let mut cpu = cpu::CPU::new(Memory::new(), Nmos6502);
|
||||
|
||||
cpu.memory.set_bytes(0x00, &zero_page_data);
|
||||
cpu.memory.set_bytes(0x10, &program);
|
||||
|
@ -29,12 +29,13 @@ extern crate mos6502;
|
||||
|
||||
#[cfg(not(test))]
|
||||
use mos6502::cpu;
|
||||
use mos6502::instruction::Nmos6502;
|
||||
use mos6502::memory::Bus;
|
||||
use mos6502::memory::Memory;
|
||||
|
||||
#[cfg(not(test))]
|
||||
fn main() {
|
||||
let mut cpu = cpu::CPU::new(Memory::new());
|
||||
let mut cpu = cpu::CPU::new(Memory::new(), Nmos6502);
|
||||
|
||||
// "Load" a program
|
||||
|
||||
|
233
src/cpu.rs
233
src/cpu.rs
@ -25,8 +25,9 @@
|
||||
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
use crate::instruction::{self, AddressingMode, DecodedInstr, Instruction, OpInput};
|
||||
use crate::instruction::{AddressingMode, DecodedInstr, Instruction, OpInput};
|
||||
use crate::memory::Bus;
|
||||
use crate::Variant;
|
||||
|
||||
use crate::registers::{Registers, StackPointer, Status, StatusArgs};
|
||||
|
||||
@ -37,19 +38,22 @@ fn arr_to_addr(arr: &[u8]) -> u16 {
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct CPU<M>
|
||||
pub struct CPU<M, V>
|
||||
where
|
||||
M: Bus,
|
||||
V: Variant,
|
||||
{
|
||||
pub registers: Registers,
|
||||
pub memory: M,
|
||||
variant: core::marker::PhantomData<V>,
|
||||
}
|
||||
|
||||
impl<M: Bus> CPU<M> {
|
||||
pub fn new(memory: M) -> CPU<M> {
|
||||
impl<M: Bus, V: Variant> CPU<M, V> {
|
||||
pub fn new(memory: M, _variant: V) -> CPU<M, V> {
|
||||
CPU {
|
||||
registers: Registers::new(),
|
||||
memory,
|
||||
variant: core::marker::PhantomData::<V>,
|
||||
}
|
||||
}
|
||||
|
||||
@ -60,7 +64,7 @@ impl<M: Bus> CPU<M> {
|
||||
pub fn fetch_next_and_decode(&mut self) -> Option<DecodedInstr> {
|
||||
let x: u8 = self.memory.get_byte(self.registers.program_counter);
|
||||
|
||||
match instruction::OPCODES[x as usize] {
|
||||
match V::decode(x) {
|
||||
Some((instr, am)) => {
|
||||
let extra_bytes = am.extra_bytes();
|
||||
let num_bytes = extra_bytes + 1;
|
||||
@ -192,6 +196,15 @@ impl<M: Bus> CPU<M> {
|
||||
debug!("add with carry. address: {:?}. value: {}", addr, val);
|
||||
self.add_with_carry(val);
|
||||
}
|
||||
(Instruction::ADCnd, OpInput::UseImmediate(val)) => {
|
||||
debug!("add with carry immediate: {}", val);
|
||||
self.add_with_no_decimal(val);
|
||||
}
|
||||
(Instruction::ADCnd, OpInput::UseAddress(addr)) => {
|
||||
let val = self.memory.get_byte(addr);
|
||||
debug!("add with carry. address: {:?}. value: {}", addr, val);
|
||||
self.add_with_no_decimal(val);
|
||||
}
|
||||
|
||||
(Instruction::AND, OpInput::UseImmediate(val)) => {
|
||||
self.and(val);
|
||||
@ -204,12 +217,12 @@ impl<M: Bus> CPU<M> {
|
||||
(Instruction::ASL, OpInput::UseImplied) => {
|
||||
// Accumulator mode
|
||||
let mut val = self.registers.accumulator;
|
||||
CPU::<M>::shift_left_with_flags(&mut val, &mut self.registers.status);
|
||||
CPU::<M, V>::shift_left_with_flags(&mut val, &mut self.registers.status);
|
||||
self.registers.accumulator = val;
|
||||
}
|
||||
(Instruction::ASL, OpInput::UseAddress(addr)) => {
|
||||
let mut operand: u8 = self.memory.get_byte(addr);
|
||||
CPU::<M>::shift_left_with_flags(&mut operand, &mut self.registers.status);
|
||||
CPU::<M, V>::shift_left_with_flags(&mut operand, &mut self.registers.status);
|
||||
self.memory.set_byte(addr, operand);
|
||||
}
|
||||
|
||||
@ -329,16 +342,16 @@ impl<M: Bus> CPU<M> {
|
||||
|
||||
(Instruction::DEC, OpInput::UseAddress(addr)) => {
|
||||
let mut operand: u8 = self.memory.get_byte(addr);
|
||||
CPU::<M>::decrement(&mut operand, &mut self.registers.status);
|
||||
CPU::<M, V>::decrement(&mut operand, &mut self.registers.status);
|
||||
self.memory.set_byte(addr, operand);
|
||||
}
|
||||
|
||||
(Instruction::DEY, OpInput::UseImplied) => {
|
||||
CPU::<M>::decrement(&mut self.registers.index_y, &mut self.registers.status);
|
||||
CPU::<M, V>::decrement(&mut self.registers.index_y, &mut self.registers.status);
|
||||
}
|
||||
|
||||
(Instruction::DEX, OpInput::UseImplied) => {
|
||||
CPU::<M>::decrement(&mut self.registers.index_x, &mut self.registers.status);
|
||||
CPU::<M, V>::decrement(&mut self.registers.index_x, &mut self.registers.status);
|
||||
}
|
||||
|
||||
(Instruction::EOR, OpInput::UseImmediate(val)) => {
|
||||
@ -351,14 +364,14 @@ impl<M: Bus> CPU<M> {
|
||||
|
||||
(Instruction::INC, OpInput::UseAddress(addr)) => {
|
||||
let mut operand: u8 = self.memory.get_byte(addr);
|
||||
CPU::<M>::increment(&mut operand, &mut self.registers.status);
|
||||
CPU::<M, V>::increment(&mut operand, &mut self.registers.status);
|
||||
self.memory.set_byte(addr, operand);
|
||||
}
|
||||
(Instruction::INX, OpInput::UseImplied) => {
|
||||
CPU::<M>::increment(&mut self.registers.index_x, &mut self.registers.status);
|
||||
CPU::<M, V>::increment(&mut self.registers.index_x, &mut self.registers.status);
|
||||
}
|
||||
(Instruction::INY, OpInput::UseImplied) => {
|
||||
CPU::<M>::increment(&mut self.registers.index_y, &mut self.registers.status);
|
||||
CPU::<M, V>::increment(&mut self.registers.index_y, &mut self.registers.status);
|
||||
}
|
||||
|
||||
(Instruction::JMP, OpInput::UseAddress(addr)) => self.jump(addr),
|
||||
@ -403,12 +416,12 @@ impl<M: Bus> CPU<M> {
|
||||
(Instruction::LSR, OpInput::UseImplied) => {
|
||||
// Accumulator mode
|
||||
let mut val = self.registers.accumulator;
|
||||
CPU::<M>::shift_right_with_flags(&mut val, &mut self.registers.status);
|
||||
CPU::<M, V>::shift_right_with_flags(&mut val, &mut self.registers.status);
|
||||
self.registers.accumulator = val;
|
||||
}
|
||||
(Instruction::LSR, OpInput::UseAddress(addr)) => {
|
||||
let mut operand: u8 = self.memory.get_byte(addr);
|
||||
CPU::<M>::shift_right_with_flags(&mut operand, &mut self.registers.status);
|
||||
CPU::<M, V>::shift_right_with_flags(&mut operand, &mut self.registers.status);
|
||||
self.memory.set_byte(addr, operand);
|
||||
}
|
||||
|
||||
@ -457,23 +470,23 @@ impl<M: Bus> CPU<M> {
|
||||
(Instruction::ROL, OpInput::UseImplied) => {
|
||||
// Accumulator mode
|
||||
let mut val = self.registers.accumulator;
|
||||
CPU::<M>::rotate_left_with_flags(&mut val, &mut self.registers.status);
|
||||
CPU::<M, V>::rotate_left_with_flags(&mut val, &mut self.registers.status);
|
||||
self.registers.accumulator = val;
|
||||
}
|
||||
(Instruction::ROL, OpInput::UseAddress(addr)) => {
|
||||
let mut operand: u8 = self.memory.get_byte(addr);
|
||||
CPU::<M>::rotate_left_with_flags(&mut operand, &mut self.registers.status);
|
||||
CPU::<M, V>::rotate_left_with_flags(&mut operand, &mut self.registers.status);
|
||||
self.memory.set_byte(addr, operand);
|
||||
}
|
||||
(Instruction::ROR, OpInput::UseImplied) => {
|
||||
// Accumulator mode
|
||||
let mut val = self.registers.accumulator;
|
||||
CPU::<M>::rotate_right_with_flags(&mut val, &mut self.registers.status);
|
||||
CPU::<M, V>::rotate_right_with_flags(&mut val, &mut self.registers.status);
|
||||
self.registers.accumulator = val;
|
||||
}
|
||||
(Instruction::ROR, OpInput::UseAddress(addr)) => {
|
||||
let mut operand: u8 = self.memory.get_byte(addr);
|
||||
CPU::<M>::rotate_right_with_flags(&mut operand, &mut self.registers.status);
|
||||
CPU::<M, V>::rotate_right_with_flags(&mut operand, &mut self.registers.status);
|
||||
self.memory.set_byte(addr, operand);
|
||||
}
|
||||
(Instruction::RTI, OpInput::UseImplied) => {
|
||||
@ -505,6 +518,16 @@ impl<M: Bus> CPU<M> {
|
||||
self.subtract_with_carry(val);
|
||||
}
|
||||
|
||||
(Instruction::SBCnd, OpInput::UseImmediate(val)) => {
|
||||
debug!("subtract with carry immediate: {}", val);
|
||||
self.subtract_with_no_decimal(val);
|
||||
}
|
||||
(Instruction::SBCnd, OpInput::UseAddress(addr)) => {
|
||||
let val = self.memory.get_byte(addr);
|
||||
debug!("subtract with carry. address: {:?}. value: {}", addr, val);
|
||||
self.subtract_with_no_decimal(val);
|
||||
}
|
||||
|
||||
(Instruction::SEC, OpInput::UseImplied) => {
|
||||
self.registers.status.or(Status::PS_CARRY);
|
||||
}
|
||||
@ -617,7 +640,7 @@ impl<M: Bus> CPU<M> {
|
||||
..StatusArgs::none()
|
||||
}),
|
||||
);
|
||||
CPU::<M>::set_flags_from_i8(status, *p_val as i8);
|
||||
CPU::<M, V>::set_flags_from_i8(status, *p_val as i8);
|
||||
}
|
||||
|
||||
fn shift_right_with_flags(p_val: &mut u8, status: &mut Status) {
|
||||
@ -631,7 +654,7 @@ impl<M: Bus> CPU<M> {
|
||||
..StatusArgs::none()
|
||||
}),
|
||||
);
|
||||
CPU::<M>::set_flags_from_i8(status, *p_val as i8);
|
||||
CPU::<M, V>::set_flags_from_i8(status, *p_val as i8);
|
||||
}
|
||||
|
||||
fn rotate_left_with_flags(p_val: &mut u8, status: &mut Status) {
|
||||
@ -647,7 +670,7 @@ impl<M: Bus> CPU<M> {
|
||||
..StatusArgs::none()
|
||||
}),
|
||||
);
|
||||
CPU::<M>::set_flags_from_i8(status, *p_val as i8);
|
||||
CPU::<M, V>::set_flags_from_i8(status, *p_val as i8);
|
||||
}
|
||||
|
||||
fn rotate_right_with_flags(p_val: &mut u8, status: &mut Status) {
|
||||
@ -663,16 +686,16 @@ impl<M: Bus> CPU<M> {
|
||||
..StatusArgs::none()
|
||||
}),
|
||||
);
|
||||
CPU::<M>::set_flags_from_i8(status, *p_val as i8);
|
||||
CPU::<M, V>::set_flags_from_i8(status, *p_val as i8);
|
||||
}
|
||||
|
||||
fn set_u8_with_flags(mem: &mut u8, status: &mut Status, value: u8) {
|
||||
*mem = value;
|
||||
CPU::<M>::set_flags_from_u8(status, value);
|
||||
CPU::<M, V>::set_flags_from_u8(status, value);
|
||||
}
|
||||
|
||||
fn load_x_register(&mut self, value: u8) {
|
||||
CPU::<M>::set_u8_with_flags(
|
||||
CPU::<M, V>::set_u8_with_flags(
|
||||
&mut self.registers.index_x,
|
||||
&mut self.registers.status,
|
||||
value,
|
||||
@ -680,7 +703,7 @@ impl<M: Bus> CPU<M> {
|
||||
}
|
||||
|
||||
fn load_y_register(&mut self, value: u8) {
|
||||
CPU::<M>::set_u8_with_flags(
|
||||
CPU::<M, V>::set_u8_with_flags(
|
||||
&mut self.registers.index_y,
|
||||
&mut self.registers.status,
|
||||
value,
|
||||
@ -688,7 +711,7 @@ impl<M: Bus> CPU<M> {
|
||||
}
|
||||
|
||||
fn load_accumulator(&mut self, value: u8) {
|
||||
CPU::<M>::set_u8_with_flags(
|
||||
CPU::<M, V>::set_u8_with_flags(
|
||||
&mut self.registers.accumulator,
|
||||
&mut self.registers.status,
|
||||
value,
|
||||
@ -696,7 +719,6 @@ impl<M: Bus> CPU<M> {
|
||||
}
|
||||
|
||||
fn add_with_carry(&mut self, value: u8) {
|
||||
#[cfg(feature = "decimal_mode")]
|
||||
fn decimal_adjust(result: u8) -> u8 {
|
||||
let bcd1: u8 = if (result & 0x0f) > 0x09 { 0x06 } else { 0x00 };
|
||||
|
||||
@ -715,15 +737,43 @@ impl<M: Bus> CPU<M> {
|
||||
|
||||
debug_assert_eq!(a_after, a_before.wrapping_add(c_before).wrapping_add(value));
|
||||
|
||||
#[cfg(feature = "decimal_mode")]
|
||||
let result: u8 = if self.registers.status.contains(Status::PS_DECIMAL_MODE) {
|
||||
decimal_adjust(a_after)
|
||||
} else {
|
||||
a_after
|
||||
};
|
||||
|
||||
#[cfg(not(feature = "decimal_mode"))]
|
||||
let result: u8 = a_after;
|
||||
let did_carry = (result) < (a_before)
|
||||
|| (a_after == 0 && c_before == 0x01)
|
||||
|| (value == 0xff && c_before == 0x01);
|
||||
|
||||
let did_overflow = (a_before > 127 && value > 127 && a_after < 128)
|
||||
|| (a_before < 128 && value < 128 && a_after > 127);
|
||||
|
||||
let mask = Status::PS_CARRY | Status::PS_OVERFLOW;
|
||||
|
||||
self.registers.status.set_with_mask(
|
||||
mask,
|
||||
Status::new(StatusArgs {
|
||||
carry: did_carry,
|
||||
overflow: did_overflow,
|
||||
..StatusArgs::none()
|
||||
}),
|
||||
);
|
||||
|
||||
self.load_accumulator(result);
|
||||
|
||||
debug!("accumulator: {}", self.registers.accumulator);
|
||||
}
|
||||
|
||||
fn add_with_no_decimal(&mut self, value: u8) {
|
||||
let a_before: u8 = self.registers.accumulator;
|
||||
let c_before: u8 = u8::from(self.registers.status.contains(Status::PS_CARRY));
|
||||
let a_after: u8 = a_before.wrapping_add(c_before).wrapping_add(value);
|
||||
|
||||
debug_assert_eq!(a_after, a_before.wrapping_add(c_before).wrapping_add(value));
|
||||
|
||||
let result = a_after;
|
||||
|
||||
let did_carry = (result) < (a_before)
|
||||
|| (a_after == 0 && c_before == 0x01)
|
||||
@ -753,6 +803,52 @@ impl<M: Bus> CPU<M> {
|
||||
self.load_accumulator(a_after);
|
||||
}
|
||||
|
||||
fn subtract_with_no_decimal(&mut self, value: u8) {
|
||||
// A - M - (1 - C)
|
||||
|
||||
// nc -- 'not carry'
|
||||
let nc: u8 = if self.registers.status.contains(Status::PS_CARRY) {
|
||||
0
|
||||
} else {
|
||||
1
|
||||
};
|
||||
|
||||
let a_before = self.registers.accumulator;
|
||||
|
||||
let a_after = a_before.wrapping_sub(value).wrapping_sub(nc);
|
||||
|
||||
// The overflow flag is set on two's-complement overflow.
|
||||
//
|
||||
// range of A is -128 to 127
|
||||
// range of - M - (1 - C) is -128 to 128
|
||||
// -(127 + 1) to -(-128 + 0)
|
||||
//
|
||||
let over = (nc == 0 && value > 127) && a_before < 128 && a_after > 127;
|
||||
|
||||
let under =
|
||||
(a_before > 127) && (0u8.wrapping_sub(value).wrapping_sub(nc) > 127) && a_after < 128;
|
||||
|
||||
let did_overflow = over || under;
|
||||
|
||||
let mask = Status::PS_CARRY | Status::PS_OVERFLOW;
|
||||
|
||||
let result = a_after;
|
||||
|
||||
// The carry flag is set on unsigned overflow.
|
||||
let did_carry = (result) > (a_before);
|
||||
|
||||
self.registers.status.set_with_mask(
|
||||
mask,
|
||||
Status::new(StatusArgs {
|
||||
carry: did_carry,
|
||||
overflow: did_overflow,
|
||||
..StatusArgs::none()
|
||||
}),
|
||||
);
|
||||
|
||||
self.load_accumulator(result);
|
||||
}
|
||||
|
||||
fn subtract_with_carry(&mut self, value: u8) {
|
||||
// A - M - (1 - C)
|
||||
|
||||
@ -794,16 +890,12 @@ impl<M: Bus> CPU<M> {
|
||||
0x00
|
||||
};
|
||||
|
||||
#[cfg(feature = "decimal_mode")]
|
||||
let result: u8 = if self.registers.status.contains(Status::PS_DECIMAL_MODE) {
|
||||
a_after.wrapping_sub(bcd1).wrapping_sub(bcd2)
|
||||
} else {
|
||||
a_after
|
||||
};
|
||||
|
||||
#[cfg(not(feature = "decimal_mode"))]
|
||||
let result = a_after;
|
||||
|
||||
// The carry flag is set on unsigned overflow.
|
||||
let did_carry = (result) > (a_before);
|
||||
|
||||
@ -980,7 +1072,7 @@ impl<M: Bus> CPU<M> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<M: Bus> core::fmt::Debug for CPU<M> {
|
||||
impl<M: Bus, V: Variant> core::fmt::Debug for CPU<M, V> {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
write!(
|
||||
f,
|
||||
@ -994,11 +1086,12 @@ impl<M: Bus> core::fmt::Debug for CPU<M> {
|
||||
mod tests {
|
||||
|
||||
use super::*;
|
||||
use crate::instruction::Nmos6502;
|
||||
use crate::memory::Memory as Ram;
|
||||
|
||||
#[test]
|
||||
fn dont_panic_for_overflow() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.add_with_carry(0x80);
|
||||
assert_eq!(cpu.registers.accumulator, 0x80);
|
||||
cpu.add_with_carry(0x80);
|
||||
@ -1012,7 +1105,7 @@ mod tests {
|
||||
|
||||
#[cfg_attr(feature = "decimal_mode", test)]
|
||||
fn decimal_add_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.registers.status.or(Status::PS_DECIMAL_MODE);
|
||||
|
||||
cpu.add_with_carry(0x09);
|
||||
@ -1039,7 +1132,7 @@ mod tests {
|
||||
|
||||
#[cfg_attr(feature = "decimal_mode", test)]
|
||||
fn decimal_subtract_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.registers
|
||||
.status
|
||||
.or(Status::PS_DECIMAL_MODE | Status::PS_CARRY);
|
||||
@ -1061,7 +1154,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn add_with_carry_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.add_with_carry(1);
|
||||
assert_eq!(cpu.registers.accumulator, 1);
|
||||
@ -1084,7 +1177,7 @@ mod tests {
|
||||
assert!(!cpu.registers.status.contains(Status::PS_NEGATIVE));
|
||||
assert!(!cpu.registers.status.contains(Status::PS_OVERFLOW));
|
||||
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
assert_eq!(cpu.registers.accumulator, 0);
|
||||
cpu.add_with_carry(127);
|
||||
@ -1116,7 +1209,7 @@ mod tests {
|
||||
assert!(cpu.registers.status.contains(Status::PS_NEGATIVE));
|
||||
assert!(!cpu.registers.status.contains(Status::PS_OVERFLOW));
|
||||
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.add_with_carry(127);
|
||||
assert_eq!(cpu.registers.accumulator, 127);
|
||||
@ -1132,7 +1225,7 @@ mod tests {
|
||||
assert!(cpu.registers.status.contains(Status::PS_NEGATIVE));
|
||||
assert!(cpu.registers.status.contains(Status::PS_OVERFLOW));
|
||||
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.registers.status.or(Status::PS_CARRY);
|
||||
cpu.add_with_carry(0xff);
|
||||
assert_eq!(cpu.registers.accumulator, 0);
|
||||
@ -1141,7 +1234,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn solid65_adc_immediate() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
// Adding $FF plus carry should be the same as adding $00 and no carry, so these three
|
||||
// instructions should leave the carry flags unaffected, i.e. set.
|
||||
@ -1155,7 +1248,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn php_sets_bits_4_and_5() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.execute_instruction((Instruction::PHP, OpInput::UseImplied));
|
||||
cpu.execute_instruction((Instruction::PLA, OpInput::UseImplied));
|
||||
cpu.execute_instruction((Instruction::AND, OpInput::UseImmediate(0x30)));
|
||||
@ -1165,7 +1258,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn and_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.registers.accumulator = 0;
|
||||
cpu.and(0xff);
|
||||
@ -1194,7 +1287,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn subtract_with_carry_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
|
||||
cpu.registers.accumulator = 0;
|
||||
@ -1254,7 +1347,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn decrement_memory_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
let addr: u16 = 0xA1B2;
|
||||
|
||||
cpu.memory.set_byte(addr, 5);
|
||||
@ -1291,7 +1384,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn decrement_x_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.registers.index_x = 0x80;
|
||||
cpu.execute_instruction((Instruction::DEX, OpInput::UseImplied));
|
||||
assert_eq!(cpu.registers.index_x, 127);
|
||||
@ -1301,7 +1394,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn decrement_y_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.registers.index_y = 0x80;
|
||||
cpu.execute_instruction((Instruction::DEY, OpInput::UseImplied));
|
||||
assert_eq!(cpu.registers.index_y, 127);
|
||||
@ -1313,7 +1406,7 @@ mod tests {
|
||||
fn logical_shift_right_test() {
|
||||
// Testing UseImplied version (which targets the accumulator) only, for now
|
||||
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.execute_instruction((Instruction::LDA, OpInput::UseImmediate(0)));
|
||||
cpu.execute_instruction((Instruction::LSR, OpInput::UseImplied));
|
||||
assert_eq!(cpu.registers.accumulator, 0);
|
||||
@ -1349,7 +1442,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn dec_x_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.execute_instruction((Instruction::DEX, OpInput::UseImplied));
|
||||
assert_eq!(cpu.registers.index_x, 0xff);
|
||||
@ -1394,7 +1487,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn jump_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
let addr: u16 = 0xA1B1;
|
||||
|
||||
cpu.jump(addr);
|
||||
@ -1403,7 +1496,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_if_carry_clear_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.execute_instruction((Instruction::SEC, OpInput::UseImplied));
|
||||
cpu.branch_if_carry_clear(0xABCD);
|
||||
@ -1416,7 +1509,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_if_carry_set_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.execute_instruction((Instruction::CLC, OpInput::UseImplied));
|
||||
cpu.branch_if_carry_set(0xABCD);
|
||||
@ -1429,7 +1522,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_if_equal_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.branch_if_equal(0xABCD);
|
||||
assert_eq!(cpu.registers.program_counter, (0));
|
||||
@ -1442,7 +1535,7 @@ mod tests {
|
||||
#[test]
|
||||
fn branch_if_minus_test() {
|
||||
{
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
let registers_before = cpu.registers;
|
||||
|
||||
cpu.branch_if_minus(0xABCD);
|
||||
@ -1451,7 +1544,7 @@ mod tests {
|
||||
}
|
||||
|
||||
{
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.registers.status.or(Status::PS_NEGATIVE);
|
||||
let registers_before = cpu.registers;
|
||||
@ -1464,7 +1557,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_if_positive_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.registers.status.insert(Status::PS_NEGATIVE);
|
||||
cpu.branch_if_positive(0xABCD);
|
||||
@ -1477,7 +1570,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_if_overflow_clear_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.registers.status.insert(Status::PS_OVERFLOW);
|
||||
cpu.branch_if_overflow_clear(0xABCD);
|
||||
@ -1490,7 +1583,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_across_end_of_address_space() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
cpu.registers.program_counter = 0xffff;
|
||||
|
||||
cpu.registers.status.insert(Status::PS_OVERFLOW);
|
||||
@ -1500,7 +1593,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn branch_if_overflow_set_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.branch_if_overflow_set(0xABCD);
|
||||
assert_eq!(cpu.registers.program_counter, (0));
|
||||
@ -1513,9 +1606,9 @@ mod tests {
|
||||
#[cfg(test)]
|
||||
fn compare_test_helper<F>(compare: &mut F, load_instruction: Instruction)
|
||||
where
|
||||
F: FnMut(&mut CPU<Ram>, u8),
|
||||
F: FnMut(&mut CPU<Ram, crate::instruction::Nmos6502>, u8),
|
||||
{
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
cpu.execute_instruction((load_instruction, OpInput::UseImmediate(127)));
|
||||
|
||||
@ -1563,7 +1656,7 @@ mod tests {
|
||||
#[test]
|
||||
fn compare_with_a_register_test() {
|
||||
compare_test_helper(
|
||||
&mut |cpu: &mut CPU<Ram>, val: u8| {
|
||||
&mut |cpu: &mut CPU<Ram, Nmos6502>, val: u8| {
|
||||
cpu.compare_with_a_register(val);
|
||||
},
|
||||
Instruction::LDA,
|
||||
@ -1573,7 +1666,7 @@ mod tests {
|
||||
#[test]
|
||||
fn compare_with_x_register_test() {
|
||||
compare_test_helper(
|
||||
&mut |cpu: &mut CPU<Ram>, val: u8| {
|
||||
&mut |cpu: &mut CPU<Ram, Nmos6502>, val: u8| {
|
||||
cpu.compare_with_x_register(val);
|
||||
},
|
||||
Instruction::LDX,
|
||||
@ -1583,7 +1676,7 @@ mod tests {
|
||||
#[test]
|
||||
fn compare_with_y_register_test() {
|
||||
compare_test_helper(
|
||||
&mut |cpu: &mut CPU<Ram>, val: u8| {
|
||||
&mut |cpu: &mut CPU<Ram, Nmos6502>, val: u8| {
|
||||
cpu.compare_with_y_register(val);
|
||||
},
|
||||
Instruction::LDY,
|
||||
@ -1592,7 +1685,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn exclusive_or_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
for a_before in 0u8..=255u8 {
|
||||
for val in 0u8..=255u8 {
|
||||
@ -1620,7 +1713,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn inclusive_or_test() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
|
||||
for a_before in 0u8..=255u8 {
|
||||
for val in 0u8..=255u8 {
|
||||
@ -1648,7 +1741,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn stack_underflow() {
|
||||
let mut cpu = CPU::new(Ram::new());
|
||||
let mut cpu = CPU::new(Ram::new(), Nmos6502);
|
||||
let _val: u8 = cpu.pull_from_stack();
|
||||
}
|
||||
}
|
||||
|
@ -44,39 +44,40 @@
|
||||
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
||||
pub enum Instruction {
|
||||
ADC, // ADd with Carry................ | NV ...ZC A = A + M + C
|
||||
AND, // logical AND (bitwise)......... | N. ...Z. A = A && M
|
||||
ASL, // Arithmetic Shift Left......... | N. ...ZC A = M << 1
|
||||
BCC, // Branch if Carry Clear......... | .. ..... PC = !C
|
||||
BCS, // Branch if Carry Set........... | .. ..... PC = C
|
||||
BEQ, // Branch if Equal (to zero?).... | .. ..... PC = Z
|
||||
BIT, // BIT test...................... | NV ...Z. = A & M
|
||||
BMI, // Branch if Minus............... | .. ..... PC = N
|
||||
BNE, // Branch if Not Equal........... | .. ..... PC = !Z
|
||||
BPL, // Branch if Positive............ | .. ..... PC = Z
|
||||
BRK, // BReaK......................... | .. B.... S PC =
|
||||
BVC, // Branch if oVerflow Clear...... | .. ..... PC = !V
|
||||
BVS, // Branch if oVerflow Set........ | .. ..... PC = V
|
||||
CLC, // CLear Carry flag.............. | .. ....C = 0
|
||||
CLD, // Clear Decimal Mode............ | .. .D... = 0
|
||||
CLI, // Clear Interrupt Disable....... | .. ..I.. = 0
|
||||
CLV, // Clear oVerflow flag........... | .V ..... = 0
|
||||
CMP, // Compare....................... | N. ...ZC = A - M
|
||||
CPX, // Compare X register............ | N. ...ZC = X - M
|
||||
CPY, // Compare Y register............ | N. ...ZC = Y - M
|
||||
DEC, // DECrement memory.............. | N. ...Z. M = M - 1
|
||||
DEX, // DEcrement X register.......... | N. ...Z. X = X - 1
|
||||
DEY, // DEcrement Y register.......... | N. ...Z. Y = Y - 1
|
||||
EOR, // Exclusive OR (bitwise)........ | N. ...Z. A = A ^ M
|
||||
INC, // INCrement memory.............. | N. ...Z. M = M + 1
|
||||
INX, // INcrement X register.......... | N. ...Z. X = X + 1
|
||||
INY, // INcrement Y register.......... | N. ...Z. Y = Y + 1
|
||||
JMP, // JuMP.......................... | .. ..... S PC =
|
||||
JSR, // Jump to SubRoutine............ | .. ..... S PC =
|
||||
LDA, // LoaD Accumulator.............. | N. ...Z. A = M
|
||||
LDX, // LoaD X register............... | N. ...Z. X = M
|
||||
LDY, // LoaD Y register............... | N. ...Z. Y = M
|
||||
LSR, // Logical Shift Right........... | N. ...ZC A = A/2
|
||||
ADC, // ADd with Carry................ | NV ...ZC A = A + M + C
|
||||
ADCnd, // ADd with Carry................ | NV ...ZC A = A + M + C
|
||||
AND, // logical AND (bitwise)......... | N. ...Z. A = A && M
|
||||
ASL, // Arithmetic Shift Left......... | N. ...ZC A = M << 1
|
||||
BCC, // Branch if Carry Clear......... | .. ..... PC = !C
|
||||
BCS, // Branch if Carry Set........... | .. ..... PC = C
|
||||
BEQ, // Branch if Equal (to zero?).... | .. ..... PC = Z
|
||||
BIT, // BIT test...................... | NV ...Z. = A & M
|
||||
BMI, // Branch if Minus............... | .. ..... PC = N
|
||||
BNE, // Branch if Not Equal........... | .. ..... PC = !Z
|
||||
BPL, // Branch if Positive............ | .. ..... PC = Z
|
||||
BRK, // BReaK......................... | .. B.... S PC =
|
||||
BVC, // Branch if oVerflow Clear...... | .. ..... PC = !V
|
||||
BVS, // Branch if oVerflow Set........ | .. ..... PC = V
|
||||
CLC, // CLear Carry flag.............. | .. ....C = 0
|
||||
CLD, // Clear Decimal Mode............ | .. .D... = 0
|
||||
CLI, // Clear Interrupt Disable....... | .. ..I.. = 0
|
||||
CLV, // Clear oVerflow flag........... | .V ..... = 0
|
||||
CMP, // Compare....................... | N. ...ZC = A - M
|
||||
CPX, // Compare X register............ | N. ...ZC = X - M
|
||||
CPY, // Compare Y register............ | N. ...ZC = Y - M
|
||||
DEC, // DECrement memory.............. | N. ...Z. M = M - 1
|
||||
DEX, // DEcrement X register.......... | N. ...Z. X = X - 1
|
||||
DEY, // DEcrement Y register.......... | N. ...Z. Y = Y - 1
|
||||
EOR, // Exclusive OR (bitwise)........ | N. ...Z. A = A ^ M
|
||||
INC, // INCrement memory.............. | N. ...Z. M = M + 1
|
||||
INX, // INcrement X register.......... | N. ...Z. X = X + 1
|
||||
INY, // INcrement Y register.......... | N. ...Z. Y = Y + 1
|
||||
JMP, // JuMP.......................... | .. ..... S PC =
|
||||
JSR, // Jump to SubRoutine............ | .. ..... S PC =
|
||||
LDA, // LoaD Accumulator.............. | N. ...Z. A = M
|
||||
LDX, // LoaD X register............... | N. ...Z. X = M
|
||||
LDY, // LoaD Y register............... | N. ...Z. Y = M
|
||||
LSR, // Logical Shift Right........... | N. ...ZC A = A/2
|
||||
// or N. ...ZC M = M/2
|
||||
NOP, // No OPeration.................. | .. ..... =
|
||||
ORA, // inclusive OR (bitwise)........ | N. ...Z. A = A | M
|
||||
@ -88,21 +89,22 @@ pub enum Instruction {
|
||||
// or N. ...ZC M = C M rotated
|
||||
ROR, // ROtate Right.................. | N. ...ZC A = C A rotated
|
||||
// or N. ...ZC M = C M rotated
|
||||
RTI, // ReTurn from Interrupt......... | NV BDIZC PC = M (stack)
|
||||
RTS, // ReTurn from Subroutine........ | .. ..... PC = M (stack)
|
||||
SBC, // SuBtract with Carry........... | NV ...ZC A = A-M-(1-C)
|
||||
SEC, // SEt Carry flag................ | .. ....C = 1
|
||||
SED, // SEt Decimal flag.............. | .. .D... = 1
|
||||
SEI, // SEt Interrupt disable......... | .. ..I.. = 1
|
||||
STA, // STore Accumulator............. | .. ..... M = A
|
||||
STX, // STore X register.............. | .. ..... M = X
|
||||
STY, // STore Y register.............. | .. ..... M = Y
|
||||
TAX, // Transfer Accumulator to X..... | N. ...Z. X = A
|
||||
TAY, // Transfer Accumulator to Y..... | N. ...Z. Y = A
|
||||
TSX, // Transfer Stack pointer to X... | N. ...Z. X = S
|
||||
TXA, // Transfer X to Accumulator..... | N. ...Z. A = X
|
||||
TXS, // Transfer X to Stack pointer... | .. ..... S = X
|
||||
TYA, // Transfer Y to Accumulator..... | N. ...Z. A = Y
|
||||
RTI, // ReTurn from Interrupt......... | NV BDIZC PC = M (stack)
|
||||
RTS, // ReTurn from Subroutine........ | .. ..... PC = M (stack)
|
||||
SBC, // SuBtract with Carry........... | NV ...ZC A = A-M-(1-C)
|
||||
SBCnd, // SuBtract with Carry........... | NV ...ZC A = A-M-(1-C)
|
||||
SEC, // SEt Carry flag................ | .. ....C = 1
|
||||
SED, // SEt Decimal flag.............. | .. .D... = 1
|
||||
SEI, // SEt Interrupt disable......... | .. ..I.. = 1
|
||||
STA, // STore Accumulator............. | .. ..... M = A
|
||||
STX, // STore X register.............. | .. ..... M = X
|
||||
STY, // STore Y register.............. | .. ..... M = Y
|
||||
TAX, // Transfer Accumulator to X..... | N. ...Z. X = A
|
||||
TAY, // Transfer Accumulator to Y..... | N. ...Z. Y = A
|
||||
TSX, // Transfer Stack pointer to X... | N. ...Z. X = S
|
||||
TXA, // Transfer X to Accumulator..... | N. ...Z. A = X
|
||||
TXS, // Transfer X to Stack pointer... | .. ..... S = X
|
||||
TYA, // Transfer Y to Accumulator..... | N. ...Z. A = Y
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
@ -154,517 +156,313 @@ impl AddressingMode {
|
||||
|
||||
pub type DecodedInstr = (Instruction, OpInput);
|
||||
|
||||
pub static OPCODES: [Option<(Instruction, AddressingMode)>; 256] = [
|
||||
/*0x00*/
|
||||
Some((Instruction::BRK, AddressingMode::Implied)),
|
||||
/*0x01*/
|
||||
Some((Instruction::ORA, AddressingMode::IndexedIndirectX)),
|
||||
/*0x02*/
|
||||
None,
|
||||
/*0x03*/
|
||||
None,
|
||||
/*0x04*/
|
||||
None,
|
||||
/*0x05*/
|
||||
Some((Instruction::ORA, AddressingMode::ZeroPage)),
|
||||
/*0x06*/
|
||||
Some((Instruction::ASL, AddressingMode::ZeroPage)),
|
||||
/*0x07*/
|
||||
None,
|
||||
/*0x08*/
|
||||
Some((Instruction::PHP, AddressingMode::Implied)),
|
||||
/*0x09*/
|
||||
Some((Instruction::ORA, AddressingMode::Immediate)),
|
||||
/*0x0A*/
|
||||
Some((Instruction::ASL, AddressingMode::Accumulator)),
|
||||
/*0x0B*/
|
||||
None,
|
||||
/*0x0C*/
|
||||
None,
|
||||
/*0x0D*/
|
||||
Some((Instruction::ORA, AddressingMode::Absolute)),
|
||||
/*0x0E*/
|
||||
Some((Instruction::ASL, AddressingMode::Absolute)),
|
||||
/*0x0F*/
|
||||
None,
|
||||
/*0x10*/
|
||||
Some((Instruction::BPL, AddressingMode::Relative)),
|
||||
/*0x11*/
|
||||
Some((Instruction::ORA, AddressingMode::IndirectIndexedY)),
|
||||
/*0x12*/
|
||||
None,
|
||||
/*0x13*/
|
||||
None,
|
||||
/*0x14*/
|
||||
None,
|
||||
/*0x15*/
|
||||
Some((Instruction::ORA, AddressingMode::ZeroPageX)),
|
||||
/*0x16*/
|
||||
Some((Instruction::ASL, AddressingMode::ZeroPageX)),
|
||||
/*0x17*/
|
||||
None,
|
||||
/*0x18*/
|
||||
Some((Instruction::CLC, AddressingMode::Implied)),
|
||||
/*0x19*/
|
||||
Some((Instruction::ORA, AddressingMode::AbsoluteY)),
|
||||
/*0x1A*/
|
||||
None,
|
||||
/*0x1B*/
|
||||
None,
|
||||
/*0x1C*/
|
||||
None,
|
||||
/*0x1D*/
|
||||
Some((Instruction::ORA, AddressingMode::AbsoluteX)),
|
||||
/*0x1E*/
|
||||
Some((Instruction::ASL, AddressingMode::AbsoluteX)),
|
||||
/*0x1F*/
|
||||
None,
|
||||
/*0x20*/
|
||||
Some((Instruction::JSR, AddressingMode::Absolute)),
|
||||
/*0x21*/
|
||||
Some((Instruction::AND, AddressingMode::IndexedIndirectX)),
|
||||
/*0x22*/
|
||||
None,
|
||||
/*0x23*/
|
||||
None,
|
||||
/*0x24*/
|
||||
Some((Instruction::BIT, AddressingMode::ZeroPage)),
|
||||
/*0x25*/
|
||||
Some((Instruction::AND, AddressingMode::ZeroPage)),
|
||||
/*0x26*/
|
||||
Some((Instruction::ROL, AddressingMode::ZeroPage)),
|
||||
/*0x27*/
|
||||
None,
|
||||
/*0x28*/
|
||||
Some((Instruction::PLP, AddressingMode::Implied)),
|
||||
/*0x29*/
|
||||
Some((Instruction::AND, AddressingMode::Immediate)),
|
||||
/*0x2A*/
|
||||
Some((Instruction::ROL, AddressingMode::Accumulator)),
|
||||
/*0x2B*/
|
||||
None,
|
||||
/*0x2C*/
|
||||
Some((Instruction::BIT, AddressingMode::Absolute)),
|
||||
/*0x2D*/
|
||||
Some((Instruction::AND, AddressingMode::Absolute)),
|
||||
/*0x2E*/
|
||||
Some((Instruction::ROL, AddressingMode::Absolute)),
|
||||
/*0x2F*/
|
||||
None,
|
||||
/*0x30*/
|
||||
Some((Instruction::BMI, AddressingMode::Relative)),
|
||||
/*0x31*/
|
||||
Some((Instruction::AND, AddressingMode::IndirectIndexedY)),
|
||||
/*0x32*/
|
||||
None,
|
||||
/*0x33*/
|
||||
None,
|
||||
/*0x34*/
|
||||
None,
|
||||
/*0x35*/
|
||||
Some((Instruction::AND, AddressingMode::ZeroPageX)),
|
||||
/*0x36*/
|
||||
Some((Instruction::ROL, AddressingMode::ZeroPageX)),
|
||||
/*0x37*/
|
||||
None,
|
||||
/*0x38*/
|
||||
Some((Instruction::SEC, AddressingMode::Implied)),
|
||||
/*0x39*/
|
||||
Some((Instruction::AND, AddressingMode::AbsoluteY)),
|
||||
/*0x3A*/
|
||||
None,
|
||||
/*0x3B*/
|
||||
None,
|
||||
/*0x3C*/
|
||||
None,
|
||||
/*0x3D*/
|
||||
Some((Instruction::AND, AddressingMode::AbsoluteX)),
|
||||
/*0x3E*/
|
||||
Some((Instruction::ROL, AddressingMode::AbsoluteX)),
|
||||
/*0x3F*/
|
||||
None,
|
||||
/*0x40*/
|
||||
Some((Instruction::RTI, AddressingMode::Implied)),
|
||||
/*0x41*/
|
||||
Some((Instruction::EOR, AddressingMode::IndexedIndirectX)),
|
||||
/*0x42*/
|
||||
None,
|
||||
/*0x43*/
|
||||
None,
|
||||
/*0x44*/
|
||||
None,
|
||||
/*0x45*/
|
||||
Some((Instruction::EOR, AddressingMode::ZeroPage)),
|
||||
/*0x46*/
|
||||
Some((Instruction::LSR, AddressingMode::ZeroPage)),
|
||||
/*0x47*/
|
||||
None,
|
||||
/*0x48*/
|
||||
Some((Instruction::PHA, AddressingMode::Implied)),
|
||||
/*0x49*/
|
||||
Some((Instruction::EOR, AddressingMode::Immediate)),
|
||||
/*0x4A*/
|
||||
Some((Instruction::LSR, AddressingMode::Accumulator)),
|
||||
/*0x4B*/
|
||||
None,
|
||||
/*0x4C*/
|
||||
Some((Instruction::JMP, AddressingMode::Absolute)),
|
||||
/*0x4D*/
|
||||
Some((Instruction::EOR, AddressingMode::Absolute)),
|
||||
/*0x4E*/
|
||||
Some((Instruction::LSR, AddressingMode::Absolute)),
|
||||
/*0x4F*/
|
||||
None,
|
||||
/*0x50*/
|
||||
Some((Instruction::BVC, AddressingMode::Relative)),
|
||||
/*0x51*/
|
||||
Some((Instruction::EOR, AddressingMode::IndirectIndexedY)),
|
||||
/*0x52*/
|
||||
None,
|
||||
/*0x53*/
|
||||
None,
|
||||
/*0x54*/
|
||||
None,
|
||||
/*0x55*/
|
||||
Some((Instruction::EOR, AddressingMode::ZeroPageX)),
|
||||
/*0x56*/
|
||||
Some((Instruction::LSR, AddressingMode::ZeroPageX)),
|
||||
/*0x57*/
|
||||
None,
|
||||
/*0x58*/
|
||||
Some((Instruction::CLI, AddressingMode::Implied)),
|
||||
/*0x59*/
|
||||
Some((Instruction::EOR, AddressingMode::AbsoluteY)),
|
||||
/*0x5A*/
|
||||
None,
|
||||
/*0x5B*/
|
||||
None,
|
||||
/*0x5C*/
|
||||
None,
|
||||
/*0x5D*/
|
||||
Some((Instruction::EOR, AddressingMode::AbsoluteX)),
|
||||
/*0x5E*/
|
||||
Some((Instruction::LSR, AddressingMode::AbsoluteX)),
|
||||
/*0x5F*/
|
||||
None,
|
||||
/*0x60*/
|
||||
Some((Instruction::RTS, AddressingMode::Implied)),
|
||||
/*0x61*/
|
||||
Some((Instruction::ADC, AddressingMode::IndexedIndirectX)),
|
||||
/*0x62*/
|
||||
None,
|
||||
/*0x63*/
|
||||
None,
|
||||
/*0x64*/
|
||||
None,
|
||||
/*0x65*/
|
||||
Some((Instruction::ADC, AddressingMode::ZeroPage)),
|
||||
/*0x66*/
|
||||
Some((Instruction::ROR, AddressingMode::ZeroPage)),
|
||||
/*0x67*/
|
||||
None,
|
||||
/*0x68*/
|
||||
Some((Instruction::PLA, AddressingMode::Implied)),
|
||||
/*0x69*/
|
||||
Some((Instruction::ADC, AddressingMode::Immediate)),
|
||||
/*0x6A*/
|
||||
Some((Instruction::ROR, AddressingMode::Accumulator)),
|
||||
/*0x6B*/
|
||||
None,
|
||||
/*0x6C*/
|
||||
Some((Instruction::JMP, AddressingMode::Indirect)),
|
||||
/*0x6D*/
|
||||
Some((Instruction::ADC, AddressingMode::Absolute)),
|
||||
/*0x6E*/
|
||||
Some((Instruction::ROR, AddressingMode::Absolute)),
|
||||
/*0x6F*/
|
||||
None,
|
||||
/*0x70*/
|
||||
Some((Instruction::BVS, AddressingMode::Relative)),
|
||||
/*0x71*/
|
||||
Some((Instruction::ADC, AddressingMode::IndirectIndexedY)),
|
||||
/*0x72*/
|
||||
None,
|
||||
/*0x73*/
|
||||
None,
|
||||
/*0x74*/
|
||||
None,
|
||||
/*0x75*/
|
||||
Some((Instruction::ADC, AddressingMode::ZeroPageX)),
|
||||
/*0x76*/
|
||||
Some((Instruction::ROR, AddressingMode::ZeroPageX)),
|
||||
/*0x77*/
|
||||
None,
|
||||
/*0x78*/
|
||||
Some((Instruction::SEI, AddressingMode::Implied)),
|
||||
/*0x79*/
|
||||
Some((Instruction::ADC, AddressingMode::AbsoluteY)),
|
||||
/*0x7A*/
|
||||
None,
|
||||
/*0x7B*/
|
||||
None,
|
||||
/*0x7C*/
|
||||
None,
|
||||
/*0x7D*/
|
||||
Some((Instruction::ADC, AddressingMode::AbsoluteX)),
|
||||
/*0x7E*/
|
||||
Some((Instruction::ROR, AddressingMode::AbsoluteX)),
|
||||
/*0x7F*/
|
||||
None,
|
||||
/*0x80*/
|
||||
None,
|
||||
/*0x81*/
|
||||
Some((Instruction::STA, AddressingMode::IndexedIndirectX)),
|
||||
/*0x82*/
|
||||
None,
|
||||
/*0x83*/
|
||||
None,
|
||||
/*0x84*/
|
||||
Some((Instruction::STY, AddressingMode::ZeroPage)),
|
||||
/*0x85*/
|
||||
Some((Instruction::STA, AddressingMode::ZeroPage)),
|
||||
/*0x86*/
|
||||
Some((Instruction::STX, AddressingMode::ZeroPage)),
|
||||
/*0x87*/
|
||||
None,
|
||||
/*0x88*/
|
||||
Some((Instruction::DEY, AddressingMode::Implied)),
|
||||
/*0x89*/
|
||||
None,
|
||||
/*0x8A*/
|
||||
Some((Instruction::TXA, AddressingMode::Implied)),
|
||||
/*0x8B*/
|
||||
None,
|
||||
/*0x8C*/
|
||||
Some((Instruction::STY, AddressingMode::Absolute)),
|
||||
/*0x8D*/
|
||||
Some((Instruction::STA, AddressingMode::Absolute)),
|
||||
/*0x8E*/
|
||||
Some((Instruction::STX, AddressingMode::Absolute)),
|
||||
/*0x8F*/
|
||||
None,
|
||||
/*0x90*/
|
||||
Some((Instruction::BCC, AddressingMode::Relative)),
|
||||
/*0x91*/
|
||||
Some((Instruction::STA, AddressingMode::IndirectIndexedY)),
|
||||
/*0x92*/
|
||||
None,
|
||||
/*0x93*/
|
||||
None,
|
||||
/*0x94*/
|
||||
Some((Instruction::STY, AddressingMode::ZeroPageX)),
|
||||
/*0x95*/
|
||||
Some((Instruction::STA, AddressingMode::ZeroPageX)),
|
||||
/*0x96*/
|
||||
Some((Instruction::STX, AddressingMode::ZeroPageY)),
|
||||
/*0x97*/
|
||||
None,
|
||||
/*0x98*/
|
||||
Some((Instruction::TYA, AddressingMode::Implied)),
|
||||
/*0x99*/
|
||||
Some((Instruction::STA, AddressingMode::AbsoluteY)),
|
||||
/*0x9A*/
|
||||
Some((Instruction::TXS, AddressingMode::Implied)),
|
||||
/*0x9B*/
|
||||
None,
|
||||
/*0x9C*/
|
||||
None,
|
||||
/*0x9D*/
|
||||
Some((Instruction::STA, AddressingMode::AbsoluteX)),
|
||||
/*0x9E*/
|
||||
None,
|
||||
/*0x9F*/
|
||||
None,
|
||||
/*0xA0*/
|
||||
Some((Instruction::LDY, AddressingMode::Immediate)),
|
||||
/*0xA1*/
|
||||
Some((Instruction::LDA, AddressingMode::IndexedIndirectX)),
|
||||
/*0xA2*/
|
||||
Some((Instruction::LDX, AddressingMode::Immediate)),
|
||||
/*0xA3*/
|
||||
None,
|
||||
/*0xA4*/
|
||||
Some((Instruction::LDY, AddressingMode::ZeroPage)),
|
||||
/*0xA5*/
|
||||
Some((Instruction::LDA, AddressingMode::ZeroPage)),
|
||||
/*0xA6*/
|
||||
Some((Instruction::LDX, AddressingMode::ZeroPage)),
|
||||
/*0xA7*/
|
||||
None,
|
||||
/*0xA8*/
|
||||
Some((Instruction::TAY, AddressingMode::Implied)),
|
||||
/*0xA9*/
|
||||
Some((Instruction::LDA, AddressingMode::Immediate)),
|
||||
/*0xAA*/
|
||||
Some((Instruction::TAX, AddressingMode::Implied)),
|
||||
/*0xAB*/
|
||||
None,
|
||||
|