1 Intermediate representation Goals: encode knowledge about the program facilitate analysis facilitate retargeting facilitate optimization scanning parsing semantic analysis HIR intermediate code gen. HIR optim LIR code gen. LIR

2 Intermediate representation Components code representation symbol table analysis information string table Issues Use an existing IR or design a new one? How close should it be to the source/target?

3 IR selection Using an existing IR cost savings due to reuse it must be expressive and appropriate for the compiler operations Designing an IR decide how close to machine code it should be decide how expressive it should be decide its structure consider combining different kinds of IRs

4 IR classification: Level High-level closer to source language used early in the process usually converted to lower form later on Example: AST

5 IR classification: Level Medium-level try to reflect the range of features in the source language in a language-independent way most optimizations are performed at this level algebraic simplification copy propagation dead-code elimination common subexpression elimination loop-invariant code motion etc.

6 IR classification: Level Low-level very close to target-machine instructions architecture dependent useful for several optimizations loop unrolling branch scheduling instruction/data prefetching register allocation etc.

7 IR classification: Level for i := op1 to op2 step op3 instructions endfor i := op1 if step < 0 goto L2 L1: if i > op2 goto L3 instructions i := i + step goto L1 L2: if i < op2 goto L3 instructions i := i + step goto L2 L3: High-level Medium-level

8 IR classification: Structure Graphical Trees, graphs Not easy to rearrange Large structures Linear Looks like pseudocode Easy to rearrange Hybrid Combine graphical and linear IRs Example: low-level linear IR for basic blocks, and graph to represent flow of control

9 Graphical IRs Parse tree Abstract syntax tree High-level Useful for source-level information Retains syntactic structure Common uses source-to-source translation semantic analysis syntax-directed editors

10 Graphical IRs Tree, for basic block* root: operator up to two children: operands can be combined Uses: algebraic simplifications may generate locally optimal code. L1: i := 2 t1:= i+1 t2 := t1>0 if t2 goto L1 assgn, i add, t1 gt, t2 2 i 1 t1 0 2 assgn, i 1 add, t1 0 gt, t2 *straight-line code with no branches or branch targets.

11 Graphical IRs Directed acyclic graphs (DAGs) Like compressed trees leaves: variables, constants available on entry internal nodes: operators annotated with variable names? distinct left/right children Used for basic blocks (DAGs don't show control flow) Can generate efficient code. Note: DAGs encode common expressions But difficult to transform Good for analysis

12 Graphical IRs Generating DAGs Check whether an operand is already present if not, create a leaf for it Check whether there is a parent of the operand that represents the same operation if not create one, then label the node representing the result with the name of the destination variable, and remove that label from all other nodes in the DAG.

13 Graphical IRs Directed acyclic graphs (DAGs) Example m := 2 * y * z n := 3 * y * z p := 2 * y - z

14 Graphical IRs Control flow graphs (CFGs) Each node corresponds to a basic block, or part of a basic block, or may need to determine facts at specific points within BB a single statement more space and time Each edge represents flow of control

15 Graphical IRs Dependence graphs : they represents constraints on the sequencing of operations Dependence = a relation between two statements that puts a constraint on their execution order. Control dependence Based on the program's control flow. Data dependence Based on the flow of data between statements. Nodes represent statements Edges represent dependences Labels on the edges represent types of dependences Built for specific optimizations, then discarded

16 Graphical IRs Dependence graphs Example: s1a := b + c s2 if a>10 goto L1 s3d := b * e s4e := d + 1 s5 L1: d := e / 2 control dependence: s3 and s4 are executed only when a<=10 true or flow dependence: s2 uses a value defined in s1 This is read-after-write dependence antidependence: s4 defines a value used in s3 This is write-after-read dependence output dependence: s5 defines a value also defined in s3 This is write-after-write dependence input dependence: s5 uses a value also uses in s3 This is read-after-read situation. It places no constraints in the execution order, but is used in some optimizations. s1s2s3s4s5

17 Basic blocks Basic block = a sequence of consecutive statements in which flow of control enters at the beginning and leaves at the end without halt or possibility of branching except at the end. Partitioning a sequence of statements into BBs 1. Determine leaders (first statements of BBs) The first statement is a leader The target of a conditional is a leader A statement following a branch is a leader 2. For each leader, its basic block consists of the leader and all the statements up to but not including the next leader.

18 Basic blocks unsigned int fibonacci (unsigned int n) { unsigned int f0, f1, f2; f0 = 0; f1 = 1; if (n <= 1) return n; for (int i=2; i<=n; i++) { f2 = f0+f1; f0 = f1; f1 = f2; } return f2; } read(n) f0 := 0 f1 := 1 if n<=1 goto L0 i := 2 L2:if i<=n goto L1 return f2 L1:f2 := f0+f1 f0 := f1 f1 := f2 i := i+1 go to L2 L0:return n

19 Basic blocks read(n) f0 := 0 f1 := 1 if n<=1 goto L0 i := 2 L2:if i<=n goto L1 return f2 L1:f2 := f0+f1 f0 := f1 f1 := f2 i := i+1 go to L2 L0:return n Leaders: read(n) f0 := 0 f1 := 1 n <= 1 i := 2 i<=n return f2f2 := f0+f1 f0 := f1 f1 := f2 i := i+1 return n exit entry

20 Linear IRs Sequence of instructions that execute in order of appearance Control flow is represented by conditional branches and jumps Common representations stack machine code three-address code

21 Linear IRs Stack machine code Assumes presence of operand stack Useful for stack architectures, JVM Operations typically pop operands and push results. Advantages Easy code generation Compact form Disadvantages Difficult to rearrange Difficult to reuse expressions

22 Linear IRs Three-address code Compact Generates temp variables Level of abstraction may vary Loses syntactic structure Quadruples operator up to two operands destination Triples similar to quadruples but the results are not named explicitly (index of operation is implicit name) Implement as table, array of pointers, or list

23 Linear IRs L1: i := 2 t1:= i+1 t2 := t1>0 if t2 goto L1 (1) 2 (2) i st (1) (3) i + 1 (4) (3) > 0 (5) if (4), (1) Quadruples Triples

24 SSA form Static Single Assignment Form Encodes information about data and control flow Two constraints: Each definition has a unique name Each use refers to a single definition all uses reached by a definition are renamed accordingly Advantages: Simplifies data flow analysis & several optimizations SSA size is linear to program size Eliminates certain dependences (write-after-read, write- after-write) Example: x := 5 x := x +1 y := x * 2 x 0 := 5 x 1 := x 0 +1 y 0 := x 1 * 2

25 SSA form Consider a situation where two control-flow paths merge (e.g. due to a loop, or an if-statement) read(x) if ( x > 0) y:= 5 else y:=10 x := y y := 5y := 10 x := y read(x) x > 0 y 0 := 5y 1 := 10 x 1 := y read(x 0 ) x 0 > 0 should this be y 0 or y 1 ?

26 SSA form The compiler inserts special join functions (called  - functions) at points where different control flow paths meet. y 0 := 5y 1 := 10 y 2 =  (y 0, y 1 ) x 1 := y 2 read(x 0 ) x 0 > 0  is not an executable function! If we do need to generate executable code from this form, we insert appropriate copy statements in the predecessors: y 0 := 5 y 2 := y 0 y 1 := 10 y 2 := y 1 x 1 := y 2

27 SSA form Example 2: x := 0 i := 1 while (i<10) x := x+i i := i+1 i < 10 exit x := x + 1 i := i + 1 x := 0 i := 1 x 1 :=  (x 0, x 2 ) i 1 :=  (i 0, i 2 ) i 1 < 10 exit x 2 := x i 2 := i x 0 := 0 i 0 := 1

28 SSA form When and where do we add  functions? Intuition: There is a definition of x in B1 and another in B2 There is a path from B1 to B3 There is a path from B2 to B3 B3 is the first "common" node in these two paths. A  function for x should be placed in B3. x 1 :=  (x 0, x 2 ) i 1 :=  (i 0, i 2 ) i 1 < 10 exit x 2 := x i 2 := i x 0 := 0 i 0 := 1 B1 B2 B3

29 SSA form A program is in SSA form if Each variable is assigned a value in exactly one statement Each use of a variable is dominated by the definition. Domination Node A dominates node B if every path from the flow graph entry to B goes through A Every node dominates itself Intuition: control will have to go through A in order to reach B Dominators are useful in identifying loops and in computing the SSA form.

30 Dominators A node N may have several dominators, but one of them will be closest to N and be dominated by all other dominators of N. That node is called the immediate dominator of N. The dominator tree is a data structure that shows the dominator relationships of a control flow graph. Each node in the tree is the immediate dominator of its children.

31 B1 B2 B3 B4 B5B6 B7 B8 B9B10 entry exit The dominator tree shows the dominator relation: each node in the tree is the immediate dominator of its children. Example: B7 is dominated by B1, B3, and B4, but its immediate (closest) dominator is B4 Note: B5 does not dominate B7 because we can go from the entry to B7 through the B6 path. B1 B2B3 B4 B5B6B7 B8 B9B10

32 Dominators and loops We can use dominators to identify the loops in a flow graph: Natural Loop = A set of basic blocks with a single entry point called the header, which dominates all other blocks in the set, and at least one way to iterate (i.e. go back to the header) Loop-finding algorithm: Find an edge B  A where A dominates B. This is called a back-edge. Add A and B to the loop Find all nodes that can reach B without going through A. Add them to the loop.

33 Loops back edge: B9  B1 loop: {B9, B8, B7, B10, B6, B5, B4, B3, B2, B1} B1 B2 B3 B4 B5B6 B7 B8 B9B10 entry exit back edge: B10  B7 loop: {B10, B8, B7} back edge: B8  B3 loop: {B8, B7, B10, B6, B5, B4, B3 } back edge: B7  B4 loop: {B7, B10, B6, B5, B8, B4} back edge: B4  B3 loop: {B4, B7, B10, B8, B6, B5, B3}

34 Nested Loops Loop K is nested within loop L if L and K have different headers, and  respectively, and is dominated by 

35 Dominators and SSA form Dominators can be used in a more efficient computation of the SSA form. Node A strictly dominates node B if A dominates B and A  B. The dominance frontier of a node B is the set of all nodes X such that B does not strictly dominate X B dominates a predecessor of X Intuition: The nodes in the dominance frontier of B are destinations of the edges that leave an area dominated by B. Since those destinations are not dominated by B, there must be some other path from the entry to them. Therefore, they must be convergence points, and we need to place  functions in them for any variables defined in B. Y is a successor of X if there is an edge X  Y in the flow graph.

36 Dominance frontier B1 B2 B3B4 B5 B0 B6 B7 B8 B9 B10 B11 B2 dominates B3, B4, and B5. B2 does not dominate B6 or B8, but does dominate their predecessors. B6 and B8 are the dominance frontier of B2. The paths that converge to B8 have been marked. For each variable definition in B2, insert a  function in B6 and in B8.

37 Dominance frontier The dominance frontier of a node B can be computed as follows: DF(B) = DF local (B) U DF up (C) where: C is the set of children of B in the dominator tree DF up (C) is the set of nodes in the dominance frontier of C, that are not strictly dominated by C's immediate dominator DF local (B) are the successors of B that are not strictly dominated by B. U C

38 Dominance frontier algorithm compute the dominator tree for each X in a bottom-up traversal of the tree, do DF(X) := { } for each Y  Succ (X) do if (idom (Y)  X) then DF(X) := DF(X)  {Y} end for for each Z in children(X) do for each W  DF(Z) do if (idom (W)  X) then DF(X) := DF(X)  {Y} end for DF local  DF up

exit entry 1 exit {2, ex} {9, 2, ex} {11} {2, ex} {6}{6}{8}{8} {8}{8} {8}{8} {ex} {local,  up} {6}{6}

40 B1 B2 B3B4 B5 B0 B6 B7 B8B9 B10 B11 entry exit entry B0 B11B6B1 B2 exit B7B8 B3B4B5B9 B10 {B5}{B8}{B6}{B10} {exit} {B8, B6} {B10}{B8, B10} {B6} {B6, exit} {exit} {}