- The "save" and "restore" instructions manipulate the register windows.
- The save
instruction will move the SPARC register window
forward
- The restore
instruction will move the SPARC register window
backward
- The "save" and "restore" instructions in SPARC
have no equivalent in M68000, because M68000 was not designed
with register windows.
- Recall that:
-
The purpose of using overlapping register windows
is to avoid using a stack in memory to store data
for subroutine calls
- Recall that the following information are stored on the stack
to implement a subroutine call:
- Parameters to the subroutine
- Return address of the caller
- Frame pointer of the caller ("a6")
- Local variables of the subroutine
- You will see that all these data will be store on
stack in SPARC also --- hence the theory on subroutine call
(and return) remains unchanged
- What is changed drastically is ordering and location of the information.
- Before I can explain why the save instruction does what it does,
I need to give you some background information about the runtime
environment.
- You may not believe it, but your program that is running in the computer
is regularly
stopped
without you even notice that it has
been stopped:
-
When many users are using the same computer (multi-user system),
the
Operating System
will allow each program to run for
a very short time (e.g., 10 milli-second), then
the Operating System will stop the program,
and let another program
have the CPU (so that program can run).
- In order to allow a program that has been stopped to restart
again later, the Operating System needs to
save the
values in the registers - since the very same
registers will be used by another program !!!
If you don't save the values in the registers, the program will not be able to find its original value when the program restarts....
- Illustration:
- Prog file: click here
Run the above program in EGTAPI. You will see the following strange phenomenon:
- The program executes mov 111, %i0
- Register %i0 changes (that's not surprising)
- Some value in the stack also changes - this is surprising
Explanation: The Operating System is saving the registers to the stack
- The values in the registers is called context and it is saved in the memory.
- Important facts:
- SPARC uses the register %o7
as stack pointer
-
Programming note: in your assembler program, you can
use
%sp
to denote the stack pointer %sp
- The stack pointer %sp must have a value that is divisible by 8
- SPARC uses the register %o7
as stack pointer
- SPARC uses the stack to store the following registers in the following
manner:
- The last word (at location %sp + 92 ) is necessary padding to make the value of %sp divisible by 8
%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
- The figure below shows how an active function
in SPARC will use the registers.
- The left part of the figure shows the registers in the CPU
The right part of the figure shows the stack in memory
CPU's registers: Memory: ^ +-------------------+ +--------------------+ C | | input registers | | | u | | | | | r | | (function's | | | r | | parameters) | | | e | +-------------------+ | | n | | local registers | | | t | | | | | | | (function's | | | W | | local vars) | | | i | +-------------------+ | | n | | output registers | | | d | | | | | o | | o6 (stack pointer)|---+ | | w | | o7 | | | | v +-------------------+ | | | | | | | | | | | | | | unused | | | unused space | | | +------>|--------------------| +-------------------+ | | | | | area to save | | unused | | function's | | | | window registers | | | | | +-------------------+ | | - The active function will use the registers in its register window
in the following manner:
- the parameters
of the active function are stored
in the
input registers i0 through i5
- the return address
(to the function that called the active function)
is in
input registers i7
(after the active function has advanced the register window)
You must realize that the active function has previously been called by some other function.
- you will soon see that
input registers i6
contains the
frame pointer
...
- The
local registers l0 through l7.
can be used to store
local variables
For now, we will assume that the function does not need more than 6 local variables. Later we will see how the function allocate more space on the stack when it needs more than 6 local variables.
- The
output registers o0 through o5.
will be used to pass
parameters to a callee function
For now, we will assume that the callee function has at most 6 parameters. Later we will see how to pass additional parameters to a function that has more than 6 parameters.
- The
output register o7
is
- The output registers o6 is used as the stack pointer
NOTE: output registers o6 is designed as stack pointer by the decree of the Operating System (written by Sun MicroSystems) and we must abide by their decree...
- The output registers o6 is used as the stack pointer
- the parameters
of the active function are stored
in the
input registers i0 through i5
- Now, suppose an active function calls another function
(the callee function).
- Let's call the active function A
- Let's call the callee function B
- The callee function
B
will create its own procedure activation record
structure on the stack...
- These are the steps that are executed when a active function
A
calls a callee function:
- Caller function
A
pass parameters to callee function
B
(for now, we assume the number of parameters is <= 6)
- Caller function
A
calls callee function
B
(using the call B instruction)
- Callee function
B
makes its own procedure activation record
(for now, we assume the number of local variables is <= 8)
- .... (callee function
B
runs and will eventually return)
- Callee function
B
stores the return value in the agreed location
- Callee function
B
deallocates its procedure activation record
- Callee function B returns to caller function A (using the jmpl instruction)
- Caller function
A
pass parameters to callee function
B
(for now, we assume the number of parameters is <= 6)
- Let us consider the steps of the function call and see what the register window looks like at each step:
- Let's call the active function A
- Initially (before passing parameters)
(function A is active)
CPU's registers: Memory: ^ +-------------------+ +--------------------+ | | i0 - i5 | | | C | | (A's parameters) | | | u | | | | | r | | i6 (frame pointer)| | | r | | i7 (return addr) | | | e | +-------------------+ | | n | | local registers | | | t | | | | | | | | | | W | | ( A 's | | | i | | local vars) | | | n | +-------------------+ | | d | | output registers | | | o | | | | | w | | | | | | | o6 (stack pointer)|---+ | | | | o7 | | | | v +-------------------+ | | | | | | | | | | | | | | unused | | | unused space | | | +------>|--------------------| | | | | +-------------------+ | area to save | | | | function's | | | | window registers | | unused | | | | | | | | | +-------------------+
- Function
A
passes parameters to callee function
B
using output registers
o0 - o5
(For now, we assume callee function has <= 6 parameters)
CPU's registers: Memory: ^ +-------------------+ +--------------------+ | | i0 - i5 | | | C | | (A's parameters) | | | u | | | | | r | | i6 (frame pointer)| | | r | | i7 (return addr) | | | e | +-------------------+ | | n | | local registers | | | t | | | | | | | | | | W | | ( A 's | | | i | | local vars) | | | n | +-------------------+ | | d | | output registers | | | o | | ( B 's | | | w | | parameters) | | | | | o6 (stack pointer)|---+ | | | | o7 | | | | v +-------------------+ | | | | | | | | | | | | | | unused | | | unused space | | | +------>|--------------------| | | | | +-------------------+ | area to save | | | | function's | | | | window registers | | unused | | | | | | | | | +-------------------+
- Function
A
calls callee function
B
using
call B
(Recall call will save return address in o7)
CPU's registers: Memory: ^ +-------------------+ +--------------------+ | | i0 - i5 | | | C | | (A's parameters) | | | u | | | | | r | | i6 (frame pointer)| | | r | | i7 (return addr) | | | e | +-------------------+ | | n | | local registers | | | t | | | | | | | | | | W | | ( A 's | | | i | | local vars) | | | n | +-------------------+ | | d | | output registers | | | o | | ( B 's | | | w | | parameters) | | | | | o6 (stack pointer)|---+ | | | | o7 (ret addr to A)| | | | v +-------------------+ | | | | | | | | | | | | | | unused | | | unused space | | | +------>|--------------------| | | | | +-------------------+ | area to save | | | | function's | | | | window registers | | unused | | | | | | | | | +-------------------+
- At this moment,
the callee function will start running
(and the caller function is suspended)
- Now take a look at a situation
when the register window is moved down:
CPU's registers: Memory: +-------------------+ +--------------------+ | old i0 - i5 | | | | (A's parameters) | | | | | | | | i6 (frame pointer)| | | | i7 (return addr) | | | +-------------------+ | | | old local regs | | | | | | | | | | | | ( A 's | | | | local vars) | | | +-------------------+ | | ^ | input registers | | | | | ( B 's | | | C | | parameters) | | | u | | i6 (FRAME pointer)|---+ | | r | | i7 (ret addr to A)| | | | r | +-------------------+ | | | e | | B 's | | | | n | | local variables | | | | t | | | | | unused space | | | | +------>|--------------------| W | | | | | i | +-------------------+ | area to save | n | | Output registers | | function's | d | | | | window registers | o | | | | | w | | o6 = ??? | | | | | | V +-------------------+ - Notice that the
stack pointer register o6
does not have a proper value !!!
- Also:
-
We need to
allocate some space on the system stack
for the
Operating System to save the callee
B's window registers !!!
(Remember from the program above: windows registers are saved when the program is stopped by the Operating System. The stack so far only has space to save A's window registers. So we must allocate space to save B's window registers.)
- Illustration:
(Demo the effect of advancing register window
WITHOUT saving space
on stack)
- Prog file: click here
Run program in EGTAPI. Check stack to see effect: B's input and local registers' values OVERWRITE A's input and local registers' values.
- From the above discussion, we need to reserve:
-
92 + 4 (padding) bytes on the stack
Now we have the necessary information to comprehend why the save instruction does what it does....
- The syntax and the effect of the "save" instruction are:
- Note that the source operands
%r1
and
%r2
are registers in the
original
register window.
- But the destination operand %r3 is a register in the NEW register window.
save %r1, constant, %r3 or: save %r1, %r2, %r3 Effect: 1. Temp <- r1 + constant (or r1 + r2) 2. CWP <- CWP - 1 (NOTE: this will move the window down !!!) 2. r3 <- Temp - Note that the source operands
%r1
and
%r2
are registers in the
original
register window.
- The commonly used form of the
save
instruction is:
save %sp, -96, %sp (i.e.: save %06, -96, %o6) - The
save
instruction is always the
first instruction
executed by a callee function
( B )
-
Let us take a look at the effect of the instruction
save %sp, -96, %sp:
First, recall that the register window looked like this when the callee ( B starts running:
CPU's registers: Memory: ^ +-------------------+ +--------------------+ | | i0 - i5 | | | C | | (A's parameters) | | | u | | | | | r | | i6 (frame pointer)| | | r | | i7 (return addr) | | | e | +-------------------+ | | n | | local registers | | | t | | | | | | | | | | W | | ( A 's | | | i | | local vars) | | | n | +-------------------+ | | d | | output registers | | | o | | ( B 's | | | w | | parameters) | | | | | o6 (stack pointer)|---+ | | | | o7 (ret addr to A)| | | | v +-------------------+ | | | | | | | | | | | | | | unused | | | unused space | | | +------>|--------------------| | | | | +-------------------+ | area to save | | | | function's | | | | window registers | | unused | | | | | | | | | +-------------------+
The instruction:
save %sp, -96, %sp (or: save %o6, -96, %o6)will do:- Temp <- o6 - 96 (this will be the new stack location !)
- CWP <- CWP - 1 (NOTE: this will push the window down !!!)
- o6 <- Temp (NOTE: the o6 in the NEW window is assigned !!!)
The result is then:
CPU's registers: Memory: +-------------------+ +--------------------+ | old i0 - i5 | | | | (A's parameters) | | | | | | | | i6 (frame pointer)| | | | i7 (return addr) | | | +-------------------+ | | | old local regs | | | | | | | | | | | | ( A 's | | | | local vars) | +-------->+--------------------+ +-------------------+ | | area on stack to | ^ | input registers | | | save B's | | | ( B 's | | | window registers | C | | parameters) | | | | u | | i6 (FRAME pointer)|---+ | | r | | i7 (ret addr to A)| | | | | r | +-------------------+ | | | | e | | B 's | | | | | n | | local variables | | | | | t | | | | | | reserved 96 bytes | | | | | +------>|--------------------| W | | | | | | i | +-------------------+ | | area to save | n | | Output registers | | | A's | d | | | | | window registers | o | | | | | | w | | o6 = i6 - 96 -----|-+ | | | | | V +-------------------+
- Illustration:
(Demo the effect of advancing register window
WITH saving space
on stack)
- Prog file: click here
Run program in EGTAPI. Check stack to see effect: B's input and local registers' values DO NOT overwrite A's input and local registers' values.
- The callee function
B
returns a value to the caller function
A
using one of the input registers
(because
A
and
B
share
B's
input registers - they are
A's
output registers)
- Typically, the output registers
i0
is used to return a value to the caller.
- The caller function A will retrieve the returned value in its output register o0
Syntax:
restore %r1, constant, %r3
or: restore %r1, %r2, %r3
Effect:
1. Temp <- r1 + constant (or r1 + r2)
2. CWP <- CWP + 1 (NOTE: this will push the window up !!!)
2. r3 <- Temp
restore %g0, %g0, %g0 (you get this when you write "restore")
The effect of this instruction is simply:
CWP <- CWP + 1
In other words: simply push the window up...