the stack pointer and the frame pointer (lecture #19) ece 445 – computer organization the slides...

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


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.


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


Example:

Calling CalculateF


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


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).


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


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


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


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


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


CalculateF calls Sum2



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


CalculateF calls Prod1



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: ...

...


CalculateF returns to Main


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


Memory Layout


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?

the stack pointer and the frame pointer (lecture #19) ece 445 – computer organization the slides...

Documents

computer organizationece

procedure frame

stack pointer points

b c d e

main function

main program calls calculatef

return address of main

calculatef calls sum2