8.

3 Stack Organization
 Stack: A storage device that stores
information in such a manner that the
item stored last is the first item
retrieved.

 Also called last-in first-out (LIFO) list.

Useful for compound arithmetic
operations and nested subroutine calls.
8.3 Stack Organization
 • Stack pointer (SP): A register that
holds the address of the top item in
the stack.
SP always points at the top item in
the stack
 • Push: Operation to insert an item into
the stack.
• Pop: Operation to retrieve an item
from the stack.
REGISTER STACK
• A stack can be
organized as a
collection of a
finite number of
registers.
 REGISTER STACK
• In a 64-word stack, the
stack pointer contains 6
bits.
• The one-bit register
FULL is set to 1 when the
stack is full;
EMPTY register is 1 when
the stack is empty.
• The data register DR
holds the data to be
written into or read from
the stack.
 The following are the micro-
operations associated with the stack

Initialization
SP ← 0, EMPTY ← 1, FULL
← 0
Push
SP ← SP + 1
M[SP] ← DR
If (SP = 0) then (FULL
← 1) Note that SP becomes 0
after 63
EMPTY ← 0
 The following are the micro-
operations associated with the stack

Pop
DR ← M[SP]
SP ← SP - 1
If (SP = 0) then
(EMPTY ← 1)
FULL ← 0
STACK OPERATIONS
REVERSE POLISH NOTATION (postfix)
 Reverse polish notation :is a postfix
notation (places operators after
operands)

 (Example)
Infix notation A+B
Reverse Polish notation AB+ also called
postfix.
STACK OPERATIONS
REVERSE POLISH NOTATION (postfix)
 A stack organization is very effective
for evaluating arithmetic expressions
 A * B + C * D → (AB *)+(CD *) →
AB * CD * +
 ( 3 * 4 ) + ( 5 * 6 ) → 34 * 56 * +
STACK OPERATIONS
REVERSE POLISH NOTATION (postfix)
n • Evaluation procedure:

n 1. Scan the expression from left to right.

2. When an operator is reached, perform the operation
with the two operands found on the left side of the
operator.
3. Replace the two operands and the operator by the
result obtained from the operation.

n (Example)
infix 3 * 4 + 5 * 6 = 42
postfix 3 4 * 5 6 * +

n 12 5 6 * +
12 30 +
42
STACK OPERATIONS
REVERSE POLISH NOTATION (postfix)
 • Reverse Polish notation evaluation with a
stack.
Stack is the most efficient way for evaluating
arithmetic expressions.
stack evaluation:
Get value
If value is data: push data
Else if value is operation:
pop, pop evaluate and push.
STACK OPERATIONS
REVERSE POLISH NOTATION (postfix)
 (Example) using stacks
to do this.
3 * 4 + 5 * 6 = 42
=> 3 4 * 5 6 * +
 8.4 Instruction Formats
• The most common fields in instruction formats are:
1. Mode field: Specifies the way the effective address is determined
2. Operation code: Specifies the operations to be performed.
3. Address field: Designates a memory address or a processor
register

Mode Opcode Address

8.4 Instruction Formats
• Zero address instruction: Stack is used. Arithmetic
operation pops two operands from the stack and pushes
the result.
• One address instructions: AC and memory. Since the
accumulator always provides one operand, only one
memory address needs to be specified.
•Two address instructions: Two address registers or two
memory locations are specified, one for the final result.
•Three address instructions: Three address registers or
memory locations are specified, one for the final result.
It is also called general address organization.
Zero address instructions
Instruction: ADD
Push and pop operations need to specify one address
involved in data transfer.

Stack-organized computer does not use an address

field for the instructions ADD, and MUL

Instruction: POP X
Evaluate X = ( A + B ) * ( C + D )

PUSH, and POP instructions need an address field

to specify the operand
 Zero address instructions

PUSH A TOS ← A
PUSH B TOS ← B
ADD TOS ← ( A + B )
PUSH C TOS ← C
PUSH D TOS ← D
ADD TOS ← (C + D)
MUL TOS ← (C + D) ∗ ( A + B)
POP X X ← TOS

Advantages: No memory addresses needed during the operation

Disadvantages: results in longer program codes.
One address instructions
 One address can be a register name or
memory address.
 SINGLE ACCUMULATOR ORGANIZATION

 Since the accumulator always provides one

operands, only one memory address needs to
be specified.
Instruction: ADD X
Microoperation: AC ← AC + M[X]
 One address instructions

LOAD A AC ← M [ A]
ADD B AC ← AC + M [ B ]
STORE T M [T ] ← AC

 All operations are done between the AC register and memory operand

Advantages: fewer bits are needed to specify the address.

Disadvantages: results in writing long programs.
Two address instructions
 • Assumes that the destination
address is the same as that of the
first operand. Can be a memory
address or a register name.

 Instruction: ADD R1, R2

Microoperation: R1  R1 + R2
 Two address instructions

MOV R1, A R1 ← M [ A]
MOV R2, B R 2 ← M [ B]
ADD R1, R2 R1 ← R1 + R 2
MOV X, R1 M [ x ] ← R1

most common in commercial computers

Each address fields specify either a processor register or a

memory operand

Advantages: results in writing medium size programs

Disadvantages: more bits are needed to specify two addresses.
 Three address organization
 GENERAL REGISTER ORGANIZATION

• Three address instructions: Memory addresses for

the two operands and one destination need to be
specified.
Instruction: ADD R1, R2, R3
Microoperation: R1  R2 + R3

ADD R1, R2, R3 R1 ← R 2 + R3

 Advantages: results in writing short programs

Disadvantages: more bits are needed to specify three addresses.
EXAMPLE: Show how can the following operation be
performed using:
a- three address instruction
b- two address instruction
c- one address instruction
d- zero address instruction
X = (A + B) * (C + D)
 a-Three-address instructions
(general register organization)
• ADD R1, A, B
• R1  M[A] + M[B]
• ADD R2, C, D
• R2  M[C] + M[D]
• MUL X, R1, R2
• M[X]  R1 * R2
 b-Two-address instructions
(general register organization)
• MOV R1, A
• R1  M[A]
• ADD R1, B
• R1  R1 + M[B]
• MOV R2, C
• R2  M[C]
• ADD R2, D
• R2  R2 + M[D]
• MOV X, R2
• M[X] R2
• MUL X, R1
• M[X]  R1 * M[X]
 c- One-address instructions
• LOAD A
• AC M[A]
• ADD B
• AC  AC + M[B]
• STORE T
• M[T ] AC
• LOAD C
• AC  M[C]
• ADD D
• AC  AC + M[D]
• MUL T
• AC  AC * M[T ]
• STORE X
• M[X]  AC Store
 d- Zero-address instructions
(stack organization)
• Push value
• Else If operator is encountered: Pop, pop, operation, push
• Pop operand pop another operand then perform an
operation and push the result back into the stack.

• PUSH A TOS  A Push

• PUSH B TOS  B
• ADD TOS  (A+B) Pop, pop, operation, push
• PUSH C TOS  C
• PUSH D TOS  D
• ADD TOS  (C+D)
• MUL TOS  (C+D)*(A+B)
• POP X M[X]  TOS
• (*TOS stands for top of stack).