CS 320: Concepts of Programming Languages

Transcription

1 CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 24: Compilation: Implementing Function Calls o Function Definitions in Mini-C o The Run-Time Stack o Intermediate Code Instructions for Function Calls

2 Defining Functions in Mini-C Examples of Programs in Mini-C: def f(x) { while( x < 10 ) { x = x + 1; return n; y = 2; n = 3; z = f(y+n); print z; return 0; def fact(x) { if(x < 1) { return 0; else { if(x < 2) { return 1; else { return x * fact( x - 1 ); z = fact(5); print(z); return 0; Differences from C: o No types (only integers!) o Function definitions start with keyword def; o All functions must have 0 or 1 argument and return a value; o Conditionals and loops must use block statements (surrounded by curly braces); o No Boolean variables or Boolean expressions on RHS of assignment; and o Conditionals and while must have Boolean expressions.

3 Defining Functions in Mini-C The Grammar for our Mini-C Language: 0: Program := Funcs 1: Funcs := Func Funcs 2: Funcs := Func 3: Func := def identifier ( ) { Stmts 4: Func := def identifier ( identifier ) { Stmts 5: Stmts := Stmt ; Stmts 6: Stmts := Stmt ; 7: Stmts := Block Stmts 8: Stmts := Block 9: Block := { Stmts 10: Block := while ( BExpr ) Block 11: Block := if ( BExpr ) Block 12: Block := if ( BExpr ) Block else Block 13: Stmt := id = Expr 14: Stmt := return Expr 15: Stmt := print identifier 16: Stmt := break 17: Stmt := continue 18: BExpr := BTerm BExpr 19: BExpr := BTerm 20: BTerm := BFactor && BTerm 21: BTerm := BFactor 22: BFactor :=! Bfactor 23: BFactor := Cond 24: Bfactor := ( Bexpr ) 25: Cond := Expr == Expr 26: Cond := Expr!= Expr 27: Cond := Expr < Expr 28: Cond := Expr <= Expr 29: Cond := Expr > Expr 30: Cond := Expr >= Expr 31: Expr := Expr + Term 32: Expr := Expr - Term 33: Expr := Term 34: Term := Term * Factor 35: Term := Term / Factor 36: Term := Term % Factor 37: Term := Factor 38: Factor := - Factor 39: Factor := identifier ( ) 40: Factor := identifier ( Expr ) 41: Factor := identifier 42: Factor := integer 43: Factor := ( Expr )

4 Let s assume we have a Unix-like 4GB virtual address space (corresponding to 32 bit addresses). A generic memory layout would be as follows:

5 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; run-time stack

6 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; main() y: run-time stack

7 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(4) main() x: 4 result: y: run-time stack

8 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(3) fact(4) main() x: 3 result: x: 4 result: y: run-time stack

9 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(2) fact(3) fact(4) main() x: 2 result: x: 3 result: x: 4 result: y: run-time stack

10 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(1) fact(2) fact(3) fact(4) main() x: 1 result: x: 2 result: x: 3 result: x: 4 result: y: run-time stack

11 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(1) fact(2) fact(3) fact(4) main() x: 1 result: 1 x: 2 result: x: 3 result : x: 4 result : y: run-time stack

12 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(2) fact(3) fact(4) main() x: 2 result : 2 x: 3 result : x: 4 result : y: run-time stack

13 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(3) fact(4) main() x: 3 result : 6 x: 4 result : y: run-time stack

14 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; fact(4) main() x: 4 result : 24 y: run-time stack

15 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; main() y: 24 run-time stack

16 Here s how a simple recursive function would use the Run-Time Stack (RTS): def fact(x) { if(x < 2) { return 1; else { tmp = x * fact(x-1); return tmp; y = fact(n); print y; y = 24 run-time stack

17 In general, each stack frame contains the following: Parameter values -- Values of expressions given as arguments to the function call, which are evaluated and stored as the values of the local parameters; Local variables -- Local variables declared inside the function and temporaries used to evaluate expressions. y: 24 x: 2 _t1: 2 _t2: -8 Saved State of the Caller or Calling Function -- When the caller invokes a function, it is in a sense suspended and will be awoken when the function call returns; hence, we must save local state (e.g., contents of registers, and CPU status bits) to be restored after the call. In addition, somewhere we have to store: o the the value returned by the called function o the return address of the caller, so we can jump back after the call. This can be done with registers, or in one of the stack frames. We will store these as temporary variables on the stack (details will be given below). _ret_val _ret_addr

18 Memory Management in our IC Interpreter We will implement the most important parts of this paradigm, using Haskell data structures; here is a summary the data structures we will use, alongside the standard memory layout:

19 Summary of Stack Frame Contents during Calling and Return sequences: f is executing Calling Function f: Parameters and other local variables;

20 Summary of Stack Frame Contents during Calling and Return sequences: f calls g, so pushes a new stack frame for g Called Function g: Calling Function f: Parameters and other local variables;

21 Summary of Stack Frame Contents during Calling and Return sequences: evaluate parameter expressions Called Function g: Parameters Calling Function f: Parameters and other local variables;

22 Summary of Stack Frame Contents during Calling and Return sequences: store return address of f Called Function g: Parameters _ret_addr of calling function f Calling Function f: Parameters and other local variables;

23 Summary of Stack Frame Contents during Calling and Return sequences: g is executing Called Function g: Parameters and other local variables and temporaries. _ret_addr of calling function f Calling Function f: Parameters and other local variables;

24 Summary of Stack Frame Contents during Calling and Return sequences: g finishes executing, stores return value, jumps to return address Called Function g: Parameters and other local variables and temporaries. _ret_addr of calling function f Calling Function f: Parameters and other local variables; _ret_val of called function g

25 Summary of Stack Frame Contents during Calling and Return sequences: f continues executing, using the return value from g. Calling Function f: Parameters and other local variables; _ret_val of called function g

26 Memory Management in our IC Interpreter Just three IC instructions suffice to implement function calls: (Push) Push a new stack frame on the RTS for the called function. (Call <address of called function> ) Store the return address (the next address after the call) in a variable _ret_addr in the stack frame of the called function; Jump to the <address of called function>. (Return <result-variable>) Lookup the value of <result-variable> in the current stack frame and store it in the stack frame of the caller as _ret_val; Put the _ret_addr into Program Counter (PC); Pop the current frame off the RTS and start to execute at address in PC.

27 Memory Layout and the Run-Time Stack

28 IC Calling and Return Sequences for Function Calls Calling Function f Called Function g Code for Calling Function f Evaluation Code to evaluate of argument expressions into expressions temporaries. and store in temporaries. _tk =... inside f: z = g(...) Environment of Calling Function Calling Sequence push Assign argument temporaries to function parameters. x = _tk New frame pushed Environment of Called Function Return Sequence II k: call m z = _ret_val Store next address k in top stack frame as _ret_addr and jump to m.... Other Code... Return Sequence I m: Code for Called Function g return y Find value of y and store as _ret_val in SF of caller, pop the stack, and jump to _ret_addr.

29 IC Calling and Return Sequences for Function Calls Example: Source Program def f(x) { n = x + 1; n = n * 2; return n; (Val 2)) y = 2; n = 3; z = f(y+n); print z; return 0;

30 IC Calling and Return Sequences for Function Calls Example: Source Program Setup RTS and call main: def f(x) { n = x + 1; n = n * 2 ; return n; Code for f: 2 First part of return sequence y = 2; n = 3; z = f(y+n); print z; return 0; Code for main: Calling sequence to transfer control from main to f. Second part of return sequence Return from main and halt.