6502 Instruction Set

HILO-NIBBLE
‐0‐1‐2‐3‐4‐5‐6‐7‐8‐9‐A‐B‐C‐D‐E‐F
0‐BRK implORA X,ind---------ORA zpgASL zpg---PHP implORA #ASL A------ORA absASL abs---
1‐BPL relORA ind,Y---------ORA zpg,XASL zpg,X---CLC implORA abs,Y---------ORA abs,XASL abs,X---
2‐JSR absAND X,ind------BIT zpgAND zpgROL zpg---PLP implAND #ROL A---BIT absAND absROL abs---
3‐BMI relAND ind,Y---------AND zpg,XROL zpg,X---SEC implAND abs,Y---------AND abs,XROL abs,X---
4‐RTI implEOR X,ind---------EOR zpgLSR zpg---PHA implEOR #LSR A---JMP absEOR absLSR abs---
5‐BVC relEOR ind,Y---------EOR zpg,XLSR zpg,X---CLI implEOR abs,Y---------EOR abs,XLSR abs,X---
6‐RTS implADC X,ind---------ADC zpgROR zpg---PLA implADC #ROR A---JMP indADC absROR abs---
7‐BVS relADC ind,Y---------ADC zpg,XROR zpg,X---SEI implADC abs,Y---------ADC abs,XROR abs,X---
8‐---STA X,ind------STY zpgSTA zpgSTX zpg---DEY impl---TXA impl---STY absSTA absSTX abs---
9‐BCC relSTA ind,Y------STY zpg,XSTA zpg,XSTX zpg,Y---TYA implSTA abs,YTXS impl------STA abs,X------
A‐LDY #LDA X,indLDX #---LDY zpgLDA zpgLDX zpg---TAY implLDA #TAX impl---LDY absLDA absLDX abs---
B‐BCS relLDA ind,Y------LDY zpg,XLDA zpg,XLDX zpg,Y---CLV implLDA abs,YTSX impl---LDY abs,XLDA abs,XLDX abs,Y---
C‐CPY #CMP X,ind------CPY zpgCMP zpgDEC zpg---INY implCMP #DEX impl---CPY absCMP absDEC abs---
D‐BNE relCMP ind,Y---------CMP zpg,XDEC zpg,X---CLD implCMP abs,Y---------CMP abs,XDEC abs,X---
E‐CPX #SBC X,ind------CPX zpgSBC zpgINC zpg---INX implSBC #NOP impl---CPX absSBC absINC abs---
F‐BEQ relSBC ind,Y---------SBC zpg,XINC zpg,X---SED implSBC abs,Y---------SBC abs,XINC abs,X---

Description

Address Modes

AAccumulatorOPC Aoperand is AC (implied single byte instruction)
absabsoluteOPC $LLHHoperand is address $HHLL *
abs,Xabsolute, X-indexedOPC $LLHH,Xoperand is address; effective address is address incremented by X with carry **
abs,Yabsolute, Y-indexedOPC $LLHH,Yoperand is address; effective address is address incremented by Y with carry **
#immediateOPC #$BBoperand is byte BB
implimpliedOPCoperand implied
indindirectOPC ($LLHH)operand is address; effective address is contents of word at address: C.w($HHLL)
X,indX-indexed, indirectOPC ($LL,X)operand is zeropage address; effective address is word in (LL + X, LL + X + 1), inc. without carry: C.w($00LL + X)
ind,Yindirect, Y-indexedOPC ($LL),Yoperand is zeropage address; effective address is word in (LL, LL + 1) incremented by Y with carry: C.w($00LL) + Y
relrelativeOPC $BBbranch target is PC + signed offset BB ***
zpgzeropageOPC $LLoperand is zeropage address (hi-byte is zero, address = $00LL)
zpg,Xzeropage, X-indexedOPC $LL,Xoperand is zeropage address; effective address is address incremented by X without carry **
zpg,Yzeropage, Y-indexedOPC $LL,Yoperand is zeropage address; effective address is address incremented by Y without carry **
*
16-bit address words are little endian, lo(w)-byte first, followed by the hi(gh)-byte.
(An assembler will use a human readable, big-endian notation as in $HHLL.)
**
The available 16-bit address space is conceived as consisting of pages of 256 bytes each, with
address hi-bytes represententing the page index. An increment with carry may affect the hi-byte
and may thus result in a crossing of page boundaries, adding an extra cycle to the execution.
Increments without carry do not affect the hi-byte of an address and no page transitions do occur.
Generally, increments of 16-bit addresses include a carry, increments of zeropage addresses don't.
Notably this is not related in any way to the state of the carry bit of the accumulator.
***
Branch offsets are signed 8-bit values, -128 ... +127, negative offsets in two's complement.
Page transitions may occur and add an extra cycle to the exucution.

Instructions by Name

ADC
add with carry
AND
and (with accumulator)
ASL
arithmetic shift left
BCC
branch on carry clear
BCS
branch on carry set
BEQ
branch on equal (zero set)
BIT
bit test
BMI
branch on minus (negative set)
BNE
branch on not equal (zero clear)
BPL
branch on plus (negative clear)
BRK
break / interrupt
BVC
branch on overflow clear
BVS
branch on overflow set
CLC
clear carry
CLD
clear decimal
CLI
clear interrupt disable
CLV
clear overflow
CMP
compare (with accumulator)
CPX
compare with X
CPY
compare with Y
DEC
decrement
DEX
decrement X
DEY
decrement Y
EOR
exclusive or (with accumulator)
INC
increment
INX
increment X
INY
increment Y
JMP
jump
JSR
jump subroutine
LDA
load accumulator
LDX
load X
LDY
load Y
LSR
logical shift right
NOP
no operation
ORA
or with accumulator
PHA
push accumulator
PHP
push processor status (SR)
PLA
pull accumulator
PLP
pull processor status (SR)
ROL
rotate left
ROR
rotate right
RTI
return from interrupt
RTS
return from subroutine
SBC
subtract with carry
SEC
set carry
SED
set decimal
SEI
set interrupt disable
STA
store accumulator
STX
store X
STY
store Y
TAX
transfer accumulator to X
TAY
transfer accumulator to Y
TSX
transfer stack pointer to X
TXA
transfer X to accumulator
TXS
transfer X to stack pointer
TYA
transfer Y to accumulator

Registers

PCprogram counter(16 bit)
ACaccumulator(8 bit)
XX register(8 bit)
YY register(8 bit)
SRstatus register [NV-BDIZC](8 bit)
SPstack pointer(8 bit)

SR Flags (bit 7 to bit 0)

NNegative
VOverflow
-ignored
BBreak
DDecimal (use BCD for arithmetics)
IInterrupt (IRQ disable)
ZZero
CCarry

Processor Stack

LIFO, top down, 8 bit range, 0x0100 - 0x01FF

Bytes, Words, Addressing

8 bit bytes, 16 bit words in lobyte-hibyte representation (Little-Endian).
16 bit address range, operands follow instruction codes.

Signed values are two's complement, sign in bit 7 (most significant bit).
(%11111111 = $FF = -1, %10000000 = $80 = -128, %01111111 = $7F = +127)

Vendor

MOS Technology, 1975

MOS Techology 6502 MPU

Image: Wikimedia Commons.

APPENDIX A: 6502 Instructions in Detail

ADC

Add Memory to Accumulator with Carry

A + M + C -> A, C

NZCIDV
+++--+
addressingassembleropcbytescyles
immediateADC #oper6922
zeropageADC oper6523
zeropage,XADC oper,X7524
absoluteADC oper6D34
absolute,XADC oper,X7D34*
absolute,YADC oper,Y7934*
(indirect,X)ADC (oper,X)6126
(indirect),YADC (oper),Y7125*
AND

AND Memory with Accumulator

A AND M -> A

NZCIDV
++----
addressingassembleropcbytescyles
immediateAND #oper2922
zeropageAND oper2523
zeropage,XAND oper,X3524
absoluteAND oper2D34
absolute,XAND oper,X3D34*
absolute,YAND oper,Y3934*
(indirect,X)AND (oper,X)2126
(indirect),YAND (oper),Y3125*
ASL

Shift Left One Bit (Memory or Accumulator)

C <- [76543210] <- 0

NZCIDV
+++---
addressingassembleropcbytescyles
accumulatorASL A0A12
zeropageASL oper0625
zeropage,XASL oper,X1626
absoluteASL oper0E36
absolute,XASL oper,X1E37
BCC

Branch on Carry Clear

branch on C = 0

NZCIDV
------
addressingassembleropcbytescyles
relativeBCC oper9022**
BCS

Branch on Carry Set

branch on C = 1

NZCIDV
------
addressingassembleropcbytescyles
relativeBCS operB022**
BEQ

Branch on Result Zero

branch on Z = 1

NZCIDV
------
addressingassembleropcbytescyles
relativeBEQ operF022**
BIT

Test Bits in Memory with Accumulator

bits 7 and 6 of operand are transfered to bit 7 and 6 of SR (N,V);
the zero-flag is set to the result of operand AND accumulator.

A AND M, M7 -> N, M6 -> V

NZCIDV
M7+---M6
addressingassembleropcbytescyles
zeropageBIT oper2423
absoluteBIT oper2C34
BMI

Branch on Result Minus

branch on N = 1

NZCIDV
------
addressingassembleropcbytescyles
relativeBMI oper3022**
BNE

Branch on Result not Zero

branch on Z = 0

NZCIDV
------
addressingassembleropcbytescyles
relativeBNE operD022**
BPL

Branch on Result Plus

branch on N = 0

NZCIDV
------
addressingassembleropcbytescyles
relativeBPL oper1022**
BRK

Force Break

interrupt,
push PC+2, push SR

NZCIDV
---1--
addressingassembleropcbytescyles
impliedBRK 00117
BVC

Branch on Overflow Clear

branch on V = 0

NZCIDV
------
addressingassembleropcbytescyles
relativeBVC oper5022**
BVS

Branch on Overflow Set

branch on V = 1

NZCIDV
------
addressingassembleropcbytescyles
relativeBVC oper7022**
CLC

Clear Carry Flag

0 -> C

NZCIDV
--0---
addressingassembleropcbytescyles
impliedCLC1812
CLD

Clear Decimal Mode

0 -> D

NZCIDV
----0-
addressingassembleropcbytescyles
impliedCLDD812
CLI

Clear Interrupt Disable Bit

0 -> I

NZCIDV
---0--
addressingassembleropcbytescyles
impliedCLI5812
CLV

Clear Overflow Flag

0 -> V

NZCIDV
-----0
addressingassembleropcbytescyles
impliedCLVB812
CMP

Compare Memory with Accumulator

A - M

NZCIDV
+++---
addressingassembleropcbytescyles
immediateCMP #operC922
zeropageCMP operC523
zeropage,XCMP oper,XD524
absoluteCMP operCD34
absolute,XCMP oper,XDD34*
absolute,YCMP oper,YD934*
(indirect,X)CMP (oper,X)C126
(indirect),YCMP (oper),YD125*
CPX

Compare Memory and Index X

X - M

NZCIDV
+++---
addressingassembleropcbytescyles
immediateCPX #operE022
zeropageCPX operE423
absoluteCPX operEC34
CPY

Compare Memory and Index Y

Y - M

NZCIDV
+++---
addressingassembleropcbytescyles
immediateCPY #operC022
zeropageCPY operC423
absoluteCPY operCC34
DEC

Decrement Memory by One

M - 1 -> M

NZCIDV
++----
addressingassembleropcbytescyles
zeropageDEC operC625
zeropage,XDEC oper,XD626
absoluteDEC operCE36
absolute,XDEC oper,XDE37
DEX

Decrement Index X by One

X - 1 -> X

NZCIDV
++----
addressingassembleropcbytescyles
impliedDEXCA12
DEY

Decrement Index Y by One

Y - 1 -> Y

NZCIDV
++----
addressingassembleropcbytescyles
impliedDEY8812
EOR

Exclusive-OR Memory with Accumulator

A EOR M -> A

NZCIDV
++----
addressingassembleropcbytescyles
immediateEOR #oper4922
zeropageEOR oper4523
zeropage,XEOR oper,X5524
absoluteEOR oper4D34
absolute,XEOR oper,X5D34*
absolute,YEOR oper,Y5934*
(indirect,X)EOR (oper,X)4126
(indirect),YEOR (oper),Y5125*
INC

Increment Memory by One

M + 1 -> M

NZCIDV
++----
addressingassembleropcbytescyles
zeropageINC operE625
zeropage,XINC oper,XF626
absoluteINC operEE36
absolute,XINC oper,XFE37
INX

Increment Index X by One

X + 1 -> X

NZCIDV
++----
addressingassembleropcbytescyles
impliedINXE812
INY

Increment Index Y by One

Y + 1 -> Y

NZCIDV
++----
addressingassembleropcbytescyles
impliedINYC812
JMP

Jump to New Location

(PC+1) -> PCL
(PC+2) -> PCH

NZCIDV
------
addressingassembleropcbytescyles
absoluteJMP oper4C33
indirectJMP (oper)6C35
JSR

Jump to New Location Saving Return Address

push (PC+2),
(PC+1) -> PCL
(PC+2) -> PCH

NZCIDV
------
addressingassembleropcbytescyles
absoluteJSR oper2036
LDA

Load Accumulator with Memory

M -> A

NZCIDV
++----
addressingassembleropcbytescyles
immediateLDA #operA922
zeropageLDA operA523
zeropage,XLDA oper,XB524
absoluteLDA operAD34
absolute,XLDA oper,XBD34*
absolute,YLDA oper,YB934*
(indirect,X)LDA (oper,X)A126
(indirect),YLDA (oper),YB125*
LDX

Load Index X with Memory

M -> X

NZCIDV
++----
addressingassembleropcbytescyles
immediateLDX #operA222
zeropageLDX operA623
zeropage,YLDX oper,YB624
absoluteLDX operAE34
absolute,YLDX oper,YBE34*
LDY

Load Index Y with Memory

M -> Y

NZCIDV
++----
addressingassembleropcbytescyles
immediateLDY #operA022
zeropageLDY operA423
zeropage,XLDY oper,XB424
absoluteLDY operAC34
absolute,XLDY oper,XBC34*
LSR

Shift One Bit Right (Memory or Accumulator)

0 -> [76543210] -> C

NZCIDV
0++---
addressingassembleropcbytescyles
accumulatorLSR A4A12
zeropageLSR oper4625
zeropage,XLSR oper,X5626
absoluteLSR oper4E36
absolute,XLSR oper,X5E37
NOP

No Operation

---

NZCIDV
------
addressingassembleropcbytescyles
impliedNOPEA12
ORA

OR Memory with Accumulator

A OR M -> A

NZCIDV
++----
addressingassembleropcbytescyles
immediateORA #oper0922
zeropageORA oper0523
zeropage,XORA oper,X1524
absoluteORA oper0D34
absolute,XORA oper,X1D34*
absolute,YORA oper,Y1934*
(indirect,X)ORA (oper,X)0126
(indirect),YORA (oper),Y1125*
PHA

Push Accumulator on Stack

push A

NZCIDV
------
addressingassembleropcbytescyles
impliedPHA4813
PHP

Push Processor Status on Stack

push SR

NZCIDV
------
addressingassembleropcbytescyles
impliedPHP0813
PLA

Pull Accumulator from Stack

pull A

NZCIDV
++----
addressingassembleropcbytescyles
impliedPLA6814
PLP

Pull Processor Status from Stack

pull SR

NZCIDV
from stack
addressingassembleropcbytescyles
impliedPLP2814
ROL

Rotate One Bit Left (Memory or Accumulator)

C <- [76543210] <- C

NZCIDV
+++---
addressingassembleropcbytescyles
accumulatorROL A2A12
zeropageROL oper2625
zeropage,XROL oper,X3626
absoluteROL oper2E36
absolute,XROL oper,X3E37
ROR

Rotate One Bit Right (Memory or Accumulator)

C -> [76543210] -> C

NZCIDV
+++---
addressingassembleropcbytescyles
accumulatorROR A6A12
zeropageROR oper6625
zeropage,XROR oper,X7626
absoluteROR oper6E36
absolute,XROR oper,X7E37
RTI

Return from Interrupt

pull SR, pull PC

NZCIDV
from stack
addressingassembleropcbytescyles
impliedRTI4016
RTS

Return from Subroutine

pull PC, PC+1 -> PC

NZCIDV
------
addressingassembleropcbytescyles
impliedRTS6016
SBC

Subtract Memory from Accumulator with Borrow

A - M - C -> A

NZCIDV
+++--+
addressingassembleropcbytescyles
immediateSBC #operE922
zeropageSBC operE523
zeropage,XSBC oper,XF524
absoluteSBC operED34
absolute,XSBC oper,XFD34*
absolute,YSBC oper,YF934*
(indirect,X)SBC (oper,X)E126
(indirect),YSBC (oper),YF125*
SEC

Set Carry Flag

1 -> C

NZCIDV
--1---
addressingassembleropcbytescyles
impliedSEC3812
SED

Set Decimal Flag

1 -> D

NZCIDV
----1-
addressingassembleropcbytescyles
impliedSEDF812
SEI

Set Interrupt Disable Status

1 -> I

NZCIDV
---1--
addressingassembleropcbytescyles
impliedSEI7812
STA

Store Accumulator in Memory

A -> M

NZCIDV
------
addressingassembleropcbytescyles
zeropageSTA oper8523
zeropage,XSTA oper,X9524
absoluteSTA oper8D34
absolute,XSTA oper,X9D35
absolute,YSTA oper,Y9935
(indirect,X)STA (oper,X)8126
(indirect),YSTA (oper),Y9126
STX

Store Index X in Memory

X -> M

NZCIDV
------
addressingassembleropcbytescyles
zeropageSTX oper8623
zeropage,YSTX oper,Y9624
absoluteSTX oper8E34
STY

Sore Index Y in Memory

Y -> M

NZCIDV
------
addressingassembleropcbytescyles
zeropageSTY oper8423
zeropage,XSTY oper,X9424
absoluteSTY oper8C34
TAX

Transfer Accumulator to Index X

A -> X

NZCIDV
++----
addressingassembleropcbytescyles
impliedTAXAA12
TAY

Transfer Accumulator to Index Y

A -> Y

NZCIDV
++----
addressingassembleropcbytescyles
impliedTAYA812
TSX

Transfer Stack Pointer to Index X

SP -> X

NZCIDV
++----
addressingassembleropcbytescyles
impliedTSXBA12
TXA

Transfer Index X to Accumulator

X -> A

NZCIDV
++----
addressingassembleropcbytescyles
impliedTXA8A12
TXS

Transfer Index X to Stack Register

X -> SP

NZCIDV
------
addressingassembleropcbytescyles
impliedTXS9A12
TYA

Transfer Index Y to Accumulator

Y -> A

NZCIDV
++----
addressingassembleropcbytescyles
impliedTYA9812
*
add 1 to cycles if page boundery is crossed
**
add 1 to cycles if branch occurs on same page
add 2 to cycles if branch occurs to different page

Legend to Flags:

+
modified
-
not modified
1
set
0
cleared
M6
memory bit 6
M7
memory bit 7

Note on assembler syntax:
Most assemblers employ "OPC *oper" for forced zeropage addressing.

Appendix B: 6502 Jump Vectors and Stack Operations

The 256 bytes processor stack of the 6502 is located at $0100 ... $01FF in
memory, growing down from top to bottom.
There are three 2-byte address locations at the very top end of the 64K address
space serving as jump vectors for reset/startup and interrupt operations:

$FFFA, $FFFB ... NMI (Non-Maskable Interrupt) vector
$FFFC, $FFFD ... RES (Reset) vector
$FFFE, $FFFF ... IRQ (Interrupt Request) vector

At the occurrence of interrupt, the value of the program counter (PC) is put in
high-low order onto the stack, followed by the value currently in the status
register and control will be transferred to the address location found in the
respective interrupt vector. These are recovered from the stack at the end of
an interrupt routine by the RTI instruction.

6502 Interrupt Operations
(Image: MCS6502 Instruction Set Summary, MOS Technology, Inc.)

Similarly, as a JSR instruction is encountered, PC is dumped onto the stack
and recovered by the JSR instruction:

6502 Subroutine Operations
(Image: MCS6502 Instruction Set Summary, MOS Technology, Inc.)

Appendix C: 6502 Instruction Layout

The 6502 instruction table is laid out according to a pattern a-b-c, where
a and b are an octal number each, followed by a group of two binary digits c,
as in the bit-vector "aaabbbcc".

aaabbbcc
bit76543210
(0…7)(0…7)(0…3)

Example:
All ROR instructions share a = 3 and c = 2 (3b2) with the address mode in b.
At the same time, all instructions addressing the zero-page share b = 1 (a1c).
abc = 312  =>  ( 3 << 5 | 1 << 2 | 2 )  =  %011.001.10  =  $66  "ROR zpg".

Notably, there are no legal opcodes defined where c = 3, accounting for the
empty columns in the usual, hexadecimal view of the instruction table.
(For compactness empty rows where c = 3 are omitted from the tables below.)

The following table lists the instruction set, rows sorted by c, then a.

Generally, instructions of a kind are typically found in rows as a combination
of a and c, and address modes are in columns b.
However, there are a few exception to this rule, namely, where bits 0 of both
c and b are low (c = 0, 2; b = 0, 2, 4, 6) and combinations of c and b select
a group of related operations. (E.g., c=0 ∧ b=4: branch, c=0 ∧ b=6: set flag)

cab
01234567
00$00BRK impl$08PHP impl$10BPL rel$18CLC impl
1$20JSR abs$24BIT zpg$28PLP impl$2CBIT abs$30BMI rel$38SEC impl
2$40RTI impl$48PHA impl$4CJMP abs$50BVC rel$58CLI impl
3$60RTS impl$68PLA impl$6CJMP ind$70BVS rel$78SEI impl
4$84STY zpg$88DEY impl$8CSTY abs$90BCC rel$94STY zpg,X$98TYA impl
5$A0LDY #$A4LDY zpg$A8TAY impl$ACLDY abs$B0BCS rel$B4LDY zpg,X$B8CLV impl$BCLDY abs,X
6$C0CPY #$C4CPY zpg$C8INY impl$CCCPY abs$D0BNE rel$D8CLD impl
7$E0CPX #$E4CPX zpg$E8INX impl$ECCPX abs$F0BEQ rel$F8SED impl
10$01ORA X,ind$05ORA zpg$09ORA #$0DORA abs$11ORA ind,Y$15ORA zpg,X$19ORA abs,Y$1DORA abs,X
1$21AND X,ind$25AND zpg$29AND #$2DAND abs$31AND ind,Y$35AND zpg,X$39AND abs,Y$3DAND abs,X
2$41EOR X,ind$45EOR zpg$49EOR #$4DEOR abs$51EOR ind,Y$55EOR zpg,X$59EOR abs,Y$5DEOR abs,X
3$61ADC X,ind$65ADC zpg$69ADC #$6DADC abs$71ADC ind,Y$75ADC zpg,X$79ADC abs,Y$7DADC abs,X
4$81STA X,ind$85STA zpg$8DSTA abs$91STA ind,Y$95STA zpg,X$99STA abs,Y$9DSTA abs,X
5$A1LDA X,ind$A5LDA zpg$A9LDA #$ADLDA abs$B1LDA ind,Y$B5LDA zpg,X$B9LDA abs,Y$BDLDA abs,X
6$C1CMP X,ind$C5CMP zpg$C9CMP #$CDCMP abs$D1CMP ind,Y$D5CMP zpg,X$D9CMP abs,Y$DDCMP abs,X
7$E1SBC X,ind$E5SBC zpg$E9SBC #$EDSBC abs$F1SBC ind,Y$F5SBC zpg,X$F9SBC abs,Y$FDSBC abs,X
20$06ASL zpg$0AASL A$0EASL abs$16ASL zpg,X$1EASL abs,X
1$26ROL zpg$2AROL A$2EROL abs$36ROL zpg,X$3EROL abs,X
2$46LSR zpg$4ALSR A$4ELSR abs$56LSR zpg,X$5ELSR abs,X
3$66ROR zpg$6AROR A$6EROR abs$76ROR zpg,X$7EROR abs,X
4$86STX zpg$8ATXA impl$8ESTX abs$96STX zpg,Y$9ATXS impl
5$A2LDX #$A6LDX zpg$AATAX impl$AELDX abs$B6LDX zpg,Y$BATSX impl$BELDX abs,Y
6$C6DEC zpg$CADEX impl$CEDEC abs$D6DEC zpg,X$DEDEC abs,X
7$E6INC zpg$EANOP impl$EEINC abs$F6INC zpg,X$FEINC abs,X

Note: The operand of instructions like "ASL A" is essentially implied, as well.
However, for consistency, they are here listed in the usual "CMD A" notation,
instead of "CMD impl". Mind that the two notations are interchangeable for any
instructions involving the accumulator.

A rotated view, rows as combinations of c and b, and columns as a:

cba
01234567
00$00BRK impl$20JSR abs$40RTI impl$60RTS impl$A0LDY #$C0CPY #$E0CPX #
1$24BIT zpg$84STY zpg$A4LDY zpg$C4CPY zpg$E4CPX zpg
2$08PHP impl$28PLP impl$48PHA impl$68PLA impl$88DEY impl$A8TAY impl$C8INY impl$E8INX impl
3$2CBIT abs$4CJMP abs$6CJMP ind$8CSTY abs$ACLDY abs$CCCPY abs$ECCPX abs
4$10BPL rel$30BMI rel$50BVC rel$70BVS rel$90BCC rel$B0BCS rel$D0BNE rel$F0BEQ rel
5$94STY zpg,X$B4LDY zpg,X
6$18CLC impl$38SEC impl$58CLI impl$78SEI impl$98TYA impl$B8CLV impl$D8CLD impl$F8SED impl
7$BCLDY abs,X
10$01ORA X,ind$21AND X,ind$41EOR X,ind$61ADC X,ind$81STA X,ind$A1LDA X,ind$C1CMP X,ind$E1SBC X,ind
1$05ORA zpg$25AND zpg$45EOR zpg$65ADC zpg$85STA zpg$A5LDA zpg$C5CMP zpg$E5SBC zpg
2$09ORA #$29AND #$49EOR #$69ADC #$A9LDA #$C9CMP #$E9SBC #
3$0DORA abs$2DAND abs$4DEOR abs$6DADC abs$8DSTA abs$ADLDA abs$CDCMP abs$EDSBC abs
4$11ORA ind,Y$31AND ind,Y$51EOR ind,Y$71ADC ind,Y$91STA ind,Y$B1LDA ind,Y$D1CMP ind,Y$F1SBC ind,Y
5$15ORA zpg,X$35AND zpg,X$55EOR zpg,X$75ADC zpg,X$95STA zpg,X$B5LDA zpg,X$D5CMP zpg,X$F5SBC zpg,X
6$19ORA abs,Y$39AND abs,Y$59EOR abs,Y$79ADC abs,Y$99STA abs,Y$B9LDA abs,Y$D9CMP abs,Y$F9SBC abs,Y
7$1DORA abs,X$3DAND abs,X$5DEOR abs,X$7DADC abs,X$9DSTA abs,X$BDLDA abs,X$DDCMP abs,X$FDSBC abs,X
20$A2LDX #
1$06ASL zpg$26ROL zpg$46LSR zpg$66ROR zpg$86STX zpg$A6LDX zpg$C6DEC zpg$E6INC zpg
2$0AASL A$2AROL A$4ALSR A$6AROR A$8ATXA impl$AATAX impl$CADEX impl$EANOP impl
3$0EASL abs$2EROL abs$4ELSR abs$6EROR abs$8ESTX abs$AELDX abs$CEDEC abs$EEINC abs
4
5$16ASL zpg,X$36ROL zpg,X$56LSR zpg,X$76ROR zpg,X$96STX zpg,Y$B6LDX zpg,Y$D6DEC zpg,X$F6INC zpg,X
6$9ATXS impl$BATSX impl
7$1EASL abs,X$3EROL abs,X$5ELSR abs,X$7EROR abs,X$BELDX abs,Y$DEDEC abs,X$FEINC abs,X

Finally, a more complex view, the instruction set listed by rows as
combinations of a and c, and b in columns:

Address modes are either a property of b (even columns) or combinations
of b and c (odd columns with aspecific row-index modulus 3; i.e., every
third row in a given column). In those latter columns, first and third
rows (c = 0 and c = 2) refer to the same kind of general operation.

Load, store and transfer instructions as well as comparisons are typically
found in the lower half of the table, while most of the arithmetical and
logical operations as well as stack and jump instructions are found in the
upper half. (However, mind the exception of SBC as a "mirror" of ADC.)

acb
01234567
00$00BRK impl$08PHP impl$10BPL rel$18CLC impl
1$01ORA X,ind$05ORA zpg$09ORA #$0DORA abs$11ORA ind,Y$15ORA zpg,X$19ORA abs,Y$1DORA abs,X
2$06ASL zpg$0AASL A$0EASL abs$16ASL zpg,X$1EASL abs,X
10$20JSR abs$24BIT zpg$28PLP impl$2CBIT abs$30BMI rel$38SEC impl
1$21AND X,ind$25AND zpg$29AND #$2DAND abs$31AND ind,Y$35AND zpg,X$39AND abs,Y$3DAND abs,X
2$26ROL zpg$2AROL A$2EROL abs$36ROL zpg,X$3EROL abs,X
20$40RTI impl$48PHA impl$4CJMP abs$50BVC rel$58CLI impl
1$41EOR X,ind$45EOR zpg$49EOR #$4DEOR abs$51EOR ind,Y$55EOR zpg,X$59EOR abs,Y$5DEOR abs,X
2$46LSR zpg$4ALSR A$4ELSR abs$56LSR zpg,X$5ELSR abs,X
30$60RTS impl$68PLA impl$6CJMP ind$70BVS rel$78SEI impl
1$61ADC X,ind$65ADC zpg$69ADC #$6DADC abs$71ADC ind,Y$75ADC zpg,X$79ADC abs,Y$7DADC abs,X
2$66ROR zpg$6AROR A$6EROR abs$76ROR zpg,X$7EROR abs,X
40$84STY zpg$88DEY impl$8CSTY abs$90BCC rel$94STY zpg,X$98TYA impl
1$81STA X,ind$85STA zpg$8DSTA abs$91STA ind,Y$95STA zpg,X$99STA abs,Y$9DSTA abs,X
2$86STX zpg$8ATXA impl$8ESTX abs$96STX zpg,Y$9ATXS impl
50$A0LDY #$A4LDY zpg$A8TAY impl$ACLDY abs$B0BCS rel$B4LDY zpg,X$B8CLV impl$BCLDY abs,X
1$A1LDA X,ind$A5LDA zpg$A9LDA #$ADLDA abs$B1LDA ind,Y$B5LDA zpg,X$B9LDA abs,Y$BDLDA abs,X
2$A2LDX #$A6LDX zpg$AATAX impl$AELDX abs$B6LDX zpg,Y$BATSX impl$BELDX abs,Y
60$C0CPY #$C4CPY zpg$C8INY impl$CCCPY abs$D0BNE rel$D8CLD impl
1$C1CMP X,ind$C5CMP zpg$C9CMP #$CDCMP abs$D1CMP ind,Y$D5CMP zpg,X$D9CMP abs,Y$DDCMP abs,X
2$C6DEC zpg$CADEX impl$CEDEC abs$D6DEC zpg,X$DEDEC abs,X
70$E0CPX #$E4CPX zpg$E8INX impl$ECCPX abs$F0BEQ rel$F8SED impl
1$E1SBC X,ind$E5SBC zpg$E9SBC #$EDSBC abs$F1SBC ind,Y$F5SBC zpg,X$F9SBC abs,Y$FDSBC abs,X
2$E6INC zpg$EANOP impl$EEINC abs$F6INC zpg,X$FEINC abs,X

APENDIX D: The 65xx-Family:

TypeFeatures, Comments
6502NMOS, 16 bit address bus, 8 bit data bus
6502Aaccelerated version of 6502
6502Caccelerated version of 6502, additional halt pin, CMOS
65C0216 bit version, additional instructions and address modes
6503, 6505, 650612 bit address bus [4 KiB]
650413 bit address bus [8 KiB]
650713 bit address bus [8 KiB], no interrupts
650920 bit address bus [1 MiB] by bankswitching
6510as 6502 with additional 6 bit I/O-port
6511integrated micro controler with I/O-port, serial interface, and RAM (Rockwell)
65F11as 6511, integrated FORTH interpreter
7501as 6502, HMOS
8500as 6510, CMOS
8502as 6510 with switchable 2 MHz option, 7 bit I/O-port
65816 (65C816)16 bit registers and ALU, 24 bit address bus [16 MiB], up to 24 MHz (Western Design Center)
65802 (65C802)as 65816, pin compatible to 6502, 64 KiB address bus, up to 16 MHz

Site Notes

Disclaimer

Errors excepted. The information is provided for free and AS IS, therefore without any warranty;
without even the implied warranty of merchantability or fitness for a particular purpose.

See also

External Links

Presented by virtual 6502, mass:werk.