1. CSC 3210 Computer Organization and Programming
Chapter 1
Dr. Anu Bourgeois

2. Layout of Chapter 1 Hand-programmable calculator
Fundamental definition of a computer
Basic computer cycle
Classic implementations of the computer
Stack machine architecture
Accumulator machine architecture
Load/store machine architecture

3. Programmable Calculators
Numeric keyboard and function keys
Single register – accumulator
Arithmetic logic unit – for computations
Stack provides memory
LIFO data structure
Pushing/popping operations
No addresses for the memory cells

4. HP-15C Programmable Calculator
Emulator available at

5. Postfix vs. Infix Postfix notation Infix notation
Operators follow operands
Uses the stack to save memory
No need for parenthesis
Operators are between operands
3 + 4
Need to specify order of operations -- parenthesis

7. y = (x-1) (x-7)
(10 – 1) = 9
(10 – 7) = 3
(9 *3) = 27
(10 – 11) = -1
27/(-1) = -27
(x-11)
10 enter
1 –
7 – *
11 – /

8. Stack Operations

9. Use of Registers Why would we want to use registers?
Registers are provided to hold constants
10 registers – named r0 thru r9
sto 0 – stores value in r0 and leaves it on top of stack
rcl copy contents of r0 to top of stack
Must specify register name

10. Programmable Calculators
In program mode, keystrokes not executed, code for each key is stored in memory
Memory has an address and holds data
Principal key designation
Function keys
Machine language – codes for keystrokes
Central processing unit
Program counter – holds address of next instruction to be executed

11. 3. 14159 sto 0. Place the constant on the stack
sto 0 Place the constant on the stack and store value in register r0  
1 –   Push 1, subtract, now TOP=
rcl 0  Place value of r0 on stack, TOP=
7 –  Push 7, subtract, TOP=
*      Multiply, TOP =
rcl 0   Place value of r0 on stack,
TOP=
11 –  Push 11, subtract, TOP =
/  Divide, TOP =

12. Memory Memory used to store program Memory locations are addressed
May compute memory addresses – unlike registers 
Registers may be selected – not indexed   
struct registers { 
 int r0, r1, r2, r3, r4, r5, r6, r7, r8, r9;  } 

13. Machine language
• Program stored using machine language – key codes of the calculator
• Central processing unit (CPU) executes the codes 
• Program counter (PC) holds address of next 
instruction to be executed 

14. Address
M/C code
Keystrokes
Comment
000 – 001
44 0
sto 0
Store in register 0
002 1
Enter 1
003 30 -
Subtract
45 0
rcl 0
Register 0 to stack
006 7
Enter 7
007
008 20 *
Multiply
011
012
Make it 11
013
014 10 /
Divide
43 32
g Rtn
Return to calculator mode

15. Calculator mode – codes (m/c lang.) sent to ALU
Program mode – codes (m/c lang.) sent to memory 
Each machine code is stored in one addressable memory location

16. Macros • Macro processor m4 copies input to output expands macros
Macros defined using define macro
– two arguments 
  define(sto, 44 0) 
define(rcl, 45 0) 
define(div, 10) 

17. Macros may have up to 9 arguments 
Specify arguments by $n  
If macro name followed immediately by ‘(‘, then arguments are present 
define(cat, $1$2$3$4$5) 
call it by: cat(a, b , c,   d, e)   ab cde 
call it by: cat(a , b , c)    a b c 

18. This makes code easier to read
define(sto, 44 0) then sto always refers to r0 
define(`sto', `44 $1') then call it as sto(0) 
This makes code easier to read
Macros are essentially substitutions that can use arguments

19. define(f, 42) 
define(g, 43) 
define(loc, 0) 
define(sto, `loc: 44 $1 define(`loc', eval(loc + 2))') 
define(rcl, `loc: 45 $1 define(`loc', eval(loc + 2))') 
define(div, `loc: 10 define(`loc', eval(loc + 1))') 
define(mul, `loc: 20 define(`loc', eval(loc + 1))') 

20. Address
M/C code
Assembly Code
Comment
000
44 0
sto(0)
Store in register 0
002 1
digit(1)
Enter 1
003 30
sub
Subtract
004
45 0
rcl(0)
Register 0 to stack
006 7
digit(7)
Enter 7
007
008 20
mul
Multiply
009
011
012
Make it 11
013
014 10
div
Divide
015
43 32
g rtn
Return to calculator mode

21. Practice Problem #1-1
Write postfix notation, assembly code and machine code to calculate the following expression

22. Von Neumann Machine
• Contains addressable memory for instructions and data 
• ALU executes instructions fetched from memory 
• PC register holds address for next instruction to execute 
Defined an instruction cycle 

23. CPU Memory I/O Von Neumann Model PC ALU Registers Data lines
Address lines
Control lines
Memory
I/O
Von Neumann Model

24. Instruction Cycle pc = 0; do { instruction = memory[pc++];
decode (instruction); 
fetch (operands); 
execute; 
store (results); 
} while (instruction != halt); 

25. Stack Machine Stack architecture does not have registers
Use memory to place items onto stack 
Use push and pop operations for moving data between memory and the stack 
Must specify memory address 
MAR – memory address register 
MDR – memory data register 
IR – instruction register holds fetched instruction 
ALU uses top two elements on the stack for all computations 

26. Stack Machine
Assume address 300 holds the value 3 and address 400 holds the value 4
push [300]
push [400]
add
pop [300]

27. Accumulator Machine
Accumulator register used as source operand and destination operand
Use load and store operations to move data from accumulator from/to memory
No registers or stack
Must access memory often

28. Accumulator Machine
Assume address 300 holds the value 3 and address 400 holds the value 4
load [300]
add [400]
store [300]

29. Load Store Machine Initially memory limited to few hundred words
Access time to all locations was the same 
As memory size increased time vs. cost issue arose 
New designs included variable access times 
Register file – high speed memory 

30. Load Store Machine
Use load and store instructions between registers and memory 
ALU functions on registers only 
Register file replaces the stack of the stack machine 
SPARC architecture is a load/store machine 

31. Load Store Machine
Assume address 300 holds the value 3 and address 400 holds the value 4
load [300], r0
load [400], r1
add r0, r1, r0
store r0, [300]

32. Assemblers
An assembler is a macro processor to translate symbolic programs into machine language programs 
Symbols may be used before they are defined – unlike using m4 
Two pass process  
Once to determine all symbol definitions 
Once to apply the definitions 

33. Symbols
A symbol followed by a colon defines the symbol to have as its value the current value of the location counter 
The symbol is called a label 

34. define(y_r, r0) 
define(x_r, r1) 
define(a2_r, r2) 
define(a1_r, r3) 
define(a0_r, r4) 
define(temp_r, r5) 
start: mov  0, %x_r  ! initialize x = 0
  mov  a2, %a2_r 
  mov  a1,  %a1_r 
  mov  a0,  %a0_r 
  sub   %x_r, %a2_r, %y_r   ! (x-1)
  sub   %x_r, %a1_r, %temp_r   ! (x-7)
  mul  %y_r, %temp_r, %y_r   ! (x-1)*(x-7)
  sub   %x_r, %a0_r, %temp_r  ! (x-11)
  div   %y_r, %temp_r, %y_r  ! divide to compute y