Code Generation and Optimisation. Local variables and procedures

Transcription

1 Code Generation and Optimisation Local variables and procedures

2 Motivation Procedures allow programmers to: abstract a general routine from a specific instance; reuse this routine many times. procedure factorial(n)(r) ( r := 1; while (n > 0) (r := n*r ; n := n-1) ); call factorial(3)(a); call factorial(2*2)(b); print a+b

3 LOCAL VARIABLES Before looking at procedures, it is useful to consider a simpler, related concept: local variables.

4 Local variables A declare statement declare v 1,, v n in s introduces n local variables v 1 v n within the scope of statement s. Modifications of v 1 v n inside s are observable only within s. Variables v 1 v n that are in scope outside s cannot be modified by s.

5 Exercise 1 What outputs are emitted when the following program is executed? x := 0; y := 0; declare x in ( x := 5; print x; y := y+1 ); print x; print y

6 Syntax Let v * denote a comma-separated list of v. s ::=... declare v * in s Concrete syntax data Stm =... Declare(String, Stm) Abstract syntax The abstract syntax allows only one variable to be introduced at a time, but: declare x, y, z in... declare x in ( declare y in ( declare z in... ))

7 Semantics To execute a statement declare v in s save the value of v, execute s, and then restore v to its original value. exec :: (Env, Stm) -> (Env, Output) exec(env, Declare(v, s)) = (env 2, out) where original = env!v (env 1, out) = exec(env, s) env 2 = insert(env 1, v, original) Semantics of declare statements

8 Run-time stack To implement the save and restore mechanism, the compiler uses a run-time stack with the following psuedo-instructions. push r subi $sp, $sp, 4 store r, $sp, 0 Push the value of a register r onto the stack. pop r load r, $sp, 0 addi $sp, $sp, 4 Pop the top stack item into register r. Register $sp points to the top stack item. The stack grows downwards.

9 Run-time stack The psuedo-instructions are easily encoded in the abstract syntax: push :: Reg -> [Instr] push(r) = [ OPI("$sp", "$sp", Sub, 4), STORE(r, "$sp", 0) ] Push the value of a register onto the stack. pop :: Reg -> [Instr] pop(r) = [ LOAD(r, "$sp", 0), OPI("$sp", "$sp", Add, 4) ] Pop the top stack item into a register.

10 Compilation To compile a statement declare v in s push v onto the stack, execute s, and then pop the stack into v. compilestm :: Stm -> [Instr] compilestm(declare(v, s)) = push(v) ++ compilestm(s) ++ pop(v) Compilation of declare statements.

11 Example Compiler x := 1; declare x in ( x := 2; print x ); print x li x, 1 push x li x, 2 print x pop x print x

12 Exercise 2 Give the contents of the run-time stack at lines 7 and 9. 1 x := 0; 2 y := 0; 3 declare x in ( 4 x := 1; 5 y := 2; 6 declare x, y in ( 7 x := 3 8 ); 9 skip 10 )

13 Possible optimisation The push and pop instructions can be discarded when the local variable being declared is not liveout of the declare statement. declare x in ( x := 2; print x ); x := 10; push x li x, 2 print x pop x li x, 10 But this is not implemented in the Tower compiler.

14 SEMANTICS OF PROCEDURES procedure: a set of instructions for a computer that has a name by which it can be called into action. Webster s Dictionary

15 Concrete syntax A procedure has a name p, input and output parameters, and a body. proc ::= procedure p ( v * ) ( v * ) ( s ) Ins Outs Body A program is a series of zero or more procedures, terminated by a main statement. prog ::= proc ; prog s

16 Abstract syntax A procedure is: a list of input parameters, a list of output parameters, and a body. type Proc = ([String], [String], Stm) A program is: a mapping from procedure names to procedures, and a main statement. type Prog = (Map String Proc, Stm)

17 Syntax of calls A procedure call provides a list of input expressions and a list of variables in which the outputs are to be stored. s ::=... call p ( e * ) ( v * ) Concrete syntax data Stm =... Call(String, [Exp], [String]) Abstract syntax

18 Informal semantics Consider a procedure p with m input parameters, n output parameters, and body s. procedure p(i 1,..., i m )(o 1,..., o n ) ( s ) Parameters i 1 i m and o 1 o n are local variables within the scope of the statement s.

19 Informal semantics When p is called, call p(e 1,..., e m )(v 1,..., v n ) the body of p is executed in a state where parameters i 1 i n contain the values of the expressions e 1 e n. When p returns, the caller continues in a state where variables v 1 v n have the values of p s output parameters o 1 o n.

20 Informal semantics From the caller's perspective, the only variables that may have been modified as a result of the call are: variables v 1 v n ; any variables that are not local to the body of p.

21 Exercise 3 What outputs are emitted when the following program is executed? procedure quad(a)(b) ( a := 2*a; b := 2*a ); a := 10; b := 20; call quad(2)(r); print a; print b; print r

22 Semantics of calls If procedure p is defined as procedure p(i 1,...,i m )(o 1,..., o n ) (s) then to execute a statement call p(e 1,, e m )(v 1 v n ) let locals be the set ({i 1 i m } {o 1 o n }) {v 1 v n }, and perform the following steps: save locals on the stack, bind i 1 i m to the values of e 1 e m, execute the body of p, bind v 1 v n to o 1 o n, restore locals from the stack.

23 COMPILING PROCEDURES

24 In-lining One way to compile a call to procedure p is to inline the body of p in the caller. procedure double(x)(y) ( y := x+x ); call double(2)(z) push x push y li x, 2 add y, x, x move z, y pop y pop x

25 Recursion However, a procedure may contain a call to itself. procedure fib(n)(r) ( declare a, b in ( if n <= 1 then ( r := 1 ) else ( call fib(n-1)(a); call fib(n-2)(b); r := a + b ) ) ); Therefore the in-lining method is only possible when compiling nonrecursive procedures.

26 Return addresses To call a procedure p, we can jump to the code for p, execute it, and then jump back (return) to the caller. Since p may be called from many different places, the return address is not constant. We need support for indirect jumps in our target language.

27 Indirect jumps instr ::=... la r, label (Load address) jumpr r (Indirect jump) Concrete syntax of indirect jumps. data Instr =... LA(Reg, Label) {- r a -} JUMPR(Reg) {- goto r -} Abstract syntax of indirect jumps.

28 Example revisited A convenient place to store the return address is on the stack. procedure double(x)(y) ( y := x+x ); call double(2)(z) Push and jump push x push y li x, 2 la tmp, return push tmp jump double return: move z, y pop y pop x halt double: add y, x, x pop ret jumpr ret Pop and return

29 Push and jump Generate code to push return address onto the stack and jump to target. pushandjump :: String -> [Instr] pushandjump(p) = [LA(tmp, return)] ++ push(tmp) ++ [JUMP(p)] ++ [LABEL(return)] where tmp = fresh() return = fresh()

30 Pop and return Generate code to pop return address and jump to it. compileproc :: (String, Proc) -> [Instr] compileproc(p, (ins, outs, body)) = [LABEL(p)] ++ compilestm(body) ++ pop(r) ++ [JUMPR(r)] where r = fresh() Compilation of procedures.

31 Simultaneous assignment Consider the following program. procedure p(x, y)(z) (...); x := 1; y := 2; call p(y, x)(r) We need to assign p's input parameters to the expressions supplied by the caller. Easy? x := y; y := x Wrong! Both input parameters are assigned value 2. The assignments must be simultaneous.

32 Simultaneous assignment Generate code to assign the values of e 1...e n to variables x 1...x n, simultaneously with the use of temporary variables. assign :: ([String], [Exp]) -> [Instr] Example: assign([x 1,x 2 ], [e 1,e 2 ]) gives code with the effect: t 1 := e 1 t 2 := e 2 x 1 := t 1 x 2 := t 2

33 Compiling calls compilestm(call(p, es, vs)) = {- Save p s locals -} concat([push(x) x <- locals]) {- Assign inputs -} ++ assign(ins, es) {- Push return address and jump -} ++ pushandjump(p) {- Assign outputs -} ++ assign(vs, [Var(o) o <- outs]) {- Restore p s locals -} ++ concat([pop(x) x <- reverse(locals)]) where (ins, outs, s) = procs!p locals = union(ins, outs) \\ vs Compilation of procedure calls.

34 Exercise 4 Show the run-time stack when execution reaches line (3). procedure fact(n)(x) ( (1) if n <= 1 then ( (2) x := 1 (3) ) else ( (4) call fact(n-1)(x); (5) x := n*x (6) ) (7) ); (8) n := 0; (9) x := 0; (10) call fact(3)(o) (11) Let Address(n) denote the return address of the call on line n.

35 Answer to Exercise 4 0 (n) 0 (x) Address(11) 3 (n) Address(5) 2 (n) Address(5) Bottom of stack Top of stack

36 Possible optimisation Saving and restoring variables local to a procedure p is not required when those variables are not live at the point where the p is called. procedure double(x)(y) ( y := x+x ); call double(2)(z); x := 0; y := 0 push x push y x := 2 z := y pop y pop x (The code for push and jump is elided.)

37 SUMMARY What have we learnt?

38 Summary Compiling local variables by save and restore to and from the runtime stack. Save and restore can often be avoided using liveness analysis. Compiling recursive procedures with in and out parameters.

39 Limitations and variations Some languages allow nested procedures. (Tower does not.) In some compilers, all parameters are passed via a stack. Tower tries to pass all parameters in registers, but accesses the stack when save and restore cannot be avoided; accesses spill-memory when registers are exhausted.

40 STATIC AND DYNAMIC SCOPING

41 Global variables What outputs are emitted when the following program is executed? procedure inc()() ( x := x + 1 ); x := 0; call inc()(); call inc()(); call inc()(); print x Variable x is a global variable.

42 Scoping What outputs are emitted when the following program is executed? procedure p()() ( declare x in ( x := 2; call q()() ) ); procedure q()() ( print x ); x := 1; call p()(); print x

43 Scoping Which x does the body of q refer to? procedure p()() ( declare x in ( x := 2; call q()() ) ); procedure q()() ( print x ); x := 1; call p()(); print x

44 Scoping Dynamic scoping: variable v refers to the most recently executed declaration of v at runtime. Static scoping: variable v refers to the innermost enclosing declaration of v in the source program.

45 Static renaming The Tower compiler implements dynamic scoping. However, static scoping semantics can be easily enforced by applying the static renaming transformation. declare v in s declare w in s[w/v] Where w is a fresh variable and s[x/y] is s with all in-scope occurrences of y replaced by x. Static renaming for declare statements.

46 Static renaming procedure p(v 1,, v m )(w 1,, w n ) (s) procedure p(a 1,, a m )(b 1,, b n ) ( s[a 1,,a m,b 1,,b n / v 1,,v m,w 1,,w n ] ) Where a 1,,a m,b 1,,b n are fresh variables and s[x 1,,x n /y 1,,y n ] is s with all in-scope occurrences of y 1,,y n replaced by x 1,,x n. Static renaming for procedures.

47 Example Static renaming transformation: procedure p()() ( declare x in ( x := 2; call q()() ) ); procedure q()() ( print x ); x := 1; call p()(); print x procedure p()() ( declare a in ( a:= 2; call q()() ) ); procedure q()() ( print x ); x := 1; call p()(); print x

48 APPENDIX Formal semantics of procedure calls

49 Semantics of binding Given environment env, variables v 1 v n and values x 1...x n, return a new environment where v i has value x i for all i in {1 n}. bind :: (Env, [String], [Int]) -> Env bind(env, vs, xs) = case (vs, xs) of (v:vs, x:xs) -> bind(insert(env, v, x), vs, xs) other -> env Binding variables to values.

50 Formal semantics of procedure calls exec :: (Env, Stm) -> (Env, Output) exec(env, Call(p, xs, ys)) = (env 4, out) where (ins, outs, body) = procs!p locals = union(ins, outs) \\ ys saved = [env!v v <- locals] env 1 = bind(env, ins, [eval(env, x) x <- xs]) (env 2, out) = exec(env 1, body) env 3 = bind(env 2, ys, [env 2!o o <- outs]) env 4 = bind(env 3, locals, saved) Semantics of procedure calls.