Chapter 10

And, Finally...
The Stack
Stack data structure
Interrupt I/O (again!)
Arithmetic using a stack

A Final Collection of ISA-related Topics

Stacks
Important low-level data structure

ASCII-Decimal Conversion
Converting between human-friendly and
computer-friendly representations

Interrupt-Driven I/O
Efficient, device-controlled interactions

10-2

Stacks
Abstract Data Structures
are defined simply by the rules for inserting and extracting data

A LIFO (last-in first-out) storage structure.

The first thing you put in is the last thing you take out.
The last thing you put in is the first thing you take out.

This means of access is what defines a stack, not the specific

implementation.
Two main operations:
PUSH: enter item at top of stack
POP: remove item from top of stack
Error conditions:
Underflow (trying to pop from empty stack)
Overflow (trying to push onto full stack)

We just have to keep track of the address of top of stack (TOS)

10-3

A Physical Stack
A coin holder as a stack

Initial State
(Empty)

1995

1996
1998
1982
1995

1998
1982
1995

After
One Push

After Three
More Pushes

After
One Pop

First quarter out is the last quarter in.

10-4

A Hardware Implementation
Data items move between registers
Note that the Top Of Stack is always in the same place.
Empty:

Yes

//////
//////
//////
//////
//////
Initial State

Empty:
TOP

No

#18
//////
//////
//////
//////
After
One Push

Empty:
TOP

No

#12
#5
#31
#18
//////
After Three
More Pushes

Empty:
TOP

No

#31
#18
//////
//////
//////

TOP

After
Two Pops

10-5

A Software Implementation
Data items don't move in memory,
just our idea about there the TOP of the stack is.
TOP

//////
//////
//////
//////
//////
x3FFF

#18
//////
//////
//////
//////
R6

Initial State
By convention, R6

x4000
After
One Push

TOP

R6

#18
#31
#5
#12
//////
x4003

TOP

R6

After Three
More Pushes

#18
#31
#5
#12
//////
x4001

TOP

R6

After
Two Pops

holds the Top of Stack (TOS) pointer.

10-6

Basic Push and Pop Code

Push
ADD
STR

R6, R6, #1
R0, R6, #0

; increment stack ptr

; store data (R0)

LDR
ADD

R0, R6, #0 ; load data from TOS

R6, R6, #-1 ; decrement stack ptr

Pop

10-7

Push & Pop (cont.)

What

if stack is already full or empty?

Before pushing, we have to test for overflow

Before popping, we have to test for underflow
In both cases, we use R5 to report success or failure

10 - 8

Pop with Underflow Detection

If we try to pop too many items off the stack,
an underflow condition occurs.
Check for underflow by checking TOS before removing data.
Return status code in R5 (0 for success, 1 for underflow)
POP

LD R1, EMPTY ;
ADD R2, R6, R1 ;
BRz FAIL
;
LDR R0, R6, #0
ADD R6, R6, #-1
AND R5, R5, #0 ;
RET
FAIL AND R5, R5, #0 ;
ADD R5, R5, #1
RET
EMPTY .FILL xC001

EMPTY = -x3FFF
Compare stack pointer
with x3FFF
SUCCESS: R5 = 0
FAIL: R5 = 1

10-9

Push with Overflow Detection

If we try to push too many items onto the stack,
an overflow condition occurs.
Check for overflow by checking TOS before adding data.
Return status code in R5 (0 for success, 1 for overflow)
PUSH

FAIL
MAX

LD R1, MAX
ADD R2, R6,
BRz FAIL
ADD R6, R6,
STR R0, R6,
AND R5, R5,
RET
AND R5, R5,
ADD R5, R5,
RET
.FILL xBFFC

; MAX = -x4004
R1 ; Compare stack pointer
; with x3FFF
#1
#0
#0 ; SUCCESS: R5 = 0
#0 ; FAIL: R5 = 1
#1
10-10

Arithmetic Using a Stack

Instead of registers, some ISA's use a stack for
source and destination operations: a zero-address machine.
Example:
ADD instruction pops two numbers from the stack,
adds them, and pushes the result to the stack.

Evaluating (A+B)(C+D) using a stack:

(1) push A
(2) push B
(3) ADD
(4) push C
(5) push D
(6) ADD
(7) MULTIPLY
(8) pop result

10-11

Data Type Conversion

Keyboard input routines read ASCII characters,
not binary values.
Similarly, output routines write ASCII.
Consider this program:
TRAP
ADD
TRAP
ADD
TRAP
TRAP

x23
R1, R0, #0
x23
R0, R1, R0
x21
x25

;
;
;
;
;
;

input from keybd

move to R1
input from keybd
add two inputs
display result
HALT

User inputs 2 and 3 -- what happens?

Result displayed: e
Why? ASCII '2' (x32) + ASCII '3' (x33) = ASCII 'e' (x65)
10-12

ASCII to Binary
Useful to deal with mult-digit decimal numbers
Assume we've read three ASCII digits (e.g., "259")
into a memory buffer.
How do we convert this to a number
we can use?

x32
x35
x39

'2'
'5'
'9'

Convert first character to digit (subtract x30)

and multiply by 100.
Convert second character to digit and
multiply by 10.
Convert third character to digit.
Add the three digits together.

10-13

Multiplication via a Lookup Table

How can we multiply a number by 100?
One approach:
Add number to itself 100 times.
Another approach:
Add 100 to itself <number> times. (Better if number < 100.)

Since we have a small range of numbers (0-9),

use number as an index into a lookup table.
Entry 0:
Entry 1:
Entry 2:
Entry 3:
etc.

0 x 100 = 0
1 x 100 = 100
2 x 100 = 200
3 x 100 = 300

10-14

Code for Lookup Table

; multiply R0 by 100, using lookup table
;
LEA R1, Lookup100 ; R1 = table base
ADD R1, R1, R0
; add index (R0)
LDR R0, R1, #0
; load from M[R1]
...
Lookup100 .FILL 0
; entry 0
.FILL 100 ; entry 1
.FILL 200 ; entry 2
.FILL 300 ; entry 3
.FILL 400 ; entry 4
.FILL 500 ; entry 5
.FILL 600 ; entry 6
.FILL 700 ; entry 7
.FILL 800 ; entry 8
.FILL 900 ; entry 9

10-15

Complete Conversion Routine (1 of 3)

; Three-digit buffer at ASCIIBUF.
; R1 tells how many digits to convert.
; Put resulting decimal number in R0.
ASCIItoBinary AND R0, R0, #0 ; clear result
ADD R1, R1, #0 ; test # digits
BRz DoneAtoB
; done if no digits
;
LD
R3, NegZero ; R3 = -x30
LEA R2, ASCIIBUF
ADD R2, R2, R1
ADD R2, R2, #-1 ; points to ones digit
;
LDR R4, R2, #0 ; load digit
ADD R4, R4, R3 ; convert to number
ADD R0, R0, R4 ; add ones contrib

10-16

Conversion Routine (2 of 3)
ADD
BRz
ADD

R1, R1, #-1

DoneAtoB
R2, R2, #-1

; one less digit

; done if zero
; points to tens digit

LDR
ADD
LEA
ADD
LDR
ADD

R4,
R4,
R5,
R5,
R4,
R0,

; load digit
; convert to number
; multiply by 10

ADD
BRz
ADD

R1, R1, #-1

DoneAtoB
R2, R2, #-1

;
R2, #0
R4, R3
Lookup10
R5, R4
R5, #0
R0, R4

; adds tens contrib

;
;
;
;
;

one less digit

done if zero
points to hundreds
digit
10-17

Conversion Routine (3 of 3)
LDR
ADD
LEA
ADD
LDR
ADD
;
DoneAtoB
NegZero
ASCIIBUF
Lookup10
...
Lookup100

RET
.FILL
.BLKW
.FILL
.FILL
.FILL

R4,
R4,
R5,
R5,
R4,
R0,

R2, #0
; load digit
R4, R3
; convert to number
Lookup100 ; multiply by 100
R5, R4
R5, #0
R0, R4
; adds 100's contrib

xFFD0
4
0
10
20

; -x30

.FILL 0
.FILL 100

...

10-18

Binary to ASCII Conversion

Converting a 2's complement binary value to
a three-digit decimal number
Resulting characters can be output using OUT

Instead of multiplying, we need to divide by 100

to get hundreds digit.
Why wouldn't we use a lookup table for this problem?
Subtract 100 repeatedly from number to divide.

First, check whether number is negative.

Write sign character (+ or -) to buffer and make positive.

10-19

Binary to ASCII Conversion Code (part 1 of 3)

; R0 is between -999 and +999.
; Put sign character in ASCIIBUF, followed by three
; ASCII digit characters.
BinaryToASCII LEA R1, ASCIIBUF ; pt to result string
ADD R0, R0, #0
; test sign of value
BRn NegSign
LD R2, ASCIIplus ; store '+'
STR R2, R1, #0
BRnzp Begin100
NegSign
LD R2, ASCIIneg ; store '-'
STR R2, R1, #0
NOT R0, R0
; convert value to pos
ADD R0, R0, #1

10-20

Conversion (2 of 3)
Begin100
Loop100

End100

LD R2, ASCIIoffset
LD R3, Neg100
ADD R0, R0, R3
BRn End100
ADD R2, R2, #1 ; add one to digit
BRnzp Loop100
STR R2, R1, #1 ; store ASCII 100's digit
LD R3, Pos100
ADD R0, R0, R3 ; restore last subtract

;
Loop10

LD R2, ASCIIoffset
LD R3, Neg10
ADD R0, R0, R3
BRn End10
ADD R2, R2, #1 ; add one to digit
BRnzp Loop10

10-21

Conversion Code (3 of 3)
End10

STR R2, R1, #2 ; store ASCII 10's digit

ADD R0, R0, #10 ; restore last subtract

;
LD R2, ASCIIoffset
ADD R2, R2, R0 ; convert one's digit
STR R2, R1, #3 ; store one's digit
RET
;
ASCIIplus
ASCIIneg
ASCIIoffset
Neg100
Pos100
Neg10

.FILL
.FILL
.FILL
.FILL
.FILL
.FILL

x2B
x2D
x30
xFF9C
100
xFFF6

;
;
;
;

plus sign
neg sign
zero
-100

; -10
10-22

Interrupt-Driven I/O
Timing of I/O controlled by device
tells the processor when something interesting happens
Example: when character is entered on keyboard
Example: when monitor is ready for next character
processor interrupts its normal instruction processing
and executes a service routine (like a TRAP)
figure out what device is causing the interrupt
execute routine to deal with event
resume execution
no need for processor to poll device, waiting for events
can perform other useful work

Interrupt is an unscripted subroutine

call,
triggered by an external event.

10-23

When to Use Interrupts

When timing of external event is uncertain
Example: incoming packet from network

When device operation takes a long time

Example: start a disk transfer,
disk interrupts when transfer is finished
processor can do something else in the meantime

When event is rare but critical

Example: building on fire -- save and shut down!

10-24

How is Interrupt Signaled?

External interrupt signal: INT
device sets INT=1 when it wants to cause an interrupt

Interrupt vector
8-bit signal for device to identify itself
(may be different for other processors)
also used as entry into system control block,
which gives starting address of Interrupt Service Routine (ISR)
like TRAP
INT

CPU

INTAC
K

Controller

Device

vector

What if more than one device wants to interrupt?

external logic controls which one gets to drive signals

10-25

How does Processor Handle It?

Look at INT signal just before entering FETCH phase.
If INT=1, dont fetch next instruction.
Instead:
save state (PC and condition codes) on

stack

use vector to fetch ISR starting address; put in PC

After service routine,

RTI instruction restores condition codes and old PC
need a different return instruction,
because RET gets PC from R7, no condition codes

Processor only checks between STORE and FETCH phases

-- why?
10-26

More Control
At the device
control register has Interrupt Enable bit
must be set for interrupt to be generated

interrupt enable
ready

KBSR
interrupt signal
to processor

At the processor
sometimes have Interrupt Mask register (LC-3 does not)
when set, processor ignores INT signal
why?
Example: dont want to interrupt while in ISR
10-27

Example (1)
Program A

//////
//////
//////
//////
//////

R6

PC

x3006

ADD

x3006

Executing ADD at location x3006 when Device B interrupts.

10-28

Example (2)
Program A

//////
x3007
R6

CC for ADD

//////
//////
PC

ISR for
Device B
x6200

x3006

ADD
x6210

RTI

x6200

Push PC and condition codes onto stack, then transfer to

Device B service routine (at x6200).

10-29

Example (3)
Program A

//////
x3007
R6

CC for ADD

//////
//////
PC

ISR for
Device B
x6200

x3006

ADD

x6202

AND

x6210

RTI

x6203

Executing AND at x6202 when Device C interrupts.

10-30

Example (4)
Program A

//////
x3007
CC for ADD

x6203
R6

CC for AND

PC

ISR for
Device B
x6200

x3006

ADD

x6202

AND
ISR for
Device C

x6210

RTI

x6300

x6300
x6315

Push PC and condition codes onto stack, then transfer to

Device C service routine (at x6300).

RTI

10-31

Example (5)
Program A

//////
x3007
R6

CC for ADD

x6203
CC for AND

PC

ISR for
Device B
x6200

x3006

ADD

x6202

AND
ISR for
Device C

x6210

RTI

x6300

x6203
x6315

RTI

Execute RTI at x6315; pop CC and PC from stack.

10-32

Example (6)
Program A

//////
x3007

R6

CC for ADD

x6203
CC for AND

PC

ISR for
Device B
x6200

x3006

ADD

x6202

AND
ISR for
Device C

x6210

RTI

x6300

x3007
x6315

Execute RTI at x6210; pop CC and PC from stack.

Continue Program A as if nothing happened.

RTI

10-33

1. Executing ADD at location x3006 when Device B interrupts.

2. Push PC and condition codes onto stack, then transfer to
Device B service routine (at x6200).
3. Executing AND at x6202 when Device C interrupts.
Program A

R6

//////
x3007
CC for ADD

x6203
CC for AND

PC

x3007

Example

ISR for
Device B
x6200

x3006

ADD

1
4

x6202

AND

2
ISR for
Device C

x6210

RTI

x6300

3
x6315

4. Push PC and condition codes onto stack, then transfer to

Device C service routine (at x6300).
5. Execute RTI at x6315; pop CC and PC from stack.
6. Execute RTI at x6210; pop CC and PC from stack.
Continue Program A as if nothing happened.

RTI

10-34