1. Common Subexpression Elimination
Johnathon Jamison
CS265
S. Graham

2. Outline Titanium Def/Use analysis (used by CSE)
Common Subexpression Elimination
Implementation
Examples

3. 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

4. Def/Use Given: a = … … …a…
We want to link the use of a to the definition of a above.

5. 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

6. Def/Use The Titanium compile has def/use information available
It seems this could be leveraged for CSE

7. CSE
Given:
a = f * i …
b = f * i
We want to compute f * i only once

8. CSE We could do: a = f * i temp = a … b = temp
But only if the value of f * i has not changed

9. 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

10. 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

11. 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

12. 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

13. 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

14. 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

15. 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

16. 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

17. 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

18. 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

19. Examples

20. 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

21. 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?