1. ECE 447: Lecture 15
Stack Operations

2. ECE 447: Stack after a function callSP
after
a function call
RTNH SP
before
a function call
RTNL
MAX_ADDRESS

3. ECE 447: Stack Operations Subroutine call and return from subroutine
N Z V C
BSR
REL
– – – –
JSR
DIR, EXT, IND
– – – –
RTS
INH
– – – –

4. ECE 447: Stack after an interrupt callSP
after
an interrupt CC B A
IXH
IXL
IYH
IYL
RTNH SP
before
an interrupt
RTNL
MAX_ADDRESS

5. Interrupt related instructions and return from an interrupt
ECE 447: Stack Operations
Interrupt related instructions
and return from an interrupt
N Z V C
SWI
INH
– – – –
WAI
INH
– – – –
RTI
INH
– – – –

6. ECE 447: Stack Operations Push and pull
N Z V C
PSH [A, B]
PSH [X, Y]
PUL [A, B]
PUL [X, Y]
INH
– – – –
Initialize and store stack pointer
N Z V C
LDS
IMM, DIR, EXT, IND
0 –
STS
DIR, EXT, IND
0 –

7. ECE 447: Stack Operations Jump Stack pointer manipulation JMP
DIR, EXT, IND
– – – –
Stack pointer manipulation
DES
INH
– – – –
INS
INH
– – – –
TS [X, Y]
INH
– – – –
T [X, Y] S
INH
– – – –

8. Using the stack - Entering a function with a fixed number of arguments and local variables
caller
function
called
function D SP
var_1
arg_1 IX
Local
variables
... or IX D
DES or
PSHX
var_M
arg_1H
arg_1L
reg_1
reg_1
...
...
Saved
registers
PSH
reg_L
TSX
reg_L
JSR or
BSR
RTNH
RTNH
RTNH
Return
address
RTNL
RTNL
RTNL
arg_2
arg_2
arg_2
arg_N
...
arg_2
arg_N
...
PSH
...
...
Function
arguments SP
arg_N
arg_N

9. ECE447: Exiting a function: “called-cleanup” method
caller
function
called
function D SP
ret or IX
var_1 IX D
Local
variables
...
retH
retL
var_M
reg_1
reg_1
INS or
PUL
...
...
Saved
registers
PUL
reg_L
reg_L
PULY
INS
RTNH
RTNH
RTNH
Return
address
RTNL
RTNL
RTNL
arg_2
arg_2
arg_N
...
arg_2
arg_N
...
...
Function
arguments
JMP 0,Y SP
arg_N

10. Using the stack - Entering a function with a variable number of arguments
caller
function
called
function SP IX
var_1
Local
variables
...
DES or
PSHX
var_M
reg_1
reg_1
...
...
Saved
registers
PSH
reg_L
TSX
reg_L
JSR or
BSR
RTNH
RTNH
RTNH
Return
address
RTNL
RTNL
RTNL
arg_1
arg_1
arg_1
arg_N
...
arg_1
arg_N
...
PSH
...
...
Function
arguments SP
arg_N
arg_N

11. Using the stack - Exiting a function “caller-cleanup” convention
called
function D SP
ret IX
var_1
Local
variables
... or IX D
TXS
var_M
retH
retL
reg_1
reg_1
INS or
PULX
...
...
Saved
registers
PUL
reg_L
reg_L
RTNH
RTNH
RTNH
Return
address
RTNL
RTNL
RTNL
RTS
arg_1
arg_1
arg_1
arg_N
...
arg_1
arg_N
...
PULz
...
...
Function
arguments SP
arg_N
arg_N

12. In this example, long = 32bits
main.c
/* C version of main function */
#include <stdio.h>
extern long multadd(unsigned int a, unsigned char b,
long c, long *pm);
long product, sum;
void main(void) {
sum = multadd(258, 17, 32L, &product); }
In this example, long = 32bits

13. multadd.c /* C version of the multadd function */
long multadd(unsigned int a, unsigned char b, long c, long *pm)
/* this function returns
a*b + c
and writes a*b to the location of memory pointed out by pm */ {
long tmul;
long tadd;
tmul = a*b;
*pm = tmul;
tadd = tmul + c;
return tadd; }

14. amain.s (1) * assembly language version of the main function
.global multadd
.global printf
.mri 1
section .bss
product rmb 4
sum rmb 4

15. amain.s (2) section .text main:
; pushing arguments arg4 thru arg2 to the stack
; arg4: pm = &product
ldx #product
pshx
; arg3: c = 32L = 0x
ldx #$0020
ldx #$0000
; arg2: b = 17 = 0x11
ldaa #$11
psha
; storing argument arg1 in the register D
; arg1: a = 258 = 0x102
ldd #$102
jsr multadd

16. amultadd.s (1) ; assembly language version of the multadd function
tmul_offset EQU 0
tadd_offset EQU 4
a_offset EQU 8
b_offset EQU 12
c_offset EQU 13
pm_offset EQU 17
SP 
IX 
0 - tmul
1 - tmul
2 - tmul
10 - RTNH
3 - tmul
11 - RTNL
4 - tadd
12 - b
5 - tadd
13 - c
6 - tadd
14 - c
7 - tadd
15 - c
8 - a
16 - c
9 - a
17 - &product
18 - &product

17. amultadd.s (2) section .text multadd:;
; Initialization sequence, similar for different functions
; storing D register
pshb
psha
; reserving space for two local variables
; long tadd
pshx
; long tmul
; IX set to point to the top of the stack
tsx

18. amultadd.s (3a) ;
; Part specific for the given function
; Multiplication
; tmul = a*b = (a_high * 2^8 + a_low) * b
; ACCB = b
ldab b_offset,X
; ACCA = LSB of a = a_low
ldaa a_offset+1,X
; ACCD = b*a_low
mul
; tmul = b*a_low
std tmul_offset+2,X
ldd #0
std tmul_offset,X
; ACCA = MSB of a = a_high
ldaa a_offset,X

19. amultadd.s (3b) ; ACCD = b*a_high mul ; tmul= b*a_low + (2^8)*b*a_high
addd tmul_offset+1,X
std tmul_offset+1,X
; *pm = tmul
ldy pm_offset,X
ldd tmul_offset,X
std 0,Y
ldd tmul_offset+2,X
std 2,Y

20. amultadd.s (4a) ;
; Addition
; tadd = c
ldd c_offset,X
std tadd_offset,X
ldd c_offset+2,X
std tadd_offset+2,X
; tadd = tadd + tmul
pshX
clc
ldab #4
loop ldaa tadd_offset+3,X
adca tmul_offset+3,X
staa tadd_offset+3,X
dex
decb
bne loop
pulx
; End of part specific for the given function

21. amultadd.s (5) ;
; Exit sequence
; restore value of the stack pointer
txs
; return long result in registers IX and D
; IX:D = tadd
ldx tadd_offset,X
ldd tadd_offset+2,X
; deallocate space for local variables
; repeat this 8 times
ins

22. amultadd.s (6) ins ; remove register D from the stack puly
; store return address in register IY
; repeat 7 times
jmp 0,Y
end

23. main multadd SP IX xx xx tmul xx xx xx xx tadd D xx LDD $0102 xx $01IX xx xx
tmul xx xx 4 xx xx
tadd D xx
LDD
$0102 xx 8
$01
$01
D=a
$02
$02
RTNH
RTNH
RTNH
PSHX
RTNL
RTNL
RTNL 12
$11
$11
$11
$11 b
$00
$00
$00
$00 13
$00
$00
$00
TSX
$00
PSHD c
LDX
PSHX
$00
$00
$00
$00
JSR
$20
$20
$20
$20 17
&product
&product
&product
&product pm SP