Enum AddressingMode 

pub enum AddressingMode {
    Implied,
    Accumulator,
    Immediate,
    ZeroPage,
    ZeroPageX,
    ZeroPageY,
    Absolute,
    AbsoluteX,
    AbsoluteY,
    Indirect,
    IndexedIndirectX,
    IndirectIndexedY,
    Relative,
}

CPU Addressing Modes

Defines how an instruction’s operand is accessed.

Variants

Implied

No operand (instruction operates on CPU state)

Example: NOP, CLC, DEX

Accumulator

Operand is the accumulator register

Example: ASL A, ROL A

Immediate

Operand is the next byte after the opcode

Example: LDA #$42 loads the value $42

ZeroPage

Operand is in zero page ($00-$FF)

Example: LDA $80 reads from address $0080

ZeroPageX

Zero page address + X register (wraps within zero page)

Example: LDA $80,X with X=$05 reads from $0085

ZeroPageY

Zero page address + Y register (wraps within zero page)

Example: LDX $80,Y with Y=$05 reads from $0085

Absolute

Operand is a 16-bit absolute address

Example: LDA $1234 reads from address $1234

AbsoluteX

Absolute address + X register

Example: LDA $1234,X with X=$10 reads from $1244

AbsoluteY

Absolute address + Y register

Example: LDA $1234,Y with Y=$10 reads from $1244

Indirect

Indirect addressing (JMP only)

Example: JMP ($1234) reads target address from $1234-$1235

IndexedIndirectX

Indexed Indirect: (Zero Page + X), then dereference

Example: LDA ($80,X) with X=$05:

1. Calculate pointer address: $80 + $05 = $85
2. Read pointer: [$85] = $20, [$86] = $30
3. Read from $3020

IndirectIndexedY

Indirect Indexed: Dereference Zero Page, then + Y

Example: LDA ($80),Y with Y=$10:

1. Read pointer: [$80] = $20, [$81] = $30
2. Add Y: $3020 + $10 = $3030
3. Read from $3030

Relative

Relative offset for branch instructions

Example: BNE $02 branches PC + 2 bytes forward

Implementations

impl AddressingMode

pub const fn operand_bytes(self) -> u8

Get the number of operand bytes for this addressing mode

Returns

• 0 bytes: Implied, Accumulator
• 1 byte: Immediate, Zero Page variants, Indexed Indirect, Indirect Indexed, Relative
• 2 bytes: Absolute variants, Indirect

pub const fn can_page_cross(self) -> bool

Check if this addressing mode can have a page crossing penalty

Returns

true for:

• Absolute,X
• Absolute,Y
• (Indirect),Y
• Relative (branches)

impl AddressingMode

Addressing mode implementations

These methods are called during instruction execution to resolve operand addresses.

pub fn resolve(self, pc: u16, x: u8, y: u8, bus: &mut impl Bus) -> AddressResult

Resolve the effective address for this addressing mode

Arguments

• pc - Current program counter (AFTER opcode fetch)
• x - X register value
• y - Y register value
• bus - Memory bus for reading operands

Returns

AddressResult containing the effective address and page crossing status

Notes

• For Immediate, addr is the value itself
• For Accumulator and Implied, addr is unused
• PC should point to the first operand byte

Trait Implementations

impl Clone for AddressingMode

fn clone(&self) -> AddressingMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AddressingMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for AddressingMode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AddressingMode

fn eq(&self, other: &AddressingMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AddressingMode

impl Eq for AddressingMode

impl StructuralPartialEq for AddressingMode