Common Subexpression Elimination Johnathon Jamison CS265 S. Graham

Outline Titanium Def/Use analysis (used by CSE) 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 def/use information available It seems this could be leveraged for 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 them a = 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

Local CSE Used Muchnick’s algorithm (described in class) Used defs to find what was killed Fully implemented Except method calls Since we are using defs already, why not so something more substantial?