Calling a function with more than 6 parameters

Warning: passing parameters on the stack in SPARC is quite different than in M68000

For clarity, I will use the following convention in the discussion below:
1. Currently, a function A is active ( A can be the main function)
2. The function A will call another function A that has more than 6 parameters
Recall that in M68000, the caller function A pushes the parameters on TOP of the stack

This method will NOT work in SPARC, because when the caller function A is active, the stack is used as follows:

%sp --------> +-----------------------+ | save %l0 | 8 local registers %sp + 4 ----> +-----------------------+ | save %l1 | (parameters to subroutine) %sp + 8 ----> +-----------------------+ | ......... | | ......... | | ......... | %sp + 32 ---> +-----------------------+ | save %i0 | 8 input registers %sp + 36 ---> +-----------------------+ | save %i1 | (local variables of subroutine) %sp + 40 ---> +-----------------------+ | ......... | | ......... | | ......... | %sp + 64 ---> +-----------------------+ | structure pointer !! | for a function that returns struct %sp + 68 ---> +-----------------------+ | save %o0 | 6 output registers: o0 - o5 %sp + 72 ---> +-----------------------+ | save %o1 | %sp + 76 ---> +-----------------------+ | ......... | | ......... | %sp + 88 ---> +-----------------------+ | save %o5 | %sp + 92 ---> +-----------------------+ 92 is NOT divisible by 8 | ???????? | Will be explained later... %sp + 96 ---> +-----------------------+ 96 is divisible by 8

Suppose the caller function A push one parameter on the stack, and the stack top increases by 8 bytes.
Then the Operating System will use the space intended for the parameter to save the local registers !!!
Illustration: (Demo the phenomenon above)
- Prog file: click here
Run the program in EGTAPI.
Make a note of the stack when SPARC reaches the instruction "add %sp, -8, %sp".
- Record the address of the stack top before "add %sp, -8, %sp" is executed.
- Record the address of the stack top after "add %sp, -8, %sp" is executed.
- Look at where the registers l0, l1, etc are stored...
From the behavior of the stack of SPARC, you may conclude that we will not be able to pass parameters using the stack....
Well, humans are much more creative than you think:
Gist of the problem:
Solution:

Allocating space for parameters on the stack in advance !!!

When a function A calls a method B than has 7 or more parameters, then at the start of the function A , we must allocate additional space for the purpose of passing parameters.

Example:

int B( int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, int p10) { ... } void A() { int x; x = B( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ); }

The function A calls a function B with 10 parameters.
1. The first 6 parameters will be passed in registers o0, o1, o2, o3, o4, o5
2. The last 4 parameters (4 x4 = 16 bytes) will be passed using the stack

Then the prelude (beginning) of the function A must allocate 16 (4 x 4) additional bytes

We can calculate the number of byte to allocate as follows:
1. As you know, the Operating System needs 92 bytes to save the context (see: click here )
2. To this amount, we must now add 16 (4 x 4) bytes for passing 4 parameters using the stack.
3. Then we must make sure that the total amount of bytes allocated is divisible by 8 and add some padding if the total is not divible by 8.
  92 + 16 = 108 is NOT divisible by 8.
  So we add 4 more bytes for padding

Therefore, the prelude of the function A is as follows:

A: save %sp, -(92 + 16 + 4), %sp ... ... ... ret restore

How to use the space to pass parameters

After allocating the space (in advance) to pass parameters, we must now figure out how to access the space allocated to store the value of the parameters
When we try to do this, we must keep in mind that: the function A may have more than 8 local variables
In other words:
From the previous discussion, we know that the local variables beyond the 8th will be stored at the bottom of the stack frame

OK, the following figure shows you the content of the stack frame when the function A allocates some space to pass addition parameters:

MEMORY %sp --------> +-----------------------+ | save %l0 | 8 local registers %sp + 4 ----> +-----------------------+ | save %l1 | (parameters to subroutine) %sp + 8 ----> +-----------------------+ | ......... | | ......... | | ......... | %sp + 32 ---> +-----------------------+ | save %i0 | 8 input registers %sp + 36 ---> +-----------------------+ | save %i1 | (local variables of subroutine) %sp + 40 ---> +-----------------------+ | ......... | | ......... | | ......... | %sp + 64 ---> +-----------------------+ | structure pointer !! | for a function that returns struct %sp + 68 ---> +-----------------------+ | save %o0 | 6 output registers: o0 - o5 %sp + 72 ---> +-----------------------+ | save %o1 | %sp + 76 ---> +-----------------------+ | ......... | | ......... | %sp + 88 ---> +-----------------------+ | save %o5 | %sp + 92 ---> +-----------------------+ | param 7 | %sp + 96 ---> +-----------------------+ | param 8 | %sp + 100 --> +-----------------------+ | param 9 | %sp + 104 --> +-----------------------+ | param 10 | --> +-----------------------+ | ... | --> +-----------------------+ <--- %fp - 4 | possible local vars | --> +-----------------------+ <--- %fp

Notice again that the first 92 bytes from the top of the stack are always used by the Operating System to save the context information
The (possible) local variables are located at bottom (end) of the new frame
The space between the necessary 92 bytes and the local variables are used to pass additional parameters.
Notice also that the location of the first additional parameter is always located at %sp + 92 --- because the first 92 bytes from the top of the stack are always used by the Operating System to save the context information
Since this location is fixed (OK, the location is somewhat strange, but something gotta give... :-)), we have obtained a workable solution to pass additional parameters.

From the figure above, we can see that the way to pass the 7th - 10th parameter as follows:

parameter 7 st ..., [%sp + 92] parameter 8 st ..., [%sp + 96] parameter 9 st ..., [%sp + 100] parameter 10 st ..., [%sp + 104]

Accessing the parameters beyond the 6th parameter

When function A calls function B and function B starts to run, the function B will execute a save instruction and change the stack to:

MEMORY %sp --------> +-----------------------+ | save %l0 | This is B's stack frame !!! %sp + 4 ----> +-----------------------+ | save %l1 | %sp + 8 ----> +-----------------------+ | ......... | | ......... | | ......... | | ......... | | ......... | %fp --------> +-----------------------+ | save %l0 | This is A's stack frame !!! %fp + 4 ----> +-----------------------+ | save %l1 | %fp + 8 ----> +-----------------------+ | ......... | | ......... | | ......... | %fp + 32 ---> +-----------------------+ | save %i0 | 8 input registers %fp + 36 ---> +-----------------------+ | save %i1 | (local variables of subroutine) %fp + 40 ---> +-----------------------+ | ......... | | ......... | | ......... | %fp + 64 ---> +-----------------------+ | structure pointer !! | for a function that returns struct %fp + 68 ---> +-----------------------+ | save %o0 | 6 output registers: o0 - o5 %fp + 72 ---> +-----------------------+ | save %o1 | %fp + 76 ---> +-----------------------+ | ......... | | ......... | %fp + 88 ---> +-----------------------+ | save %o5 | %fp + 92 ---> +-----------------------+ | param 7 | %fp + 96 ---> +-----------------------+ | param 8 | %fp + 100 --> +-----------------------+ | param 9 | %fp + 104 --> +-----------------------+ | param 10 | --> +-----------------------+ | ... | --> +-----------------------+ | A's local vars | (B shoul NOT touch A's locals) --> +-----------------------+

Notice that NOW (after B executed the save instruction) the additional parameters for function B are located at:

parameter 1 in register %i0 parameter 2 in register %i1 parameter 3 in register %i2 parameter 4 in register %i3 parameter 5 in register %i4 parameter 6 in register %i5 parameter 7 in stack at address [%fp + 92] parameter 8 in stack at address [%fp + 96] parameter 9 in stack at address [%fp + 100] parameter 10 in stack at address [%fp + 104]

Example Program:
- The main program that passes 10 parameters to a function: click here
- A function that has 10 parameters: click here
Compile it with:
Run it inside EGTAPI. Scroll the stack area down to the bottom and you will see how the additional parameters are passed.