4.2: MIPS function calls

Transcription

1 4.2: MIPS function calls Topics: Nested function calls: poly() and pow() Saving the return address ($31) Saving temporary registers Looking at activation records on the stack Introduction: In CSc 256 lectures, we discussed operations involving the stack. By using the stack with procedure calls, we will have all of the function call capability available to us in high level languages such as C and C++. We saw some examples of function calls and stack frames in the previous exercise. Recall some guidelines about MIPS register usage from CSc 256 lectures: $a0 - $a3 are used for arguments. These are not preserved across function calls. What does "not preserved across function calls" mean? Consider the following example: li $a0, 4 jal func1 move $t0,$a0 First $a0 is loaded with the constant 4. Then we call func1. Since $a0 is not preserved across function calls, after the jal func1, there is no guarantee that $a0 will still contain the constant 4! Hence, to be safe, we should assume that $a0 contains some other value, and we are moving some random value into $t0. $v0 and $v1 are used by functions as output registers to return results. Since $v0 and $v1 contain results, they are also not preserved across function calls. $t0 - $t9 are used as temporary registers (for temporary variables, loop counters, etc). These are also not preserved across function calls. $s0 - $s8 are also used as temporary registers. However, these are preserved across function calls. Consider the following example: li $s0, 4 jal func1 move $t0,$s0 Since, according to MIPS register usage conventions, $s0 is preserved across function calls, we CSc 256 Lab Manual 4.2.1

2 know that $s0 will contain the constant 4 both before and after the jal func1. So we will move a 4 into $t0. Remember that registers do not magically get preserved across function calls!! In the code for a function, if you're using $s0 as a temporary register, you will first have to save it on the stack, and then restore it later. This makes sure that the old value of $s0 is preserved. In the last exercise, we looked at stack frames or activation records in C++. This is a data structure that's associated with a function call that's active, and is stored on the stack. When the function is called (i.e., there is an active instance of that function), a stack frame/activation record is created on the stack. Recall from the last exercise, in Example 4.2, the main program calls the function poly(); a stack frame for poly() is created on the stack. Then poly() makes calls to the function pow(); an stack frame for pow() is created on the stack, on top of the activation record for poly(). In MIPS, pow() is a leaf procedure which does not call other functions; hence, it doesn t need a stack frame or activation record. The activation records for poly() contains the saved values of temporary registers, and the return address for poly(). Remember that the return address of a function call is saved in $31 by the jal instruction. Hence, when the main program calls poly(), the return address for poly() is saved in $31. When poly() calls pow(), pow() will also try to save its return address in $31! Hence, to prevent pow()'s return address from overwriting poly()'s return address, poly() has to save its return address in its activation record. The exact position in the activation record where the return address is saved depends on the procedure call convention of the operating system and compiler that we are working with. Obviously, before we return from poly(), we'll need to restore its return address from the stack (simply load it from the stack into $31). Now on to the exercise. Again, you may use either spim or xspim for the exercise; we ll only show the spim version to save space. Steps: Earlier, we copied the file ~whsu/csc256/labs/progs/4.2 into our directory. This is essentially identical to Example 4.2 that we discussed in 256 lectures, but with a few extra global labels (for breakpoints). First we look at the main program (some lines omitted for clarity): # # CSc 256 Example 4.2: Poly function # Name: William Hsu # Date: 6/22/2010 # Description: Computes x^4 + x^3 + 1, x from 2 to 4.data CSc 256 Lab Manual 4.2.2

3 endl:.asciiz "\n" # i $s0 # 4 $s2.text.globl bk1.globl end_pow main: li $s1, 4 li $s0, 0 # for (i=2; i<=4; i++) { m_for: move $a0, $s0 # result = poly(i); bk1: jal poly move $a0, $v0 # cout << result << endl; li $v0, 1 syscall la $a0, endl li $v0, 4 syscall addi $s0, $s0, 1 # } ble $s0, $s1, m_for li $v0, 10 #} syscall Fairly straightforward; the main program calls poly(i) (the argument for poly() is passed in $a0), repeatedly. Let's take a look at the function poly(): # int poly(int arg) # arg $a0 # return result in $v0 # computes arg^4 + arg^3 + 1 # copy of arg $s0 # temp1 $s1 First we save the return address and registers $s0 and $s1 used by poly(): poly: addi $sp, $sp, -12 sw $s1, ($sp) sw $s0, 4($sp) sw $ra, 8($sp) Remember from CSc 256 lectures that $s0 and $s1 have to be saved because the temporary registers $s0 through $s8 are preserved across function calls. Hence, we must make sure we do CSc 256 Lab Manual 4.2.3

4 not mess them up for the main program. However, if we used $t0 through $t9 in poly(), we won't have to save them, because $t0 through $t9 are not preserved across function calls, and the main program expects any function calls to change them. Next we prepare for the call to pow(arg,4). We load the arguments, and save arg (currently in $a0) in $s0. This is because $a0 through $a3 are not preserved across function calls. We need to make sure we have a copy of arg for later. (Actually pow() doesn't change $a0, but we don't always know that a function will not change its input registers.) move $s0,$a0 # temp1 = pow(arg, 4); li $a1,4 jal pow Notice that here we use $s0 (instead of $t0, $t1 etc). This is because we want the contents of $s0 to remain unchanged after the jal. After the jal pow, the result of pow(arg,4) is in $v0. We save a copy of this in $s1, then call pow(arg,3): move $s1,$v0 move $a0,$s0 # result = pow(arg, 3); li $a1,3 jal pow Finally, we compute the result by adding up our partial results. To wrap up, we move the stack pointer, restore all temporaries and the return address, and return to the main program: poly() calls pow(): add $v0, $v0, $s1 # result = temp1 + result + 1; addi $v0, $v0, 1 lw $ra, 8($sp) lw $s0, 4($sp) lw $s1, ($sp) addi $sp, $sp, 12 # return result; jr $ra #} # int pow(int arg0, int arg1) # arg0 $a0 # arg1 $a1 # return result in $v0 # Computes arg0 to the arg1-th power # i $t0 # product $t1 CSc 256 Lab Manual 4.2.4

5 pow: li $t1, 1 # int product = 1; li $t0, 0 # for (int i=0; i<arg1; i++) { bge $t0, $a1, endpow for: mul $t1, $t1, $a0 # product *= arg0; addi $t0, $t0, 1 # } blt $t0, $a1, for endpow: move $v0, $t1 # return product; jr $ra #} Now we're ready to run poly.s. We'll set some breakpoints, and start the program: lo "4.2" br bk1 br endpow run Breakpoint encountered at 0x We're stopped at the first breakpoint bk1 (at 0x400030): bk1: jal poly Let's check some registers: print $a0 Reg 4 = 0x (2) pr $31 Reg 31 = 0x ( ) arg for poly(2) return address (not loaded yet) When we step through the jal instruction, we should jump to the label poly, and put the return address for poly() (0x40002c) in $31. step [0x ] 0x0c jal 0x [poly] poly pr $31 Reg 31 = 0x ( ) pr $sp Reg 29 = 0x7ffffac0 ( ) pr $s0 Reg 16 = 0x (0) pr $s1 ; 21: jal CSc 256 Lab Manual 4.2.5

6 Reg 17 = 0x (4) The jal instruction is at 0x400030, and the return address is 0x The next few instructions save $31, and the temporaries $s0 and $s1 on the stack. step [0x ] 0x23bdfff4 addi $29, $29, -12 ; 45: addi $sp, $sp, -12 [0x ] 0xafb10000 sw $17, 0($29) ; 46: sw $s1, ($sp) [0x ] 0xafb00004 sw $16, 4($29) ; 47: sw $s0, 4($sp) [0x c] 0xafbf0008 sw $31, 8($29) ; 48: sw $ra, 8($sp) [0x ] 0x addu $16, $0, $4 ; 50: move $s0, $a0 pr $sp Reg 29 = 0x7ffffab4 ( ) pr 0x7ffffab4 Stack 0x7ffffab4 ( ) = 0x (4) Stack 0x7ffffab8 ( ) = 0x (0) Stack 0x7ffffabc ( ) = 0x ( ) So the top of the stack looks like this: address description 0x7ffffab4 old $s1 0x7ffffab8 old $s0 0x7fffabc return address for poly(2) The return address for poly(2) and temporary registers have been saved on the stack. Now we'll save a copy of the argument for poly(2), load arguments for pow(2,4) and call pow(2,4). When we execute the jal pow instruction, we'll jump to the label pow, and save the return address for pow(2,4) in $31: step CSc 256 Lab Manual 4.2.6

7 [0x ] 0x23bdfff4 addi $29, $29, -12 ; 45: addi $sp, $sp, -12 [0x ] 0x ori $5, $0, 4 ; 51: li $a1, 4 # temp1 = pow(arg, 4); [0x ] 0x0c10002a jal 0x004000a8 [pow] ; 52: jal pow pr $31 Reg 31 = 0x c ( ) (The address of pow is 0x4000a8. The address of the instruction jal pow is 0x400078, and the return address for pow(0,4) is 0x40007c, which is now in $31.) When we continue, we skip past the entire loop of pow(2,4), and stop at endpow (a breakpoint). We ve calculated pow(2,4) = 16, now in $v0. Finally, we return to the code of poly() which performed the call, with the jr $31 (remember that $31 contains the return address 0x40007c). cont Breakpoint encountered at 0x004000c8 pr $31 Reg 31 = 0x c ( ) step [0x004000c8] 0x addu $2, $0, $9 ; 84: move $v0, $t1 # return product; [0x004000cc] 0x03e00008 jr $31 ; 85: jr $ra #} [0x c] 0x addu $17, $0, $2 ; 53: move $s1, $v0 pr $v0 Reg 2 = 0x (16) We're back in the code for poly(), right after the first jal pow (the move $s1, $v0 instruction at 0x40007c): move li jal move $s0,$a0 $a1,4 pow $s1,$v0 CSc 256 Lab Manual 4.2.7

8 We'll step through a few more instructions, save the result of pow(2,4), load the arguments, and call pow(2,3). After we step through the jal pow instruction, PC becomes 0x4000a8, the address of pow, and $31 gets the new return address, 0x40008c. (Remember that the jal pow instruction is at 0x ) step [0x c] 0x addu $17, $0, $2 ; 53: move $s1, $v0 [0x ] 0x addu $4, $0, $16 ; 55: move $a0, $s0 # result = pow(arg, 3); [0x ] 0x ori $5, $0, 3 ; 56: li $a1, 3 [0x ] 0x0c10002a jal 0x004000a8 [pow] ; 57: jal pow pr PC PC = 0x004000a8 ( ) pr $31 Reg 31 = 0x c ( ) Now we continue past the loop for pow(2,3), stopping at endpow. We'll check that $v0 contains the result (2^3 = 8), $31 contains the return address 0x40008c, then return to poly(2) by executing jr $31: cont Breakpoint encountered at 0x004000c8 step [0x004000c8] 0x addu $2, $0, $9 ; 84: move $v0, $t1 # return product; pr $v0 Reg 2 = 0x (8) pr $31 Reg 31 = 0x c ( ) step [0x004000cc] 0x03e00008 jr $31 ; 85: jr $ra #} pr PC PC = 0x c ( ) Back in the code for poly(2), we've already calculated pow(2,4) and pow(2,3). Now we accumulate the partial result, to get the result for poly(2) (2^4 + 2^3 + 1 = 25): CSc 256 Lab Manual 4.2.8

9 step [0x c] 0x add $2, $2, $17 ; 59: add $v0, $v0, $s1 # result = temp1 + result + 1; [0x ] 0x addi $2, $2, 1 ; 60: addi $v0, $v0, 1 pr $v0 Reg 2 = 0x (25) Now remember that the activation record for poly(2) is still on the stack. Let's check this: pr $sp Reg 29 = 0x7ffffab4 ( ) pr 0x7ffffab4 Stack 0x7ffffab4 ( ) = 0x (0) Stack 0x7ffffab8 ( ) = 0x (0) Stack 0x7ffffabc ( ) = 0x ( ) We need to restore all the temporary registers we saved, restore the return address of poly(2) to $31, and "destroy" the activation record by updating $sp: step [0x ] 0x8fbf0008 lw $31, 8($29) ; 62: lw $ra, 8($sp) [0x ] 0x8fb00004 lw $16, 4($29) ; 63: lw $s0, 4($sp) [0x c] 0x8fb10000 lw $17, 0($29) ; 64: lw $s1, ($sp) [0x004000a0] 0x23bd000c addi $29, $29, 12 ; 65: addi $sp, $sp, 12 # return result; [0x004000a4] 0x03e00008 jr $31 ; 66: jr $ra #} pr PC PC = 0x ( ) 0x is the address of the move $a0, $v0 instruction preparing to print the result: CSc 256 Lab Manual 4.2.9

10 pr 0x [0x ] 0x addu $4, $0, $2 ; 23: move $a0, $v0 # cout << result << endl; So we're back in the main program! Now a continue will print out the result of 2^4 + 2^3 + 1: cont 25 Breakpoint encountered at 0x We've just traced through a single call to poly(2). The main program contains calls to poly(3), poly(4), etc. If you feel that you need additional practice, you should trace through the second call yourself. It should be fairly similar to the first. If you're lazy, just hit continue a few times and get the result for the rest: cont [more blank lines here...] 109 cont [more blank lines here...] 321 etc etc Let's review what we saw in this exercise: i. When a function/procedure is called, an activation record is created on the stack. ii. When we return from that function call, its activation record is destroyed. iii. The activation record contains saved registers and the saved return address. iv. Activation records (or stack frames) keep track of what function calls are active. CSc 256 Lab Manual