irinterp: Consider cfg information from discovered errors (#49692)

If we infer a call to `Union{}`, we can terminate further abstract interpretation. However, this of course also means that we can make use of that information to refine the types of any phis that may have originated from the basic block containing the call that was refined to `Union{}`. Co-authored-by: Shuhei Kadowaki <[email protected]>
JuliaLang · May 10, 2023 · e204e20 · e204e20
1 parent b9b8b38
commit e204e20
Show file tree

Hide file tree

Showing 2 changed files with 103 additions and 36 deletions.
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
@@ -58,6 +58,49 @@ function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, irsv::IRIn
  return RTEffects(rt, effects)
 end
 
+function update_phi!(irsv::IRInterpretationState, from::Int, to::Int)
+ ir = irsv.ir
+ if length(ir.cfg.blocks[to].preds) == 0
+ # Kill the entire block
+ for bidx = ir.cfg.blocks[to].stmts
+ ir.stmts[bidx][:inst] = nothing
+ ir.stmts[bidx][:type] = Bottom
+ ir.stmts[bidx][:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+ end
+ return
+ end
+ for sidx = ir.cfg.blocks[to].stmts
+ sinst = ir.stmts[sidx][:inst]
+ isa(sinst, Nothing) && continue # allowed between `PhiNode`s
+ isa(sinst, PhiNode) || break
+ for (eidx, edge) in enumerate(sinst.edges)
+ if edge == from
+ deleteat!(sinst.edges, eidx)
+ deleteat!(sinst.values, eidx)
+ push!(irsv.ssa_refined, sidx)
+ break
+ end
+ end
+ end
+end
+update_phi!(irsv::IRInterpretationState) = (from::Int, to::Int)->update_phi!(irsv, from, to)
+
+function kill_terminator_edges!(irsv::IRInterpretationState, term_idx::Int, bb::Int=block_for_inst(irsv.ir, term_idx))
+ ir = irsv.ir
+ inst = ir[SSAValue(term_idx)][:inst]
+ if isa(inst, GotoIfNot)
+ kill_edge!(ir, bb, inst.dest, update_phi!(irsv))
+ kill_edge!(ir, bb, bb+1, update_phi!(irsv))
+ elseif isa(inst, GotoNode)
+ kill_edge!(ir, bb, inst.label, update_phi!(irsv))
+ elseif isa(inst, ReturnNode)
+ # Nothing to do
+ else
+ @assert !isexpr(inst, :enter)
+ kill_edge!(ir, bb, bb+1, update_phi!(irsv))
+ end
+end
+
 function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union{Int,Nothing},
  @nospecialize(inst), @nospecialize(typ), irsv::IRInterpretationState,
  extra_reprocess::Union{Nothing,BitSet,BitSetBoundedMinPrioritySet})
@@ -66,30 +109,6 @@ function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union
  cond = inst.cond
  condval = maybe_extract_const_bool(argextype(cond, ir))
  if condval isa Bool
- function update_phi!(from::Int, to::Int)
- if length(ir.cfg.blocks[to].preds) == 0
- # Kill the entire block
- for bidx = ir.cfg.blocks[to].stmts
- ir.stmts[bidx][:inst] = nothing
- ir.stmts[bidx][:type] = Bottom
- ir.stmts[bidx][:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
- end
- return
- end
- for sidx = ir.cfg.blocks[to].stmts
- sinst = ir.stmts[sidx][:inst]
- isa(sinst, Nothing) && continue # allowed between `PhiNode`s
- isa(sinst, PhiNode) || break
- for (eidx, edge) in enumerate(sinst.edges)
- if edge == from
- deleteat!(sinst.edges, eidx)
- deleteat!(sinst.values, eidx)
- push!(irsv.ssa_refined, sidx)
- break
- end
- end
- end
- end
  if isa(cond, SSAValue)
  kill_def_use!(irsv.tpdum, cond, idx)
  end
@@ -100,10 +119,10 @@ function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union
  if condval
  ir.stmts[idx][:inst] = nothing
  ir.stmts[idx][:type] = Any
- kill_edge!(ir, bb, inst.dest, update_phi!)
+ kill_edge!(ir, bb, inst.dest, update_phi!(irsv))
  else
  ir.stmts[idx][:inst] = GotoNode(inst.dest)
- kill_edge!(ir, bb, bb+1, update_phi!)
+ kill_edge!(ir, bb, bb+1, update_phi!(irsv))
  end
  return true
  end
@@ -123,9 +142,6 @@ function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union
  rt, nothrow = concrete_eval_invoke(interp, inst, inst.args[1]::MethodInstance, irsv)
  if nothrow
  ir.stmts[idx][:flag] |= IR_FLAG_NOTHROW
- if isa(rt, Const) && is_inlineable_constant(rt.val)
- ir.stmts[idx][:inst] = quoted(rt.val)
- end
  end
  elseif head === :throw_undef_if_not || # TODO: Terminate interpretation early if known false?
  head === :gc_preserve_begin ||
@@ -148,9 +164,17 @@ function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union
  else
  error("reprocess_instruction!: unhandled instruction found")
  end
- if rt !== nothing && !⊑(typeinf_lattice(interp), typ, rt)
- ir.stmts[idx][:type] = rt
- return true
+ if rt !== nothing
+ if isa(rt, Const)
+ ir.stmts[idx][:type] = rt
+ if is_inlineable_constant(rt.val)
+ ir.stmts[idx][:inst] = quoted(rt.val)
+ end
+ return true
+ elseif !⊑(typeinf_lattice(interp), typ, rt)
+ ir.stmts[idx][:type] = rt
+ return true
+ end
  end
  return false
 end
@@ -227,12 +251,22 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
  any_refined = true
  delete!(ssa_refined, idx)
  end
- if any_refined && reprocess_instruction!(interp,
- idx, bb, inst, typ, irsv, extra_reprocess)
- push!(ssa_refined, idx)
+ did_reprocess = false
+ if any_refined
+ did_reprocess = reprocess_instruction!(interp,
+ idx, bb, inst, typ, irsv, extra_reprocess)
+ if did_reprocess
+ push!(ssa_refined, idx)
+ inst = ir.stmts[idx][:inst]
+ typ = ir.stmts[idx][:type]
+ end
+ end
+ if idx == lstmt
+ process_terminator!(ir, inst, idx, bb, all_rets, bb_ip) && @goto residual_scan
+ (isa(inst, GotoNode) || isa(inst, GotoIfNot) || isa(inst, ReturnNode) || isexpr(inst, :enter)) && continue
  end
- idx == lstmt && process_terminator!(ir, inst, idx, bb, all_rets, bb_ip) && @goto residual_scan
  if typ === Bottom && !isa(inst, PhiNode)
+ kill_terminator_edges!(irsv, lstmt, bb)
  break
  end
  end

diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
@@ -4871,3 +4871,36 @@ function nt_splat_partial(x::Int)
  Val{tuple(nt...)[2]}()
 end
 @test @inferred(nt_splat_partial(42)) == Val{2}()
+
+# Test that irinterp refines based on discovered errors
+Base.@assume_effects :foldable Base.@constprop :aggressive function kill_error_edge(b1, b2, xs, x)
+ y = b1 ? "julia" : xs[]
+ if b2
+ a = length(y)
+ else
+ a = sin(y)
+ end
+ a + x
+end
+
+Base.@assume_effects :foldable Base.@constprop :aggressive function kill_error_edge(b1, b2, xs, ys, x)
+ y = b1 ? xs[] : ys[]
+ if b2
+ a = length(y)
+ else
+ a = sin(y)
+ end
+ a + x
+end
+
+let src = code_typed1((Bool,Base.RefValue{Any},Int,)) do b2, xs, x
+ kill_error_edge(true, b2, xs, x)
+ end
+ @test count(@nospecialize(x)->isa(x, Core.PhiNode), src.code) == 0
+end
+
+let src = code_typed1((Bool,Base.RefValue{String}, Base.RefValue{Any},Int,)) do b2, xs, ys, x
+ kill_error_edge(true, b2, xs, ys, x)
+ end
+ @test count(@nospecialize(x)->isa(x, Core.PhiNode), src.code) == 0
+end