# 15

Shared by:
Categories
Tags
-
Stats
views:
0
posted:
12/18/2011
language:
pages:
23
Document Sample

```							            Copy Propagation

• What does it mean?
– Given an assignment x = y, replace later uses of x
with uses of y, provided there are no intervening
assignments to x or y.
• Similar to register coalescing, which eliminates copies
from one register to another.
• When is it performed?
– At any level, but usually early in the optimization
process.
• What is the result?
– Smaller code

1
Copy Propagation

• Local copy propagation
– Performed within basic blocks
– Algorithm sketch:
• traverse BB from top to bottom
• maintain table of copies encountered so far
• modify applicable instructions as you go

2
Copy Propagation
• Algorithm sketch for a basic block containing instructions i1, i2, ..., in
for instr = i1 to in
if instr is of the form 'res = opd1 op opd2'
flag = replace(opd1, instr) || replace(opd2, instr); /* no short-circuit */
if instr is of the form 'res = var'
flag = replace(var, instr); /* replaces var with var2 */
if flag is true /* then we need to update the table */
if instr is of the form 'res = opd1 op opd2'
if the table contains any pairs involving res, remove them
if instr is of the form 'res = var'
insert {(res, var2)} in the table
endfor

replace(opd, instr)
if you find (opd, x) in table /* use hashing for faster access */
replace the use of opd in instr with x
return true
return false                                                             3
Copy Propagation
b=a
c=b+1
Example: Local copy propagation on basic block:                 d=b
b=d+c
b=d
step    instruction        updated instruction          table contents

1        b=a               b=a                          {(b,a)}
2        c=b+1             c=a+1                        {(b,a)}
3        d=b               d=a                          {(b,a), (d,a)}
4        b=d+c             b=a+c                        {(d,a)}
5        b=d               b=a                         {(d,a), (b,a)}

Note: if there was a definition of 'a' between 3 and 4, then we would have
to remove (b,a) and (d,a) from the table. As a result, we wouldn't
be able to perform local copy propagation at instructions 4 and 5.
However, this will be taken care of when we perform global copy      4
propagation.
Copy Propagation

•   Global copy propagation
–   Performed on flow graph.
–   Given copy statement x=y and use w=x, we can
replace w=x with w=y only if the following
conditions are met:
1.   x=y must be the only definition of x reaching w=x
–   This can be determined through ud-chains
•    there may be no definitions of y on any path from
x=y to w=x.
–   Use iterative data flow analysis to solve this.
» Even, better, use iterative data flow analysis to
solve both problems at the same time.

5
Copy Propagation

• Data flow analysis to determine which instructions
are candidates for global copy propagation
– forward direction
– gen[Bi] = {(x,y,i,p) | p is the position of x=y in block Bi and
neither x nor y is assigned a value after p}
– kill[Bi] = {(x,y,j,p) | x=y, located at position p in block
BjBi, is killed due to a definition of x or y in Bi }
– in[B]=out[P] where P is a predecessor
– Initialize in[B1]=, in[B]=U for BB1

6
Copy Propagation
entry                            entry

c=a+b              dead code?    c=a+b
d=c                              d=c
e=d*d                            e=c*c

f=a+c                            f=a+c
g=e                              g=e
a=g+d                            a=e+c
a<c                              a<c

h=g+1              f=d-g      h=e+1                f=c-e
f>a                             f>a

b=g*a                            b=e*a
h<f                              h<f

7
exit                             exit
Copy Propagation

• Copy propagation will not detect the opportunity
to replace x with y in the last block below:
z >0
Mini quiz: which optimization can handle this?
Answer: If we perform an optimization similar to
x=y       x=y
code hoisting (i.e. one that would move the copy
w=x+z
either up or down the graph) then copy
propagation will be able to update "w=y+z"

• Copy propagation may generate code that does not
need to be evaluated any longer.
– This will be handled by optimizations that perform
redundancy elimination.

8
Constant Propagation

• What does it mean?
– Given an assignment x = c, where c is a constant, replace
later uses of x with uses of c, provided there are no
intervening assignments to x.
• Similar to copy propagation
• Extra feature: It can analyze constant-value conditionals to
determine whether a branch should be executed or not.
• When is it performed?
– Early in the optimization process.
• What is the result?
– Smaller code
– Fewer registers

9
Redundancy Elimination

• Several optimizations deal with locating
and appropriately eliminating redundant
calculations.
• These optimizations require data flow
analysis
• They include
–   common subexpression elimination
–   loop-invariant code motion
–   partial-redundancy elimination
–   code hoisting

10
Common Subexpression
Elimination
• Local common subexpression elimination
– Performed within basic blocks
– Algorithm sketch:
• traverse BB from top to bottom
• maintain table of expressions evaluated so far
– if any operand of the expression is redefined, remove it
from the table
• modify applicable instructions as you go
– generate temporary variable, store the expression in it
and use the variable next time the expression is
encountered.
t=a+b
x=a+b                 x=t
...                   ...
y=a+b                 y=t                        11
Common Subexpression
Elimination
c=a+b                        t1 = a + b
d=m*n                        c = t1
e=b+d                        t2 = m * n
f=a+b                        d = t2
g=-b                         t3 = b + d
h=b+a                        e = t3
a=j+a                        f = t1
k=m*n                        g = -b
j=b+d                        h = t1 /* commutative */
a=-b                         a=j+a
if m * n go to L             k = t2
j = t3
a = -b
if t2 go to L
the table contains quintuples:
(pos, opd1, opr, opd2, tmp)
12
Common Subexpression
Elimination
• Global common subexpression elimination
– Performed on flow graph
– Requires available expression information
• In addition to finding what expressions are available at
the endpoints of basic blocks, we need to know where
each of those expressions was most recently evaluated
(which block and which position within that block).

13
Common Subexpression
Elimination
•   Global common subexpression elimination
–   Algorithm sketch:
For each block B and each statement x=y+z, s.t.
{y+z}in[B]
i.     Find the evaluation of y+z that reaches B, say w=x+y
ii.    Create temporary variable t
iii.   Replace [w=y+z] with [t=y+z; w=t]
iv.    Replace [x=y+z] with [x=t]
–   Notes:
•    This method will miss the fact that b and d have the
same value: a = x+y
c = x+y     Mini quiz: which optimization
can handle this?
b = a*z
Answer: Value Numbering
d = c* z                                  14
Common Subexpression Elimination
entry                entry

t1 = a + b
c = t1
c=a+b                d=a*c
d=a*c                t2 = d * d
e=d*d                e = t2

f=a+b                f = t1
c=c*2                c=c*2
c>d                  c>d

g=a*c        g=d*d   g=a*c        g = t2

g > 10               g > 10

exit                 exit          15
Loop-Invariant Code Motion
• What does it mean?
– Computations that are performed in a loop and have the
same value at every iteration are moved outside the loop.
• Before we go on: What is a loop?
– A set of basic blocks with
• a single entry point called the header, which dominates all
the other blocks in the set and
• at least one way to iterate (i.e. go back to the header)
– Block Bi dominates block Bj if every path from the flow
graph entry to Bj goes through Bi
– A loop can be identified by finding an flow graph edge
BjBi (called a back edge) s.t. Bi dominates Bj and then
finding all blocks that can reach Bj without going through
Bi

16
(Loops)
entry

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

B5           B6                B2         B3

B4
B7

B5    B6     B7
B8

B8
B9           B10
B9     B10     17
exit
(Loops)
entry

B1
back edge: B9B1
B2                 loop: {B9, B8, B7, B10, B6, B5, B4, B3, B2, B1}

B3                          back edge: B10B7
loop: {B10, B8, B7}
B4
back edge: B8B3
B5           B6          loop: {B8, B7, B10, B6, B5, B4, B3 }

B7                    back edge: B7B4
loop: {B7, B10, B6, B5, B8, B4}

B8
back edge: B4B3
loop: {B4, B7, B10, B8, B6, B5, B3}
B9           B10
18
exit
Loop-Invariant Code Motion
•   How do we identify loop-invariant computations?
–   Easy: use ud-chains
–   But also:
•   If an computation i depends on a loop-invariant computation j,
then i is also loop-invariant.
•   This gives rise to an inductive definition of loop-invariant
computations
•   An instruction is loop-invariant if, for each operand:
1. The operand is constant, OR
2. All definitions of that operand that reach the instruction
are outside the loop, OR
3. There is exactly one in-loop definition of the operand that
reaches the instruction, and that definition is loop
invariant

19
Loop-Invariant Code Motion
•       Algorithm sketch:
1.    Find all loop-invariant instructions
2.    For each instruction i: x=y+z found in step 1, check
i. that its block dominates all exits of the loop
ii. that x is not defined anywhere else in the loop
iii. that all uses of x in the loop can be reached only by i
(i.e. its block dominates all uses of x)
3.    Move each instruction i that satisfies the requirements in
step 2 to a newly created pre-header of the loop, making
certain that any operands (such as y, z) have already had
their definitions moved to the pre-header.
•       Note:
–     When applying loop-invariant code motion to nested loops,
work from the innermost loop outwards.

20
Loop-Invariant Code Motion

entry          Mini quiz: What happens if you perform
constant propagation followed by constant folding
b=2            after the loop-invariant code motion in this loop?
i=1

a = b+1
c=2
i mod 2 = 0

d=a+d       d = -c
e=1+d       f=1+a

i = i+1
a<2
F
T
21
exit
Loop-Invariant Code Motion

entry                  entry

b=2                   b=2
i=1                   i=1
a = b+1
c=2
t1 = a<2
a = b+1
c=2
i mod 2 = 0
i mod 2 = 0

d=a+d         d = -c   d=a+d           d = -c
e=1+d         f=1+a    e=1+d           f=1+a

i = i+1                i = i+1
a<2                    t1
F                     F
T                      T
22
exit                    exit
entry
entry

b=2
i=1                                                   b=2
a = b+1             after constant propagation        i=1
c=2                 and constant folding              a=3
t1 = a<2                                              c=2
t1 = false

i mod 2 = 0
i mod 2 = 0

d=a+d           d = -c
e=1+d           f=1+a                                 d=a+d            d = -c
e=1+d            f=1+a

i = i+1
t1                                                   i = i+1
t1
F
T                                             F

exit
exit            23

```
Related docs
Other docs by xiaoyounan
Technical data - SEW-EURODRIVE
Views: 98  |  Downloads: 1
TestMer_Szelepcs3
Views: 86  |  Downloads: 0
Te - DecVar_
Views: 54  |  Downloads: 0
TDS - Sew Clean
Views: 62  |  Downloads: 0
Tava izvēle_ - Rēzeknes Augstskola
Views: 70  |  Downloads: 0
Tautskola “Bārbele”
Views: 23  |  Downloads: 0
TAUTAS LAIKS - Jānis Lūsēns - [LV]
Views: 33  |  Downloads: 0