6502 Registers

Why Does a CPU Need Registers?

Let's imagine for a moment that a large bookshelf is in front of you, you are the CPU, and the bookshelf represents RAM. We can think of your hands as registers, our hands will pick books from the bookshelf for us to read, or write in, when we are done, we return it to the bookshelf.

OK... but Why U8?

The 6502 chip has 8 physical wires attached to it, it can physically only consume one byte at a time. This means the ALU which is essentially the calculator part within the chip itself, can only handle 8-bits at a time. If we have to add two 16-bit numbers together, the ALU needs to perform two separate 8-bit additions. (one for the low byte, one for the high byte)

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Registers {
    pub accumulator: u8,
    pub x_register: u8,
    pub y_register: u8,
    pub stack_pointer: u8,
    pub program_counter: u16,
    pub status_register: Status
}

impl Default for Registers {
    fn default() -> Self {
        Self::new()
    }
}

impl Registers {
    #[must_use]
    pub fn new() -> Self {
        Self {
            accumulator: 0,
            x_register: 0,
            y_register: 0,
            stack_pointer: 0,
            program_counter: 0,
            status_register: Status::default(),
        }
    }
}

Hang on... the Program Counter Is 16-Bits??

Even though the CPU thinks in terms of 8-bits we would need more than memory then what 8-bits can provide. An 8-bit number only has a range of 0-255 whereas a 16-bit gives us 64KB of space to use. In order to achieve this the 6502 uses two 8-bit registers.

Status Struct

Status

Registers

Status Register