1. Problem: ! bell ! help ! ! 1 ! 2 ! ! Bal help ! ! ! !
! 1 ! !
! Bal help !
! ! !
Bal bell ! Jr $31
! !
! Jr $31 !
What happend
here?
What will happen here?

2. The activation concept
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep

3. The activation concept
Son
1. Wakes up,
starts executing “bell”, wants “help”
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep
3. Asleep

4. The activation concept
Grandson
Son
1. Wakes up,
starts executing “bell”, wants “help”
2. Creates son, tells him help, falls asleep
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep
3. Asleep

5. The activation concept
Grandson
1. Wakes up.
starts executing “help”
Son
1. Wakes up,
starts executing “bell”, wants “help”
2. Creates son, tells him help, falls asleep
3. Asleep
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep
3. Asleep

6. The activation concept
Grandson
1. Wakes up.
starts executing “help”
2. Finished. Vanishes, Wakes up his parent
Son
1. Wakes up,
starts executing “bell”, wants “help”
2. Creates son, tells him help, falls asleep
3. Asleep
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep
3. Asleep

7. The activation concept
Son
1. Wakes up,
starts executing “bell”, wants “help”
2. Creates son, tells him help, falls asleep
3. Asleep
4. Finished, Vanishes, wakes up his parent
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep
3. Asleep

8. The activation concept
Main
1. Executing program, wants “bell”
2. Creates son,
Tells him “bell”,
Falls asleep
3. Asleep
4. Executing

9. The main points:
We talk about activations, not the code being executed.
Last in - first out
implies a stack
OK for different activations to share the same instructions

10. A parents responsibilities to his unborn son:
Be prepared for the son to trash $tx-registers.
Put input arguments into $a0 - $a3.
Give him a return address (by Bal- instr.).
Tell him which code to execute (also by Bal).

11. The son’s responsibility to his sleeping parent:
Leave the stack like he found it.
Return results (if any) into registers $v0 - $v1.
Leave the $ax-registers like he found them.
OK to change $tx-registers and not restore them.

12. The activations responsibility to himself
Need space for local variables?
Create space on stack. Use $tx registers as scratchpads.
Want to change $ax-register?
Save the incoming values into local variables.
Want to create a son?
Protect the $tx-registers.
Protect the return address ($31).
by saving them on the stack

13. What does one activation own?
Return address to his parent.
His incoming parameters.
A place to put his results.
Some local variables.
Which code to execute (his PC).
Called his “activation record”

14. Stack the activation records:
Grandson
used activation
record “grandson”
Son (asleep)
The concept gives
unique context.
saved activation
record “son”
Main (asleep)
saved activation
record “main”

15. The user stack $sp points to top- of- stack User stack (part of the
data memory)
$sp

16. The user stack Stack grows toward lower addresses.
Basic stack operations:
Push $t5 onto stack Pop from stack into $a2
Addi $sp $sp -4 Lw $a2 0($sp)
Sw $t5 0($sp) Addi $sp $sp 4

17. Wrong!!!!! reason: interrupts.
Push $t5 onto stack Pop from stack into $a2
Sw $t5 -4($sp) Addi $sp $sp 4
Addi $sp $sp -4 Lw $a2 -4($sp)
This method writes Never use a negative
beyond T.O.S first, displacement with
then fixes $sp respect to T.O.S.
reason: interrupts.

18. Framepointer <= $sp points here -8($fp) -4($fp)
Low address
-8($fp)
<= $sp points here
Var2
-4($fp)
Var1
<= $fp points here
0($fp)
Old fp
4($fp)
Return addr
Caller’s
stack
High address

19. Example Compute  i Define as recursive definition: 1 if N = 1
sum(N) =
N + sum(N-1) otherwise

20. Pseudocode Procedure sum(N:integer):integer; if (N=1) then return (1)
else
T := N + sum(N-1);
return (T)
end;

21. Where do we start? Parameter comes in in $a0. Return address in $31.
This activation will probably need a son
(because of the recursion) so:
Local variables.
save $31.
save $a0.
the variable T?

22. The Code sum: addi $sp $sp -4 #store return address on stack
sw $31 0($sp)
addi $sp $sp -4 #store incoming parameter on stack
sw $a0 0($sp)
if: ori $t0 $r0 1 #test: fixed point?
bne $a0 $t0 else
then: ori $v0 $r0 1
b exit
else: addi $a0 $a0 -1 #sum(N-1) in $v0, original $a0 lost
bal sum #recursive call to sum
lw $t0 0($sp) #retrive the incoming parameter value
add $v0 $v0 $t0 #$v0 has N + T
exit: lw $31 4($sp) #restore return address
addi $sp $sp 8 #Stack cleaned
jr $31 #end activation

23. Procedure Call
Place parameters in a place where the procedure can access them ($a0 - $a3)
Transfer control to the procedure (bal bell)
Acquire the storage resources needed for the procedure.
Perform the desired task.
Place the result value in a place where the calling program can access it. ($v0 - $v1)
Return control to the point of origin.(jr $31)