2/16/2018. Procedures, the basic idea. MIPS Procedure convention. Example: compute multiplication. Re-write it as a MIPS procedure

Transcription

1 Procedures, the basic idea CSCI206 - Computer Organization & Programming Introduction to Procedures zybook: 81 (for next class) MIPS Procedure convention 1 Prepare parameters in $a0 through $a3 2 Return values on $v0, $v1 3 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 1

2 Terminology jal instruction details jump and link (J-type) $ra = PC + 4 (PC + 8 if a delay slot is inserted) PC = JumpAddr procedure begins after procedure: add instruction 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 jal procedure PC add PC + 4 [delay slot instruction ] lw PC + 8 procedure returns before lw instruction Assumptions Question After calling a function return to the next line side-effects follow conventions Which registers should use? for doing work for passing arguments to for reading the result from 2

3 Question Problems Which registers should use? for doing work for reading arguments from for passing the result to 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 Problems Solutions 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 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 Stack operations main program initializes $sp points to the last used word! li $sp, 0x to allocate one word decrement $sp by 4 $sp moves DOWN to deallocate a word increment $sp by 4 $sp moves UP 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 3

4 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: 1 allocate stack space 2 store $ra [return from nonleaf] 3 call sum 3 times, storing partial results 4 restore $ra 5 deallocate stack 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; push $ra # save my $ra push $a3 # save a3 push $a2 # save a2 pop $a0 # restore a2 to a0 pop $a1 # restore a3 to a1 push $v0 # store result of sum(a0, a1) pop $a0 # restore sum(a0, a1) into a0 move $a1, $v0 # move second result to a1 pop $ra # restore $ra # return nonleaf uses 4 words of stack space push $ra # save my $ra push $a3 # save a3 push $a2 # save a2 pop $a0 # restore a2 to a0 pop $a1 # restore a3 to a1 push sum # store result of a0/a1 pop $a0 # restore first result move $a1, $v0 # move second result to a1 pop $ra # restore $ra # return 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 2 nd to a1 jal sum # final sum into $v0 lw $ra, 12($sp) # restore $ra addi $sp, $sp, 16 # deallocate space # return a1 nonleaf stack memory map addi $sp, $sp, 16 # allocate space sw $ra, 12($sp) sw $a2, 8($sp) # store a2 sw $a3, 4($sp) # store a3 sw $v0, 0($sp) # store $v0 to stack! lw $a0, 8($sp) # restore a2 to a0 lw $a1, 4($sp) # restore a3 to a1 lw $a0, 0($sp) # restore first result move $a1, $v0 # move second result to lw $ra, 12($sp) # restore $ra addi $sp, $sp, 16 # deallocate space # return $fp = $sp+16 $sp+12 $sp+8 $sp+4 $sp+0 BOTTOM of stack nonleaf s $ra a2 (c) a3 (d) sum(a,b) General Stack Allocation caller callee 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 1 prepare arguments for procedure 2 jal to procedure a allocate all stack space for local variables and to store any preserved registers that will be changed b do some work c restore stack and preserved registers for caller d place result where the caller expects e 3 process result 4

5 Write MIPS proedure 1 Square(n) using mult 2 Power(b, n) using mult 5