6502

Branch on

Carry Clear

a.k.a. Register is LESS THAN value

Branch on Carry Set

Register is GREATER THAN OR EQUAL to value

Branch on equal

a.k.a. zero flag set

Branch on Minus

a.k.a. negative flag set

Branch on not equl

a.k.a. zero flag cleared

Branch on plus

a.k.a. negative flag clear

Branch on overflow clear

Branch on overflow set

Add with carry

Accumulator + operand + carry

Want to CLC before doing multi-byte add.

Can change: C Z V N

logical (bitwise) And (with accumulator)

Can change: Z N

Arithmetic shift left.

shift bits of accumulator memory one to the left (a.k.a. multiply by two), shifting in a zero

high bit shifted in to C (a.k.a. if multiplying by two, the result will not fit into 8 bits)

Can change: C Z V N

Bit test

Take the operand. Use the accumulator as a mask pattern. Use that to test the operand (zero page or absolute). AND the mask with memory to set the flags. N is set based on bit 7, and V on bit 6. no value is modified

Can change: Z, V, N

Force interrupt

PC and Processor status pushed on stack.

IRQ interrupt vector at $FFFE is loaded into the PC and break flag in status word is set

Can change: B

clear carry flag

Use this before doing an add so that stale carry bits won’t affect the addition

clear decimal mode. Go back to two’s complement math

Clears D

clear interrupt Disable - allows normal interrupt requests to be serviced

Clears I

Clear overflow flag

Clears V

compare opcode with accumulator (A - M)

Carry set if A >= M

Zero set if A = M

Negative set to bit seven of the subtraction

Can change: Z C N

compare opcode with X register (X - M)

Carry set if X >= M

Zero set if X = M

Negative set to bit seven of the subtraction

Can change: Z C N

compare opcode with Y register (Y - M)

Carry set if Y >= M

Zero set if Y = M

Negative set to bit seven of the subtraction

Can change: Z C N

Decrement memory

Can change: Z N

Decrement X register

Can change: Z N

Decrement Y register

Can change: Z N

Exclusive-OR accumulator with operand

Can change: Z N

Increment memory operand

Can change: Z N

Increment X register

Can change: Z N

Increment Y register

Can change: Z N

jump jump jump jump

Jump to Subroutine

Pushes address (minus one) of the return point onto the stack, then sets the PC to the target.

The minus-one address is the last byte of the JSR,

Absolute address is the only allowed addressing mode

Paired with RTS to return (which will add one to the address to compensate for the minus one)

Load Accumulator from operand

Can change: Z N

Load X register from operand

Can change: Z N

Logical Shift Right.

Shift the bits in the operand to the right. zero bit moved to C, Bit 7 cleared

Can change: C Z N

no operation

Logical bitwise “inclusive” OR into accumulator from operand

Can change: Z N

Push Accumulator on to the stack

Push status flags on to the stack

Pull 8 bit value from the stack and put into the accumulator

Can change: Z N

Pull 8 bit value from the tack and into the processor flags.

Can change: all of them

Rotate Left

Move bits in the accumulator to the left. Carry gets shifted into bit zero. Bit 7 gets shifted into Carry

Can change: C Z N

Rotate Left

Move bits in the accumulator to the right Carry gets shifted into bit seven. Bit 0 gets shifted into Carry

Can change: C Z N

Return from Interrupt - pulls processor flags from the stack, followed by program counter.

There is no Minus-one offset for this address, like JSR/RTS do

Can change: all of them

Return from Subroutine

Usually paired with JSR

Pulls the program counter from the stack, adds one, then puts into PC

Subtract with Carry

Subtract the operand from the accumulator with the NOT of the carry bit.

Overflow clears carry bit

Always set the carry before doing multi-byte subtraction

A = A - M-(1-C)

V set if sign is incorrect

Can change: C Z V

Set Carry Flag

Set Decimal Flag

We now be doing BCD math

Set Interrupt Disable

Sets the disable flag, so maskable interrupts can’t happen

Store accumulator into memory

Store X register into memory

Store Y register into memory

transfer accumulator to X register

Can change: Z N

transfer accumulator to Y register

Can change: Z N

transfer stack pointer to X register

Can change: Z N

transfer X register to accumulator

Can change: N Z

transfer X register to stack pointer

transfer Y to accumulator

Can set N Z

BCC

BCS

BEQ

BNE

C Carry Z Zero I Interrupt Disable D Decimal mode B Break command V Overflow N Negative

X register indexed absolute addressing. Take the 16 address from the operand and add X register

Y register indexed absolute addressing. Take the 16 address from the operand and add Y register

Indirect. Go to the address indicated, use the two bytes there as an address to jump to JMP is the only instruction that can do it.

Indexed Indirect. Take the zero-page address as the base of a table of pointers. Use X to find the X'th item. Then grab the two bytes there to use as an address. X is the only register that can be used for this

Indirect Indexed. One of the most common indirect addressing modes. A zero-page location has a 16-bit address. Take that, then add Y. Y is the only register that can be used for this.

A way of faking an indirect JMP by explicitly pushing an address (minus one) on the stack, then calling RTS

Load Y register from operand Can change: Z N

Carry flag is an INVERTED borrow. If set, no borrow was done previously. If clear, a borrow did happen

Thats why you do a SEC before a subtraction (SBC)

The carry flag is an INVERTED borrow. When doing the CMP (acc - operand), if a borrow DID happen happened, the carry is CLEARED

So, acc - operand is carry CLEAR, a borrow HAPPENED. Means acc < operand

If carry is SET, a borrow did NOT happen. Which means acc >= operand