Recap Let’s do a recap of what we’ve seen so far Started with worklist algorithm for reaching definitions

Worklist algorithm for reaching defns let m: map from edge to computed value at edge let worklist: work list of nodes for each edge e in CFG do m(e) := ; for each node n do worklist.add(n) while (worklist.empty.not) do let n := worklist.remove_any; let info_in := m(n.incoming_edges); let info_out := F(n, info_in); for i := 0.. info_out.length do let new_info := m(n.outgoing_edges[i]) [ info_out[i]; if (m(n.outgoing_edges[i])  new_info]) m(n.outgoing_edges[i]) := new_info; worklist.add(n.outgoing_edges[i].dst);

Generalized algorithm using lattices let m: map from edge to computed value at edge let worklist: work list of nodes for each edge e in CFG do m(e) := ? for each node n do worklist.add(n) while (worklist.empty.not) do let n := worklist.remove_any; let info_in := m(n.incoming_edges); let info_out := F(n, info_in); for i := 0.. info_out.length do let new_info := m(n.outgoing_edges[i]) t info_out[i]; if (m(n.outgoing_edges[i])  new_info]) m(n.outgoing_edges[i]) := new_info; worklist.add(n.outgoing_edges[i].dst);

Next step: removed outer join Wanted to remove the outer join, while still providing termination guarantee To do this, we re-expressed our algorithm more formally We first defined a “global” flow function F, and then expressed our algorithm as a fixed point computation

Fixedpoint view We want to find a fixed point of F, that is to say a map m such that m = F(m) Define ?, which is ? lifted to be a map: ? = e. ? Compute F( ? ), then F(F( ? )), then F(F(F( ? ))),... until the result doesn’t change anymore

Guarantees If F is monotonic and height of lattice is finite: iterative algorithm terminates If F is monotonic, the fixed point we find is the least fixed point. Any questions so far?

What about if we start at top? What if we start with > : F( > ), F(F( > )), F(F(F( > ))) We get the greatest fixed point Why do we prefer the least fixed point? –More precise

Graphically x y 10

Graphically x y 10

Graphically x y 10

Graphically, another way

Another example: constant prop Set D = x := N in out F x := n (in) = x := y op z in out F x := y op z (in) =

Another example: constant prop Set D = 2 { x ! N | x 2 Vars Æ N 2 Z } x := N in out F x := n (in) = in – { x ! * } [ { x ! N } x := y op z in out F x := y op z (in) = in – { x ! * } [ { x ! N | ( y ! N 1 ) 2 in Æ ( z ! N 2 ) 2 in Æ N = N 1 op N 2 }

Another example: constant prop *x := y in out F *x := y (in) = x := *y in out F x := *y (in) =

Another example: constant prop *x := y in out F *x := y (in) = in – { z ! * | z 2 may-point(x) } [ { z ! N | z 2 must-point-to(x) Æ y ! N 2 in } [ { z ! N | (y ! N) 2 in Æ (z ! N) 2 in } x := *y in out F x := *y (in) = in – { x ! * } [ { x ! N | 8 z 2 may-point-to(x). (z ! N) 2 in }

Another example: constant prop x := f(...) in out F x := f(...) (in) = *x := *y + *z in out F *x := *y + *z (in) =

Another example: constant prop x := f(...) in out F x := f(...) (in) = ; *x := *y + *z in out F *x := *y + *z (in) = F a := *y;b := *z;c := a + b; *x := c (in)

Another example: constant prop s: if (...) in out[0]out[1] merge out in[0]in[1]

Lattice (D, v, ?, >, t, u ) =

Lattice (D, v, ?, >, t, u ) = (2 { x ! N | x 2 Vars Æ N 2 Z }, ¶, D, ;, Å, [ )

Example x := 5 v := 2 x := x + 1 w := v + 1 w := 3 y := x * 2 z := y + 5 w := w * v

Back to lattice (D, v, ?, >, t, u ) = (2 { x ! N | x 2 Vars Æ N 2 Z }, ¶, D, ;, Å, [ ) What’s the problem with this lattice?

Back to lattice (D, v, ?, >, t, u ) = (2 { x ! N | x 2 Vars Æ N 2 Z }, ¶, D, ;, Å, [ ) What’s the problem with this lattice? Lattice is infinitely high, which means we can’t guarantee termination

Better lattice Suppose we only had one variable

Better lattice Suppose we only had one variable D = { ?, > } [ Z 8 i 2 Z. ? v i Æ i v > height = 3

For all variables Two possibilities Option 1: Tuple of lattices Given lattices (D 1, v 1, ? 1, > 1, t 1, u 1 )... (D n, v n, ? n, > n, t n, u n ) create: tuple lattice D n =

For all variables Two possibilities Option 1: Tuple of lattices Given lattices (D 1, v 1, ? 1, > 1, t 1, u 1 )... (D n, v n, ? n, > n, t n, u n ) create: tuple lattice D n = ((D 1 £... £ D n ), v, ?, >, t, u ) where ? = ( ? 1,..., ? n ) > = ( > 1,..., > n ) (a 1,..., a n ) t (b 1,..., b n ) = (a 1 t 1 b 1,..., a n t n b n ) (a 1,..., a n ) u (b 1,..., b n ) = (a 1 u 1 b 1,..., a n u n b n ) height = height(D 1 ) height(D n )

For all variables Option 2: Map from variables to single lattice Given lattice (D, v, ?, >, t, u ) and a set V, create: map lattice V ! D = (V ! D, v, ?, >, t, u )

Back to example x := y op z in out F x := y op z (in) =

Back to example x := y op z in out F x := y op z (in) = in [ x ! in(y) op in(z) ] where a op b =