Administration. Where we are. Canonical form. Canonical form. One SEQ node. CS 412 Introduction to Compilers

Transcription

1 Administration CS 412 Introduction to Compilers Andrew Myers Cornell University Lecture 15: Canonical IR 26 Feb 01 HW3 due Friday Prelim 1 next Tuesday evening (7:30-9:30PM) location TBA covers topics up through this lecture lexical, syntactic analysis type checking and static semantics syntax-directed translation and IR 2 Where we are source code parsing abstract syntax tree (HIR) syntax-directed translation intermediate code (MIR) syntax-directed translation canonical intermediate code (MIR) code generation abstract assembly code (LIR) register allocation assembly code 3 Intermediate code has general tree form easy to generate from AST, but... Hard to translate directly to assembly assembly code is a sequence of statements Intermediate code (IR) has nodes corresponding to assembly statements deep in expression trees : all statements brought up to top level of tree generate assembly directly 4 One node In canonical form, only one node at the very top of tree s 1 s 2 s 3 s 4 s 5... Function body is just a list of statements: (s 1,s 2,s 3,s 4,s 5, ) Can translate to assembly by translating each s i to assembly statement(s) and concatenating Idea: rewrite IR to get rid of constructs incompatible with assembly code arbitrarily deep expression trees deal with this later as part of instruction tiling E & CALL nodes rewrite tree so no E nodes, CALLs moved to top CJUMPis two-way jump rather than fall-through convert to one-way jumps 5 6 1

2 no E nodes Enodes put a statement node underneath an expression: s E S x = a[(i = i+1)] = Problem: statement can have arbitrary number of side effects; assembly can t : no E nodes similar to: x = a[(i = i+1)] i=i+1; x=a[i]; 7 e Top-level CALL statements CALLnodes have arbitrary side effects CALLnode deep in expression tree will break translation to assembly Example: x = f(g(x) + h(y)) Solution: move to top level Call that discards return result: Call that uses result: EXP CALL TEMP(t) CALL 8 Canonical tree has top-level node with following kinds of children: (dest, e) (TEMP(t), CALL( )) EXP(CALL( )) JUMP(e) CJUMP(e, l 1, l 2 ) LABEL(l) Code is a just sequence of these statements Straightforward translation to assembly 9 Simplifying a function body Last time: translate a function definition f(a 1,, a n ) = e as ( (TEMP(RV), E e ), LABEL(epilogue)) : node with all of T ((TEMP(RV), E e ), LABEL(epilogue)) as children. s 1 s 2 s 3 s 4 s Example Canonical MIR to LIR x = a[(i = f(y))] parsing, intermediate code generation TEMP(x) MEM ADD TEMP(a) MUL 4 E TEMP(t1) TEMP(t1) CALL TEMP(i) TEMP(t1) NAME(f) TEMP(y) 11 Canonical IR TEMP(t1) CALL NAME(f) TEMP(y) Abstract assembly code push y call f mov t1, rv TEMP(i) TEMP(t1) mov i, t1 TEMP(x) MEM ADD TEMP(a) MUL 4 TEMP(t1) mov x, [a + 4*t1] 12 2

3 E rewriting Want to move E nodes up to top of tree where they can become nodes Idea: define syntax-directed rules that take an IR tree and move E nodes to top. Goal: avoid ripping apart expressions more than necessary -- leads to better code because expression patterns can be recognized and mapped to instruction set E rewrite rules Example transformations: E(s1, E(s2, e)) E((s1, s2), e)) (E(s1, e), dest) (s1, (e, dest)) OP(E(s1, e1), e2) E(s1, OP(e1, e2)) OP(e1, E(s1, e2)) Rewriting expressions OP(e1, E(s1, e2)) OP E e1 E s1 OP s1 e2 e1 e2 e1 + ( a=0; e2 ) ( a=0; e1 + e2 ) Implementation options Option 1: Walk over tree looking for places to apply rewrite rules bad nodes (E, CALL) percolate upward, eventually disappear Problem: may need to restart tree traversal at every rewrite Option 2: Rewrite whole IR tree in one pass to build canonical IR tree Syntax-directed translation! General case When we move all E nodes to top, arbitrary expression node e looks like: E Transformation returns list of sub-statements s i plus final eʹ expression eʹ eachs i has at most one side-effect eʹ is free of side effects. s 1 s 2 s 3... Arbitrary statement node becomes a new node with no E nodes (or list of substatements s i ) eachs i has at most one side-effect s 1 s 2 s IR simplification Interface class CanonicalExpr { IRStmt[ ] pre_stmts; IRExpr expr; } } class CanonicalStmt { IRStmt[ ] stmts; } abstract class IRExpr { CanonicalExpr simplify(); } abstract class IRStmt { IRStmt[ ] simplify( ); } 18 3

4 Simplification Two translation functions: T e gives a list of canonical statements s i and a canonical expression eʹ where executing the s i and then evaluating e has same side effects and value as e (IRExpr.simplify) T e = (s 1,, s n ) ; e T s gives a list of canonical statements s i such that executing the s i has same side effects as s (= IRStmt.simplify) T s = (s 1,, s n ) 19 Rules Simplify arbitrary expression e: T e = (s 1, s 2, s 3, ) ; eʹ Goal: define T e and T s for all 13 node types 3 trival cases: T CONST(i) = ( ) ; CONST(i) T NAME(n) = ( ) ; NAME(n) T TEMP(t) = ( ) ; TEMP(t) Already in canonical form! 20 JUMP, CJUMP, MEM JUMP(e), CJUMP(e, l 1, l 2 ), MEM(e) Need to make sure e is canonical T JUMP(e) = (s 1,, s n, JUMP(eʹ)) if T e = (s 1,, s n, ) ; eʹ Similarly for CJUMP Can write as inference rule: T MEM(e) = (s 1,, s n ) ; MEM(eʹ) E How to simplify an expression E(s, e) T E(s, e) = (s, s 1,, s n ) ; eʹ Correct E rule T s = (sʹ1,, sʹm ) T E(s, e) = (sʹ1,, sʹm, s 1,, s n ) ; eʹ Assuming T e, T s produce canonical statements s i, sʹj and canonical expression e, T E(s, e) works properly. nodes How to get rid of nodes: concatenate canonical versions of all sub-statements T s 1 = (s 1,, s m ) T s 2 = (s 1,, s n ) T (s 1, s 2 ) = (s 1,, s m, s 1,, s n )

5 EXP EXP(e) evaluates e for its side effects, discards value Simplified IR does same: T e = (s 1,, s n ) ; eʹ T EXP(e) = (s 1,, s n ) Translating binary operators T e 1 = (s 1,, s m ) ; eʹ1 T e 2 = (sʹ1,, sʹn) ; eʹ2 T OP(e 1, e 2 ) = (s 1,.., s m, sʹ1,,sʹn) ; OP(eʹ1, eʹ2) When does this rule work Note: OP allows either e 1 or e 2 to be evaluated first Translating binary operators Previous rule works if eʹ1 commutes with each of sʹi or eʹ2 commutes with each of sʹi Idea: save value of e 1 in a temporary before executing all the side effects of e 2 T e 1 = (s 1,, s m ) ; eʹ1 T e 2 = (sʹ1,, sʹn) ; eʹ2 T OP(e 1, e 2 ) = (s 1,.., s m, (TEMP(t), eʹ1), sʹ1,,sʹn) ; OP(TEMP(t), eʹ2) Works, but: Introduces extra register t No opportunity to do eʹ1 and eʹ2 in one instruction 27 Reordering Statement s and expression e commute if executing s does not change result of e. False if: s overwrites any TEMP used by e s overwrites any MEM location that might be the same location as (alias) a MEM in e conservative assumption: all memory locations may alias one another less conservative: use alias analysis to determine which memory locations may alias 28 CALL nodes CALLnodes call a function; may have side effects overwrites return value register at least can t be operand at assembly-code level CALLnodes must move to top T e f = (s 1,, s m ) ; e fʹ T e 1 = (s 1ʹ,, s nʹ) ; e 1ʹ T CALL(e f, e 1 ) = (s 1,, s m, sʹ1,, sʹn, (TEMP(t), CALL(e fʹ, eʹ1)); TEMP(t) Canonical intermediate code Syntax-directed translation function T simplifies an IR tree into canonical form Yields recursive implementation of IRStmt.simplify, IRExpr.simplify : IR is a sequence of simple IR statements ready for translation to assembly Assumes e fʹ commutes with sʹ1,, sʹn Iota, C: operands may be reordered freely