The Stack Pointer and the Frame Pointer
(Lecture #19)
ECE 445 – Computer Organization
The slides included herein were taken from the materials accompanying Computer Organization and Design, 4th Edition, by Patterson and Hennessey,
and were used with permission from Morgan Kaufmann Publishers.
Material to be covered ...
Chapter 2: Sections 8 – 9
ECE 445 - Computer Organization 3
Some Basic Definitions
Stack Pointer
A value denoting the most recently allocated address in a stack that shows where registers should be spilled or where old register values can be found.
Frame Pointer
A value denoting the location of the saved registers and local variables for a given procedure.
Procedure Frame (aka. Activation Record)
The segment of the stack containing a procedure's saved registers and local variables.
Caller: A program or function that calls a procedure
Callee: The procedure that is called
ECE 445 - Computer Organization 4
Frame Pointer
The frame pointer points to the highest address in the procedure frame (or activation record).
The frame pointer remains fixed at this memory location for the duration of the procedure.
Whereas, the stack pointer moves each time an element is added to or removed from the stack.
The frame pointer must be preserved across procedure calls.
ECE 445 - Computer Organization 5
Stack Allocation and the Frame Pointer
Local data – stack space allocated by the called procedure
stack allocation when a procedure is called
before procedure call
after procedure call
$fp points to the highest addressof the procedure frame
$sp points to the “top” of the stack
ECE 445 - Computer Organization 6
Example:
Calling CalculateF
ECE 445 - Computer Organization 7
CalculateF: f = g*(a+b+c+d+e*2)
main{ .. f = CalculateF( a, b, c, d, e, g ); .. print( f );}
CalculateF( pa, pb, pc, pd, pe, pg ){ x = Sum2( a, b, c, d, e ); pf = Prod1( x, g ); return( pf );}
1000
2000
1024
2004
Sum2( pa, pb, pc, pd, pe ){ px = pa + pb + pc + pd + pe*2; return( px );}
Prod1( px, pg ){ y = pg * px; return( y );}
3000
4000
3004
4004
ECE 445 - Computer Organization 8
CalculateF: f = g*(a+b+c+d+e*2) The main program calls CalculateF to carry out the arithmetic operation.
CalculateF calls Sum2 to carry out the addition. CalculateF then calls Prod1 to carry out the multiplication.
Main
CalculateF
f = g*(a+b+c+d+e*2)
Sum2
f = (a+b+c+d+e*2)
Prod1
f = g*(sum)
calls
callscalls
Before calling Sum2:
1. Save return address (of main) on the stack.2. Save argument e on the stack.
Before returning to Main:
1. Restore return address (of main) from the stack.2. Restore stack (i.e. stack pointer).
ECE 445 - Computer Organization 9
Main calls CalculateF
Data local to Main function is pushed on the stack.
Parameters to be passed to the called function are also pushed onto the stack.
Stack Pointer points to the last element pushed onto the stack.
low address
high addressStack
.
.
.
data
$sp
e
g
main
Saved arguments
Local Data
$fp
jal CalculateF
procedure call in Main
ECE 445 - Computer Organization 10
Main calls CalculateF
Main program pushes arguments (e and g) onto the stack.
Main function executes
jal CalculateF
$ra = return address of Main
PC = CalculateF
low address
high addressStack
.
.
.
data
$sp
e
g
main
Saved arguments from calling program
$fp
ECE 445 - Computer Organization 11
Stack Usage by CalculateF
low address
high addressStack
.
.
.
data
e
g
$fp (from Main)
addi $sp, $sp -4sw $fp, 0($sp)add $fp, $sp, $zero
Main
$fp, $sp
1. Frame pointer from Main pushed onto stack.
2. Frame pointer for CalculateF set equal to stack pointer
($fp = $sp).
Stack pointer and Frame pointer now point to the highest address in the procedure frame for CalculateF.
All arguments are now relative to the frame pointer.
CalculateF
ECE 445 - Computer Organization 12
Stack Usage byCalculateF
low address
high addressStack
.
.
.
data
$sp
e
g
$fp (from Main)
• Return address is pushed onto the stack.
• Stack pointer adjusted.
It is now possible to call another function.
$ra (from Main)
$fp
addi $sp, $sp, -4sw $ra, 0($sp)
Main
CalculateF
ECE 445 - Computer Organization 13
Stack Usage by CalculateF
low address
high addressStack
.
.
.
data
$sp
e
g
lw $t0, 8($fp)sll $t0, $t0, 1addi $sp, $sp, -4sw $t0, 0($sp)
Read argument e from stack.Multiply e by 2.Push value onto stack.Adjust stack pointer.
$fp (from Main)
$ra (from Main)
e * 2
$fp
Main
CalculateF
ECE 445 - Computer Organization 14
CalculateF calls Sum2
ECE 445 - Computer Organization 15
CalculateF: f = g*(a+b+c+d+e*2)
lw $t0, 0($sp)
add $t0, $t0, $a0
add $t0, $t0, $a1
add $t0, $t0, $a2
add $t0, $t0, $a3
add $v0, $t0, $zero
jr $ra
Sum2: # f=(e*2)
# f=(e*2)+a
# f=(e*2)+a+b
# f=(e*2)+a+b+c
# f=(e*2)+a+b+c+d
# return value
# return control
jal Sum2 procedure call in CalculateF
return value from Sum2
CalculateF calls Sum2 Arguments passed to Sum2
a, b, c, d → $a0 - $a3
e*2 → last element on stack Return address ($ra) for Main pushed onto stack before call Value returned to CalculateF in register $v0
ECE 445 - Computer Organization 16
CalculateF calls Prod1
ECE 445 - Computer Organization 17
CalculateF: f = g*(a+b+c+d+e*2)
add $a0, $v0, $zero
lw $a1, 4($fp)
jal Prod1
# sum from Sum2
# read g from stack
# call Prod1
procedure call to Prod1
passing the sum to Prod1
passing g to Prod1
CalculateF calls Prod1 Arguments passed to Prod1
sum from Sum2 → $a0
g → $a1 Return address ($ra) for Main pushed onto stack before call Value returned to CalculateF in register $v0
CalculateF: ...
...
ECE 445 - Computer Organization 18
CalculateF returns to Main
ECE 445 - Computer Organization 19
Restore $sp, $fp, $ra and Return
low address
high addressStack
.
.
.
data
$sp
e
g
main
lw $ra, -4($fp)add $sp, $fp, $zerolw $fp, 0($sp)addi $sp, $sp, 4jr $ra
Read $ra from stack.Restore $sp.Read $fp from stack.Return to main.
$fp (from Main)
$ra (from Main)
e * 2
$fp
CalculateF
ECE 445 - Computer Organization 20
Memory Layout
ECE 445 - Computer Organization 21
Memory Layout Text: program code Static data: global variables
e.g., static variables in C, constant arrays and strings
$gp initialized to address allowing ±offsets into this segment
Dynamic data: heap e.g., malloc in C, new in Java
Stack: automatic storage
Heap – memory allocated for dynamic data.The heap and stack grow towards each other in the same memory space.
Fall 2010 ECE 445 - Computer Organization 22
Questions?
Top Related