CSCI206 - Computer Organization & Programming Introduction to Procedures zyBook: 8.1 (for next class)

Procedures, the basic idea

$a0-$a3 jr $ra $v0-$v1

MIPS Procedure convention Prepare parameters in $a0 through $a3 Return values on $v0, $v1 Call the procedure by jal (jump and link)

Example: compute multiplication mult_begin: # goal: multiply $a0 by $a1 li $v0, 0 # the result will be in $v0 mult_loop: beq $a1, $zero mult_done # check if done ($a1 == 0) add $v0, $v0, $a0 # add $a0 to result one time addi $a1, $a1, -1 # decrement $a1 j mult_loop # repeat mult_done: # the result is in $v0

Re-write it as a MIPS procedure mult_proc: # goal: multiply $a0 by $a1 li $v0, 0 # the result will be in $v0 mult_loop: beq $a1, $zero mult_done # check if done ($a1 == 0) add $v0, $v0, $a0 # add $a0 to result one time addi $a1, $a1, -1 # decrement $a1 j mult_loop # repeat mult_done: # the result is in $v0 Almost identical!!! The difference is how it is used. MIPS procedure call: jal mult_proc

multiply in asm activity Show how you would call the function to compute 2 * 7 and store the result in $s0. Then compute 5 * 9 and store the result in $s1.

$a0-$a3 jr $ra $v0-$v1

Multiply in asm w/ procedure

Terminology $a0-$a3 CALLER CALLEE $v0-$v1 jr $ra

jal instruction details jump and link (J-type) $ra = PC + 8 (from green sheet) PC = JumpAddr procedure: . jr $ra procedure begins after add instruction. jal procedure ← PC add … ← PC + 4 [delay slot instruction ] lw … ← PC + 8 procedure returns before lw instruction.

Assumptions After calling a function return to the “next line” side-effects follow conventions

Question Which registers should CALLER use? for doing work CALLEE Which registers should CALLER use? for doing work for passing arguments to CALLEE for reading the result from CALLEE

Question Which registers should CALLEE use? for doing work CALLER CALLEE Which registers should CALLEE use? for doing work for reading arguments from CALLER for passing the result to CALLER

Problems More arguments than $a registers (4)? Return more results than $v registers (2) Need more registers than $s (caller) or $t (callee) to do work. Callee needs to call another function. jal would overwrite the first $ra! what registers to use (callee vs caller?)

Dynamic storage The solution to all of these problems requires some form of dynamic storage. As the name implies, the stack memory segment is managed as a stack data structure and provides dynamic run-time storage.

Problems Solutions Have more arguments than $a registers (4)? Return more results than $v registers (2) Need more registers than $s (caller) or $t (callee) to do work. Callee needs to call another function. jal would overwrite the first $ra! what registers to use (callee vs caller?) Push extra arguments onto the stack Push extra results onto the stack Use the stack to store/restore register values Push registers (including $ra) onto the stack, callee becomes caller!

Program Memory Map main program initializes $sp to allocate one word points to the last used word! li $sp, 0x80000000 to allocate one word decrement $sp by 4 $sp moves DOWN to deallocate a word increment $sp by 4 $sp moves UP

Stack operations PUSH $x: push reg[x] onto the stack addi $sp, $sp, -4 # allocate one word sw $x, 0($sp) # store reg $x onto the stack POP $x: pop reg[x] from the stack lw $x, 0($sp) # read the top value of stack addi $sp, $sp, 4 # deallocate word from stack

Illustrating a nonleaf procedure int main(){ printf(“result: %d”, nonleaf(1,1,2,3) ); } int nonleaf(int a, int b, int c, int d){ return sum( sum(a,b), sum(c,d)); int sum(int a, int b){ return a+b; nonleaf needs a stack: allocate stack space store $ra [return from nonleaf] call sum 3 times, storing partial results restore $ra deallocate stack

nonleaf assembly main: li $a0, 1 li $a1, 1 li $a2, 2 li $a3, 3 jal nonleaf … <other code> … nonleaf: push $ra # save my $ra push $a3 # save a3 push $a2 # save a2 jal sum # a0/a1 are summed pop $a0 # restore a2 to a0 pop $a1 # restore a3 to a1 push $v0 # store result of sum(a0, a1) jal sum # a0/a1 are used to sum a2/a3 pop $a0 # restore sum(a0, a1) into a0 move $a1, $v0 # move second result to a1 jal sum # compute final sum into $v0 pop $ra # restore $ra jr $ra # return nonleaf assembly int main(){ printf(“result: %d”, nonleaf(1,1,2,3) ); } int nonleaf(int a, int b, int c, int d){ return sum( sum(a,b), sum(b,c)); int sum(int a, int b){ return a+b;

nonleaf uses 4 words of stack space... main: li $a0, 1 li $a1, 1 li $a2, 2 li $a3, 3 jal nonleaf … <other code> … nonleaf: addi $sp, $sp, -16 # allocate space sw $ra, 12($sp) sw $a2, 8($sp) # store a2 sw $a3, 4($sp) # store a3 jal sum # sum (a0,a1) sw $v0, 0($sp) # store sum(a0,a1)! lw $a0, 8($sp) # restore a2 to a0 lw $a1, 4($sp) # restore a3 to a1 jal sum # sum (b, c) lw $a0, 0($sp) # restore sum(a0,a1) move $a1, $v0 # move 2nd to a1 jal sum # final sum into $v0 lw $ra, 12($sp) # restore $ra addi $sp, $sp, 16 # deallocate space jr $ra # return main: li $a0, 1 li $a1, 1 li $a2, 2 li $a3, 3 jal nonleaf … <other code> … nonleaf: push $ra # save my $ra push $a3 # save a3 push $a2 # save a2 jal sum # a0/a1 are summed pop $a0 # restore a2 to a0 pop $a1 # restore a3 to a1 push sum # store result of a0/a1 jal sum # a0/a1 are used to sum a2/a3 pop $a0 # restore first result move $a1, $v0 # move second result to a1 jal sum # compute final sum into $v0 pop $ar # restore $ra jr $ra # return nonleaf uses 4 words of stack space...

nonleaf stack memory map main: li $a0, 1 li $a1, 1 li $a2, 2 li $a3, 3 jal nonleaf … <other code> … nonleaf: addi $sp, $sp, -16 # allocate space sw $ra, 12($sp) sw $a2, 8($sp) # store a2 sw $a3, 4($sp) # store a3 jal sum # a0/a1 are summed sw $v0, 0($sp) # store $v0 to stack! lw $a0, 8($sp) # restore a2 to a0 lw $a1, 4($sp) # restore a3 to a1 jal sum # a0/a1 are used to sum a2/a3 lw $a0, 0($sp) # restore first result move $a1, $v0 # move second result to a1 jal sum # compute final sum into $v0 lw $ra, 12($sp) # restore $ra addi $sp, $sp, 16 # deallocate space jr $ra # return nonleaf stack memory map $fp = $sp+16 BOTTOM of stack $sp+12 nonleaf’s $ra $sp+8 a2 (c) $sp+4 a3 (d) $sp+0 sum(a,b)

General Stack Allocation callee caller return to caller stack frame or activation record: everything stored on the stack for a particular function. $sp points to the end of the record, $fp points to the start of the record (initial $sp before the function changes it)! Access local variables relative to $sp or $fp, it’s up to you!

Procedure Call Outline prepare arguments for procedure jal to procedure allocate all stack space for local variables and to store any preserved registers that will be changed. do some work. restore stack and preserved registers for caller. place result where the caller expects. jr $ra. process result

Square in asm using mult

power with mult