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.

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

ECE 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

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

ECE 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

ECE Computer Organization6 Example: Calling CalculateF

ECE 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 ); } Sum2( pa, pb, pc, pd, pe ) { px = pa + pb + pc + pd + pe*2; return( px ); } Prod1( px, pg ) { y = pg * px; return( y ); }

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

ECE 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

ECE 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

ECE 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

ECE 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

ECE 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

ECE Computer Organization14 CalculateF calls Sum2

ECE 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

ECE Computer Organization16 CalculateF calls Prod1

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

ECE Computer Organization18 CalculateF returns to Main

ECE 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

ECE Computer Organization20 Memory Layout

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

Fall 2010ECE Computer Organization22 Questions?