Procedure Calls, Overview

• This is section 2.8 and parts of appendix A (A.6)
  • You should read this.
  • This is not tricky, but detailed oriented.
  • There are lots of little pieces you need to get right.
• We will start with an overview.
• A function can be called from anywhere
  • The main function
  • Or any other function.
  • The function doing the calling is the caller
  • The function being called is the callee.
  • If a function does not call any other functions, it is a leaf function.
• A series of function calls is called a call chain.
  • This call chain is maintained on the run time stack.
• The general flow of control for a function call is
  • The caller saves any information needed to preserve the environment.
  • The caller places arguments somewhere that the callee can find them.
  • The caller transfers control to the callee.
  • The callee sets up its environment
  • The callee executes its code
  • The callee places any return values where the caller can find them.
  • The callee restores the old environment.
  • The callee transfers control back to the caller, to the next instruction after it the callee was called.
  • The caller restores the local environment.
• Lets look at the transfer of control
  • A simple jump will not do, why?
  • We need to return to different places.
    • Consider the following code

    •  
      1. do some work
      2. call function foo
      3. do some more work
      4. call function foo
      5. do some more work 

    • In this case, if we just used jumps, foo would have to decide if it were returning to line 3 or 5.
  • Somehow we need to save the return address.
• To do this, we have two machine instructions
  • jal jumpAddr
    • R[31] = pc+8, $pc = jumpAddr
    • Shouldn't this be pc+4?
    • Well yes, but for now we will not worry about this.
  • jr $rs
    • pc = $rs
  • For these two, we have a dedicated register,
    • $ra is register 31.
    • It is reserved for function calls.
    • This is part of the call convention for MIPS
    • The call convention describes the register use across function calls.
    • By this convention $ra or register 31 is reserved for the return address.
    • The caller places the return address in register 31 with jal
    • The callee preserves $ra if necessary
    • The callee returs (via jr) to the address pointed to by $ra when finished.
• Consider funCall.asm

  • const int ARRAY_SIZE{4};
    const int array[ARRAY_SIZE] {3,5,7,9};
    
    void Print(int i);
    
    int main() {
       int i;
       for (i = 0; i < ARRAY_SIZE; ++i) {
           Print(i)
       }
       return 0;
    }
    
    void Print(int i) {
        cout <<"A[" << i << "] = " << array[i] << endl;
    }
            

  • IN assembly

  • .data
    
    arraySize:	.word 4
    array:		.word 3 5 7 9
    
    part1:		.asciiz "a["
    part2:		.asciiz "] ="
    endl:		.asciiz "\n"
    
    
    .text
    .globl main
    main:
    
    	# $t1 will hold the index
    	# $t0 will hold the max value
    	
    	lw	$t0, arraySize
    	li	$t1, 0
    
    TopOfLoop:	
    	beq $t0, $t1 done
    		jal print
    		addi $t1, $t1, 1
    	j TopOfLoop
    	
    done:
    	li $v0 10
    	syscall
    
    
    # expect $t1 to contain the index of the element to print
    # we will clobber $t2 in this function
    print:
            la	$a0, part1        
            li	$v0, 4
            syscall
            
    	move	$a0, $t1
    	li	$v0, 1
    	syscall
    	
    	la	$a0, part2
    	li	$v0, 4
    	syscall
    	
    	mul	$t2, $t1, 4
    	lw	$a0, array($t2)
    	li	$v0, 1
    	syscall
    	
    	la	$a0, endl
    	li	$v0, 4
    	syscall
    	
    	jr $ra
            

• This code has some nice simplifications
  • print is a leaf function, so life is easy
  • It is a void function or returns nothing.
• This code has some serious problems
  • It really has no parameters, we just assume $t1 is the parameter.
  • It clobbers $t2, but how do we communicate that.
  • array and ARRAY_SIZE are global.
• We use the calling convention to address these.
  • Arguments: $a0 through $a3 are used for arguments.
    • The first in $a0, ....
    • If additional arguments are needed, they are placed at the end of the callers activation record or procedure call frame or just frame.
    • More on this later.
  • Return values:
    • MIPS allows two return values in $v0 and $v1
    • If more are needed, they should be passed through the arguments.
  • The convention tells us what registers may be "wiped out" or used with out saving and which ones may not.
    • the temporary registers may be used, as they are not preserved across function calls
    • The saved registers must be saved if they are to be used as they are preserved across function calls.
    • These descriptions are somewhat false, as it is not automated
    • The programmer must preserve registers.
    • In the calling function
      • You should assume that all temporary registers will be changed during the course of a function call.
      • If you want these values saved, you should do it yourself.
      • But you may assume that the values of the saved registers will be preserved across a function call.
    • In a called function
      • You may use the temporaries at will, unless you call a function, then see above
      • If you wish to use a saved, you must
        • Save the value of the register upon entry.
        • Use the register for computation
        • Restore the value of the register upon exit.
    • a, v and ra are expected to be semi preserved.
      • V and A registers can be used to return values.
      • RA is used as described.
    • fp, sp and gp should be restored or not messed with.
• We will continue this in the next notes.