Anda di halaman 1dari 9

1

Machine Language to Assembly Language Conversion Table


Hex
Code
00
01
02
03
04
05
06

Mnemonic
Code
*
NOP
*
*
*
*
TAP

07

TPA

08
09
0A

INX
DEX
CLV

0B

SEV

0C
0D
0E
0F
10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F
20
21
23
24
25
26
27
28
29
2A
2B
2C

CLC
SEC
CLI
SEI
SBA
CBA
*
*
*
*
TAB
TBA
*
DAA
*
ADA
*
*
*
*
BRA
*
BLS
BCC
BCS
BNE
BEQ
BVC
BVS
BPL
BMI
BGE

2D
2E
2F

BLT
BGT
BLE

Mnemonic
Description

Mode

Number
of Bytes

No operation

Inherent

Transfer from accumulator A


to process code register
Transfer from process code
register to accumulator A
Increment index register
Decrement index register
Clear 2's complement overflow
bit
Set 2's complement overflow
bit
Clear carry
Set carry
Clear interrupt mask
Set interrupt mask
Subtract accumulator
Compare accumulator

Inherent

Inherent

Inherent
Inherent
Inherent

1
1
1

Inherent

Inherent
Inherent
Inherent
Inherent
Inherent
Inherent

1
1
1
1
1
1

Transfer from A to B
Transfer from B to A

Inherent
Inherent

1
1

Decimal Adjust (A)

Inherent

Add B to A

Inherent

Branch always

Relative

Branch if lower or same


Branch if carry clear
Branch if carry set
Branch if not equal
Branch if equal
Branch if overflow clear
Branch if overflow set
Branch if plus
Branch if minus
Branch if greater than zero
or equal to
Branch if less than zero
Branch if greater than zero
Branch if less than zero or
equal to

Relative
Relative
Relative
Relative
Relative
Relative
Relative
Relative
Relative
Relative

2
2
2
2
2
2
2
2
2
2

Relative
Relative
Relative

2
2
2

2
Machine Language to Assembly Language Conversion Table (continued)
Hex
Code
30

Mnemonic
Code
TSX

31
32
33
34
35

INS
PUL(A)
PUL(B)
DES
TXS

36
37
38
39
3A
3B
3C
3D
3E
3F
40
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F
50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F

PSH(A)
PSH(B)
*
RTS
*
RTI
*
*
WAI
SWI
NEG(A)
*
*
COM(A)
LSR(A)
*
ROR(A)
ASR(A)
ASL(A)
ROL(A)
DEC(A)
*
INC(A)
TST(A)
*
CLR(A)
NEG(B)
*
*
COM(B)
LSR(B)
*
ROR(B)
ASR(B)
ASL(B)
ROL(B)
DEC(B)
*
INC(B)
TST(B)
*
CLR(B)

Mnemonic
Description
Transfer from stack pointer
to index register
Increment stack pointer
Pull data from stack
Pull -data from stack
Decrement stack pointer
Transfer from index register
to stack pointer
Push data on stack
Push data on stack

Mode

Return from subroutine

Inherent

Return from interrupt

Inherent

Wait for interrupt


Software interrupt
Negate

Inherent
Inherent

1
1
1

Inherent
Inherent

Inherent
Inherent

Number
of Bytes
1
1
1
1
1
1
1
1

Complement
Logical shift right

1
1

Rotate right
Arithmetic right shift
Arithmetic shift left
Rotate left
Decrement

1
1
1
1
1

Increment
Test

1
1

Clear
Negate

1
1

Complement
Logical shift right

1
1

Rotate right
Arithmetic shift right
Arithmetic shift left
Rotate left
Decrement

1
1
1
1
1

Increment
Test

1
1

Clear

3
Machine Language to Assembly Language Conversion Table (continued)
Hex
Code
60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F
70
71
72
73
74
9F
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
AE
AF
B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
BA
BB
BC
BD
BE
BF

Mnemonic
Code
NEG
*
*
COM
LSR
*
ROR
ASR
ASL
ROL
DEC
*
INC
TST
JMP
CLR
NEG
*
*
COM
LSR
STS
SUB(A)
CMP(A)
SBC(A)
*
AND(A)
BIT(A)
LDA(A)
STA(A)
EOR(A)
ADC(A)
ORA(A)
ADD(A)
CPX
JSR
LDS
STS
SUB(A)
CMP(A)
SBC(A)
*
AND(A)
BIT(A)
LDA(A)
STA(A)
EOR(A)
ADC(A)
ORA(A)
ADD(A)
CPX
JSR
LDS(A)
STS(A)

Mnemonic
Description
Negate

Mode
Indexed

Number
of Bytes
2

Complement
Logical shift right

Indexed
Indexed

2
2

Rotate Right
Arithmetic shift right
Arithmetic shift left
Rotate left
Decrement

Indexed
Indexed
Indexed
Indexed
Indexed

2
2
2
2
2

Increment
Test
Jump
Clear
Negate

Indexed
Indexed
Indexed
Indexed
Extended

2
2
2
2
3

Complement
Logical shift right
Store stack pointer
Subtract
Compare
Subtract with carry

Extended
Extended
Direct
Indexed
Indexed
Indexed

3
3
2
2
2
2

Logical AND
Bit test
Load accumulator
Store accumulator
Exclusive OR
Add with carry
Inclusive OR
Add without carry
Compare index register
Jump to subroutine
Load stack pointer
Store stack pointer
Subtract
Compare
Subtract with carry

Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Extended
Extended
Extended

2
2
2
2
2
2
2
2
2
2
2
2
3
3
3

Logical AND
Bit test
Load accumulator
Store accumulator
Exclusive OR
Add with carry
Inclusive OR
Add without carry
Compare index register
Jump to subroutine
Load stack pointer
Store stack pointer

Extended
Extended
Extended
Extended
Extended
Extended
Extended
Extended
Extended
Extended
Extended
Extended

3
3
3
3
3
3
3
3
3
3
3
3

4
Machine Language to Assembly Language Conversion Table (continued)
Hex
Code
C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CC
CD
CE
CF
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DA
DB
DC
DD
DE
DF
E0
E1
E2
E3
E4
E5
E6
E7
E8
E9
EA
EB
EC
ED
EE
EF

Mnemonic
Code
SUM(B)
CMP(B)
SBC(B)
*
AND(B)
BIT(B)
LDA(B)
*
EOR(B)
ADC(B)
ORA(B)
ADD(B)
*
*
LDX
*
SUB(B)
CMP(B)
SBC(B)
*
AND(B)
BIT(B)
LDA(B)
STA(B)
EOR(B)
ADC(B)
ORA(B)
ADD(B)
*
*
LDX
STX
SUB(B)
CMP(B)
SBC(B)
*
AND(B)
BIT(B)
LDA(B)
STAB)
EOR(B)
ADC(B)
ORA(B)
ADD(B)
*
*
LDX
STX

Mnemonic
Description
Subtract
Compare
Subtract with carry

Mode
Immediate
Immediate
Immediate

Number
of Bytes
3
2
2

Logical AND
Bit test
Load accumulator

Immediate
Immediate
Immediate

2
2
2

Exclusive OR
Add with carry
Inclusive OR
Add without carry

Immediate
Immediate
Immediate
Immediate

2
2
2
2

Load index register

Immediate

Subtract
Compare
Subtract with carry

Direct
Direct
Direct

2
2
2

Logical AND
Bit test
Load accumulator
Store accumulator
Exclusive OR
Add with carry
Inclusive OR
Add without carry

Direct
Direct
Direct
Direct
Direct
Direct
Direct
Direct

2
2
2
2
2
2
2
2

Load index register


Store index register
Subtract
Compare
Subtract with carry

Direct
Direct
Indexed
Indexed
Indexed

2
2
2
2
2

Logical AND
Bit test
Load accumulator
Store accumulator
Exclusive OR
Add with carry
Inclusive OR
Add without carry

Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed
Indexed

2
2
2
2
2
2
2
2

Load index register


Store index register

Indexed
Indexed

2
2

5
Machine Language to Assembly Language Conversion Table (continued)
Hex
Code
F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
FA
FB
FC
FD
FE
FF

Mnemonic
Code
SUB(B)
CMP(B)
SBC(B)
*
AND(B)
BIT(B)
LDA(B)
STA(B)
EOR(B)
ADC(B)
ORA(B)
ADD(B)
*
*
LDX
STX

Mnemonic
Description
Subtract
Compare
Subtract with carry

Mode
Extended
Extended
Extended

Number
of Bytes
3
3
3

Logical AND
Bit test
Load accumulator
Store accumulator
Exclusive
Add with carry
Inclusive OR
Add without carry

Extended
Extended
Extended
Extended
Extended
Extended
Extended
Extended

3
3
3
3
3
3
3
3

Load index register


Store index register

Extended
Extended

3
3

6
Assembly Language to Machine Language Conversion Table
Mnemonic
Code
ADA
ADC(A)
ADC(A)
ADC(B)
ADC(B)
ADC(B)
ADC(B)
ADD(A)
ADD(A)
ADD(B)
ADD(B)
ADD(B)
ADD(B)
AND(A)
AND(A)
AND(B)
AND(B)
AND(B)
AND(B)
ASL
ASL(A)
ASL(B)
ASR
ASR(A)
ASR(B)
BCC
BCS
BEQ
BGE

Hex
Code
1B
A9
B9
C9
D9
E9
F9
AB
BB
CB
DB
EB
FB
A4
B4
C4
D4
E4
F4
68
48
58
67
47
57
24
25
27
2C

BGT
BHI
BIT(A)
BIT(A)
BIT(B)
BIT(B)
BIT(B)
BIT(B)
BLE

2E
22
A5
B5
C5
D5
E5
F5
2F

BLS
BLT
BMI
BNE
BPL
BRA
BVC
BVS

23
2D
2B
26
2A
20
28
29

Mnemonic Description

Mode

Relative
Relative
Relative
Relative

Number of
Bytes
1
2
3
2
2
2
3
2
3
2
2
2
3
2
3
2
2
2
3
2
1
1
2
1
1
2
2
2
2

Add B to A
Add with carry
Add with carry
Add with carry
Add with carry
Add with carry
Add with carry
Add without carry
Add without carry
Add without carry
Add without carry
Add without carry
Add without carry
Logical AND
Logical AND
Logical AND
Logical AND
Logical AND
Logical AND
Arithmetic shift left
Arithmetic shift left
Arithmetic shift left
Arithmetic shift right
Arithmetic right shift
Arithmetic shift right
Branch if carry clear
Branch if carry set
Branch if equal
Branch if greater than zero
or equal to
Branch if greater than zero
Branch if higher
Bit test
Bit test
Bit test
Bit test
Bit test
Bit test
Branch if less than zero or
equal to
Branch if lower or same
Branch if less than zero
Branch if minus
Branch if not equal
Branch if plus
Branch always
Branch if overflow clear
Branch if overflow set

Inherent
Indexed
Extended
Immediate
Direct
Indexed
Extended
Indexed
Extended
Immediate
Direct
Indexed
Extended
Indexed
Extended
Immediate
Direct
Indexed
Extended
Indexed

Relative
Relative
Indexed
Extended
Immediate
Direct
Indexed
Extended
Relative

2
2
2
3
2
2
2
3
2

Relative
Relative
Relative
Relative
Relative
Relative
Relative
Relative

2
2
2
2
2
2
2
2

Indexed

7
Assembly Language to Machine Language Conversion Table (continued)
Mnemonic
Code
CBA
CLC
CLI
CLR
CLR(A)
CLR(B)
CLV

Hex
Code
11
0C
0E
6F
4F
5F
0A

CMP(A)
CMP(A)
CMP(B)
CMP(B)
CMP(B)
CMP(B)
COM
COM
COM(A)
COM(B)
CPX
CPX
DAA
DEC
DEC(A)
DEC(B)
DES
DEX
EOR(A)
EOR(A)
EOR(B)
EOR(B)
EOR(B)
EOR(B)
INC
INC(A)
INC(B)
INS
INX
JMP
JSR
JSR
LDA(A)
LDA(A)
LDA(B)
LDA(B)
LDA(B)
LDA(B)
LDS
LDS(A)

A1
B1
C1
D1
E1
F1
63
73
43
53
AC
BC
19
6A
4A
5A
34
09
A8
B8
C8
D8
E8
F8
6C
4C
5C
31
08
6E
AD
BD
A6
B6
C6
D6
E6
F6
AE
BE

Mnemonic Description

Mode

Compare accumulator
Clear carry
Clear interrupt mask
Clear
Clear
Clear
Clear 2's complement overflow
bit
Compare
Compare
Compare
Compare
Compare
Compare
Complement
Complement
Complement
Complement
Compare index register
Compare index register
Decimal Adjust (A)
Decrement
Decrement
Decrement
Decrement stack pointer
Decrement index register
Exclusive OR
Exclusive OR
Exclusive OR
Exclusive OR
Exclusive OR
Exclusive
Increment
Increment
Increment
Increment stack pointer
Increment index register
Jump
Jump to subroutine
Jump to subroutine
Load accumulator
Load accumulator
Load accumulator
Load accumulator
Load accumulator
Load accumulator
Load stack pointer
Load stack pointer

Inherent
Inherent
Inherent
Indexed

Inherent
Indexed
Extended
Immediate
Direct
Indexed
Extended
Indexed
Extended

Indexed
Extended
Inherent
Indexed

Inherent
Inherent
Indexed
Extended
Immediate
Direct
Indexed
Extended
Indexed

Inherent
Inherent
Indexed
Indexed
Extended
Indexed
Extended
Immediate
Direct
Indexed
Extended
Indexed
Extended

Number of
Bytes
1
1
1
2
1
1
1
2
3
2
2
2
3
2
3
1
1
2
3
1
2
1
1
1
1
2
3
2
2
2
3
2
1
1
1
1
2
2
3
2
3
2
2
2
3
2
3

8
Assembly Language to Machine Language Conversion Table (continued)
Mnemonic
Code
LDX
LDX
LDX
LDX
LSR
LSR
LSR(A)
LSR(B)
NEG
NEG
NEG(A)
NEG(B)
NOP
ORA(A)
ORA(A)
ORA(B)
ORA(B)
ORA(B)
ORA(B)
PSH(A)
PSH(B)
PUL(A)
PUL(B)
ROL
ROL(A)
ROL(B)
ROR
ROR(A)
ROR(B)
RTI
RTS
SBA
SBC(A)
SBC(A)
SBC(B)
SBC(B)
SBC(B)
SBC(B)
SEC
SEI
SEV

Hex
Code
CE
DE
EE
FE
64
74
44
54
60
70
40
50
01
AA
BA
CA
DA
EA
FA
36
37
32
33
69
49
59
66
46
56
3B
39
10
A2
B2
C2
D2
E2
F2
0D
0F
0B

STA(A)
STA(A)
STA(B)
STA(B)
STAB)

A7
B7
D7
F7
E7

Mnemonic Description

Mode

Inherent
Inherent
Inherent
Indexed
Extended
Immediate
Direct
Indexed
Extended
Inherent
Inherent
Inherent

Number of
Bytes
3
2
2
3
2
3
1
1
2
3
1
1
1
2
3
2
2
2
3
1
1
1
1
2
1
1
2
1
1
1
1
1
2
3
2
2
2
3
1
1
1

Load index register


Load index register
Load index register
Load index register
Logical shift right
Logical shift right
Logical shift right
Logical shift right
Negate
Negate
Negate
Negate
No operation
Inclusive OR
Inclusive OR
Inclusive OR
Inclusive OR
Inclusive OR
Inclusive OR
Push data on stack
Push data on stack
Pull data from stack
Pull -data from stack
Rotate left
Rotate left
Rotate left
Rotate Right
Rotate right
Rotate right
Return from interrupt
Return from subroutine
Subtract accumulator
Subtract with carry
Subtract with carry
Subtract with carry
Subtract with carry
Subtract with carry
Subtract with carry
Set carry
Set interrupt mask
Set 2's complement overflow
bit
Store accumulator
Store accumulator
Store accumulator
Store accumulator
Store accumulator

Immediate
Direct
Indexed
Extended
Indexed
Extended

Indexed
Extended
Direct
Extended
Indexed

2
3
2
3
2

Indexed
Extended

Inherent
Indexed
Extended
Immediate
Direct
Indexed
Extended

Indexed

Indexed

9
Assembly Language to Machine Language Conversion Table (continued)
Mnemonic
Code
STS
STS
STS(A)
STX
STX
STX
SUB(A)
SUB(A)
SUB(B)
SUB(B)
SUB(B)
SUM(B)
SWI
TAB
TAP

Hex
Code
AF
9F
BF
DF
EF
FF
A0
B0
D0
E0
F0
C0
3F
16
06

TBA
TPA

17
07

TST
TST(A)
TST(B)
TSX

6D
4D
5D
30

TXS

35

WAI

3E

Mnemonic Description

Mode

Store stack pointer


Store stack pointer
Store stack pointer
Store index register
Store index register
Store index register
Subtract
Subtract
Subtract
Subtract
Subtract
Subtract
Software interrupt
Transfer from A to B
Transfer from accumulator A
to process code register
Transfer from B to A
Transfer from process code
register to accumulator A
Test
Test
Test
Transfer from stack pointer
to index register
Transfer from index register
to stack pointer
Wait for interrupt

Indexed
Direct
Extended
Direct
Indexed
Extended
Indexed
Extended
Direct
Indexed
Extended
Immediate
Inherent
Inherent
Inherent

Number of
Bytes
2
2
3
2
2
3
2
3
2
2
3
3
1
1
1

Inherent
Inherent

1
1

Indexed

Inherent

2
1
1
1

Inherent

Inherent