1. 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, 4 th Edition, by Patterson and Hennessey, and were used with permission from Morgan Kaufmann Publishers.

2. Material to be covered... Chapter 2: Sections 8 – 9

3. ECE 445 - Computer Organization3 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

4. ECE 445 - Computer Organization4 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.

5. ECE 445 - Computer Organization5 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 address of the procedure frame $sp points to the “top” of the stack

6. ECE 445 - Computer Organization6 Example: Calling CalculateF

7. ECE 445 - Computer Organization7 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

8. ECE 445 - Computer Organization8 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 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).

9. ECE 445 - Computer Organization9 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 address Stack...... data $sp e g main Saved arguments Local Data $fp jal CalculateF procedure call in Main

10. ECE 445 - Computer Organization10 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 address Stack...... data $sp e g main Saved arguments from calling program $fp

11. ECE 445 - Computer Organization11 Stack Usage by CalculateF low address high address Stack...... data e g $fp (from Main) addi $sp, $sp -4 sw $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

12. ECE 445 - Computer Organization12 Stack Usage byCalculateF low address high address Stack...... 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, -4 sw $ra, 0($sp) Main CalculateF

13. ECE 445 - Computer Organization13 Stack Usage by CalculateF low address high address Stack...... data $sp e g lw $t0, 8($fp) sll $t0, $t0, 1 addi $sp, $sp, -4 sw $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

14. ECE 445 - Computer Organization14 CalculateF calls Sum2

15. ECE 445 - Computer Organization15 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

16. ECE 445 - Computer Organization16 CalculateF calls Prod1

17. ECE 445 - Computer Organization17 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:...

18. ECE 445 - Computer Organization18 CalculateF returns to Main

19. ECE 445 - Computer Organization19 Restore $sp, $fp, $ra and Return low address high address Stack...... data $sp e g main lw $ra, -4($fp) add $sp, $fp, $zero lw $fp, 0($sp) addi $sp, $sp, 4 jr $ra Read $ra from stack. Restore $sp. Read $fp from stack. Return to main. $fp (from Main) $ra (from Main) e * 2 $fp CalculateF

20. ECE 445 - Computer Organization20 Memory Layout

21. ECE 445 - Computer Organization21 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.

22. Fall 2010ECE 445 - Computer Organization22 Questions?