SSA use count checking framework

Author: Ian Atol

base/compiler/ssair/ir.jl

@@ -890,6 +890,27 @@ function setindex!(compact::IncrementalCompact, @nospecialize(v), idx::Int)
     return compact
 end
 
+__set_check_ssa_counts(onoff::Bool) = __check_ssa_counts__[] = onoff
+const __check_ssa_counts__ = fill(false)
+
+function _oracle_check(compact::IncrementalCompact)
+    observed_used_ssas = Core.Compiler.find_ssavalue_uses1(compact)
+    for i = 1:length(observed_used_ssas)
+        if observed_used_ssas[i] != compact.used_ssas[i]
+            return observed_used_ssas
+        end
+    end
+    return nothing
+end
+
+function oracle_check(compact::IncrementalCompact)
+    maybe_oracle_used_ssas = _oracle_check(compact)
+    if maybe_oracle_used_ssas !== nothing
+        @eval Main (compact = $compact; oracle_used_ssas = $maybe_oracle_used_ssas)
+        error("Oracle check failed, inspect Main.compact and Main.oracle_used_ssas")
+    end
+end
+
 getindex(view::TypesView, idx::SSAValue) = getindex(view, idx.id)
 function getindex(view::TypesView, idx::Int)
     if isa(view.ir, IncrementalCompact) && idx < view.ir.result_idx
@@ -979,11 +1000,15 @@ function renumber_ssa2!(@nospecialize(stmt), ssanums::Vector{Any}, used_ssas::Ve
     urs = userefs(stmt)
     for op in urs
         val = op[]
-        isa(val, OldSSAValue) || isa(val, NewSSAValue) && push!(late_fixup, result_idx)
+        if isa(val, OldSSAValue) || isa(val, NewSSAValue)
+            push!(late_fixup, result_idx)
+        end
         if isa(val, Union{SSAValue, NewSSAValue})
             val = renumber_ssa2(val, ssanums, used_ssas, new_new_used_ssas, do_rename_ssa)
         end
-        isa(val, OldSSAValue) || isa(val, NewSSAValue) && push!(late_fixup, result_idx)
+        if isa(val, OldSSAValue) || isa(val, NewSSAValue)
+            push!(late_fixup, result_idx)
+        end
         op[] = val
     end
     return urs[]
@@ -1520,6 +1545,9 @@ end
 function complete(compact::IncrementalCompact)
     result_bbs = resize!(compact.result_bbs, compact.active_result_bb-1)
     cfg = CFG(result_bbs, Int[first(result_bbs[i].stmts) for i in 2:length(result_bbs)])
+    if __check_ssa_counts__[]
+        oracle_check(compact)
+    end
     return IRCode(compact.ir, compact.result, cfg, compact.new_new_nodes)
 end
 

base/compiler/utilities.jl

@@ -354,6 +354,38 @@ end
 @inline slot_id(s) = isa(s, SlotNumber) ? (s::SlotNumber).id :
     isa(s, Argument) ? (s::Argument).n : (s::TypedSlot).id
 
+######################
+# IncrementalCompact #
+######################
+
+# specifically meant to be used with body1 = compact.result and body2 = compact.new_new_nodes, with nvals == length(compact.used_ssas)
+function find_ssavalue_uses1(compact)
+    body1, body2 = compact.result.inst, compact.new_new_nodes.stmts.inst
+    nvals = length(compact.used_ssas)
+    nbody1 = length(body1)
+    nbody2 = length(body2)
+
+    uses = zeros(Int, nvals)
+    function increment_uses(ssa::SSAValue)
+        uses[ssa.id] += 1
+    end
+
+    for line in 1:(nbody1 + nbody2)
+        # index into the right body
+        if line <= nbody1
+            isassigned(body1, line) || continue
+            e = body1[line]
+        else
+            line -= nbody1
+            isassigned(body2, line) || continue
+            e = body2[nline]
+        end
+
+        foreachssa(increment_uses, e)
+    end
+    return uses
+end
+
 ###########
 # options #
 ###########

test/compiler/ssair.jl

@@ -328,17 +328,17 @@ f_if_typecheck() = (if nothing; end; unsafe_load(Ptr{Int}(0)))
         end
         code_typed(foo; optimize=true)
 
-        code_typed(Core.Compiler.setindex!, (Core.Compiler.UseRef, Core.Compiler.NewSSAValue); optimize=true)
+        code_typed(Core.Compiler.setindex!, (Core.Compiler.UseRef,Core.Compiler.NewSSAValue); optimize=true)
     end |> string
     cmd = `$(Base.julia_cmd()) -g 2 -e $code`
     stderr = IOBuffer()
     success(pipeline(Cmd(cmd); stdout=stdout, stderr=stderr)) && isempty(String(take!(stderr)))
 end
 
 let
-    function test_useref(stmt, v)
+    function test_useref(stmt, v, op)
         if isa(stmt, Expr)
-            @test any(arg -> arg === v, stmt.args)
+            @test stmt.args[op] === v
         elseif isa(stmt, GotoIfNot)
             @test stmt.cond === v
         elseif isa(stmt, ReturnNode) || isa(stmt, UpsilonNode)
@@ -350,7 +350,7 @@ let
         elseif isa(stmt, PiNode)
             @test stmt.val === v && stmt.typ === typeof(stmt)
         elseif isa(stmt, PhiNode) || isa(stmt, PhiCNode)
-            @test any(arg -> arg === v, stmt.values)
+            @test stmt.values[op] === v
         end
     end
 
@@ -364,7 +364,7 @@ let
             v1 = Core.Compiler.getindex(ur)
             # set to dummy expression and then back to itself to test `_useref_setindex!`
             v2 = Core.Compiler.setindex!(ur, ex)
-            test_useref(v2, ex)
+            test_useref(v2, ex, op)
             Core.Compiler.setindex!(ur, v1)
             @test Core.Compiler.getindex(ur) === v1
             it = Core.Compiler.iterate(urs, op)