---

What happens in a function call

---

• Recall there are two places where you can pass parameters:
  • in registers - only when the calld function is not recursive
  • on the program stack - will always work

• NOTE:

  Although parameters can be passed in registers if the called function is not recursive, the compiler will not attempt to make this check and will usually pass parameters on the stack because this method will work for both recursive and non-recursive functions.

• The SPARC register window mechanism is designed to support function calls in high level language programs. Therefore, the designers assumed that parameters will be passed on the stack.

• To understand the following 4 instructions, you must realise that memory read/write operations take much more time than reading and writing registers

  SPARC tries to eliminate the need to access memory by putting the following inside registers:

  • parameters
  • local variables

• It is infinitely expensive to accommodate all possible functions, and SPARC will accomodate the most common functions (the most economical solution):
  • Functions with less than 6 parameters (using o0 thru 05), and
  • with less than 8 local variables (l0 thru l7)

• The following 3 diagrams sums up what will be done when "main" calls the function "func":

    Code in Java/C/C++:
    ============================================================
  
    main(...)              ---->  int func(int x, int y, int z)
    {			/	{
       ...	       /	   ...
       ...	      /		   ...
       r = func(a, b, c)		   return(value);
       ^                          }           |
       |  			            |
       +--------------------------------------+
       ...
    }
  
  
    Assembler code in a traditional (e.g. M68000) computer:
    ============================================================
  
    main:  ...			     func: Save frame pointer of 
  	 ...				     my caller
   	 ... 				   Allocate local variables 
  	 Push parameters on stack	     on stack
  	 Call func			   ....
           Pop params off the stack	   .... (function body)
   	 Assign return value to		   ....
  	   its destination
   	 ... 				   Pass return value in 
  					     a register
  					   Deallocate local variables 
  					     from stack
  					   Restore frame pointer 
  					     of my caller
  					   Return to my caller
  
  
    Assembler code in SPARC:
    ============================================================
  
    main:  ...			     func: + Save frame pointer of 
  	 ...				       my caller
   	 ... 				   + Obtain my own copy of
  	 Push parameters in 	               local registers
  	   Output registers                + Allocate space on stack
  	 Call func			   ....
           Pop params off the stack	   .... (function body)
   	 Assign return value to		   ....
  	   its destination
   	 ... 				   Pass return value in 
  					     an input register
  					   + Return local registers
  					   + Deallocate locaL
  					     variables from stack
  					   + Restore frame pointer 
  					     of my caller
  					   Return to my caller
  

  • Note: the function "func" in SPARC's must still allocate space on the stack to store the window registers for the following reasons:
    • The SPARC CPU has a total of 8 sets of register windows, when the function calling is nested more than 8 levels deep (this happens easily in recursion), the SPARC CPU will run out of register windows).

      The computer can make it "look like" it has more register windows by saving a set of register window (all input, local and output registers) to memory when the register window overflow is detected. The place to save the overflow register window is on the stack.

    • Even when the function calling is not nested more than 8 levels, the SPARC CPU may still have to save the registers to memory - that happens when the system is used by multiple programs. When one program is halt so that another program can run, the registers contains values that must not be lost. More on this phenomenom in CS355 and CS451 when "multi-programming" and "context switching" will be discussed.

• Keep the figure above in mind when we discuss the 4 SPARC instructions that realise function call & return