1. Principles of Computers 17th Lecture
Pavel Ježek, Ph.D.

2. ... ??
$ A 00
SP + 10 07 $
SP + 8 05 $ 09
SP + 4 $ xx
SP + 2
$ E
SP →
$ C
procedure P1(a : word;
b : longword);
var
loc1, loc2 : word;
$0A50: SP := SP – (2+2)
...
SP := SP + (2+2)
ret
begin
push h
push 0005h
$0900: call 00000A50h
$0905: SP := SP + (4+2)
nop
end.
procedure argument b
procedure argument a
procedure prolog
return address from procedure P1
to main program
procedure body
procedure epilog
local variable loc1
local variable loc2

3. ... ??
$ A 00
SP + 10 07 $
SP + 8 05 $ 09 $
SP + 2
$ E
SP →
$ C
$00000B00
function F1(a : word;
b : longword
) : word;
var
loc1, loc2 : word;
$0A50: SP := SP – (2+2)
...
SP := SP + (2+2)
ret
x : word;
begin
push h
push 0005h
$0900: call 00000A50h
$0905: ($00000B00)^ := ?
SP := SP + (4+2)
nop
end.
procedure argument b
procedure argument a
← IP
begin
...
end;
return address from procedure P1
to main program
local variable loc1
local variable loc2
x := F1(5, 7);
global variable x

4. ... ??
$ A 00
SP + 12 07 $
SP + 10 05 $
SP + 8 $ 09
$ E
SP + 2
$ C
SP →
$ A
$00000B00
function F1(a : word;
b : longword
) : word;
var
loc1, loc2 : word;
$0A50: SP := SP – (2+2)
...
SP := SP + (2+2)
ret
x : word;
begin
push h
push 0005h
SP := SP - 2
$0900: call 00000A50h
$0905: ($00000B00)^ := ?
SP := SP + (4+2+2)
nop
end.
procedure argument b
procedure argument a
← IP
begin
...
end;
reserved space for return value
return address from procedure P1
to main program
local variable loc1
local variable loc2
x := F1(5, 7);
global variable x

5. ... ??
$ A 00
SP + 12 07 $
SP + 10 05 $
SP + 8 $ 09
$ E
SP + 2
$ C
SP →
$ A
$00000B00
function F1(a : word;
b : longword
) : word;
var
loc1, loc2 : word;
$0A50: SP := SP – (2+2)
...
(SP + 8)^ := retval
SP := SP + (2+2)
ret
x : word;
begin
push h
push 0005h
SP := SP - 2
$0900: call 00000A50h
$0905: ($00000B00)^ := ?
SP := SP + (4+2+2)
nop
end.
procedure argument b
procedure argument a
begin
...
F1 := retval;
end;
reserved space for return value
return address from procedure P1
to main program
local variable loc1
local variable loc2
x := F1(5, 7);
global variable x

6. ... ??
$ A 00
SP + 4 07 $
SP + 2 05 $
SP → $ 09
$ E
$ C
$ A
$00000B00
function F1(a : word;
b : longword
) : word;
var
loc1, loc2 : word;
$0A50: SP := SP – (2+2)
...
(SP + 8)^ := retval
SP := SP + (2+2)
ret
x : word;
begin
push h
push 0005h
SP := SP - 2
$0900: call 00000A50h
$0905: (^word($00000B00))^ := SP^
SP := SP + (4+2+2)
nop
end.
procedure argument b
procedure argument a
reserved space for return value
x := F1(5, 7);
← IP
global variable x

7. ... 00
$00007A08
00 (00)
00 (20)
$00007A04
$00007A02
$00007A00 B C3 $ A $ C2 0D F5
CALL E8 $ 7A 04
indir 15 FF $ C1 $
variable j
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end.
variable ptr
padding
variable i A
procedure P2
procedure P1 B
$ ← $ – ($ )
= $ – $ B = $00000DF5
E8 = relative call (E9 = relative jump)
main program
$00007A04 C1
FF 15 = indirect call
(FF 25 = indirect jump) C2

8. ... ?? $
CALL
indir 15 FF $ C1 $
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end. A B ?
main program
ptr
addr? C1 C2

9. ... ?? $ 00
CALL
indir 15 FF $ C1 $
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end. A B
main program
ptr
addr? C1 C2

10. A C2 B C1 C1 C2 ?? $00002000 00 CALL E8 $00001306 indir 15 FF
... ?? $ C2 00
CALL E8 $
indir 15 FF $ C1 $
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end. A B P2
addr?
main program
ptr
addr? C1 C2

11. ... ??
$00007A00 B C3 $ A $ C2 00
CALL E8 $
indir 15 FF $ C1 $
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end. A
procedure P2
procedure P1 B P2
addr?
main program
ptr
addr? C1 C2

12. ... 00
$00007A08
00 (00)
00 (20)
$00007A04
$00007A02
$00007A00 B C3 $ A $ C2
CALL E8 $
indir 15 FF $ C1 $
variable j
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end.
variable ptr
padding
variable i A
procedure P2
procedure P1 B P2
addr?
main program
ptr
addr? C1 C2

13. B A C2 C1 B A C2 C1 A B C1 C2 00 $00007A08 00 (00) 00 (20) $00007A04
... 00
$00007A08
00 (00)
00 (20)
$00007A04
$00007A02
$00007A00 B C3 $ A $ C2
CALL E8 $
indir 15 FF $ C1 $
... 00
$00007A08
00 (00)
00 (20)
$00007A04
$00007A02
$00007A00 B C3 $ A $ C2 0D F5
CALL E8 $ 7A 04
indir 15 FF $ C1 $
variable j
program PascalProgram;
type
PProc = procedure;
procedure P1;
begin α
end; jmp back = ret
procedure P2; β
var
i : word;
ptr : PProc;
j : word; γ1
ptr
ptr;
P2; γ2
end.
variable ptr
padding
variable i A
procedure P2
procedure P1 B P2
addr?
main program
ptr
addr? C1 C2

14. Typical ISA Arithmetic Instructions
MIPS: a := b op c
x86, 6502: a := a op b

15. 6502 Registers (Accumulator Architecture) X Y S P PC
6502: 8-bit CPU with 16-bit logical and physical address spaces (1:1 mapping between logical and physical addresses, i.e. logical address = physical address)

16. Load Value Into Register (6502)
LDA #$xx
LDA $xxxx
A := xx
A := ($xxxx)^

17. Load Value Into Accumulator
LDA #$xx
LDA $xxxx
LDA $xxxx,X
LDA $xxxx,Y
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^

18. Load Value Into Accumulator
LDA #$xx
LDA $xxxx
LDA $xxxx,X
LDA $xxxx,Y
LDA ($xx,X)
LDA ($xx),Y
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
A := (
(^word($00xx + X))^ )^
(^word($00xx))^ + Y

19. Load Value Into Register
LDA #$xx
LDA $xxxx
LDA $xxxx,X
LDA $xxxx,Y
LDX imm/addr
LDY imm/addr
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
X := imm/addr
Y := imm/addr
2 different variants implies 2 different OPCODEs for LDX!
2 different variants implies additional 2 different OPCODEs for LDY!

20. & Store Value From Register
LDA #$xx
LDA $xxxx
LDA $xxxx,X
LDA $xxxx,Y
LDX imm/addr
LDY imm/addr
STA $xxxx
STA $xxxx,X
STA $xxxx,Y
STX addr
STY addr
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
X := imm/addr
Y := imm/addr
($xxxx)^ := A
($xxxx + X)^ := A
($xxxx + Y)^ := A
addr := X
addr := Y

21. Move (Transfer) Value Between Registers
LDA #$xx
LDA $xxxx
LDA $xxxx,X
LDA $xxxx,Y
LDX imm/addr
LDY imm/addr
STA $xxxx
STA $xxxx,X
STA $xxxx,Y
STX addr
STY addr
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
X := imm/addr
Y := imm/addr
($xxxx)^ := A
($xxxx + X)^ := A
($xxxx + Y)^ := A
addr := X
addr := Y
TAX
TXA
TAY
TYA
TSX
TXS
X := A
A := X
Y := A
A := Y
X := S
S := X

22. Push To Stack & Pop (Pull) From Stack
LDA #$xx
LDA $xxxx
LDA $xxxx,X
LDA $xxxx,Y
LDX imm/addr
LDY imm/addr
STA $xxxx
STA $xxxx,X
STA $xxxx,Y
STX addr
STY addr
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
X := imm/addr
Y := imm/addr
($xxxx)^ := A
($xxxx + X)^ := A
($xxxx + Y)^ := A
addr := X
addr := Y
TAX
TXA
TAY
TYA
TSX
TXS
X := A
A := X
Y := A
A := Y
X := S
S := X
PHP
PLP
PHA
PLA
push P (flags)
pop P (flags)
push A
pop A

23. Setting Flags LDA #$xx LDA $xxxx LDA $xxxx,X LDA $xxxx,Y LDX imm/addr
LDY imm/addr
STA $xxxx
STA $xxxx,X
STA $xxxx,Y
STX addr
STY addr
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
X := imm/addr
Y := imm/addr
($xxxx)^ := A
($xxxx + X)^ := A
($xxxx + Y)^ := A
addr := X
addr := Y
TAX
TXA
TAY
TYA
TSX
TXS
X := A
A := X
Y := A
A := Y
X := S
S := X P
N... ..Z.
P.Negative := target.7
if target = 0 then
P.Zero := 1
else
P.Zero := 0;
PHP
PLP
PHA
PLA
push P (flags)
pop P (flags)
push A
pop A

24. Setting Flags LDA #$xx LDA $xxxx LDA $xxxx,X LDA $xxxx,Y LDX imm/addr
LDY imm/addr
STA $xxxx
STA $xxxx,X
STA $xxxx,Y
STX addr
STY addr
A := xx
A := ($xxxx)^
A := ($xxxx + X)^
A := ($xxxx + Y)^
X := imm/addr
Y := imm/addr
($xxxx)^ := A
($xxxx + X)^ := A
($xxxx + Y)^ := A
addr := X
addr := Y
TAX
TXA
TAY
TYA
TSX
TXS
X := A
A := X
Y := A
A := Y
X := S
S := X P
N... ..Z.
P.Negative := target.7
if target = 0 then
P.Zero := 1
else
P.Zero := 0;
PHP
PLP
PHA
PLA
push P (flags)
pop P (flags)
push A
pop A
CLC
SEC
P.Carry := 0
P.Carry := 1

25. Bitwise Operations ORA imm/addr AND imm/addr EOR imm/addr ? NOT ASL A
LSR A
ROL A
ROR A
A := A BitwiseOr imm/addr
A := A BitwiseAnd imm/addr
A := A BitwiseXor imm/addr
EOR #$FF
A := A shl 1
A := A shr 1
A := A rol 1
A := A ror 1
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;

26. Oring 16-bit Numbers (e.g. Little Endian)
MSB of A stored at $A001
LSB of A stored at $A000
A15
A14
A13
A12
A11
A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 or
MSB of B stored at $B001
LSB of B stored at $B000
B15
B14
B13
B12
B11
B10 B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 =
MSB of C stored at $C001
LSB of C stored at $C000
C15
C14
C13
C12
C11
C10 C9 C8 C7 C6 C5 C4 C3 C2 C1 C0

27. Oring 16-bit Numbers (e.g. Little Endian)
MSB of A stored at $A001
LSB of A stored at $A000
A15
A14
A13
A12
A11
A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 or or
LDA $A000
ORA $B000
STA $C000
LDA $A001
ORA $B001
STA $C001
MSB of B stored at $B001
LSB of B stored at $B000
B15
B14
B13
B12
B11
B10 B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 = =
MSB of C stored at $C001
LSB of C stored at $C000
C15
C14
C13
C12
C11
C10 C9 C8 C7 C6 C5 C4 C3 C2 C1 C0

28. Integer Operations 7654 3210 ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 P
N... ..ZC
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;

29. Integer Operations (Adding 8-bit Numbers)
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 P
N... ..ZC
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
LSB of A stored at $A000 A7 A6 A5 A4 A3 A2 A1 A0
carry + +
LSB of B stored at $B000 B7 B6 B5 B4 B3 B2 B1 B0 =
LSB of C stored at $C000 = C8
carry C7 C6 C5 C4 C3 C2 C1 C0
LDA $A000
CLC
ADC $B000
STA $C000

30. Integer Operations (Adding 8-bit Numbers)
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 P
N... ..ZC
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
LSB of A stored at $A000 A7 A6 A5 A4 A3 A2 A1 A0
carry + +
LSB of B stored at $B000 B7 B6 B5 B4 B3 B2 B1 B0
Signed Integers? =
LSB of C stored at $C000 = C8
carry C7 C6 C5 C4 C3 C2 C1 C0
LDA $A000
CLC
ADC $B000
STA $C000

31. Adding 16-bit Numbers (e.g. Little Endian)
MSB of A stored at $A001
LSB of A stored at $A000
A15
A14
A13
A12
A11
A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 +
MSB of B stored at $B001
LSB of B stored at $B000
B15
B14
B13
B12
B11
B10 B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 =
MSB of C stored at $C001
LSB of C stored at $C000
C15
C14
C13
C12
C11
C10 C9 C8 C7 C6 C5 C4 C3 C2 C1 C0

32. Adding 16-bit Numbers (e.g. Little Endian)
LSB of A stored at $A000 A7 A6 A5 A4 A3 A2 A1 A0
A15
A14
A13
A12
A11
A10 A9 A8
LSB of A stored at $A000
MSB of A stored at $A001 B7 B6 B5 B4 B3 B2 B1 B0
B15
B14
B13
B12
B11
B10 B9 B8
LSB of B stored at $B000
MSB of B stored at $B001 + = C7 C6 C5 C4 C3 C2 C1 C0
C15
C14
C13
C12
C11
C10 C9 C8
LSB of C stored at $C000
MSB of C stored at $C001 A7 A6 A5 A4 A3 A2 A1 A0 +
LSB of B stored at $B000 B7 B6 B5 B4 B3 B2 B1 B0 =
LSB of C stored at $C000
C8’ C7 C6 C5 C4 C3 C2 C1 C0
MSB of A stored at $A001 +
A15
A14
A13
A12
A11
A10 A9 A8 +
MSB of B stored at $B001
B15
B14
B13
B12
B11
B10 B9 B8 =
MSB of C stored at $C001
C16
C15
C14
C13
C12
C11
C10 C9 C8

33. Adding 16-bit Numbers (e.g. Little Endian)
LSB of A stored at $A000
ADC imm/addr A7 A6 A5 A4 A3 A2 A1 A0
carry
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 + +
LSB of B stored at $B000
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0; B7 B6 B5 B4 B3 B2 B1 B0 =
LSB of C stored at $C000 = C8
carry C7 C6 C5 C4 C3 C2 C1 C0

34. Adding 16-bit Numbers (e.g. Little Endian)
LSB of A stored at $A000
ADC imm/addr A7 A6 A5 A4 A3 A2 A1 A0
carry
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 + +
LDA $A000
CLC
ADC $B000
STA $C000
LSB of B stored at $B000
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0; B7 B6 B5 B4 B3 B2 B1 B0 =
LSB of C stored at $C000 = C8
carry C7 C6 C5 C4 C3 C2 C1 C0

35. Adding 16-bit Numbers (e.g. Little Endian)
LSB of A stored at $A000
ADC imm/addr A7 A6 A5 A4 A3 A2 A1 A0
carry
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 + +
LDA $A000
CLC
ADC $B000
STA $C000
LSB of B stored at $B000
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0; B7 B6 B5 B4 B3 B2 B1 B0 =
LSB of C stored at $C000 = C8
carry C7 C6 C5 C4 C3 C2 C1 C0
MSB of A stored at $A001 +
A15
A14
A13
A12
A11
A10 A9 A8 +
MSB of B stored at $B001
B15
B14
B13
B12
B11
B10 B9 B8 =
MSB of C stored at $C001 =
C16
carry
C15
C14
C13
C12
C11
C10 C9 C8

36. Adding 16-bit Numbers (e.g. Little Endian)
LSB of A stored at $A000
ADC imm/addr A7 A6 A5 A4 A3 A2 A1 A0
carry
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 + +
LDA $A000
CLC
ADC $B000
STA $C000
LSB of B stored at $B000
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0; B7 B6 B5 B4 B3 B2 B1 B0 =
LSB of C stored at $C000 = C8
carry C7 C6 C5 C4 C3 C2 C1 C0
MSB of A stored at $A001 +
A15
A14
A13
A12
A11
A10 A9 A8 +
MSB of B stored at $B001
LDA $A001
ADC $B001
STA $C001
B15
B14
B13
B12
B11
B10 B9 B8 =
MSB of C stored at $C001 =
C16
carry
C15
C14
C13
C12
C11
C10 C9 C8

37. Adding 16-bit Numbers (e.g. Little Endian)
MSB of A stored at $A001
LSB of A stored at $A000
ADC imm/addr
A15
A14
A13
A12
A11
A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0 +
MSB of B stored at $B001
LSB of B stored at $B000
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
B15
B14
B13
B12
B11
B10 B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 =
MSB of C stored at $C001
LSB of C stored at $C000
C15
C14
C13
C12
C11
C10 C9 C8 C7 C6 C5 C4 C3 C2 C1 C0
LDA $A000
CLC
ADC $B000
STA $C000
LDA $A001
ADC $B001
STA $C001

38. Integer Operations – Increments and Decrements (only X and Y)
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

39. Integer Operations – Subtraction?
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
unsigned numbers
A := value – A
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

40. Integer Operations – Subtraction?
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
A := value – A
A := value + (– A)
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

41. Integer Operations – Subtraction? Two’s Complement?
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
unsigned numbers
Negative number ↓
signed representation needed
A := value – A
A := value + (– A)
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

42. Integer Operations – Subtraction? Two’s Complement?
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
unsigned numbers
Negative number ↓
signed representation needed
A := value – A
A := value + (– A)
How to represent non-negative number in two’s complement?
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

43. Integer Operations – Subtraction? Via Two’s Complement
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
A := value – A ↓
NOT A
INC A
ADD value
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
Not a problem, that everything is in unsigned arithmetic
A := value – A
A := value + (– A)
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

44. Integer Operations – Subtraction? Via Two’s Complement
ADC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
A := value – A ↓
NOT A
INC A
ADD value
A := value – A ↓
EOR #$FF
CLC
ADC #1
ADC value
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
A := value – A
A := value + (– A)
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

45. Integer Operations – Subtraction? Subtract with Borrow
ADC imm/addr
SBC imm/addr
result := A + imm/addr + P.Carry
P.Carry := result.8
A := result.7 … result.0
result := A – imm/addr – not(P.Carry)
P.Carry := not(result.7)
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;
P.Negative := X/Y.7
if X/Y = 0 then
P.Zero := 1
else
P.Zero := 0;
INX
INY
DEX
DEY
X := X + 1
Y := Y + 1
X := X – 1
Y := Y - 1

46. Shifts in More Detail ASL A oldA := A A.0 := 0 A.1 := oldA.0
LSR A
ROR A
ROL A
oldA := A
A.0 := 0
A.1 := oldA.0
A.2 := oldA.1 …
A.7 := oldA.6
P.Carry := oldA.7
A.7 := 0
A.6 := oldA.7
A.5 := oldA.6
A.0 := oldA.1
P.Carry := oldA.0
A.7 := P.Carry
Using Carry flag as “ninth” bit as well
P.Negative := A.7
if A = 0 then
P.Zero := 1
else
P.Zero := 0;

47. No Division (div), No Mutiplication (*) Instructions on 6502

48. Instruction Timing