Assembler Related Directives
.data
.byte A, B, C
.half 1, 2, 3
.word 1, 2, 3
.float 6.02E23
.double 6.02E23
#
#
#
#
#
initialize
initialize
initialize
initialize
initialize
byte data
half-word data
word data
float data
double data
Example: Saving $ra to Memory
Suppose we now want functions putstr and putchar, where putstr
calls putchar. Then putstr needs to save $ra before it calls
putchar.
#
# hello5: "Hello world" program with putstr and putchr subroutines.
#
la
$t0, mesg1
# Load address of first string in $t0
jal putstr
# Call putstr
la
$t0, mesg2
# Load address of second string in $t0
jal putstr
# Call putstr
done:
ori $v0, $0, 10
# Exit system call
syscall
#
# putstr: Subroutine to print a string.
#
Assumes $t0 contains address of string to be printed.
#
The value in $t0 is *not* preserved.
#
putstr: sw
$ra, oldra
# Save return address in oldra variable
nextch: lb
$a0, 0($t0)
# Load next character in $a0
beq $a0, $0, return # If character is 0, then return to caller
jal putchr
# Call putchr
addi $t0, $t0, 1
# Advance to next character
bgez $0, nextch
return: lw
$ra, oldra
# Restore saved return address
jr
$ra
# Return to caller
.data
oldra: .space
4
# Space for saved return address
.text
#
# putchr: Subroutine to print a character.
#
Assumes $a0 contains the character to be printed.
#
putchr: ori
$v0, $0, 11
# Print character system call
syscall
jr
$ra
# Return to caller.
.data
mesg1: .asciiz "Hello world\n"
mesg2: .asciiz "Wasnt that fun?\n"
Its Getting Confusing!
Note that putstr in the previous example modies $a0, so the
caller must save this register if it needs the contents after
the call.
What if we want to create a recursive subroutine? Each
recursive call is going to clobber the same set of registers
being used by its caller.
If each subroutine modies a dierent set of registers, it
becomes very confusing to keep track of what is going on.
We need a more systematic approach. . .
Register Usage Conventions
Things are made more manageable by introducing (and adhering
to) conventions on the use of registers.
$zero
$at
$v0-$v1
$a0-$a3
$t0-$t7
$s0-$s7
$t8-$t9
$k0-$k1
$gp
$sp
$fp
$ra
Hard-wired to zero
Reserved for assembler for pseudo-instructions
Return values from subroutines
Arguments to subroutines
Temporaries (not preserved across calls)
Temporaries (callee-saved, preserved across calls)
Temporaries (not preserved across calls)
Reserved for OS kernel
Global pointer
Stack pointer
Frame pointer
Return address (used by Jump and Link)
Except for $zero and $ra, these conventions are not forced on us
by the hardware.
Our Responsibilities
Registers $s0-$s7, $fp, and $gp must be saved before modication, and restored before the current subroutine returns.
Register $ra must be saved before another subroutine is
called using jal.
We must put arguments to a subroutine in $a0-$a3, and return results in $v0-$v1. We cannot assume these registers
are preserved across a subroutine call.
We must avoid entirely the use of $at and $k0-$k1.
We can do whatever we want with $t0-$t9, but we cannot
assume they are preserved across subroutine calls.
Where to Save Registers?
Q: Where do we get the space to save the registers we need to
save?
We could use static variables (i.e. memory in the data segment), but that wont work with recursion (why not?).
A: We can allocate space on the stack.
When a program starts, the OS sets up the stack pointer
($sp) to point to the high-address end of a region of memory
that can be used as temporary storage.
We can allocate space in this region by subtracting from the
stack pointer.
We can free space by adding to the stack pointer.
This works, as long as a last-allocated, rst-freed discipline
is followed.
Each subroutine can allocate as much stack space as it needs,
as long as it frees it before it returns.
Stack Space Management
Stack space can be allocated by subtracting from the stack
pointer:
addiu
$sp, $sp, -SPACE
# SPACE is how many bytes we need
Stack space can be freed by adding to the stack pointer:
addiu
$sp, $sp, SPACE
We can load and store to locations in the stack:
sw
$ra, 0($sp)
# save $ra in the stack area
lw
$ra, 0($sp)
# restore $ra from the stack area
Example
Lets re-visit the previous example, adhering to register conventions and using the stack as the place to save registers.
#
# hello5a: "Hello world" program with putstr and putchr subroutines,
# following register conventions and using the stack to save registers.
#
la
$a0, mesg1
# Load address of first string in $a0
jal
putstr
# Call putstr
la
$a0, mesg2
# Load address of second string in $a0
jal
putstr
# Call putstr
done:
ori
$v0, $0, 10
# Exit system call
syscall
#
# putstr: Subroutine to print a string.
#
Assumes $a0 contains address of string to be printed.
#
putstr: addiu
$sp, $sp, -8
# Get stack space (to save $ra, $s0)
sw
$ra, 0($sp)
# Save $ra on stack
sw
$s0, 4($sp)
# Save $s0 on stack
or
$s0, $0, $a0
# Move argument to $s0
nextch: lb
$a0, 0($s0)
# Load next character in $a0
beq
$a0, $0, return # If character is 0, then return
jal
putchr
# Call putchr
addi
$s0, $s0, 1
# Advance to next character
bgez
$0, nextch
return: lw
$s0, 4($sp)
# Restore saved $s0
lw
$ra, 0($sp)
# Restore saved $ra
addiu
$sp, $sp, 8
# Free stack space
jr
$ra
# Return to caller
#
# putchr: Subroutine to print a character.
#
Assumes $a0 contains the character to be printed.
#
No stack space needed here, because we dont modify any
#
registers that are required to be saved.
#
putchr: ori
$v0, $0, 11
# Print character system call
syscall
jr
$ra
# Return to caller.
.data
mesg1: .asciiz
"Hello world\n"
mesg2: .asciiz
"Wasnt that fun?\n"
Multiple Allocations
in Stack One Subroutine
In the previous example, all the data stored on the stack is accessed by an index over $sp.
We have to keep track of the oset for each item stored on
the stack.
If just one stack region is allocated per subroutine, this is
ne.
If we allocate another stack region in the same subroutine,
all the osets of previously saved data change.
It would be less confusing if we could access stack data using
xed osets, which dont change with subsequent stack allocations.
Frame Pointer
A frame pointer is a register that is maintained so that data allocated on the stack can be accessed at xed osets, independent
of the stack pointer.
The stack area allocated by a subroutine is called its
activation record.
When a subroutine is called, the frame pointer is set to point
to the base of the activation record.
The stack pointer points to the other (active) end of the
activation record.
Data in the activation record is accessed at xed osets from
the frame pointer.
Example Activation Record Format
<-----------+
|
-------------------|
saved ra
>-----------+
saved fp
<-----------+
DATA
|
...
|
-------------------|
saved ra
|
FP->
saved fp
>-----------+
DATA
SP->
...
-------------------ARs form a linked list via saved frame pointers.
PREVIOUS AR
CURRENT AR
Subroutine Linkage with Frame Pointer
In Caller: Subroutine is called using jal.
jal
subr
(call will return here)
In Callee: Linkage protocol executed at beginning of subroutine:
subr:
addiu
sw
sw
or
$sp,
$ra,
$fp,
$fp,
$sp, -8
4($sp)
0($sp)
$0, $sp
#
#
#
#
allocate space to save $ra, $fp
save $ra
save $fp
update $fp
At this point, we can allocate whatever additional space we want
(e.g. for local variables) on the stack, and we dont have to keep
track of how much it is.
In Callee: Allocating space on stack:
addiu
$sp, $sp, -LOCALS
# allocate space for locals
In Callee: Accessing data in AR:
sw
lw
$s0, -4($fp)
$s0, -4($fp)
# save $s0
# restore $s0
Access to local variables will be at xed osets to the frame
pointer, regardless of whatever else we do with the stack pointer.
In Callee: Exit protocol executed before return:
or
lw
lw
addiu
$sp,
$ra,
$fp,
$sp,
$0, $fp
4($fp)
0($fp)
$sp, 8
#
#
#
#
delete junk on stack
restore $ra
restore $fp
delete space for $ra, $fp
In Callee: Returning from subroutine:
jr
$ra
# return to caller
There are many possible AR formats and many possible linkage
protocols. I presented here a simple one, with some useful properties, but which is not the fastest possible. People spend time
thinking about how to minimize subroutine linkage overhead.
Example: Recursive Factorial
#
# factorial: Recursive factorial
#
main:
ori
$a0, 5
jal
factorial
or
$a0, $0, $v0
ori
$v0, $0, 1
syscall
ori
$v0, $0, 10
syscall
demo using a frame pointer.
#
#
#
#
argument = 5
call factorial
move result to arg 0
print integer
# exit syscall
# hasta la vista, baby!
#
# Recursive factorial: argument in $a0, result to $v0.
# Uses callee-save register $s0 to preserve argument
# over recursive call.
#
factorial:
# Subroutine linkage protocol
addiu
$sp, $sp, -8
# allocate space to save $ra, $fp
sw
$ra, 4($sp)
# save $ra
sw
$fp, 0($sp)
# save $fp
or
$fp, $0, $sp
# update $fp
#######################
# Allocate space on stack for $s0
addiu
$sp, $sp, -4
# allocate space to save $s0
sw
$s0, -4($fp)
# save $s0
bne
$a0, $0, nonz
# check for base case
ori
$v0, $0, 1
# arg = 0, return 1
b
return
nonz:
or
$s0, $0, $a0
#
addi
$a0, $a0, -1
#
jal
factorial
#
mult
$v0, $s0
#
mflo
$v0
#
return: lw
$s0, -4($fp)
#
# Subroutine exit protocol
or
$sp, $0, $fp
#
lw
$ra, 4($fp)
#
lw
$fp, 0($fp)
#
addiu
$sp, $sp, 8
#
#######################
jr
$ra
#
copy $a0 to $s0
decrement $a0
recursive call
multiply $s0 by recursive result
get product in $v0
restore $s0 for caller
delete junk on stack
restore $ra
restore $fp
delete space for $ra, $fp
return to caller
Passing Arguments on the Stack
The normal MIPS convention is to pass up to four arguments in
$a0-$a3. The linkage protocol presented above can also handle
arguments passed on the stack.
In Caller:
addiu
$sp, $sp, -ARGS
(store args on stack)
jal
subr
addiu
$sp, $sp, ARGS
# allocate space for args
# deallocate space for args
In Callee: Args are accessible starting at 8($fp).
Example: Factorial with Arg on Stack
#
# factorial1: Recursive factorial
# rather than in $a0.
#
main:
ori
$t0, 5
addiu
$sp, $sp, -4
sw
$t0, 0($sp)
jal
factorial
addiu
$sp, $sp, 4
or
$a0, $0, $v0
ori
$v0, $0, 1
syscall
ori
$v0, $0, 10
syscall
demo that passes argument on stack,
#
#
#
#
#
#
#
argument = 5
allocate space for argument
store argument on stack
call factorial
deallocate space for argument
move result to arg 0
print integer
# exit syscall
# hasta la vista, baby!
#
# Recursive factorial: argument on stack, result to $v0.
#
factorial:
# Subroutine linkage protocol
addiu
$sp, $sp, -8
# allocate space to save $ra, $fp
sw
$ra, 4($sp)
# save $ra
sw
$fp, 0($sp)
# save $fp
or
$fp, $0, $sp
# update $fp
#######################
lw
$t0, 8($fp)
# get argument in $t0
bne
$t0, $0, nonz
# check for base case
ori
$v0, $0, 1
# arg = 0, return 1
b
return
nonz:
addi
$t0, $t0, -1
addiu
$sp, $sp, -4
sw
$t0, 0($sp)
jal
factorial
addiu
$sp, $sp, 4
lw
$t0, 8($fp)
mult
$v0, $t0
mflo
$v0
return: # Subroutine exit protocol
or
$sp, $0, $fp
lw
$ra, 4($fp)
lw
$fp, 0($fp)
addiu
$sp, $sp, 8
#######################
jr
$ra
#
#
#
#
#
#
#
#
decrement $t0
allocate space for arg
store arg on stack
recursive call
deallocate space for arg
recover arg to this call
multiply $t0 by recursive result
get product in $v0
#
#
#
#
delete junk on stack
restore $ra
restore $fp
delete space for $ra, $fp
# return to caller