1. Based on Mike Feeley’s and Tamara Munzner’s original slides; Modified by George Tsiknis Parameters and Local Variables Relevant Information CPSC 213 Companion -2.8 (all subsections) (Optional) Textbook - 3.7

2. Learning Outcomes At the end of this unit you should be able to:  translate into sm213 assembly java methods that contain local variables and parameters and vice versa  translate into sm213 assembly C functions that contain local variables and parameters and vice versa  describe at least two ways that compiler deal with local variables and list their advantages and disadvantages  describe at least two ways that compiler deal with function/method parameters and arguments and list their advantages and disadvantages Unit 12 2

3. 3 Local Variables of Functions and Methods

4. Unit 12 4 Local Variables of a Function/Method Are part of the local scope (local environment) of a procedure/method Exist only when procedure/method is running Each call has its own instances Need to allocate and deallocate a method’s environment at each call Similar to instance variables? void b () { int local0 = 0; int local1 = 1; } void foo () { b (); }

5. Unit 12 5 Accessing Local Scope Similar to instance variables : Compiler sets their layout Compiler stores all local variables together Accessing local variables is similar to accessing instance variables  need the address of the start of the local scope  each variable will be determined by a constant offset Can have a register holding the address of the beginning of the local scope of the current call  usually called stack pointer  in our machine we use r5

6. Unit 12 6 Accessing Local Scope (cont') Unlike instance variables : Local scopes have to be allocated/deallocated fast  allocated at each call  deallocated when the call returns Note that function calls return in reverse order Therefore, dealocation of local scopes is in reverse order of allocation  what structure should we use to store the local scopes?

7. Unit 12 7 Example 1 public class A { public static void f () { int m = 0; int n = 1;... }... void main() { A.f ();... void f () { int m = 0; int n = 1;... } void main() { f();... Java C So, since r5 will point to the local scope when f is called, to initialize m and n, f has to do: ld $0x0, r0# r0 = 0 st r0, 0x0(r5)# m = 0 ld $0x1, r0 # r0 = 1 st r0, 0x4(r5) # n = 1

8. Unit 12 8 The Runtime Stack Every thread in a program is given a part of memory called the runtime stack A call to a method pushes onto the stack an activation frame with the method’s local scope  local variables  saved registers  any storage needed just for this call The compiler generates code (as part of a method's code)  to allocate a frame when a method is called (size is known) –can allocate space for one variable at a time or all space at once  to deallocate the frame when a method returns  to access local variables within the frame (constant offsets) Stack usually starts at the highest address and grows towards lower addresses Stack pointer register (r5 in our machine) points to ( the top of the) current stack frame Locating local variables within a frame  use the stack pointer (r5 ) and constant offsets

9. Unit 12 9 The Memory Segments STATIC  instructions  constants  static variables HEAP  all dynamically allocated objects created by –new –malloc STACK  all local scopes of the methods invoked but not returned yet address 0 max

10. Unit 12 10 Example 2.address 0x100 start:ld $0x400000, r5 # initialize stack # pointer.address 0x200 main:gpc $6 r6 # r6 = pc+6 j f# call f () halt.address 0x300 f:deca r5 # create space for n deca r5 # create space for m ld $0x0, r0# r0 = 0 st r0, 0x0(r5)# m = 0 ld $0x1, r0# r0 = 1 st r0, 0x4(r5)# n = 1 inca r5# remove m inca r5# remove n j 0x0(r6)# return void f () { int m = 0; int n = 1; } void main() { f(); } main’s frame r5 n m stack

11. Decision on Local Variables Local variables are only needed during the execution of the function Therefore we can  either store them on the stack as part of the function’s frame (as we did so far)  or keep them in registers, whenever it is possible If we keep them in registers, we can still save them on the stack when we run out of registers. Compiler can decide which method to use for each function  if function has few locals (1-3), store them in registers; otherwise store them on the stack We’ll try to keep the local variables in registers until we run out of registers. Unit 12 11 1, 2

12. Unit 12 12 Saving the Return Address A procedure g may call another procedure f  g needs to set in r6 its own return address before it calls f  when f returns, g needs the address that WAS in r6 to return If a procedure calls many other procedures only needs to save r6 once Optimizing procedure code:  At the beginning: If a procedure calls another procedure, save r6 on the stack  Before a call: compute new return address and put it in r6  At the end: restore r6 to the value on the stack and release its space. void f() { int m = 0; int n = 1; } void g() { f();... } void main() { g()... }

13. Unit 12 13 Example 3: Return-Address Saving & Locals in Registers.address 0x200 g:deca r5# create space for r6 st r6, 0x0(r5)# save r6 to stack gpc $6, r6# r6 = pc + 6 j f# call f() 20c: ld $x, r1 st r0, 0(r1)# x = f() ld 0x0(r5), r6# restore r6 from stack inca r5# remove r6 space j 0x0(r6)# return.address 0x300 f:ld $0x2, r0# r0 = m = 2 ld $0x3, r1# r1 = n = 2 add r1, r0# r0 = return value j 0x0(r6)# return int x; void f() { int m = 2; int n = 3; return m+n; } void g() { x = f(); } stack r5 main’s frame 1000C 10008 10000 1000C 10008 r6 500 20c 500 1000C

14. Unit 12 14 Return Value In C and Java functions/methods return a single value Traditionally return value is left in register 0 (%eax in IA32) Our machine also uses r0 for it Normal procedure:  function moves return value to r0 before it returns  caller gets the value from r0 3, 4

15. Unit 12 15 Arguments of Procedures and Methods

16. Unit 12 16 Function/Method Arguments Formal arguments (or parameters) are part of method’s scope Are different than local variables  values are supplied at the call ( actual arguments ) by the caller Two ways to pass arguments  through registers (good for small number of arguments)  on the stack (more general) When stack is used  calling procedure pushes the actual arguments onto the stack  arguments are pushed in the reverse order ( from right to left)  on return, calling procedure pops the arguments We’ll always pass arguments on the stack.

17. Register Usage Convention r0-r3 are caller-save registers:  function may use them freely, but if it calls other functions, their values may be changed after a call.  Use them for values that do not need to be preserved across function calls. r4-r7 are callee-save registers:  function may use them, but must save their values on the stack upon entering, and restore their values before returning.  Note that r5 is an exception: It should not be changed and used for anything else, except as stack pointer. Note that you have to pop registers from the stack in the reverse order in which they were pushed Unit 12 17

18. Unit 12 18 Responsibilities of a Function/Method At the beginning  Save on stack any of registers r4-r7 if you plan to use them  Specifically, save r6 on the stack if function calls another Before it returns  Set the return value in r0  Restore saved registers  Restore r6 Before calling another function  Set callee’s arguments on the stack (in reverse order)  Set the return address in r6 After the call to another function  Pop the called function’s arguments from the stack  Get return value from r0

19. Unit 12 19 Example 4: Putting all Together # bar’s code (reg use: m  r0, n  r1) bar:ld 0x0(r5), r0# r0 = i (holds m) inc r0# r0 = m = i+1 ld 0x4(r5), r1# r1 = j (holds n) inc r1# r1 = = n = j+1 # leave result in r0 add r1, r0# r0 = m+n # return j 0x0(r6)#return int bar(int i, int j) { int m = i+1; int n = j+1; rerurn m+n; } void foo() { int k; k = bar(8, 10); } r5 j i stack 8008 800c 8004 8000 10 8 r0 20

20. Unit 12 20 Example 4: Putting all Together # set ret addr and call bar gpc $6, r6# r6 = ret. addr j bar # remove arg’s inca r5# remove i inca r5# remove j # restore and remove r6 ld 0x0(r5), r6# restore r6 inca r5# remove r6 # return value is in 0 # asume that this is k #just return j 0x0(r6)#return # foo’s code foo: # save r6 deca r5 #space for r6 st r6, 0x0(r5)# save r6 # prepare for calling bar(8,10) # set actual arguments deca r5# space for j ld $0xa, r1 st r1, 0x0(r5)# j = 10 deca r5# space for i ld $0x8, r1 st r1, 0x0(r5) # i = 8 r6 r5 500 8014 8010 800c 8008 r6 j i8 10 500 stack frame of caller of foo 610

21. Unit 12 21 The First Activation Frame The first method that is executed by any thread is main(). So at the bottom of every stack is the frame for main.  How is the stack pointer set initially?  How is main called? There is an OS operation _start() or crt0() or crt1() that  its code is executed first  sets the stack pointer to (largest memory address +1)  calls main _start() for our sm213 Machine’s with 4 MB memory: # _start () _start:ld 0x400000, r5# initialize stack pointer # to the base of stack gpc $6, r6# r6 = pc jmp main# goto main() halt 5, 6

22. APPENDIX Example 4 with Local Variables Stored on the Stack Unit 12 22

23. Unit 12 23 Example 4: Putting all Together # bar’s code # set local var’s deca r5# space for n deca r5 # space for m # do calculations ld 0x8(r5), r0# r0 = i inc r0# r0 = i+1 st r0, 0x0(r5)# m = i+1 ld 0xc(r5), r1# r1 = j inc r1# r1 = j+1 st r1, 0x4(r5)# n = j+1 # leave result in r0 add r1, r0# r0 = m+n # remove local var’s inca r5# remove m inca r5# remove n # return j 0x0(r6)#return int bar(int i, int j) { int m = i+1; int n = j+1; rerurn m+n; } void foo() { int k; k = bar(8, 10); } r5 j i n m stack 8008 800c 8004 8000 10 8 11 9 r0 20 7f f f

24. Unit 12 24 Example 4: Putting all Together # set return address and call bar gpc $6, r6# r6 = ret. addr j bar # perform after call tasks # remove arg’s inca r5# remove i inca r5# remove j # restore and remove r6 ld 0x0(r5), r6# restore r6 inca r5# remove r6 # set k to the return value st r0, 0x0(r5) # prepare to return inca r5# remove k j 0x0(r6)#return # foo’s code # set local var’s foo: deca r5 # space for k # prepare for calling bar(8,10) # save r6 deca r5 #space for r6 st r6, 0x0(r5)# save r6 # set actual arguments deca r5# space for j ld $0xa, r1 st r1, 0x0(r5)# j = 10 deca r5# space for i ld $0x8, r1 st r1, 0x0(r5) # i = 8 r6 r5 500 8018 8014 8010 800c 8008 k r6 j i8 10 ? 500 stack frame of caller of foo 610 20