Common Subexpression Elimination

1. Common Subexpression Elimination Johnathon Jamison CS265 S. Graham

2. Titanium • Titanium is a compiler

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

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

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

6. Def/Use • The link should be of every possible definition of a • Thus method calls or pointer indirection could define a

7. Def/Use • Titanium has def/use information available • Every use of a variable has a list of all possible definitions associated with it • It seems this could be leveraged for CSE

8. CSE Revisited • 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 • But checking for that could be onerous

9. CSE Revisited • 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

10. CSE Revisited • 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

11. CSE Revisited • This is fine and dandy for straight line code, but what if you have: • a = f * i b = f * i • … … • --------------------------- • V • c = f * i

12. CSE Revisited • 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 def introduced by this analysis? • If not, then an elimination can occur

13. CSE Revisited • This is complicated by the fact that all CSEs are done simultaneously • So, extra assignments are placed everywhere in the code a CSE could be • Therefore, when tracing defs, those introduced defs must be explicitly ignored

14. CSE Tidbits • After completion, these assignments are deleted, so as not to interfere with anything else • Any temps introduced are placed after the calculation, so that copy propagation can remove them • Compiler temps are placed at top level, as the live range of CSEs are unknown • Associatively is accounted for • Only binary and unary operations are done

15. CSE Examples

16. Timings

17. Local CSE • Used the standard Muchnik (sp?) algorithm • Used defs to find what was killed • Fully implemented • Except method calls