Compilation 2013 Basic Blocks and Traces

Transcription

1 Compilation 2013 Basic Blocks and Traces Erik Ernst Aarhus University

2 IR = Intermediate IR does not match either end perfectly Source: Translation non-trivial, e.g., using the static link Target: & CALL enable side-effects in expressions CJUMP has 2 targets, machine instructions fall through CALL puts returned value in specific register (RV) Why not just drop them? CALL in expression: needed for function : very convenient Strategy: Remove, move CALL 2

3 Idea: Require well-formed IR Trees Type Correct MOVE(TEMP t, ) (MOVE, TEMP t) Satisfies Constraints MOVE(MEM,CALL ) SEQ(MEM,SEQ(,SEQ )) MOVE(BINOP, TEMP s) Only a subset of type correct terms used 3

4 Canonical IR Trees Just ordinary IR trees, but well-formed Requirements: SEQ only topmost (will be removed using exp list) never used Parent of CALL is EXP( ) or MOVE(TEMP t, ) Created in module Canon signature CANON = sig val linearize: stm -> stm list val basicblocks: stm list -> (stm list list * Temp.label) val traceschedule: stm list list Temp.label -> stm list end structure Canon: CANON = struct... end 4

5 Technique: Rewriting Goal of linearize achieved by repeated rewrite Rewriting rules: Specify a from pattern, to be matched Specify a to pattern, to construct from match Correctness requirement: Every possible rewrite preserves the semantics one replaced IR tree by another will be IR tree 5

6 Rewriting 1 Purpose: Eliminate one node Matching: For given IR tree matching concrete nodes, bind subtrees to metavariables Construction: replace metavariables by their values s1 SEQ e s2 e s1 s2 6

7 Rewriting 2 Purpose: Move up BINOP op e2 s BINOP s e1 op e1 e2 MEM((s,e1)) JUMP((s,e1)) CJUMP(op,(s,e1),e2,l1,l2) (s,mem(e1)) (s,jump(e1)) SEQ(s,CJUMP(op,e1,e2,l1,l2)) 7

8 Rewriting 3 Purpose: Pull over operand BINOP MOVE op e1 TEMP e1 s BINOP s e2 t op TEMP e2 t CJUMP(op,e1,(s,e2),l1,l2) SEQ(MOVE(TEMP t,e1),seq(s,cjump(op,temp t,e2,l1,l2) 8

9 Rewriting 4 Purpose: Pull over operand for free BINOP s,e1 commute op e1 s BINOP s e2 op e1 e2 CJUMP(op,e1,(s,e2),l1,l2) s,e1 commute SEQ(s,CJUMP(op,e1,e2,l1,l2)) 9

10 Algorithm Doing the Rewriting Functions do handle deconstruct/reconstruct Functions reorder perform subtree transforms val reorderstm: exp list * (exp list -> stm) -> stm val reorderexp: exp list * (exp list -> exp) -> (stm*exp) fun dostm (T.JUMP(e,labs)) = reorderstm ([e], fn [e] => T.JUMP(e,labs)) dostm (T.CJUMP(p,a,b,t,f)) = reorderstm ([a,b], fn [a,b] => T.CJUMP(p,a,b,t,f)) dostm (T.MOVE(T.TEMP t, b)) = reorderstm ([b], fn [b] => T.MOVE(T.TEMP t, b))... and doexp (T.BINOP(p,a,b)) = reorderexp ([a,b], fn [a,b] => T.BINOP(p,a,b)) doexp (T.MEM(a)) = reorderexp ([a], fn [a] => T.MEM(a))... 10

11 On CALL Problem: A CALL returns result in register RV Why does CALL(f, CALL( ),CALL( )) not work? (unless we are careful) CALL(f,args)) Why does this solve the problem? (MOVE(TEMP t,call(f,args)),temp t) 11

12 After Rewriting 1-4 Stabilizes Eliminate SEQ: First rewrite SEQ to enforce list structure SEQ(SEQ(a,b),c)) Then replace SEQ by list constructor SEQ(a,SEQ(b,c)) SEQ(a,SEQ(b,c)) a::(b::c) fun linearize (stm0: stm): stm list = let definitions of reorderexp, reorderstm, doexp,.. fun linear (T.SEQ(a,b),l) = linear(a,linear(b,l)) linear (s,l) = s::l in linear(dostm stm0, nil) end 12

13 Basic Blocks Control flow: Studying program behavior with no regard to values, just movement (*JUMP, step) Basic block: Sequence of instructions w/o JUMP First statement: LABEL Last statement: [C]JUMP No other LABELs or [C]JUMPs Simple algorithm: at [C]JUMP: end current block; at LABEL: start new blk fixup: add blocks label at very beginning, JUMP to done label at very end Result: basic blocks can be freely reordered 13

14 Traces Trace: instruction sequence that could be executed consecutively (choice: CJUMP) We reorder such that CJUMP is followed by its false label, thus enabling fall through Pseudo-code algorithm: Put all blocks of the program into a list Q. while Q is not empty Start a new (empty) trace, call it T Remove the head element b from Q. while b is not marked Mark b; append b to the end of the current trace T. Examine the successors of b; if there is any unmarked successor c b := c end current trace T. 14

15 Traces May be Optimized All these are correct tracings for the same function prologue statements JUMP (NAME test) LABEL test CJUMP (>,i,n,done,body) LABEL body loop body statements JUMP(NAME test) LABEL done epilogue statements prologue statements JUMP (NAME test) LABEL test CJUMP(<=,i,N,done,body) LABEL done epilogue statements LABEL body loop body statements JUMP(NAME test) Count instructions for the loop Optimal traces: not this compiler prologue statements JUMP (NAME test) LABEL body loop body statements JUMP(NAME test) LABEL test CJUMP (>,i,n,done,body) LABEL done epilogue statements 15

16 Implementation File canon.sml available, fully implemented Has signature CANON (including linearize, basicblocks, traceschedule) Note warnings during compilation: canon.sml: Warning: match nonexhaustive e :: nil =>... canon.sml: Warning: match nonexhaustive a :: b :: nil =>... Not a problem ;-) Caused by using well-formed subset of type correct trees, carefully.. 16

17 Summary IR trees really intermediate: Not a perfect fit for source, nor for target For target: Eliminate & SEQ, move CALL, ensure parent EXP( ) or MOVE(TEMP t, ) Transformations: Move up, eliminate an, pull over expression, ditto for free Tricky algorithm: note deconstruct/reconstruct Protect register RV: Transform CALL Move CALL up to EXP/MOVE Basic blocks: find, then reorder into traces Translation to IR 17