Subroutines, parameters and the stack Bryan Duggan

What is this lecture about? What is a subroutine? Subroutines in assembler Jal, jr instructions Passing parameters, getting return values Nested subroutines The stack Stack overflow

Introduction He once attempted to incorporate the personality subroutines of several great thinkers from Vulcan, Earth, and other planet's histories. As an unexpected result from this modification, he began to experience 'split personas' and almost killed Kes. The problem was remedied when the subroutines were isolated and purged from his system.

Introduction I'm always amused by the references to programming, which inevitably lead to a discussion of subroutines. Poor Data, whose "grammar subroutines" couldn't be changed to let him say contractions... Except he can use the contractions built into French. Maybe he "thinks in English", so that's special...

Why Subroutines? As our programs grow, we have a need to break them into separate logical units. A subroutine is a set of instructions that performs a specific task for a main routine, requiring direction back to the proper place in the main routine on completion of the task. AKA – Methods, Member functions, functions or procedures

Why Subroutines? Another way to break up an application is by using either functions or subroutines. Functions and subroutines are used to make our programs more readable by breaking large amounts of code into smaller more concise parts. By breaking code into functions and subroutines code can be written once and reused often, thus saving space and debugging time. This is called Modular Programming or Top Down Programming A function is used when a value is returned to the calling routine, while a subroutine is used when a desired task is needed, but no answer is returned.

Subroutines in assembler Need to find the subroutine......and return afterwards Pass parameters to the subroutine......and return results Provide local storage within the procedure

2 main primitives jal address ``jump and link'' jumps to the required address stores address of the following instruction in $ra (register 31) (actually copies PC into $ra) jr $ra return to the instruction following the jal

Simple Example.text.globl __start __start: jal printHello li $v0, 10 syscall# exit..... printHello: li $v0, 4 la $a0, prompt syscall jr $ra.data pi:.word 3 prompt:.asciiz"Hello world! " endl:.asciiz "\n"

Passing parameters & getting return values Parameters can be passed in in $a0 - $a3 Return values go in $v0-$v1

Parameters Example.text.globl __start __start: li $v0, 4 la $a0, enter syscall li $v0, 8 la $a1, 8 la $a0, name syscall jal printHello li $v0, 4 la $a0, endl syscall li $v0, 10 syscall printHello: move $a1, $a0 li $v0, 4 la $a0, prompt syscall li $v0, 4 move $a0, $a1 syscall jr $ra.data name:.asciiz " " enter:.asciiz"Whats your name?\n" prompt:.asciiz"Hello " endl:.asciiz "\n"

Nested subroutines You have a big problem with this approach if you have subroutines that call other subroutines $ra register will get overwritten $a registers will get overwritten $v registers will get overwritten So you need a different approach… Store those registers in memory in a special data structure called the stack

The Stack Most CPUs have PUSH and POP instructions MIPS does not Must use load and store instructions Stack pointer Initialized to address of stack area

Stack Layout $SP points to the top of the stack POP increases $SP PUSH Decreases $SP

To push an item onto the stack Places an item on the stack Sub $sp, $sp, 4 # Make room sw $a0, 0($sp) #

To pop an item off the stack Reads an item from the stack lw $a0, 0($sp) # read item add $sp, $sp, 4 # adjust pointer

Initialising the stack Normally must be done by programmer Reserving memory Initializing the value of the stack pointer SPIM does this for us SPIM initializes stack pointer to high address of stack area

Basic approach push $ra onto stack before a procedure call pop $ra from stack after procedure call use a register to store the address of the current top of stack handle push and pop by doing arithmetic in this register The stack in MIPS grows backwards!

Basic Factorial algorithm int factorial(int x) { if (x == 1) { return 1; } else { return x * factorial(x -1); }

Example - Factorial.text.globl __start __start: li $a0, 3 jal FACT move $a0, $v0 li $v0, 1 syscall li $v0, 10 syscall FACT: beq $a0, 1 RET1 sub $sp,$sp,4 # Push $a0 sw $a0, ($sp) sub $sp,$sp,4 # Push $ra sw $ra, ($sp) sub $a0, $a0, 1 jal FACT lw $ra,0($sp) # Pop $ra addi $sp,$sp,4 lw $a0,($sp) # Pop $a0 addi $sp,$sp,4 mul $v0, $v0, $a0 jr $ra RET1: li $v0, 1 jr $ra

Stack overflow Can be caused by too many subroutines on the stack. Run out of stack space: E.g.: void a() { a(); } int factorial(int x) { if (x == 1) { return 1; } else { return x * factorial(x); }