From b4f9f48160ae2e1f857c5fab51fd2ad0561db67c Mon Sep 17 00:00:00 2001 From: Keno Fischer Date: Tue, 10 Apr 2018 20:07:28 -0400 Subject: [PATCH] WIP: The one SROA pass to rule them all --- base/compiler/ssair/driver.jl | 5 +- base/compiler/ssair/ir.jl | 297 ++++++++++++++++---- base/compiler/ssair/passes.jl | 476 +++++++++++++++++++++++++------- base/compiler/ssair/show.jl | 16 +- base/compiler/ssair/slot2ssa.jl | 56 ++-- base/compiler/ssair/verify.jl | 4 +- 6 files changed, 652 insertions(+), 202 deletions(-) diff --git a/base/compiler/ssair/driver.jl b/base/compiler/ssair/driver.jl index 08abce3a32780..24f81c69ae076 100644 --- a/base/compiler/ssair/driver.jl +++ b/base/compiler/ssair/driver.jl @@ -17,7 +17,7 @@ include("compiler/ssair/passes.jl") include("compiler/ssair/inlining2.jl") include("compiler/ssair/verify.jl") include("compiler/ssair/legacy.jl") -@isdefined(Base) && include("compiler/ssair/show.jl") +#@isdefined(Base) && include("compiler/ssair/show.jl") function normalize_expr(stmt::Expr) if stmt.head === :gotoifnot @@ -147,8 +147,9 @@ function run_passes(ci::CodeInfo, nargs::Int, linetable::Vector{LineInfoNode}, s @timeit "Inlining" ir = ssa_inlining_pass!(ir, nothing, linetable, sv) #@timeit "verify 2" verify_ir(ir) @timeit "domtree 2" domtree = construct_domtree(ir.cfg) + ir = compact!(ir) @timeit "SROA" ir = getfield_elim_pass!(ir, domtree) - @timeit "compact 2" ir = compact!(ir) + ir = adce_pass!(ir) @timeit "type lift" ir = type_lift_pass!(ir) @timeit "compact 3" ir = compact!(ir) #@timeit "verify 3" verify_ir(ir) diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl index 976a0c2d6fcc1..52b103edb763e 100644 --- a/base/compiler/ssair/ir.jl +++ b/base/compiler/ssair/ir.jl @@ -147,7 +147,22 @@ function first_insert_for_bb(code, cfg, block) end -const NewNode = Tuple{Int, #= reverse affinity =#Bool, Any, Any, #=LineNumber=#Int} +struct NewNode + # Insertion position (interpretation depends on which array this is in) + pos::Int + # For BB purposes, attaches to the BB of the instruction before `pos` + reverse_affinity::Bool + # The type of the instruction to insert + typ::Any + # The node itself + node::Any + # The index into the line number table of this entry + line::Int +end +function NewNode(nnode::NewNode; pos=nnode.pos, reverse_affinity=nnode.reverse_affinity, + typ=nnode.typ, node=nnode.node, line=nnode.line) + NewNode(pos, reverse_affinity, typ, node, line) +end struct IRCode stmts::Vector{Any} @@ -171,7 +186,7 @@ function getindex(x::IRCode, s::SSAValue) if s.id <= length(x.stmts) return x.stmts[s.id] else - return x.new_nodes[s.id - length(x.stmts)][4] + return x.new_nodes[s.id - length(x.stmts)].node end end @@ -333,7 +348,7 @@ end function insert_node!(ir::IRCode, pos::Int, @nospecialize(typ), @nospecialize(val), reverse_affinity::Bool=false) line = ir.lines[pos] - push!(ir.new_nodes, (pos, reverse_affinity, typ, val, line)) + push!(ir.new_nodes, NewNode(pos, reverse_affinity, typ, val, line)) return SSAValue(length(ir.stmts) + length(ir.new_nodes)) end @@ -359,12 +374,18 @@ mutable struct IncrementalCompact # This could be Stateful, but bootstrapping doesn't like that perm::Vector{Int} new_nodes_idx::Int + # This supports insertion while compacting + new_new_nodes::Vector{NewNode} # New nodes that were before the compaction point at insertion time + # TODO: Switch these two to a min-heap of some sort + pending_nodes::Vector{NewNode} # New nodes that were after the compaction point at insertion time + pending_perm::Vector{Int} + # State idx::Int result_idx::Int active_result_bb::Int function IncrementalCompact(code::IRCode) - # Sort by position with reverse affinity nodes before regular ones - perm = my_sortperm(Int[(code.new_nodes[i][1]*2 + Int(!code.new_nodes[i][2])) for i in 1:length(code.new_nodes)]) + # Sort by position with reverse affinity nodes after regular ones + perm = my_sortperm(Int[(code.new_nodes[i].pos*2 + Int(code.new_nodes[i].reverse_affinity)) for i in 1:length(code.new_nodes)]) new_len = length(code.stmts) + length(code.new_nodes) result = Array{Any}(undef, new_len) result_types = Array{Any}(undef, new_len) @@ -372,18 +393,28 @@ mutable struct IncrementalCompact used_ssas = fill(0, new_len) ssa_rename = Any[SSAValue(i) for i = 1:new_len] late_fixup = Vector{Int}() - return new(code, result, result_types, result_lines, code.cfg.blocks, ssa_rename, used_ssas, late_fixup, perm, 1, 1, 1, 1) + new_new_nodes = NewNode[] + pending_nodes = NewNode[] + pending_perm = Int[] + return new(code, result, result_types, result_lines, code.cfg.blocks, ssa_rename, used_ssas, late_fixup, perm, 1, + new_new_nodes, pending_nodes, pending_perm, + 1, 1, 1) end # For inlining function IncrementalCompact(parent::IncrementalCompact, code::IRCode, result_offset) - perm = my_sortperm(Int[code.new_nodes[i][1] for i in 1:length(code.new_nodes)]) + perm = my_sortperm(Int[code.new_nodes[i].pos for i in 1:length(code.new_nodes)]) new_len = length(code.stmts) + length(code.new_nodes) ssa_rename = Any[SSAValue(i) for i = 1:new_len] used_ssas = fill(0, new_len) late_fixup = Vector{Int}() + new_new_nodes = NewNode[] + pending_nodes = NewNode[] + pending_perm = Int[] return new(code, parent.result, parent.result_types, parent.result_lines, parent.result_bbs, ssa_rename, parent.used_ssas, - late_fixup, perm, 1, 1, result_offset, parent.active_result_bb) + late_fixup, perm, 1, + new_new_nodes, pending_nodes, pending_perm, + 1, result_offset, parent.active_result_bb) end end @@ -400,7 +431,30 @@ function getindex(compact::IncrementalCompact, idx) end end +function getindex(compact::IncrementalCompact, ssa::SSAValue) + @assert ssa.id < compact.result_idx + return compact.result[ssa.id] +end + +function getindex(compact::IncrementalCompact, ssa::OldSSAValue) + id = ssa.id + if id <= length(compact.ir.stmts) + return compact.ir.stmts[id] + end + id -= length(compact.ir.stmts) + if id <= length(compact.ir.new_nodes) + return compact.ir.new_nodes[id].node + end + id -= length(compact.ir.new_nodes) + return compact.pending_nodes[id].node +end + +function getindex(compact::IncrementalCompact, ssa::NewSSAValue) + return compact.new_new_nodes[ssa.id].node +end + function count_added_node!(compact, v) + needs_late_fixup = isa(v, NewSSAValue) if isa(v, SSAValue) compact.used_ssas[v.id] += 1 else @@ -408,9 +462,57 @@ function count_added_node!(compact, v) val = ops[] if isa(val, SSAValue) compact.used_ssas[val.id] += 1 + elseif isa(val, NewSSAValue) + needs_late_fixup = true end end end + needs_late_fixup +end + +function resort_pending!(compact) + sort!(compact.pending_perm, DEFAULT_STABLE, Order.By(x->compact.pending_nodes[x].pos)) +end + +function insert_node!(compact::IncrementalCompact, before, @nospecialize(typ), @nospecialize(val), reverse_affinity::Bool=false) + if isa(before, SSAValue) + if before.id < compact.result_idx + count_added_node!(compact, val) + line = compact.result_lines[before.id] + push!(compact.new_new_nodes, NewNode(before.id, reverse_affinity, typ, val, line)) + return NewSSAValue(length(compact.new_new_nodes)) + else + line = compact.ir.lines[before.id] + push!(compact.pending_nodes, NewNode(before.id, reverse_affinity, typ, val, line)) + push!(compact.pending_perm, length(compact.pending_nodes)) + resort_pending!(compact) + os = OldSSAValue(length(compact.ir.stmts) + length(compact.ir.new_nodes) + length(compact.pending_nodes)) + push!(compact.ssa_rename, os) + push!(compact.used_ssas, 0) + return os + end + elseif isa(before, OldSSAValue) + pos = before.id + if pos > length(compact.ir.stmts) + @assert reverse_affinity + entry = compact.pending_nodes[pos - length(compact.ir.stmts) - length(compact.ir.new_nodes)] + pos, reverse_affinity = entry.pos, entry.reverse_affinity + end + line = 0 #compact.ir.lines[before.id] + push!(compact.pending_nodes, NewNode(pos, reverse_affinity, typ, val, line)) + push!(compact.pending_perm, length(compact.pending_nodes)) + resort_pending!(compact) + os = OldSSAValue(length(compact.ir.stmts) + length(compact.ir.new_nodes) + length(compact.pending_nodes)) + push!(compact.ssa_rename, os) + push!(compact.used_ssas, 0) + return os + elseif isa(before, NewSSAValue) + before_entry = compact.new_new_nodes[before.id] + push!(compact.new_new_nodes, NewNode(before_entry.pos, reverse_affinity, typ, val, before_entry.line)) + return NewSSAValue(length(compact.new_new_nodes)) + else + error("Unsupported") + end end function insert_node_here!(compact::IncrementalCompact, @nospecialize(val), @nospecialize(typ), ltable_idx::Int) @@ -428,23 +530,39 @@ function insert_node_here!(compact::IncrementalCompact, @nospecialize(val), @nos end function getindex(view::TypesView, v::OldSSAValue) - return view.ir.ir.types[v.id] + id = v.id + if id <= length(view.ir.ir.types) + return view.ir.ir.types[id] + end + id -= length(view.ir.ir.types) + if id <= length(view.ir.ir.new_nodes) + return view.ir.ir.new_nodes[id].typ + end + id -= length(view.ir.ir.new_nodes) + return view.ir.pending_nodes[id].typ +end + +function setindex!(compact::IncrementalCompact, @nospecialize(v), idx::SSAValue) + @assert idx.id < compact.result_idx + (compact.result[idx.id] === v) && return + # Kill count for current uses + for ops in userefs(compact.result[idx.id]) + val = ops[] + if isa(val, SSAValue) + @assert compact.used_ssas[val.id] >= 1 + compact.used_ssas[val.id] -= 1 + end + end + compact.result[idx.id] = v + # Add count for new use + if count_added_node!(compact, v) + push!(compact.late_fixup, idx.id) + end end function setindex!(compact::IncrementalCompact, @nospecialize(v), idx) if idx < compact.result_idx - (compact.result[idx] === v) && return - # Kill count for current uses - for ops in userefs(compact.result[idx]) - val = ops[] - if isa(val, SSAValue) - @assert compact.used_ssas[val.id] >= 1 - compact.used_ssas[val.id] -= 1 - end - end - compact.result[idx] = v - # Add count for new use - count_added_node!(compact, v) + compact[SSAValue(idx)] = v else compact.ir.stmts[idx] = v end @@ -460,11 +578,17 @@ function getindex(view::TypesView, idx) if idx <= length(ir.types) return ir.types[idx] else - return ir.new_nodes[idx - length(ir.types)][3] + return ir.new_nodes[idx - length(ir.types)].typ end end end +function getindex(view::TypesView, idx::NewSSAValue) + @assert isa(view.ir, IncrementalCompact) + compact = view.ir + compact.new_new_nodes[idx.id].typ +end + # maybe use expr_type? function value_typ(ir::IRCode, value) isa(value, SSAValue) && return ir.types[value.id] @@ -512,6 +636,8 @@ function process_node!(result::Vector{Any}, result_idx::Int, ssa_rename::Vector{ ssa_rename[idx] = SSAValue(result_idx) if stmt === nothing ssa_rename[idx] = stmt + elseif isa(stmt, OldSSAValue) + ssa_rename[idx] = ssa_rename[stmt.id] elseif isa(stmt, GotoNode) || isa(stmt, GlobalRef) result[result_idx] = stmt result_idx += 1 @@ -571,7 +697,24 @@ end function reverse_affinity_stmt_after(compact::IncrementalCompact, idx::Int) compact.new_nodes_idx > length(compact.perm) && return false entry = compact.ir.new_nodes[compact.perm[compact.new_nodes_idx]] - entry[1] == idx + 1 && entry[2] + entry.pos == idx && entry.reverse_affinity +end + +function process_newnode!(compact, new_idx, new_node_entry, idx, active_bb) + old_result_idx = compact.result_idx + bb = compact.ir.cfg.blocks[active_bb] + compact.result_types[old_result_idx] = new_node_entry.typ + compact.result_lines[old_result_idx] = new_node_entry.line + result_idx = process_node!(compact, old_result_idx, new_node_entry.node, new_idx, idx) + compact.result_idx = result_idx + # If this instruction has reverse affinity and we were at the end of a basic block, + # finish it now. + if new_node_entry.reverse_affinity && idx == last(bb.stmts)+1 && !reverse_affinity_stmt_after(compact, idx-1) + active_bb += 1 + finish_current_bb!(compact, old_result_idx) + end + (old_result_idx == result_idx) && return next(compact, (idx, active_bb)) + return (old_result_idx, compact.result[old_result_idx]), (compact.idx, active_bb) end function next(compact::IncrementalCompact, (idx, active_bb)::Tuple{Int, Int}) @@ -580,23 +723,21 @@ function next(compact::IncrementalCompact, (idx, active_bb)::Tuple{Int, Int}) resize!(compact, old_result_idx) end bb = compact.ir.cfg.blocks[active_bb] - if compact.new_nodes_idx <= length(compact.perm) && compact.ir.new_nodes[compact.perm[compact.new_nodes_idx]][1] == idx + if compact.new_nodes_idx <= length(compact.perm) && + (entry = compact.ir.new_nodes[compact.perm[compact.new_nodes_idx]]; + entry.reverse_affinity ? entry.pos == idx - 1 : entry.pos == idx) new_idx = compact.perm[compact.new_nodes_idx] compact.new_nodes_idx += 1 - _, reverse_affinity, typ, new_node, new_line = compact.ir.new_nodes[new_idx] + new_node_entry = compact.ir.new_nodes[new_idx] new_idx += length(compact.ir.stmts) - compact.result_types[old_result_idx] = typ - compact.result_lines[old_result_idx] = new_line - result_idx = process_node!(compact, old_result_idx, new_node, new_idx, idx) - compact.result_idx = result_idx - # If this instruction has reverse affinity and we were at the end of a basic block, - # finish it now. - if reverse_affinity && idx == last(bb.stmts)+1 && !reverse_affinity_stmt_after(compact, idx-1) - active_bb += 1 - finish_current_bb!(compact, old_result_idx) - end - (old_result_idx == result_idx) && return next(compact, (idx, active_bb)) - return (old_result_idx, compact.result[old_result_idx]), (compact.idx, active_bb) + return process_newnode!(compact, new_idx, new_node_entry, idx, active_bb) + elseif !isempty(compact.pending_perm) && + (entry = compact.pending_nodes[compact.pending_perm[1]]; + entry.reverse_affinity ? entry.pos == idx - 1 : entry.pos == idx) + new_idx = popfirst!(compact.pending_perm) + new_node_entry = compact.pending_nodes[new_idx] + new_idx += length(compact.ir.stmts) + length(compact.ir.new_nodes) + return process_newnode!(compact, new_idx, new_node_entry, idx, active_bb) end # This will get overwritten in future iterations if # result_idx is not, incremented, but that's ok and expected @@ -617,10 +758,12 @@ function next(compact::IncrementalCompact, (idx, active_bb)::Tuple{Int, Int}) return (old_result_idx, compact.result[old_result_idx]), (compact.idx, active_bb) end -function maybe_erase_unused!(extra_worklist, compact, idx) - effect_free = stmt_effect_free(compact.result[idx], compact, compact.ir.mod) +function maybe_erase_unused!(extra_worklist, compact, idx, callback = x->nothing) + stmt = compact.result[idx] + stmt === nothing && return false + effect_free = stmt_effect_free(stmt, compact, compact.ir.mod) if effect_free - for ops in userefs(compact.result[idx]) + for ops in userefs(stmt) val = ops[] if isa(val, SSAValue) if compact.used_ssas[val.id] == 1 @@ -629,10 +772,13 @@ function maybe_erase_unused!(extra_worklist, compact, idx) end end compact.used_ssas[val.id] -= 1 + callback(val) end end compact.result[idx] = nothing + return true end + return false end function fixup_phinode_values!(compact, old_values) @@ -645,45 +791,80 @@ function fixup_phinode_values!(compact, old_values) if isa(val, SSAValue) compact.used_ssas[val.id] += 1 end + elseif isa(val, NewSSAValue) + val = SSAValue(length(compact.result) + val.id) end values[i] = val end values end +function fixup_node(compact, @nospecialize(stmt)) + if isa(stmt, PhiNode) + return PhiNode(stmt.edges, fixup_phinode_values!(compact, stmt.values)) + elseif isa(stmt, PhiCNode) + return PhiCNode(fixup_phinode_values!(compact, stmt.values)) + elseif isa(stmt, NewSSAValue) + return SSAValue(length(compact.result) + stmt.id) + else + urs = userefs(stmt) + urs === () && return stmt + for ur in urs + val = ur[] + if isa(val, NewSSAValue) + ur[] = SSAValue(length(compact.result) + val.id) + end + end + return urs[] + end +end + function just_fixup!(compact) for idx in compact.late_fixup - stmt = compact.result[idx]::Union{PhiNode, PhiCNode} - if isa(stmt, PhiNode) - compact.result[idx] = PhiNode(stmt.edges, fixup_phinode_values!(compact, stmt.values)) - else - compact.result[idx] = PhiCNode(fixup_phinode_values!(compact, stmt.values)) - end + stmt = compact.result[idx] + new_stmt = fixup_node(compact, stmt) + (stmt !== new_stmt) && (compact.result[idx] = new_stmt) + end + for idx in 1:length(compact.new_new_nodes) + node = compact.new_new_nodes[idx] + new_stmt = fixup_node(compact, node.node) + (node.node !== new_stmt) && (compact.new_new_nodes[idx] = NewNode(node, node=new_stmt)) end end -function finish(compact::IncrementalCompact) - just_fixup!(compact) - # Record this somewhere? - result_idx = compact.result_idx - resize!(compact.result, result_idx-1) - resize!(compact.result_types, result_idx-1) - resize!(compact.result_lines, result_idx-1) - bb = compact.result_bbs[end] - compact.result_bbs[end] = BasicBlock(bb, - StmtRange(first(bb.stmts), result_idx-1)) +function simple_dce!(compact) # Perform simple DCE for unused values extra_worklist = Int[] for (idx, nused) in Iterators.enumerate(compact.used_ssas) - idx >= result_idx && break + idx >= compact.result_idx && break nused == 0 || continue maybe_erase_unused!(extra_worklist, compact, idx) end while !isempty(extra_worklist) maybe_erase_unused!(extra_worklist, compact, pop!(extra_worklist)) end +end + +function non_dce_finish!(compact::IncrementalCompact) + result_idx = compact.result_idx + resize!(compact.result, result_idx-1) + resize!(compact.result_types, result_idx-1) + resize!(compact.result_lines, result_idx-1) + just_fixup!(compact) + bb = compact.result_bbs[end] + compact.result_bbs[end] = BasicBlock(bb, + StmtRange(first(bb.stmts), result_idx-1)) +end + +function finish(compact::IncrementalCompact) + non_dce_finish!(compact) + simple_dce!(compact) + complete(compact) +end + +function complete(compact) cfg = CFG(compact.result_bbs, Int[first(bb.stmts) for bb in compact.result_bbs[2:end]]) - return IRCode(compact.ir, compact.result, compact.result_types, compact.result_lines, cfg, NewNode[]) + return IRCode(compact.ir, compact.result, compact.result_types, compact.result_lines, cfg, compact.new_new_nodes) end function compact!(code::IRCode) diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl index 1cde1d1ecee91..fb21d2e52bed4 100644 --- a/base/compiler/ssair/passes.jl +++ b/base/compiler/ssair/passes.jl @@ -1,5 +1,5 @@ function compact_exprtype(compact, value) - if isa(value, Union{SSAValue, OldSSAValue}) + if isa(value, Union{SSAValue, OldSSAValue, NewSSAValue}) return types(compact)[value] elseif isa(value, Argument) return compact.ir.argtypes[value.n] @@ -116,36 +116,63 @@ function compute_value_for_use(ir, domtree, allblocks, du, phinodes, fidx, use_i end end -function walk_to_def(compact, def, intermediaries = IdSet{Int}(), allow_phinode=true, phi_locs=Tuple{Int, Int}[]) - if !isa(def, SSAValue) - return (def, 0) +function simple_walk(compact, defssa::Union{SSAValue, NewSSAValue, OldSSAValue}, pi_callback=(pi,idx)->nothing) + while true + if isa(defssa, OldSSAValue) && already_inserted(compact, defssa) + rename = compact.ssa_rename[defssa.id] + @assert rename != defssa + if isa(rename, Union{SSAValue, OldSSAValue, NewSSAValue}) + defssa = rename + continue + end + return rename + end + def = compact[defssa] + if isa(def, PiNode) + pi_callback(def, defssa) + if isa(def.val, SSAValue) + defssa = def.val + else + return def.val + end + elseif isa(def, Union{SSAValue, OldSSAValue, NewSSAValue}) + defssa = def + elseif isa(def, Union{PhiNode, Expr}) + return defssa + else + return def + end end - orig_defidx = defidx = def.id +end + +function simple_walk_constraint(compact, defidx, typeconstraint = types(compact)[defidx]) + def = simple_walk(compact, defidx, (pi,_)->(typeconstraint = typeintersect(typeconstraint, pi.typ))) + def, typeconstraint +end + +""" + walk_to_defs(compact, val, intermediaries) + +Starting at `val` walk use-def chains to get all the leaves feeding into +this val (pruning those leaves rules out by path conditions). +""" +function walk_to_defs(compact, defssa, typeconstraint, visited_phinodes=Any[]) # Step 2: Figure out what the struct is defined as - def = compact[defidx] - typeconstraint = types(compact)[defidx] + def = compact[defssa] ## Track definitions through PiNode/PhiNode found_def = false ## Track which PhiNodes, SSAValue intermediaries ## we forwarded through. - while true - if isa(def, PiNode) - push!(intermediaries, defidx) - typeconstraint = typeintersect(typeconstraint, def.typ) - if isa(def.val, SSAValue) - defidx = def.val.id - def = compact[defidx] - else - def = def.val - end - continue - elseif isa(def, FastForward) - append!(phi_locs, def.phi_locs) - def = def.to - elseif isa(def, PhiNode) - # For now, we don't track setfields structs through phi nodes - allow_phinode || break - push!(intermediaries, defidx) + visited = IdSet{Any}() + worklist = Tuple{Any, Any}[] + leaves = Any[] + push!(worklist, (defssa, typeconstraint)) + while !isempty(worklist) + defssa, typeconstraint = pop!(worklist) + push!(visited, defssa) + def = compact[defssa] + if isa(def, PhiNode) + push!(visited_phinodes, defssa) possible_predecessors = let def=def, typeconstraint=typeconstraint collect(Iterators.filter(1:length(def.edges)) do n isassigned(def.values, n) || return false @@ -154,35 +181,33 @@ function walk_to_def(compact, def, intermediaries = IdSet{Int}(), allow_phinode= return typeintersect(edge_typ, typeconstraint) !== Union{} end) end - # For now, only look at unique predecessors - if length(possible_predecessors) == 1 - n = possible_predecessors[1] + for n in possible_predecessors pred = def.edges[n] val = def.values[n] - if isa(val, SSAValue) - push!(phi_locs, (pred, defidx)) - defidx = val.id - def = compact[defidx] - elseif def == val + if isa(val, Union{SSAValue, OldSSAValue, NewSSAValue}) + new_def, new_constraint = simple_walk_constraint(compact, val, typeconstraint) + if isa(new_def, Union{SSAValue, OldSSAValue, NewSSAValue}) + if !(new_def in visited) + push!(worklist, (new_def, new_constraint)) + end + continue + end + end + if def == val # This shouldn't really ever happen, but # patterns like this can occur in dead code, # so bail out. break else - def = val + push!(leaves, val) end continue end - elseif isa(def, SSAValue) - push!(intermediaries, defidx) - defidx = def.id - def = compact[def.id] - continue + else + push!(leaves, defssa) end - found_def = true - break end - found_def ? (def, defidx) : nothing + leaves end is_tuple_call(ir, def) = isa(def, Expr) && is_known_call(def, tuple, ir, ir.mod) @@ -200,19 +225,138 @@ struct FastForward phi_locs::Vector{Tuple{Int64, Int64}} end +function already_inserted(compact, old::OldSSAValue) + id = old.id + if id < length(compact.ir.stmts) + return id <= compact.idx + end + id -= length(compact.ir.stmts) + if id < length(compact.ir.new_nodes) + error() + end + id -= length(compact.ir.new_nodes) + @assert id <= length(compact.pending_nodes) + return !(id in compact.pending_perm) +end + +function lift_leaves(compact, stmt, result_t, field, leaves) + # For every leaf, the lifted value + lifted_leaves = IdDict{Any, Any}() + maybe_undef = false + for leaf in leaves + leaf_key = leaf + if isa(leaf, Union{SSAValue, OldSSAValue, NewSSAValue}) + if isa(leaf, OldSSAValue) && already_inserted(compact, leaf) + leaf = compact.ssa_rename[leaf.id] + if isa(leaf, Union{SSAValue, OldSSAValue, NewSSAValue}) + leaf = simple_walk(compact, leaf) + end + if isa(leaf, Union{SSAValue, OldSSAValue, NewSSAValue}) + def = compact[leaf] + else + def = leaf + end + else + def = compact[leaf] + end + if is_tuple_call(compact.ir, def) && isa(field, Int) && 1 <= field < length(def.args) + lifted_leaves[leaf_key] = Ref{Any}(def.args[1+field]) + continue + elseif isexpr(def, :new) + typ = def.typ + if isa(typ, UnionAll) + typ = unwrap_unionall(typ) + end + (isa(typ, DataType) && (!typ.abstract)) || return nothing + @assert !typ.mutable + field = try_compute_fieldidx(typ, stmt) + field === nothing && return nothing + if length(def.args) < 1 + field + ftyp = fieldtype(typ, field) + if !isbits(ftyp) + # On this branch, this will be a guaranteed UndefRefError. + # We use the regular undef mechanic to lift this to a boolean slot + maybe_undef = true + lifted_leaves[leaf_key] = nothing + continue + end + # Expand the Expr(:new) to include it's element Expr(:new) nodes up until the one we want + compact[leaf] = nothing + for i = (length(def.args) + 1):(1+field) + ftyp = fieldtype(typ, i - 1) + isbits(ftyp) || return nothing + push!(def.args, insert_node!(compact, leaf, result_t, Expr(:new, ftyp))) + end + compact[leaf] = def + end + lifted_leaves[leaf_key] = Ref{Any}(def.args[1+field]) + continue + else + typ = compact_exprtype(compact, leaf) + if !isa(typ, Const) + # If the leaf is an old ssa value, insert a getfield here + # We will revisit this getfield later when compaction gets + # to the appropriate point. + # N.B.: This can be a bit dangerous because it can lead to + # infinite loops if we accidentally insert a node just ahead + # of where we are + if isa(leaf, OldSSAValue) && (isa(field, Int) || isa(field, Symbol)) + (isa(typ, DataType) && (!typ.abstract)) || return nothing + @assert !typ.mutable + # If there's the potential for an undefref error on access, we cannot insert a getfield + if field > typ.ninitialized && !isbits(fieldtype(typ, field)) + lifted_leaves[leaf] = Ref{Any}(insert_node!(compact, leaf, make_MaybeUndef(result_t), Expr(:call, :unchecked_getfield, SSAValue(leaf.id), field), true)) + maybe_undef = true + else + lifted_leaves[leaf] = Ref{Any}(insert_node!(compact, leaf, result_t, Expr(:call, getfield, SSAValue(leaf.id), field), true)) + end + continue + end + return nothing + end + leaf = typ.val + # Fall through to below + end + elseif isa(leaf, Union{Argument, Expr}) + return nothing + end + isimmutable(leaf) || return nothing + isdefined(leaf, field) || return nothing + val = getfield(leaf, field) + is_inlineable_constant(val) || return nothing + lifted_leaves[leaf_key] = Ref{Any}(quoted(val)) + end + lifted_leaves, maybe_undef +end + +make_MaybeUndef(typ) = isa(typ, MaybeUndef) ? typ : MaybeUndef(typ) + +const AnySSAValue = Union{SSAValue, OldSSAValue, NewSSAValue} + function getfield_elim_pass!(ir::IRCode, domtree) compact = IncrementalCompact(ir) insertions = Vector{Any}() defuses = IdDict{Int, Tuple{IdSet{Int}, SSADefUse}}() + lifting_cache = IdDict{Tuple{AnySSAValue, Int}, AnySSAValue}() + revisit_worklist = Int[] + #ndone, nmax = 0, 200 for (idx, stmt) in compact + @Base.show stmt isa(stmt, Expr) || continue + #ndone >= nmax && continue + #ndone += 1 + result_t = compact_exprtype(compact, SSAValue(idx)) is_getfield = false is_ccall = false + is_unchecked = false # Step 1: Check whether the statement we're looking at is a getfield/setfield! if is_known_call(stmt, setfield!, ir, ir.mod) is_setfield = true elseif is_known_call(stmt, getfield, ir, ir.mod) is_getfield = true + elseif isexpr(stmt, :call) && stmt.args[1] == :unchecked_getfield + is_getfield = true + is_unchecked = true elseif isexpr(stmt, :foreigncall) nccallargs = stmt.args[5] new_preserves = Any[] @@ -220,9 +364,10 @@ function getfield_elim_pass!(ir::IRCode, domtree) for (pidx, preserved_arg) in enumerate(old_preserves) intermediaries = IdSet() isa(preserved_arg, SSAValue) || continue - def = walk_to_def(compact, preserved_arg, intermediaries, false) - def !== nothing || continue - (def, defidx) = def + def = simple_walk(compact, preserved_arg, (pi, idx)->push!(intermediaries, idx)) + isa(def, SSAValue) || continue + defidx = def.id + def = compact[defidx] if is_tuple_call(ir, def) process_immutable_preserve(new_preserves, compact, def) old_preserves[pidx] = nothing @@ -261,61 +406,118 @@ function getfield_elim_pass!(ir::IRCode, domtree) isa(field, QuoteNode) && (field = field.value) isa(field, Union{Int, Symbol}) || continue - intermediaries = IdSet() - phi_locs = Tuple{Int, Int}[] - def = walk_to_def(compact, stmt.args[2], intermediaries, is_getfield, phi_locs) - def !== nothing || continue - (def, defidx) = def + struct_typ = unwrap_unionall(widenconst(compact_exprtype(compact, stmt.args[2]))) + (isa(struct_typ, DataType) && !struct_typ.mutable) || continue - if !is_getfield - (defidx == 0) && continue - mid, defuse = get!(defuses, defidx, (IdSet{Int}(), SSADefUse())) + def, typeconstraint = stmt.args[2], struct_typ + + if struct_typ.mutable + isa(def, SSAValue) || continue + intermediaries = IdSet() + def = simple_walk(compact, def, (pi, idx)->push!(intermediaries, idx)) + # Mutable stuff here + isa(def, SSAValue) || continue + mid, defuse = get!(defuses, def.id, (IdSet{Int}(), SSADefUse())) push!(defuse.defs, idx) union!(mid, intermediaries) continue end - # Step 3: Check if the definition we eventually end up at is either - # a tuple(...) call or Expr(:new) and perform replacement. - if is_tuple_call(ir, def) && isa(field, Int) && 1 <= field < length(def.args) - forwarded = def.args[1+field] - elseif isexpr(def, :new) - typ = def.typ - if isa(typ, UnionAll) - typ = unwrap_unionall(typ) + + if isa(def, Union{OldSSAValue, SSAValue}) + def, typeconstraint = simple_walk_constraint(compact, def, typeconstraint) + end + + visited_phinodes = Any[] + if isa(def, Union{OldSSAValue, SSAValue, NewSSAValue}) && isa(compact[def], PhiNode) + leaves = walk_to_defs(compact, def, typeconstraint, visited_phinodes) + else + leaves = [def] + end + + isempty(leaves) && continue + + field = try_compute_fieldidx(struct_typ, stmt) + field === nothing && continue + + r = lift_leaves(compact, stmt, result_t, field, leaves) + r === nothing && continue + lifted_leaves, any_undef = r + + reverse_mapping = IdDict{Any, Any}(ssa => id for (id, ssa) in enumerate(visited_phinodes)) + + if any_undef + result_t = make_MaybeUndef(result_t) + end + + # Insert PhiNodes + lifted_phis = map(visited_phinodes) do item + if (item, field) in keys(lifting_cache) + ssa = lifting_cache[(item, field)] + return (ssa, compact[ssa], false) end - isa(typ, DataType) || continue - if typ.mutable - @assert defidx != 0 - mid, defuse = get!(defuses, defidx, (IdSet{Int}(), SSADefUse())) - push!(defuse.uses, idx) - union!(mid, intermediaries) - continue + n = PhiNode() + ssa = insert_node!(compact, item, result_t, n) + lifting_cache[(item, field)] = ssa + (ssa, n, true) + end + + # Fix up arguments + for (old_node, (_, new_node, need_argupdate)) in zip(map(x->compact[x], visited_phinodes), lifted_phis) + need_argupdate || continue + for i = 1:length(old_node.edges) + edge = old_node.edges[i] + isassigned(old_node.values, i) || continue + val = old_node.values[i] + if isa(val, Union{NewSSAValue, SSAValue, OldSSAValue}) + val = simple_walk(compact, val) + end + if val in keys(lifted_leaves) + push!(new_node.edges, edge) + lifted_val = lifted_leaves[val] + if lifted_val === nothing + resize!(new_node.values, length(new_node.values)+1) + continue + end + lifted_val = lifted_val.x + if isa(lifted_val, Union{NewSSAValue, SSAValue, OldSSAValue}) + lifted_val = simple_walk(compact, lifted_val) + end + push!(new_node.values, lifted_val) + elseif isa(val, Union{NewSSAValue, SSAValue, OldSSAValue}) && val in keys(reverse_mapping) + push!(new_node.edges, edge) + push!(new_node.values, lifted_phis[reverse_mapping[val]][1]) + else + # Probably ignored by path condition, skip this + end end - field = try_compute_fieldidx(typ, stmt) - field === nothing && continue - forwarded = def.args[1+field] - else - obj = compact_exprtype(compact, def) - isa(obj, Const) || continue - obj = obj.val - isimmutable(obj) || continue - field = try_compute_fieldidx(typeof(obj), stmt) - field === nothing && continue - isdefined(obj, field) || continue - val = getfield(obj, field) - is_inlineable_constant(val) || continue - forwarded = quoted(val) - end - # Step 4: Remember any phinodes we need to insert - if !isempty(phi_locs) && isa(forwarded, SSAValue) - # TODO: We have have to use BB ids for phi_locs - # to avoid index invalidation. - push!(insertions, idx) - compact[idx] = FastForward(forwarded, phi_locs) + end + + for (_, node) in lifted_phis + count_added_node!(compact, node) + end + + # Fixup the stmt itself + val = stmt.args[2] + if isa(val, Union{SSAValue, OldSSAValue}) + val = simple_walk(compact, val) + end + if val in keys(lifted_leaves) + val = lifted_leaves[val] + @assert val !== nothing + val = val.x else - compact[idx] = forwarded + isa(val, Union{SSAValue, OldSSAValue}) && val in keys(reverse_mapping) + val = lifted_phis[reverse_mapping[val]][1] end + + # Insert the undef check if necessary + if any_undef && !is_unchecked + insert_node!(compact, SSAValue(idx), Nothing, Expr(:undefcheck, :getfield, val)) + end + + compact[idx] = val end + ir = finish(compact) # Now go through any mutable structs and see which ones we can eliminate for (idx, (intermediaries, defuse)) in defuses @@ -406,25 +608,87 @@ function getfield_elim_pass!(ir::IRCode, domtree) ir[SSAValue(use)] = new_expr end end - for idx in insertions - # For non-dominating load-store forward, we may have to insert extra phi nodes - # TODO: Can use the domtree to eliminate unnecessary phis, but ok for now - ff = ir.stmts[idx] - ff === nothing && continue # May have been DCE'd if there were no more uses - ff = ff::FastForward - forwarded = ff.to - if isa(forwarded, SSAValue) - forwarded_typ = ir.types[forwarded.id] - for (pred, pos) in reverse!(ff.phi_locs) - node = PhiNode() - push!(node.edges, pred) - push!(node.values, forwarded) - forwarded = insert_node!(ir, pos, forwarded_typ, node) + ir +end + +function adce_erase!(phi_uses, extra_worklist, compact, idx) + if isa(compact.result[idx], PhiNode) + maybe_erase_unused!(extra_worklist, compact, idx, val->phi_uses[val.id]-=1) + else + maybe_erase_unused!(extra_worklist, compact, idx) + end +end + +function count_uses(stmt, uses) + for ur in userefs(stmt) + if isa(ur[], SSAValue) + uses[ur[].id] += 1 + end + end +end + +function mark_phi_cycles(compact, safe_phis, phi) + worklist = Int[] + push!(worklist, phi) + while !isempty(worklist) + phi = pop!(worklist) + push!(safe_phis, phi) + for ur in userefs(compact.result[phi]) + val = ur[] + isa(val, SSAValue) || continue + isa(compact[val], PhiNode) || continue + (val.id in safe_phis) && continue + push!(worklist, val.id) + end + end +end + +function adce_pass!(ir) + phi_uses = fill(0, length(ir.stmts) + length(ir.new_nodes)) + all_phis = Int[] + compact = IncrementalCompact(ir) + for (idx, stmt) in compact + if isa(stmt, PhiNode) + push!(all_phis, idx) + end + end + non_dce_finish!(compact) + for phi in all_phis + count_uses(compact.result[phi], phi_uses) + end + # Perform simple DCE for unused values + extra_worklist = Int[] + for (idx, nused) in Iterators.enumerate(compact.used_ssas) + idx >= compact.result_idx && break + nused == 0 || continue + adce_erase!(phi_uses, extra_worklist, compact, idx) + end + while !isempty(extra_worklist) + adce_erase!(phi_uses, extra_worklist, compact, pop!(extra_worklist)) + end + # Go back and erase any phi cycles + changed = true + while changed + changed = false + safe_phis = IdSet{Int}() + for phi in all_phis + # Save any phi cycles that have non-phi uses + if compact.used_ssas[phi] - phi_uses[phi] != 0 + mark_phi_cycles(compact, safe_phis, phi) + end + end + for phi in all_phis + if !(phi in safe_phis) + push!(extra_worklist, phi) + end + end + while !isempty(extra_worklist) + if adce_erase!(phi_uses, extra_worklist, compact, pop!(extra_worklist)) + changed = true end end - ir.stmts[idx] = forwarded end - ir + complete(compact) end function type_lift_pass!(ir::IRCode) diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl index 02a7a7ae1b5f9..7abcea980774b 100644 --- a/base/compiler/ssair/show.jl +++ b/base/compiler/ssair/show.jl @@ -80,7 +80,7 @@ function Base.show(io::IO, code::IRCode) used = IdSet{Int}() Base.println(io, "Code") foreach(stmt->scan_ssa_use!(used, stmt), code.stmts) - foreach(((_a, _b, node, _d),) -> scan_ssa_use!(used, node), code.new_nodes) + foreach(entry -> scan_ssa_use!(used, entry.node), code.new_nodes) if isempty(used) maxsize = 0 else @@ -90,7 +90,7 @@ function Base.show(io::IO, code::IRCode) cfg = code.cfg max_bb_idx_size = length(string(length(cfg.blocks))) bb_idx = 1 - perm = sortperm(code.new_nodes, by = x->x[1]) + perm = sortperm(code.new_nodes, by = x->x.pos) new_nodes_perm = Iterators.Stateful(perm) for idx in eachindex(code.stmts) if !isassigned(code.stmts, idx) @@ -116,9 +116,9 @@ function Base.show(io::IO, code::IRCode) print_sep = true end floop = true - while !isempty(new_nodes_perm) && code.new_nodes[peek(new_nodes_perm)][1] == idx + while !isempty(new_nodes_perm) && code.new_nodes[peek(new_nodes_perm)].pos == idx node_idx = popfirst!(new_nodes_perm) - _, reverse_affinity, typ, node, line = code.new_nodes[node_idx] + new_node = code.new_nodes[node_idx] node_idx += length(code.stmts) if print_sep if floop @@ -129,13 +129,13 @@ function Base.show(io::IO, code::IRCode) end print_sep = true floop = false - print_ssa_typ = !isa(node, PiNode) && node_idx in used + print_ssa_typ = !isa(new_node.node, PiNode) && node_idx in used Base.with_output_color(:yellow, io) do io′ - print_node(io′, node_idx, node, used, maxsize; color = false, - print_typ=!print_ssa_typ || (isa(node, Expr) && typ != node.typ)) + print_node(io′, node_idx, new_node.node, used, maxsize; color = false, + print_typ=!print_ssa_typ || (isa(new_node.node, Expr) && new_node.typ != new_node.node.typ)) end if print_ssa_typ - Base.printstyled(io, "::$(typ)", color=:red) + Base.printstyled(io, "::$(new_node.typ)", color=:red) end Base.println(io) end diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl index 32e84f68514ff..4de74b453b1d5 100644 --- a/base/compiler/ssair/slot2ssa.jl +++ b/base/compiler/ssair/slot2ssa.jl @@ -420,10 +420,14 @@ function domsort_ssa!(ir, domtree) end result_stmts = Any[renumber_ssa!(result_stmts[i], inst_rename, true) for i in 1:length(result_stmts)] cfg = CFG(new_bbs, Int[first(bb.stmts) for bb in new_bbs[2:end]]) - new_new_nodes = NewNode[(inst_rename[pos].id, reverse_affinity, typ, - renumber_ssa!(isa(node, PhiNode) ? - rename_phinode_edges(node, 0, result_order, bb_rename) : node, - inst_rename, true), lno) for (pos, reverse_affinity, typ, node, lno) in ir.new_nodes] + # (pos, reverse_affinity, typ, node, lno) + new_new_nodes = NewNode[ + NewNode(entry, + pos = inst_rename[entry.pos].id, + node = renumber_ssa!(isa(entry.node, PhiNode) ? + rename_phinode_edges(entry.node, 0, result_order, bb_rename) : entry.node, + inst_rename, true) + ) for entry in ir.new_nodes] new_ir = IRCode(ir, result_stmts, result_types, result_ltable, cfg, new_new_nodes) new_ir end @@ -595,12 +599,12 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do end typ = incoming_val == undef_token ? MaybeUndef(Union{}) : typ_for_val(incoming_val, ci) new_node_id = ssaval - length(ir.stmts) - old_insert, reverse_affinity, old_typ, _, old_line = ir.new_nodes[new_node_id] + old_entry = ir.new_nodes[new_node_id] if isa(typ, DelayedTyp) push!(type_refine_phi, ssaval) end - new_typ = isa(typ, DelayedTyp) ? Union{} : tmerge(old_typ, typ) - ir.new_nodes[new_node_id] = (old_insert, reverse_affinity, new_typ, node, old_line) + new_typ = isa(typ, DelayedTyp) ? Union{} : tmerge(old_entry.typ, typ) + ir.new_nodes[new_node_id] = NewNode(old_entry, typ=new_typ, node=node) incoming_vals[slot] = NewSSAValue(ssaval) end (item in visited) && continue @@ -659,7 +663,7 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do typ = MaybeUndef(Union{}) end push!(phicnodes[exc][cidx][3].values, - NewSSAValue(insert_node!(ir, idx+1, typ, node, true).id)) + NewSSAValue(insert_node!(ir, idx, typ, node, true).id)) end end end @@ -710,16 +714,16 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do for (_, ssa, node) in nodes new_typ = Union{} new_idx = ssa.id - length(ir.stmts) - old_insert, reverse_affinity, old_typ, _, old_line = ir.new_nodes[new_idx] - for i = 1:length(node.values) - orig_typ = typ = typ_for_val(node.values[i], ci) + node = ir.new_nodes[new_idx] + for i = 1:length(node.node.values) + orig_typ = typ = typ_for_val(node.node.values[i], ci) @assert !isa(typ, MaybeUndef) while isa(typ, DelayedTyp) - typ = ir.new_nodes[typ.phi.id - length(ir.stmts)][3] + typ = ir.new_nodes[typ.phi.id - length(ir.stmts)].typ end new_typ = tmerge(new_typ, typ) end - ir.new_nodes[new_idx] = (old_insert, reverse_affinity, new_typ, node, old_line) + ir.new_nodes[new_idx] = NewNode(node, typ=new_typ) end end # This is a bit awkward, because it basically duplicates what type @@ -730,16 +734,16 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do changed = false for phi in type_refine_phi new_idx = phi - length(ir.stmts) - old_insert, reverse_affinity, old_typ, node, old_line = ir.new_nodes[new_idx] + node = ir.new_nodes[new_idx] new_typ = Union{} - for i = 1:length(node.values) - if !isassigned(node.values, i) + for i = 1:length(node.node.values) + if !isassigned(node.node.values, i) if !isa(new_typ, MaybeUndef) new_typ = MaybeUndef(new_typ) end continue end - typ = typ_for_val(node.values[i], ci) + typ = typ_for_val(node.node.values[i], ci) was_maybe_undef = false if isa(typ, MaybeUndef) typ = typ.typ @@ -747,25 +751,25 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do end @assert !isa(typ, MaybeUndef) while isa(typ, DelayedTyp) - typ = ir.new_nodes[typ.phi.id - length(ir.stmts)][3] + typ = ir.new_nodes[typ.phi.id - length(ir.stmts)].typ end new_typ = tmerge(new_typ, was_maybe_undef ? MaybeUndef(typ) : typ) end - if !(old_typ ⊑ new_typ) || !(new_typ ⊑ old_typ) - ir.new_nodes[new_idx] = (old_insert, reverse_affinity, new_typ, node, old_line) + if !(node.typ ⊑ new_typ) || !(new_typ ⊑ node.typ) + ir.new_nodes[new_idx] = NewNode(node, typ=new_typ) changed = true end end end - types = Any[isa(types[i], DelayedTyp) ? ir.new_nodes[types[i].phi.id - length(ir.stmts)][2] : types[i] for i in 1:length(types)] - new_nodes = NewNode[let (pos, reverse_affinity, typ, node, line) = ir.new_nodes[i] - typ = isa(typ, DelayedTyp) ? ir.new_nodes[typ.phi.id - length(ir.stmts)][2] : typ - (pos, reverse_affinity, typ, node, line) + types = Any[isa(types[i], DelayedTyp) ? ir.new_nodes[types[i].phi.id - length(ir.stmts)].typ : types[i] for i in 1:length(types)] + new_nodes = NewNode[let node = ir.new_nodes[i] + typ = isa(node.typ, DelayedTyp) ? ir.new_nodes[node.typ.phi.id - length(ir.stmts)].typ : node.typ + NewNode(node, typ=typ) end for i in 1:length(ir.new_nodes)] # Renumber SSA values new_code = Any[new_to_regular(renumber_ssa!(new_code[i], ssavalmap)) for i in 1:length(new_code)] - new_nodes = NewNode[let (pt, reverse_affinity, typ, stmt, line) = new_nodes[i] - (pt, reverse_affinity, typ, new_to_regular(renumber_ssa!(stmt, ssavalmap)), line) + new_nodes = NewNode[let node = new_nodes[i] + NewNode(node, node=new_to_regular(renumber_ssa!(node.node, ssavalmap))) end for i in 1:length(new_nodes)] ir = IRCode(ir, new_code, types, ir.lines, ir.cfg, new_nodes) @timeit "domsort" ir = domsort_ssa!(ir, domtree) diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl index 3fd5674313280..38f7cf8279853 100644 --- a/base/compiler/ssair/verify.jl +++ b/base/compiler/ssair/verify.jl @@ -11,13 +11,13 @@ end function check_op(ir::IRCode, domtree::DomTree, @nospecialize(op), use_bb::Int, use_idx::Int) if isa(op, SSAValue) if op.id > length(ir.stmts) - def_bb = block_for_inst(ir.cfg, ir.new_nodes[op.id - length(ir.stmts)][1]) + def_bb = block_for_inst(ir.cfg, ir.new_nodes[op.id - length(ir.stmts)].pos) else def_bb = block_for_inst(ir.cfg, op.id) end if (def_bb == use_bb) if op.id > length(ir.stmts) - @assert ir.new_nodes[op.id - length(ir.stmts)][1] <= use_idx + @assert ir.new_nodes[op.id - length(ir.stmts)].pos <= use_idx else @assert op.id < use_idx end