Professional Documents
Culture Documents
O o o o
O o o o
Goals: encode knowledge about the program facilitate analysis facilitate retargeting facilitate optimization
LIR
optim
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?
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
IR classification: Level
High-level closer to source language used early in the process usually converted to lower form later on Example: AST
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.
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.
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
7
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
8
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
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 2 if t2 goto L1 i 1 t1 0 assgn, i add, t1 gt, t2 assgn, i 1 gt, t2
add, t1
2
10
Graphical IRs
Directed acyclic graphs (DAGs) Like compressed trees leaves: variables, constants available on entry internal nodes: operators
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
11
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.
12
Graphical IRs
Directed acyclic graphs (DAGs) Example m := 2 * y * z n := 3 * y * z p := 2 * y - z
13
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 more space and time
a single statement
14
Graphical IRs
Dependence graphs : they represents constraints on
Dependence = a relation between two statements that puts a constraint on their execution order. Control dependence
Based on the program's control flow. Based on the flow of data between statements.
Data dependence
Nodes represent statements Edges represent dependences Labels on the edges represent types of dependences
Graphical IRs
Dependence graphs Example:
s1 s2 s3 s4 s5 L1: a := b + c if a>10 goto L1 d := b * e e := d + 1 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 16 in the execution order, but is used in some optimizations.
s1
s2
s3
s4
s5
Basic blocks
2.
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 For each leader, its basic block consists of the leader and all the statements up to but not including the next leader.
17
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
18
Basic blocks
Leaders: 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 entry read(n) f0 := 0 f1 := 1 n <= 1 return n
i := 2 i<=n
f2 := f0+f1 f0 := f1 f1 := f2 i := i+1
return f2
exit
19
Linear IRs
Sequence of instructions that execute in order of
appearance Control flow is represented by conditional branches and jumps Common representations
20
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
21
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
22
Linear IRs
L1: i := 2 t1:= i+1 t2 := t1>0 if t2 goto L1 Quadruples (1) 2 (2) i st (1) (3) i + 1 (4) (3) > 0 (5) if (4), (1) Triples
23
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
Advantages: Simplifies data flow analysis & several optimizations SSA size is linear to program size Eliminates certain dependences (write-after-read, writeafter-write) Example: x := 5 x := 5
0
x := x +1 y := x * 2
x1 := x0 +1 y0 := x1 * 2
24
SSA form
Consider a situation where two control-flow paths
y := 5
y := 10
y0 := 5
y1 := 10
x := y
SSA form
The compiler inserts special join functions (called N-
y0 := 5
y1 := 10
y2 = N(y0, y1) x1 := y2
x1 := y2
26
SSA form
Example 2:
x := 0 i := 1 while (i<10) x := x+i i := i+1
x := 0 i := 1 x0 := 0 i0 := 1
i < 10
x := x + 1 i := i + 1
exit
x2 := x1 + 1 i2 := i1 + 1
exit
27
SSA form
B1 x0 := 0 i0 := 1
When and where do we add N
functions? Intuition:
B2
x2 := x1 + 1 i2 := i1 + 1
exit
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 N function for x should be placed in B3.
28
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
29
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.
30
entry
B1 B2 B3 B4 B5 B7 B8 B9
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 B6 B2 B3 B4 B5 B6 B7 B8 B9 B10
31
B10
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 BpA 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.
32
entry
Loops
back edge: B9pB1 loop: {B9, B8, B7, B10, B6, B5, B4, B3, B2, B1}
B1 B2 B3 B4 B5 B7 B8 B9
exit
back edge: B10pB7 loop: {B10, B8, B7} back edge: B8pB3 loop: {B8, B7, B10, B6, B5, B4, B3 } back edge: B7pB4 loop: {B7, B10, B6, B5, B8, B4} back edge: B4pB3 loop: {B4, B7, B10, B8, B6, B5, B3}
33
B6
B10
Nested Loops
Loop K is nested within loop L if L and K have different headers, P and O respectively, and P is dominated by O
34
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 N functions in them for any variables defined in B.
35
Dominance frontier
B0 B1 B2 B11 B3 B5 B6 B4 B7
The paths that converge to B8 have been marked. 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.
B8 B10
B9
36
Dominance frontier
The dominance frontier of a node B can be computed
as follows:
DF(B) = DFlocal(B) where:
U
C
DFup(C)
C is the set of children of B in the dominator tree DFup(C) is the set of nodes in the dominance frontier of C, that are not strictly dominated by C's immediate dominator DFlocal(B) are the successors of B that are not strictly dominated by B.
37
entry
1 2 1 3 4 5 7 2 {ex}
entry
exit
{ex}
7 {8}
up}
{2, ex} 39
exit
entry B0 B1 B2 B11 B3 B5 B6 B4 B7 B8
{B10}
entry B0
{}
B11
{B6}
B1
{B6, exit}
B6
{exit}
exit
B8 B10
B9
B2
B7
B10
{exit}
B3 exit
{B5}
B4
{B8}
B5
{B6}
B9
{B10}
40