Basic Types of CPU

Question 1

Basic Types of CPU

According to Instruction Set Architecture:

Answer 1

1. Accumulator-based
2. General Purpose Register Type
3. Stack Machine

Question 2

• “1-operand CPU”
• the accumulator is where intermediate arithmetic and logic results are stored
• early computers were accumulator-based

Answer 2

Accumulator-based

Question 3

Registers in an Accumulator-based CPU:

Answer 3

• A (accumulator)
• PC (program counter)
• X (index register) – contains address of memory data
• SP (stack pointer)
• Flags register

Question 4

Convert this to acculumator-based instruction set:

z = (b - c) * d;

Answer 4

load b ; A <- [b]
sub c ; A <- A – [c]
mul d ; A <- A * [d]
store z ; [z] <- A

Question 5

• The most common type of CPU, Intel 80x86 is of this type but with enhanced/modified features.
• Other GPR-type CPUs such as PDP-11: 16-bit registers cannot be “divided” into higher and lower bytes.

Answer 5

General Purpose Register (GPR) Type

Question 6

Registers in a GPR Type:

Answer 6

• R0, R1, R2,… R7
• In PDP-11, R7 is used as PC and R6 serves as SP
• PC
• SP
• Flags

Question 7

• 2-address instructions
• register-memory type:
  each arithmetic instruction has two operands
  destination address is always a register
  source address can be either a register or a memory location

Answer 7

GPR Type Instruction Set

Question 8

Conver this to GPR Type Instruction Set

z = b + c;

Answer 8

mov R0, b ; R0 <- [b]
add R0, c ; R0 <- b + c
mov z, R0 ; [z] <- R0

Question 9

Any computer system that has no general purpose register and simply uses the stack for computations falls on this category.

Answer 9

Stack Machine

Question 10

Registers in a Stack Machine:

Answer 10

• PC
• X (serves as Memory Address Register for operands)
• Flags

Question 11

Convert this to Stack Machine Instruction Set

z = b + c;

Answer 11

push b
push c
add ;push(pop() + pop())
pop z

NOTE: arithmetic expressions should first be translated to postfix form to easily write a program for a stack

Question 12

Basic Types of CPU

Answer 12

1. Accumulator-based - one operand is implicitly the accumulator
2. GPR-type - all operands are explicitly mentioned, which can be either a register or memory location
3. Stack machine - the operands are implicitly on top of the stack

Question 13

Convert this to Stack Machine Instruction Set

z = (b - c) * d;

Postfix: bc-d*

Answer 13

push b
push c
sub ; push(pop() - pop())
push d
mul ; push(pop() * pop())
pop z

Question 14

Accumulator-based instruction set

Data Transfer:

Answer 14

load addr ; A <- [addr]
store addr ; [addr] <- A

Question 15

Accumulator-based instruction set

Arithmetic Operations:

Answer 15

add addr ; A <- A + [addr]
sub addr ; A <- A - [addr]
mul addr ; A <- A * [addr]
div addr ; A <- A / [addr]

Question 16

Accumulator-based instruction set

Logical Operations:

Answer 16

and addr ; A <- A and [addr]
or addr ; A <- A or [addr]
not ; A <- not A
not addr ; A <- not [addr]

Question 17

GPR Type Instruction Set

Data Transfer:

Answer 17

• register <- register
  mov dst, src ; dst <- src
• register <- memory variable
  mov dst, [src] ; dst <- [src]
• memory variable <- register
  mov [dst], src ; [dst] <- src

Question 18

GPR Type Instruction Set

Arithmetic Operations:

Answer 18

add dst, src ; dst <- dst + src
sub dst, src ; dst <- dst – src
mul dst, src ; dst <- dst * src
div dst, src ; dst <- dst / src

Question 19

Stack Machine Instruction Set

Data Transfer:

Answer 19

push data ; push immediate
push addr ; push memory var
pop addr ; pop memory var
pop X ; pop an address

Question 20

Stack Machine Instruction Set

Arithmetic Operations:

Answer 20

add ; push(pop() + pop())
sub ; push(pop() – pop())
mul ; push(pop() * pop())
div ; push(pop() / pop())

Question 21

Stack Machine Instruction Set

Logical Operations:

Answer 21

and ; push(pop() and pop())
or ; push(pop() or pop())
not ; push(not pop())