- When a function uses
8 local variables or less
(which is the common case),
the SPARC local registers can accomodate such a function
(and the execution of such function will be very speedy)
- However, when a function needs to use
more than 8 local variables ,
the 9th local variable and beyond must be stored
in the stack.
- As you know, the
save
instruction is used to allocate space on the stack.
- You also know that you
must
allocate
92 bytes
for the Operating System to store
the input, local, a structure pointer and 6 output registers.
- When a function has more than 8 local variables,
the save
instruction must allocate additional space.
Example:
- If a function uses 9 local variables, then the
save instruction
must allocate
one additional word
for the 9th local variable.
- If a function uses 9 local variables, then the
save instruction
must allocate
two additional word
for the 9th and the 10th local variable.
- And so on...
- If a function uses 9 local variables, then the
save instruction
must allocate
one additional word
for the 9th local variable.
- NOTE:
-
You must also remember that the stack pointer must be
divisible by 8
So when you allocate 4 bytes for one additional local variable, you must add 4 more bytes for padding (to keep the stack pointer divisible by 8)
- Suppose we have a function with 12 local variables:
void myFunc() { int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11; .... } - The save
instruction will need to save
4 x 4 = 16 bytes
beyond
the required
92
bytes.
- So we must use 92 + 16 to
allocate space on the stack.
- However, 92 + 16
is
not divisible by 8
So we must add 4 more bytes for padding:
myFunc: save %sp, -(92 + 16 + 4), %sp ... rest of the function body ret restore
- Since the first 8 local variable are in the local registers,
the first 8 local variables are accessed as follows:
%l0 - local variable a0 %l1 - local variable a1 %l2 - local variable a2 %l3 - local variable a3 %l4 - local variable a4 %l5 - local variable a5 %l6 - local variable a6 %l7 - local variable a7
- To access the local variables a9, a10, a11 and a12, you need to
know where they are on the stack.
The following picture shows the manner in whcih SPARC store the local variables:
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 ---> +-----------------------+ | padding | %sp + 96 ---> +-----------------------+ <--- %fp - 16 | a11 | %sp + 100 --> +-----------------------+ <--- %fp - 12 | a10 | %sp + 104 --> +-----------------------+ <--- %fp - 8 | a9 | %sp + 108 --> +-----------------------+ <--- %fp - 4 | a8 | %sp + 112 --> +-----------------------+ <--- %fp - Notice that the
first 92 bytes from the top of the stack
are
always
used by the Operating System to save the context information
- The local variables
a8, a9, a10 and a11 are located at
bottom (end)
of the new frame
- Notice also that the
frame pointer (%fp or %i6)
points to the end of the new frame (see figure)
- From the figure above, we can see that
the way to read the 9th - 12 local variables is as follows:
a8 ld [%fp - 4], ... a9 ld [%fp - 8], ... a10 ld [%fp - 12], ... a11 ld [%fp - 16], ...
- The way to write the 9th - 12 local variables is as follows:
a8 st ..., [%fp - 4] a9 st ..., [%fp - 8] a10 st ..., [%fp - 12] a11 st ..., [%fp - 16]
- A C program with 12 local variables click here
Compile it with:
-
cc -o C-sparc-12-locals C-sparc-12-locals.c
Run it inside EGTAPI. Scroll the stack area down to the bottom and you will see how C uses local variables.
The C compiler seems to allocate 12 local variables on the stack and does not use any local register at all... Not very optimal, but still works...