Function Calls in MIPS

• We saw that WOMBAT did not support function calls.
  • No way to return to an arbitrary location.
• JAL and JR solve this problem
  • JAL (Jump and link)
    • Saves the PC+4/8 into register $ra
      • For now we will use +4
      • In the future, we will use +8 (Pipelining)
    • Jumps to the jump address
      • There is a problem here, the jump address is 26 bits
      • We can gain 2 bits by assuming this is a word address
      • We still have four bits remaining
        • The solution is to take the top 4 bits of the pc.
        • The assumption is that we are jumping within the "program" space of memory.
        • And this will will be within the 1/16 of memory indicated by these four bits.
  • JR is the compliment of this
    • Set the pc to the value contained in the register.
  • Most function calls will look like

  • # calling routine
    	jal	subroutine
    	#code to execute after call
    	...
    
    subroutine:
    	#code to execute subroutine
    
    	jr $ra
    

• Parameters
  • Functions need parameters,
  • Four can be passed through the $a registers
    • values or pointers
  • Two things can be returned through the v registers ($v0, $v1)
  • What if there are more than that or larger?
  • Use the stack
• The runtime stack
  • A stack is a ADT which is a FIFO
  • Operations
    • Push: add a new item onto the stack
    • Pop: remove the top item from the stack
  • In our case, the stack consists of a number of frames or activation records.
    • Activiation records contain
      • Parameters if needed
      • Return values if needed
      • Local variables
      • Local record keeping storage
        • The return address if this is not a leaf routine
        • Data to maintain the stack
        • Any temporary retisters to preserve before making a function call
        • Any saved registers used in this function.
  • The stack is maintained by two registers
    • The frame pointer points to the beginning of the activation record.
      • The first word in the frame.
    • The stack pointer points to the end of the activation record.
      • The last word in the stack.
    • The stack grows down from high memory
  • Push:

  • sw	$fp, -4($sp)
    addi	$fp, $sp, -4
    addi	$sp, $fp -4
    

  • Pop:

  • addi	$sp, $fp, 4
    lw	$fp, -4($sp)
    

• The return address
  • Unless this is a leaf routine, we need to store the ra.
  • The place to do this is on the stack.

  • subroutine:
            # save $ra and stack
    	sw	$fp, -4($sp)
    	addi	$fp, $sp, -4
    	sw	$ra, -r($fp)
    	addi	$sp, $fp, -8
    	...
    
            # restore $ra and stack 
    	lw	$ra, -4($fp)
    	addi	$sp, $fp, 4
    	lw	$fp, -4($sp)
    	jr	$ra
    

• So what else do we need to store on the stack?
  • Are you going to use a saved register? Save the value on the stack.
  • Assume you are using s2 and s3

  • subroutine:
            # save $ra and stack
    	sw	$fp, -4($sp)
    	addi	$fp, $sp, -4
    	sw	$ra, -4($fp)
    
            # save the $s*
    	sw	$s2, -8($fp)
    	sw	$s3, -12($fp)
    	addi	$sp, $fp, -12
    	...
    
            # restore the $s*
    	lw	$s2, -8($fp)
    	lw	$s3, -12($fp)
    
            # restore the ra and stack 
    	lw	$ra, -4($fp)
    	addi	$sp, $fp, 4
    	lw	$fp, -4($sp)
    	jr	$ra
    

  • How about a local array of 10 items.

  • subroutine:
            # save $ra and stack
    	sw	$fp, -4($sp)
    	addi	$fp, $sp, -4
    	sw	$ra, -4($fp)
    
            # save the $s*
    	sw	$s2, -8($fp)
    	sw	$s3, -12($fp)
    
            #   int ary[10];
    	# $fp -16 to $fp -52 is the array
    	addi	$sp, $fp, -52
    
    
    	...
    
            # restore the $s*
    	lw	$s2, -8($fp)
    	lw	$s3, -12($fp)
    
            # restore the ra and stack 
    	lw	$ra, -4($fp)
    	addi	$sp, $fp, 4
    	lw	$fp, -4($sp)
    	jr	$ra
    

• Other things on the stack
  • temps
    • If I make a call and I want to save the values in the temps
    • I need to save these on the stack before the call
    • And restore them after the call
    • Assume I want to save $t0 and $t1 when I call foo

    • 	sw	$t0, -4($sp)
      	sw 	$t1, -8($sp)
      	addi	$sp, $sp, -8
      	jal	foo
      	addi	$sp, $sp, 8
      	lw	$t1, -8($sp)
      	lw	$to, -4($sp)
      	       

  • Additional arguments go on the stack before a function call
  • And return values can be placed on the stack upon return.