add the original constant folding problem

Author: aviatesk

dataflow.jl

@@ -97,15 +97,15 @@ const AbstractValue = Dict{Symbol,LatticeElement}
 <=(X::AbstractValue, Y::AbstractValue) = X⊓Y == X
 <(X::AbstractValue, Y::AbstractValue)  = X<=Y && X!=Y
 
-# Note: we solve an existential data-flow problem below, so:
+# Note: if we solve a "existential" data-flow problem, we need to
 # - initialize states with `⊥` instead of `⊤`
 # - use `!<=` instead of `!<=` to check whether or not the instruction makes a change
 # - use `⊔` instead of `⊓` to update states
-function max_fixed_point(P::Program, a₁::AbstractValue, eval) where {Program<:AbstractVector{Stmt}}
+function max_fixed_point(P::Program, a₁::AbstractValue, eval; existential::Bool = false) where {Program<:AbstractVector{Stmt}}
     n = length(P)
-    bot = AbstractValue( v => ⊥ for v in keys(a₁) )
-    s = [ a₁; [ bot for i = 2:n ] ]
-    W = BitSet(1)
+    init = AbstractValue( v => (existential ? ⊥ : ⊤) for v in keys(a₁) )
+    s = [ a₁; [ init for i = 2:n ] ]
+    W = BitSet(1:n)
 
     while !isempty(W)
         pc = first(W)
@@ -118,20 +118,21 @@ function max_fixed_point(P::Program, a₁::AbstractValue, eval) where {Program<:
                 new = copy(new)
                 new[I.lhs.name] = eval(I.rhs, new)
             end
+
             if isa(I, Goto)
                 pc´ = I.label
             else
                 pc´ = pc+1
                 if isa(I, GotoIf)
                     l = I.label
-                    if !(new <= s[l])
+                    if (existential ? !(new <= s[l]) : !(new >= s[l]))
                         push!(W, l)
-                        s[l] = s[l] ⊔ new
+                        s[l] = (existential ? s[l] ⊔ new : s[l] ⊓ new)
                     end
                 end
             end
-            if pc´<=n && !(new <= s[pc´])
-                s[pc´] = s[pc´] ⊔ new
+            if pc´<=n && (existential ? !(new <= s[pc´]) : !(new >= s[pc´]))
+                s[pc´] = (existential ? s[pc´] ⊔ new : s[pc´] ⊓ new)
                 pc = pc´
             else
                 pc = n+1
@@ -141,8 +142,7 @@ function max_fixed_point(P::Program, a₁::AbstractValue, eval) where {Program<:
     s
 end
 
-
-# example problem - find uses of undefined variables
+# example problem 1. - find uses of undefined variables
 
 # flat lattice of variable definedness
 
@@ -176,3 +176,47 @@ prog1 = [Assign(:x, 0),                       # 1
 l = AbstractValue(:x => undef, :y => undef, :z => undef)
 
 max_fixed_point(prog1, l, abstract_eval)
+
+
+# example problem 2. - constant folding propagation (the paper example)
+
+struct Const <: LatticeElement
+    val::Int
+end
+
+abstract_eval(x::Num, s::AbstractValue) = Const(x.val)
+
+abstract_eval(x::Sym, s::AbstractValue) = get(s, x.name, ⊥)
+
+function abstract_eval(x::Call, s::AbstractValue)
+    if any(a->(abstract_eval(a,s) == ⊤), x.args)
+        return ⊤
+    end
+    if any(a->(abstract_eval(a,s) == ⊥), x.args)
+        return ⊥
+    end
+
+    to_val(x::Num)   = x.val
+    to_val(x::Const) = x.val
+    to_val(x::Sym)   = to_val(abstract_eval(x, s))
+
+    f = getfield(@__MODULE__, x.head.name)
+    args = to_val.(x.args)
+    return Const(f(args...))
+end
+
+prog1 = [Assign(:x, 1),                 # 1
+         Assign(:y, 2),                 # 2
+         Assign(:z, 3),                 # 3
+         Goto(9),                       # 4
+         Assign(:r, Call(:(+), [:y, :z])), # 5
+         GotoIf(8, Call(:(≤), [:x, :z])),  # 6
+         Assign(:r, Call(:(+), [:z, :y])), # 7
+         Assign(:x, Call(:(+), [:x, 1])),  # 8
+         GotoIf(5, Call(:(<), [:x, 10])),  # 9
+         Ret()]
+
+# variables initially undefined
+a₁ = AbstractValue(:x => ⊤, :y => ⊤, :z => ⊤, :r => ⊤)
+
+max_fixed_point(prog1, a₁, abstract_eval) # The solution contains the `:r => Const(5)`, which is not found in the program