Copy Propagation and Common Subexpression Elimination in Titanium Johnathon Jamison David Marin CS265 S. Graham.

Copy Propagation and Common Subexpression Elimination in Titanium

Johnathon Jamison

David Marin

CS265

S. Graham

Outline

• Titanium

• Def/Use analysis (used by CSE)

• Copy Propagation

• Common Subexpression Elimination

• Implementation

• Examples

Titanium

• Titanium is an extension of Java

• The Titanium compiler compiles Titanium code to C

• The C code is then compiled by the system compiler, e.g. gcc

Def/Use

• Given:

a = …

…

…a…

• We want to link the use of a to the definition of a above.

Def/Use

• Every use of a variable has a list of all possible definitions associated with it

• Every definition of a variable has a list of all possible uses associated with it

• Method calls and pointer indirection are included in this analysis

Def/Use

• The Titanium compile has (may) def/use information available

• It seems this could be leveraged for Copy Propagation or CSE (rather than writing a whole new dataflow analysis)

Global Copy Propagation

• Given

a = b;

…

x = a + 1;

• We want to replace a with b on the last line, but we need to know that a and b are unchanged

• Def/use analysis isn’t quite enough (why?)

Inserting Fake Defs and Uses

• Add fake defs and uses so that def/use analysis gives us the info we need

b = b;

a = b;

…

newfaketemp = b;

x = a + 1;• We can use a similar technique to enable CSE.

CSE

• Given:

a = f * i

…

b = f * i

• We want to compute f * i only once

CSE

• We could do:

a = f * i

temp = a

…

b = temp

• But only if the value of f * i has not changed

Finding CSEs

a = f * i

…

b = f * i

• The second f * i can be eliminated if the definitions of f and i that are used are exactly the same as the first– Leverage our def/use analysis!

• But checking for that could be onerous

Finding CSEs

• So, lets create some fake definitions of f and i immediately before the first f * i

• Then, there is one explicit definition that can be traced to for checking the previously mentioned condition

Finding CSEs

f = f

i = i

a = f * i

…

b = f * i

• Thus, if f and i have the same definitions in both places, then the second f * i can be eliminated

Handing Global CSEs

• This is fine and dandy for straight line code, but what if you have:

a = f * i b = f * i

… …

c = f * i

Handing Global CSEs

• So, you need to see if f and i have the same definitions in all pairs of places where the common subexpression exists.

• I.e., does f or i have any definition that is not associated with a fake definition introduced by this analysis?

• If not, then an elimination can occur

Simultaneous CSEs

• The def/use analysis is expensive– You can not run the def use analysis for every

potential CSE

• Thus all CSEs should be analyzed simultaneously

• So, extra assignments are placed everywhere in the code a CSE could be

Simultaneous CSEs

• When tracing definitions, those introduced definitions must be explicitly ignored

• Trace back from a use

• If it is a definition associated with a CSE we are cool

• If it is an introduced one, pass through

• If it is neither, we can not use this

Altogether Now…

• Insert the extra assignments

• For every similar expression– At every site, try to eliminate this expression

• Delete the assignments, so as not to interfere with anything else

Interaction with Copy Propagation

• Any temps introduced are placed after the calculation, so that copy propagation can remove thema = f * i a = f * i

temp_1 = a… …b = f * i b = temp_1

temp_2 = b… …c = f * i c = temp_2

CSE Tidbits

• Compiler temps are placed at top level, as the live range of CSEs are unknown

• Associativity is accounted for

• Only binary and unary operations are done– Can be extended

Examples

Timings – Preliminary Results

• CSE alone seems to have negligable effect

• Global copy propagation gives a few percent increase

• CSE on top of global copy propagation gives a couple percent more