Stack Mechanics & Motivation

† Stack Motivation/Limitations of static variables

EE 3170 Microcontroller „
„
Subroutines / multiple call-site procedures
Recursion
Applications „ Interrupt Service Routines

Lecture 12: Advanced Assembly Language Programming † Stacks

Part I: Stacks and Subroutines „ Definition of the stack data structure
- Miller §5.4 - § 5.5
„ Stack management and the SP Register
„ 68HC11 stack management instructions
Based on slides for ECE3170 by Profs. Davis, Kieckhafer, Tan, and Cischke
„ 68HC11 stack example

EE3170/CC/Lecture#12-Part I 1 EE3170/CC/Lecture#12 - Part I 2

Stacks Motivation 1: Subroutines

† Stacks perform a necessary function of a † It is desirable to have a subroutine which can
computer be invoked from multiple call-sites

† They are not the ONLY method, but they are the
most common method
† Briefly discuss 3 motivations before mechanics to
help motivate the understanding
† Break from thinking about linear execution
towards depth-first tree-shaped execution model
EE3170/CC/Lecture#12 - Part I
† This implies that each call-site must
„ have a common protocol for passing parameters
„ store live variables at the time of the subroutine
invocation
„ have a common protocol for returning values from
subroutine
† A Stack (and associated usage protocol) is a
common method to accomplish these
requirements
3 EE3170/CC/Lecture#12 - Part I 4

1
 Motivation 2: Recursion Motivation 3: Interrupt Service Routines (ISR)
† Recursion – a subroutine which calls itself † Interrupts (we will learn about them later) enable
code (service routine) to be invoked by an outside
† A variable “n” may have multiple instances at signal (i.e. service keyboard interrupt)
any point in time
† Similar problem to that of Subroutines – but
† Fibonacci (example) programmer does not determine call-site
„ fib( n ) = if ( n = 0 ) then 0
if ( n = 1 ) then 1
else fib( n-1 ) + fib( n-2 ) † Because programmer can not constrain call-site,
all registers used in a ISR must be saved at the
† Multiple instances implies that static variable beginning of an ISR and loaded/restored at the
addresses are not sufficient end of an ISR

EE3170/CC/Lecture#12 - Part I 5 EE3170/CC/Lecture#12 - Part I 6

Stacks Stack Operation & Management (added)

† Stack
„ A Dynamic Data Structure † To emulate the behavior of a stack. All needed is
† The stack is a temporary storage place „ Some unused memory + index register, called stack pointer
„ Access is strictly Last-In-First-Out (LIFO) † always points to the next available (empty) location above the
current top of the stack.
„ Structure:

† A stack can be implemented without special hardware

„ 68HC11 has a special double-byte stack pointer register SP
„ and special purpose instructions for controlling it.

† The only other thing needed to implement a stack is

decide where the bottom of the stack is
„ initialize the stack pointer to this value when the stack is empty.

EE3170/CC/Lecture#12 - Part I 7 EE3170/CC/Lecture#12 - Part I 8

2
Stack Operation & Management (added)
† Stack grows from higher addresses to lower
„ the top of the stack grows upwards
„ Note: the text shows memory upside-down in its stack
examples so that the stack grows downward
† The bottom of the stack is often located at the highest
available memory address.
† The stack allows dynamic memory allocation
„ don’t have to decide when you write the program: how many
bytes to reserve, just push stuff on when you need to save it.
† Push too much without popping
„ you can overwrite your program! It’s your responsibility not to
do this.
Stacks
† Stack Access Operations
„ Push – Put new item on top of the stack
„ Pop – Remove the top item from stack
† Microprocessor Interpretation
„ Stack is a contiguous set of memory
„ Push – Copy data from a register into the next
available word above current top
† New word becomes new top of stack
„ Pop – Move data from top word in stack into a register
† Next word down in the stack becomes new top
† Value of previous top is lost to the stack

EE3170/CC/Lecture#12 - Part I 9 EE3170/CC/Lecture#12 - Part I 10

Stack Management Stack Management

† Address of the top of the stack changes with each Push † Stack Location in Memory (initial value of SP)
or Pop
† Stack Size grows and shrinks as the program runs
† Need an addressing register to keep track of the „ Push increase stack size
„ Pop decrease stack size
address of the top of the stack
† Want to keep stack from running into program memory space as it
† Stack Pointer (SP) register grows
„ Register holding address of the first empty byte above the top
of stack † Code & mem space starts at lowest address (00..00) and grows
„ The last register not-yet-discussed in the 68HC11 programming into higher addresses
model
† Therefore, we start stacks at highest address (FF..FF) and let it
† SP must be incremented or decremented with each grow into lower addresses
Push or Pop
„ This is done automatically by the hardware. † Stack grows down (textbook)/up

EE3170/CC/Lecture#12 - Part I 11 EE3170/CC/Lecture#12 - Part I 12

3
 Stack Management Stack Management
† Result: code and stack to not “collide” † Stack Operations
„ until there is no memory space left „ Push
† Put data on stack
„ known as stack overflow † Decrement SP (after)
„ overflow occurs with infinite recursion † PUSH Reg
MEM[SP] = Reg
PC
SP = SP-1

„ Pull
† Remove data from stack
† Increment SP (before)
† POP Reg
SP SP = SP+1
Reg= MEM[SP]

EE3170/CC/Lecture#12 - Part I 13 EE3170/CC/Lecture#12 - Part I 14

68HC11 Stack Management 68HC11 Stack Management

† Double-Precision Push & Pull instructions
† In 68HC11:
„ PSHX & PSHY
„ Pops are called Pull † store lo-byte of X (or Y) & decrement SP
„ ISA predates the standardization of the term † store hi-byte of X (or Y) & decrement SP
Pop
„ PULX & PULY
† increment SP & load hi-byte of X (or Y)
† Single-Precision Push & Pull instructions † increment SP & load lo-byte of X (or Y)
„ PSHA & PSHB
† Store A (or B) onto stack & decrement SP † There is no PSHD or PULD
„ D = A:B
„ PULA & PULB
„ Can emulate PSHD with PSHB and PSHA
† Increment SP & Load A (or B) from stack

EE3170/CC/Lecture#12 - Part I 15 EE3170/CC/Lecture#12 - Part I 16

4
 68HC11 Stack Management Stack Example
ORG $E100
† Stack Pointer Manipulation Instructions * INITIALIZE STACK
„ LDS & STS START LDS #$B7FF • SP
† Load and Store SP * CREATE SAMPLE DATA B7FC • • •
† needed to initialize SP LDAA #$22 B7FD • A
LDAB #$33 B7FE • •
„ INS & DES * STORE DATA IN STACK B7FF • B
† Increment and Decrement SP PSHA • •
† NOT needed during normal PSHx & PULx instructions PSHB
* GET DATA FROM STACK
„ TSX, TXS, TSY, TYS PULA
† Transfer (copy) between SP and X or Y regs PULB
SWI

EE3170/CC/Lecture#12 - Part I 17 EE3170/CC/Lecture#12 - Part I 18

Stack Example Stack Example

ORG $E100 ORG $E100
* INITIALIZE STACK * INITIALIZE STACK
START LDS #$B7FF • SP START LDS #$B7FF • SP
* CREATE SAMPLE DATA * CREATE SAMPLE DATA
B7FC • B7 FF B7FC • B7 FF
LDAA #$22 LDAA #$22
B7FD • A B7FD • A
LDAB #$33 LDAB #$33
B7FE • • B7FE • 22
* STORE DATA IN STACK * STORE DATA IN STACK
B7FF • B B7FF • B
PSHA PSHA
• • • 33
PSHB PSHB
* GET DATA FROM STACK * GET DATA FROM STACK
PULA PULA
PULB PULB
SWI SWI

EE3170/CC/Lecture#12 - Part I 19 EE3170/CC/Lecture#12 - Part I 20

5
 Stack Example Stack Example
ORG $E100 ORG $E100
* INITIALIZE STACK * INITIALIZE STACK
• SP
START LDS #$B7FF • SP START LDS #$B7FF
* CREATE SAMPLE DATA B7FC • B7 FD
B7FC • B7 FE * CREATE SAMPLE DATA
LDAA #$22 B7FD • A
B7FD • A LDAA #$22
LDAB #$33 B7FE 33 22
B7FE • 22 LDAB #$33
* STORE DATA IN STACK * STORE DATA IN STACK B7FF 22 B
B7FF 22 B
PSHA • 33
• 33 PSHA
PSHB PSHB
* GET DATA FROM STACK * GET DATA FROM STACK
PULA PULA
PULB PULB
SWI SWI

EE3170/CC/Lecture#12 - Part I 21 EE3170/CC/Lecture#12 - Part I 22

Stack Example Stack Example

ORG $E100 ORG $E100
* INITIALIZE STACK * INITIALIZE STACK
START LDS #$B7FF • SP START LDS #$B7FF • SP
* CREATE SAMPLE DATA * CREATE SAMPLE DATA
B7FC • B7 FE B7FC • B7 FF
LDAA #$22 LDAA #$22
B7FD • A B7FD • A
LDAB #$33 LDAB #$33
B7FE 33 33 B7FE 33 33
* STORE DATA IN STACK * STORE DATA IN STACK
B7FF 22 B B7FF 22 B
PSHA PSHA
• 33 • 22
PSHB PSHB
* GET DATA FROM STACK * GET DATA FROM STACK
PULA PULA
PULB PULB
SWI SWI

EE3170/CC/Lecture#12 - Part I 23 EE3170/CC/Lecture#12 - Part I 24

6
 Stack Instructions
† LDS
„ Load SP
„ Creates a stack
† PSHA, PSHB
„ Push accumulator on
stack
„ Decrement SP (after)
† PULA, PULB
„ Pull from stack to
accumulator
„ Increment SP (before)
† PSHX, PSHY
„ Push index register on
stack (2 bytes)
† PULX, PULY
„ Pull from stack to index
register (2 bytes)
† TSX, TXS, TSY, TYS
„ Transfer the SP to index
register
„ Transfer index register
to SP
What is a Subroutine?
† Subroutine (a.k.a. Procedure or Function) =
† A reusable program module
„ Write it once
„ Store it once
„ invoke it from several places in the main program
„ when finished it returns to the main program
† A sequence of instructions invoked so that it
looks like a single instruction in the main
source-code
„ e.g. “call” label-of-first-instruction-in-subroutine

EE3170/CC/Lecture#12 - Part I 25 EE3170/CC/Lecture#12 - Part I 26

Subroutines How to use subroutines? (added)

† To use a subroutine
† A program module used multiple times during the „ there must be a mechanism for transferring control (as in a
branch) to the beginning of the subroutine and
execution of a program „ then returning to execute what would have been the next
instruction (the return address) after the subroutine is done.
„ This should work no matter where in memory the subroutine is
† It can be imbedded repeatedly in the main called from.
program listing BUT is more efficiently CALLED „ It should also work even if the subroutine is called from inside
by the main program. another subroutine.

† It turns out that the stack is the perfect mechanism for

keeping track of the return address.
† Subroutines increase our programming
productivity † It is also very helpful in passing parameters to and from
subroutines and in defining variables local to subroutines

EE3170/CC/Lecture#12 - Part I 27 EE3170/CC/Lecture#12 - Part I 28

7
 Subroutines Desirable Properties
† It is desirable to have a subroutine which can be
invoked from multiple call-sites † Independence
„ Subr. & main program may be written independently
† Subr makes no references to addresses or labels defined in
† This implies that each call-site must the main
„ have a common protocol for passing parameters † and vice-versa (except for the first instruction)
„ store live variables at the time of the subroutine
invocation
„ have a common protocol for returning values from † Subr. & main can be edited without affecting
subroutine each other
† A Stack (and associated usage protocol) is a
common method to accomplish these † Subr & main can be assembled independently
requirements and linked at loading time
EE3170/CC/Lecture#12 - Part I 29 EE3170/CC/Lecture#12 - Part I 30

Good Subroutines (added) Call and Return

† Are correctly structured † Calling A Subroutine
„ Single entry point and a single exit point „ main program “transfers control” to the subroutine
„ First instruction is always the first instruction executed „ main program “jumps” to subroutine
„ Ends with RTS „ PC = address of (first instr in subroutine)

† Take extra care when using microprocessor

resources within the subroutine
„ Very easy for the main program and subroutine to conflict
when both use a particular accumulator or register
† Returning From a Subroutine
„ subr. transfers control back to the main program
„ subr. “jumps” back into main program
„ PC = address of (first instruction after the Calling
instr)

EE3170/CC/Lecture#12 - Part I 31 EE3170/CC/Lecture#12 - Part I 32

8
 Call and Return
† Subr. can be called from many locations in main
† Always returns to the instr. immediately after the call
EE3170/CC/Lecture#12 - Part I 33
Subroutine Definitions
† Parent – The routine executing the call instruction (caller)
† Child – the called routine (callee)
† Return Address – Address of instruction in parent program to which the
child returns
„ Just after the call instruction
„ PC incremented during fetch of call
† Parameters – Data passed from parent to child
† Return Values – Data passed from child to parent
† Recursion – When a subroutine calls itself
„ Subroutine is its own parent and child
„ Example, factorial N! = N x (N-1)!
EE3170/CC/Lecture#12 - Part I 35
Subroutine Definitions
† Nesting – One subroutine calls another
subroutine
† Nesting Level – Number of calls needed to
reach a routine
„ Level 0 – Main program
„ Level 1 – Subroutine called by main program
„ Level 2 – Subroutine called by a Level 1 routine
„ Level k – Subroutine called by a Level k-1 routine
EE3170/CC/Lecture#12 - Part I 34
Subroutine Linkage
† Subroutine Linkage = the process of:
„ Passing parameters and return values between parent
and child
„ Saving and restoring the return address
† Calling Convention = protocol to implement
linkage
„ Defines actions to be taken on call and return
„ Assigns responsibilities to parent and child
„ Must be strictly obeyed, OR ELSE:
† data could get lost or corrupted
† return address could get lost or corrupted
EE3170/CC/Lecture#12 - Part I 36
9
 Return Address Linkage
† Where do we store the return address?
„ Do not want to use a register
† inhibits nesting and recursion
„ Do not want to use a “fixed” static memory location
† inhibits nesting and recursion
† subr. would have to know a parent’s label
† It is temporary
„ only needed until return
„ would like to “liberate” that word when done
† Stacks are designed to perform these functions
EE3170/CC/Lecture#12 - Part I
EE3170/CC/Lecture#12 - Part I
68HC11 Call Instructions
† Two “Call” Instructions
„ BSR addr = Branch to subroutine starting at “addr”
† relative addressing (short range)
„ JSR addr = Jump to subroutine starting at “addr”
† direct, extended, or indexed addressing
† Actions:
„ Push current PC onto stack ( = return address)
„ PC = “addr” (actually the calculated effective address)
37 EE3170/CC/Lecture#12 - Part I 38
68HC11 Return Instruction
† One “return” Instruction
„ RTS = Return from Subroutine
† Actions:
„ Pop stack to PC ( = return address)
† PC = previously pushed return address
† next instruction fetched will be instruction after the Call
„ Caution:
† The subr. could use the stack while running
† must be careful to pop everything it pushes
† then return address is at “top” for RTS instruction
39 EE3170/CC/Lecture#12 - Part I 40
10
 Subroutine Return Instructions
† The only condoned way of
returning from a
subroutine is
† to retrieve the return
address from the stack
† The stack can always be
modified by a child
procedure
† If the child does not wish
to modify the return
address, it should perform
an equal # of Push & Pop
EE3170/CC/Lecture#12 - Part I
Parent-Child Communication
† Values to be Passed
„ Return Address (parent → child)
„ Call Parameters (parent → child)
„ Return Variables (child → parent)
† Values to be Preserved
„ Parent’s Original Register Contents
„ Parent’s Local Variables
„ Child’s Local Variables
EE3170/CC/Lecture#12 - Part I
Subroutine Example (added)
† Every subroutine should
be documented with a
brief “header”
„ sets it off visually,
„ gives its name, its inputs
and outputs, its basic
function, and
„ its side effects (i.e., any
registers it modifies or
other important effects it
has that may not be part of
its obvious function).
41 EE3170/CC/Lecture#12 - Part I 42
Details & Attention
† During Call and the Return sequence
„ we do not have to use PSHx or PULx instructions
„ we do not explicitly adjust the stack pointer
„ all of that is built-into the BSR, JSR, and RTS instr.
† Note: in some processors it is not built-in
† Attention
„ Subroutine could use the stack while running.
„ Subroutine must be careful to pop everything it
pushes.
† “Take only pictures, leave only footprints.”
† Make sure the stack is the same as when the subroutine
was called.
„ We need the return address to be at the top of the
stack for rts instruction
43 EE3170/CC/Lecture#12 - Part I 44
11
 3 Types of Calling Conventions Register-Based Calling
† Types are based on how data is † Parent
passed between parent and child „ Stores parameters in registers
„ 1. Register-based: passes data in registers „ Calls child
„ 2. Memory-based: passes data in a fixed
memory area † Child
† usually uses mem space immediately following „ Uses parameters stored in registers
the call „ Stores return values in registers
† management gets a little tricky „ Returns to parent
„ 3. Stack-based: passes data in the stack
† everybody knows where it is (SP tells them) † Parent
† expands and shrinks with demand „ Uses return values in registers

EE3170/CC/Lecture#12 - Part I 45 EE3170/CC/Lecture#12 - Part I 46

Register-Based Calling Conventions Register-Based Calling Conventions

† Parent † Child
† Example: Summation of (j = 1 to N)
„ sum(n) { … adds clra * sum = 0
for (s=0, j=1 ; j <= n ; j++) {s += j} ldab #N tstb *set CCs w/ B
return s; } jsr adds loop beq retn * while b<>0
† Storage Convention … aba *sum = sum + i
„ A = return value s
decb *i = i-1
„ B = calling parameter n
bra loop
† For simplicity:
retn rts
„ We will ignore the likely overflow problem in B
EE3170/CC/Lecture#12 - Part I 47 EE3170/CC/Lecture#12 - Part I 48

12
Register-Based Calling Conventions Memory-Based Calling Conventions
† Parent
† Advantages „ Store parameters in Data Link Area in memory
„ Very fast (no extra load or store) † Usually the memory words right after the call
„ Pretty easy too. „ Call child

† Disadvantages † Child
„ May have more parameters than available registers „ get return address from the stack
† Given that we have a whopping 4 registers in the HC11, this is
extremely likely. „ access parameters using offset from return address
„ Nested Calls „ Store any return values using offset
† Require more registers „ Return to parent
† Must coordinate register usage between subroutines
„ Recursion † Parent
† Child wants same registers as parent
„ Load return values from Data Link Area
† Parent must move parameters before calling child

EE3170/CC/Lecture#12 - Part I 49 EE3170/CC/Lecture#12 - Part I 50

Memory-Based Calling Conventions Memory-Based Calling Conventions

† Parent † Advantages
„ …
ldab #N „ Arbitrary number of parameters
stab LNK
jsr adds „ Some older ISAs do this efficiently
LNK rmb 1 *Reserve Memory Bytes
ldaa LNK
…
† Disadvantages
† Child
„ adds pulx *get base for LNK „ Slower (more loads and stores)
inx *correct ret addr „ Requires mixing of instructions and data in memory
pshx *restore ret addr
clra *sum = 0 (BAD!!)
ldab -1,X *get val of N
loop beq retn *while b != 0 „ Complex
aba *sum = sum + i † jsr does not actually store the return address
decb *i = i-1
bra loop † Subroutine must adjust and re-push the return address
retn staa -1,X *save sum † Very easy to mess this one up
rts

EE3170/CC/Lecture#12 - Part I 51 EE3170/CC/Lecture#12 - Part I 52

13
 Stack-Based Calling Conventions Stack-Based Calling Convention
† Parent † Parent
„ Pushes parameters onto stack „ …
ldab #N
„ Calls child pshb
† No address passing - address is in SP jsr adds
pula
† Child …
„ Pops return address to safe place ‰ Child

„
† Usually the X or Y register
Pops parameters off stack
ƒ adds pulx * save RA
clra * sum = 0
pulb * get N
„ Pushes return values on stack loop beq return * while b != 0
„ Re-pushes return address on stack aba * sum = sum + i
decb
„ Returns to parent bra loop
return psha * save sum
† Parent pshx * push RA
„ Pops returned values off stack rts

EE3170/CC/Lecture#12 - Part I 53 EE3170/CC/Lecture#12 - Part I 54

Stack-Based Calling Conventions Comments on Calling

† Advantages
„ Arbitrary number of parameters
„ No need to know storage location at assembly time
„ Nested Calls
† Each routine builds on previous stack
† Each routine has its storage space
„ Recursion
† Same as any other nested call
† Disadvantages
„ Slower - still have to load and store
† Register-based conventions are fastest and
simplest.
† However, stack-based are preferred.
„ Flexible and predictable
† We have avoided a few complexities so far
„ What if:
† Parent has data stored in a register
† Child wants to use that register
„ Nesting and recursion are complex.

EE3170/CC/Lecture#12 - Part I 55 EE3170/CC/Lecture#12 - Part I 56

14
Summary of Stacks & Subroutines
† The stack is a dynamic data structure mostly maintained
by the hardware.
† You need to initialize the stack pretty much all the time.
† Pushing puts data on the top of the stack.
† Pulling takes data off the top of the stack.
† Subroutines are called by jsr or bsr and returned from by
rts.
† Three different calling conventions:
„ Register-based
„ Memory-based
„ Stack-based

EE3170/CC/Lecture#12 - Part I 57

15