x := 11; if (x == 11) { DoSomething(); } else { DoSomethingElse(); x := x + 1; } y := x; // value of y? Phase ordering problem Optimizations can interact in mutually beneficial ways, and no order exploits all of these interactions. Classic example: constant propagation and unreachable code elimination. x := 11; DoSomething(); y := x; // value of y? x := 11; DoSomething(); y := 11; const prop followed by unreachable code elimination const prop again true

One known solution: Iterate individual analyses until the results don’t change x := 11; do { if (x == 11) { DoSomething(); } else { DoSomethingElse(); x := x + 1; } } while (...) y := x; // value of y? Compiler is slow. In the presence of loops in the source program, might not yield best possible results.

Another known solution: hand written super-analysis Lose modularity: –difficult to write, reuse, and extend such analyses Examples: –conditional constant propagation [Wegman and Zadeck 91] –class analysis, splitting and inlining [Chambers and Ungar 90] –const prop and pointer analysis [Pioli and Hind 99] Monolithic Super-Analysis

Ideally we want to: –Write analyses modularly –Exploit mutually beneficial interactions –Have a fast compiler We present a framework that achieves this. Composition Framework

The key to modular composition Traditionally, optimizations are defined in two parts: 1.A dataflow analysis. 2.Rules for transforming the program representation after the analysis is solved. The key insight is to merge these two parts: –Dataflow functions return either a dataflow value OR a replacement graph with which to replace the current statement.

Flow function returning a dataflow value y := 5

Flow function returning a dataflow value y := 5 [... ] [..., y → 5] PROPAGATE

Flow function returning a replacement graph y := x+2

[x → 3] Flow function returning a replacement graph y := x+2 [x → 3] REPLACE y := 5 Replacement graph Step 1: Initialize input edges with dataflow information

Flow function returning a replacement graph y := 5 [x → 3] PROPAGATE [x → 3, y → 5] Step 2: Perform recursive dataflow analysis on the replacement graph

Flow function returning a replacement graph y := 5 [x → 3] PROPAGATE [x → 3, y → 5] Step 3: Propagate dataflow information from output edges.

Flow function returning a replacement graph y := x+2 [x → 3] [x → 3, y → 5] Replacement graphs: –used to compute outgoing dataflow information for the current statement. Replacement graphs: –used to compute outgoing dataflow information for the current statement. –a convenient way of specifying what might otherwise be a complicated flow function.

Flow function returning a replacement graph y := x+2 [x → 3] [x → 3, y → 5] Soundness requirement: –Replacement graph must have the same concrete semantics as the original statement, but only on concrete inputs that are consistent with the current dataflow facts.

Flow function returning a replacement graph y := x+2 [x → 3] [x → 3, y → 5] Let’s assume we’ve reached a fixed point.

Flow function returning a replacement graph y := x+2 [x → 3] [x → 3, y → 5] y := 5 Let’s assume we’ve reached a fixed point.

Flow function returning a replacement graph y := 5 [x → 3] [x → 3, y → 5] Replacement graphs: –used to transform the program once a fixed point has been reached. Let’s assume we’ve reached a fixed point.

Iterative analysis example y := x+2 [x → 3, y → 5] [x → 3][x → T ] Now, let’s assume we haven’t reached a fixed point.

Iterative analysis example y := x+2 [x → 3, y → 5] PROPAGATE [x → 3][x → T ] [x → T, y → T ] Now, let’s assume we haven’t reached a fixed point.

Branch folding example if (x == 11) FT

Branch folding example if (x == 11) REPLACE [x → 11] FT

Branch folding example [x → 11]

Branch folding example if (x == 11) [x → 11] FT

Composing several analyses x := new C; do { b := x instanceof C; if (b) { x := x.foo(); } else { x := new D; } } while (...) class A { A foo() { return new A; } }; class C extends A { A foo() { return self; } }; class D extends A { }; Constant Propagation Class Analysis Inlining Unreachable code elimination

x := new C merge b := x instanceof C x := new Dx := x.foo() merge while(…) if (b) TF

x := new C b := x instanceof C x := new Dx := x.foo() if (b) PROPAGATE while(…) PROPAGATE [x → T ] [x → {C}] T merge TF PROPAGATE T

x := new C b := x instanceof C x := new Dx := x.foo() if (b) PROPAGATE while(…) PROPAGATE [x → T ] [x → {C}] T ([x → T ], [x → {C}], T, T ) merge PROPAGATE TF T

x := new C b := x instanceof C x := new Dx := x.foo() if (b) PROPAGATE ([x → T ], [x → {C}], T, T ) while(…) merge TF

x := new C b := x instanceof C x := new Dx := x.foo() if (b) while(…) PROPAGATE [x → T, b → T ] merge TF ([x → T ], [x → {C}], T, T )

x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T ], [x → {C}], T, T ) REPLACE b := true while(…) [x → T, b → T ] merge TF ([x → T ], [x → {C}], T, T )

b := true ([x → T ], [x → {C}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) PROPAGATE

([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) b := true ([x → T ], [x → {C}], T, T )

([x → T, b → true], [x → {C}, b → {Bool}], T, T ) x := new C b := x instanceof C x := new Dx := x.foo() if (b) Replacement graph is analyzed by composed analysis. When one analysis chooses a replacement graph, other analyses see it immediately. Analyses communicate implicitly through graph transformations while(…) merge TF ([x → T ], [x → {C}], T, T )

x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) REPLACE σ while(…) merge TF ([x → T ], [x → {C}], T, T )

x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) σσ while(…) merge TF ([x → T ], [x → {C}], T, T )

σ σ (,,, )

σ σ σ (,,, ) (,,, )

x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) while(…) merge TF ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T )

x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T ], [x → {C}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) while(…) merge TF ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) REPLACE (,,, )

(,,, ) (,,, ) (,,, )

x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) while(…) merge TF ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T ) (,,, )

σ x := new C b := x instanceof C x := new Dx := x.foo() if (b) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) REPLACE x := C::foo(x) while(…) merge T (,,, ) (,,, ) F ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T ], [x → {C}], T, T ) σ

x := C::foo(x) σ REPLACE x := x σ class C extends A { A foo() { return self; } }

x := x σ σ PROPAGATE

x := x σ σ σ

x := C::foo(x) σ σ σ

σ σ ([x → T, b → true], [x → {C}, b → {Bool}], T, T )

([x → T, b → true], [x → {C}, b → {Bool}], T, T ) x := new C b := x instanceof C x := x.foo() if (b) while(…) merge T ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T ) (,,, ) x := new D F

x := new C b := x instanceof C x := x.foo() if (b) PROPAGATE ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) while(…) merge T x := new D F ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T ) (,,, )

x := new C b := x instanceof C x := x.foo() if (b) PROPAGATE ([x → T ], [x → {C}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) while(…) merge T x := new D F ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T ) (,,, )

x := new C b := x instanceof C x := x.foo() if (b) while(…) merge T x := new D F ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) ([x → T, b → true], [x → {C}, b → {Bool}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T ) (,,, ) ([x → T ], [x → {C}], T, T )

x := new C b := x instanceof C x := x.foo() if (b) x := x b := true while(…) merge T x := new D F

x := new C b := true x := x x := new C; do { b := x instanceof C; if (b) { x := x.foo(); } else { x := new D; } } while (...) x := new C; do { b := true; x := x; } while (...) while(…) merge

x := new C; do { b := x instanceof C; if (b) { x := x.foo(); } else { x := new D; } } while (...) x := new C; do { b := true; x := x; } while (...) Analyses are defined modularly and separately. Combining them achieves the results of a monolithic analysis. If the analyses were run separately in any order any number of times, no optimizations could be performed.

Analysis followed by transformations

Integrating analysis and transformations

Composing analyses and transformations