Merge pull request #26726 from JuliaLang/kf/ssaexc

[NewOptimizer] Handle exceptions in new IR

Author: Keno

base/boot.jl

@@ -108,6 +108,14 @@
 #    values::Vector{Any}
 #end
 
+#struct PhiCNode
+#    values::Vector{Any}
+#end
+
+#struct UpsilonNode
+#    val
+#end
+
 #struct QuoteNode
 #    value
 #end
@@ -151,7 +159,7 @@ export
     TypeError, ArgumentError, MethodError, AssertionError, LoadError, InitError,
     UndefKeywordError,
     # AST representation
-    Expr, QuoteNode, LineNumberNode, GlobalRef, PiNode, PhiNode,
+    Expr, QuoteNode, LineNumberNode, GlobalRef,
     # object model functions
     fieldtype, getfield, setfield!, nfields, throw, tuple, ===, isdefined, eval,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
@@ -357,6 +365,9 @@ eval(Core, :(SlotNumber(n::Int) = $(Expr(:new, :SlotNumber, :n))))
 eval(Core, :(TypedSlot(n::Int, @nospecialize(t)) = $(Expr(:new, :TypedSlot, :n, :t))))
 eval(Core, :(PhiNode(edges::Array{Any, 1}, values::Array{Any, 1}) = $(Expr(:new, :PhiNode, :edges, :values))))
 eval(Core, :(PiNode(val, typ) = $(Expr(:new, :PiNode, :val, :typ))))
+eval(Core, :(PhiCNode(values::Array{Any, 1}) = $(Expr(:new, :PhiCNode, :values))))
+eval(Core, :(UpsilonNode(val) = $(Expr(:new, :UpsilonNode, :val))))
+eval(Core, :(UpsilonNode() = $(Expr(:new, :UpsilonNode))))
 
 Module(name::Symbol=:anonymous, std_imports::Bool=true) = ccall(:jl_f_new_module, Ref{Module}, (Any, Bool), name, std_imports)
 
@@ -419,13 +430,26 @@ function Symbol(a::Array{UInt8,1})
 end
 Symbol(s::Symbol) = s
 
+struct LineInfoNode
+    mod::Module
+    method::Symbol
+    file::Symbol
+    line::Int
+    inlined_at::Int
+    LineInfoNode(mod::Module, method::Symbol, file::Symbol, line::Int, inlined_at::Int) =
+        new(mod, method, file, line, inlined_at)
+end
+
 # module providing the IR object model
 module IR
 export CodeInfo, MethodInstance, GotoNode, LabelNode,
-    NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot
+    NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
+    PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode
 
 import Core: CodeInfo, MethodInstance, GotoNode, LabelNode,
-    NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot
+    NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
+    PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode
+
 end
 
 # docsystem basics

base/compiler/abstractinterpretation.jl

@@ -866,7 +866,8 @@ function abstract_eval_global(M::Module, s::Symbol)
 end
 
 function abstract_eval_ssavalue(s::SSAValue, src::CodeInfo)
-    typ = src.ssavaluetypes[s.id + 1]
+    new_style_ir = src.codelocs !== nothing
+    typ = src.ssavaluetypes[new_style_ir ? s.id : (s.id + 1)]
     if typ === NOT_FOUND
         return Bottom
     end

base/compiler/optimize.jl

@@ -1,7 +1,5 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-include("compiler/ssair/driver.jl")
-
 #####################
 # OptimizationState #
 #####################
@@ -71,6 +69,8 @@ function OptimizationState(linfo::MethodInstance, params::Params)
     return OptimizationState(linfo, src, params)
 end
 
+include("compiler/ssair/driver.jl")
+
 _topmod(sv::OptimizationState) = _topmod(sv.mod)
 
 genlabel(sv::OptimizationState) = LabelNode(sv.next_label += 1)
@@ -279,37 +279,33 @@ function optimize(me::InferenceState)
         me.linfo.inInference = false
     elseif me.optimize
         opt = OptimizationState(me)
-        # This pass is required for the AST to be valid in codegen
-        # if any `SSAValue` is created by type inference. Ref issue #6068
-        # This (and `reindex_labels!`) needs to be run for `!me.optimize`
-        # if we start to create `SSAValue` in type inference when not
-        # optimizing and use unoptimized IR in codegen.
-        gotoifnot_elim_pass!(opt)
-        inlining_pass!(opt, opt.src.propagate_inbounds)
-        any_enter = any_phi = false
-        if enable_new_optimizer[]
-            any_enter = any(x->isa(x, Expr) && x.head == :enter, opt.src.code)
-            any_phi = any(x->isa(x, PhiNode) || (isa(x, Expr) && x.head == :(=) && isa(x.args[2], PhiNode)), opt.src.code)
-        end
-        if enable_new_optimizer[] && !any_enter && isa(def, Method)
+        if enable_new_optimizer[] && isa(def, Method)
             reindex_labels!(opt)
             nargs = Int(opt.nargs) - 1
             if def isa Method
-                topline = LineInfoNode(opt.mod, def.name, def.file, def.line, 0)
+                topline = LineInfoNode(opt.mod, def.name, def.file, Int(def.line), Int(0))
             else
                 topline = LineInfoNode(opt.mod, NullLineInfo.name, NullLineInfo.file, 0, 0)
             end
             linetable = [topline]
-            ir = run_passes(opt.src, nargs, linetable)
-            replace_code!(opt.src, ir, nargs, linetable)
-            push!(opt.src.code, LabelNode(length(opt.src.code) + 1))
-            any_phi = true
-        elseif !any_phi
+            @timeit "optimizer" ir = run_passes(opt.src, nargs, linetable, opt)
+            force_noinline = any(x->isexpr(x, :meta) && x.args[1] == :noinline, ir.meta)
+            #@timeit "legacy conversion" replace_code!(opt.src, ir, nargs, linetable)
+            replace_code_newstyle!(opt.src, ir, nargs, linetable)
+        else
+            # This pass is required for the AST to be valid in codegen
+            # if any `SSAValue` is created by type inference. Ref issue #6068
+            # This (and `reindex_labels!`) needs to be run for `!me.optimize`
+            # if we start to create `SSAValue` in type inference when not
+            # optimizing and use unoptimized IR in codegen.
+            gotoifnot_elim_pass!(opt)
+            inlining_pass!(opt, opt.src.propagate_inbounds)
             # Clean up after inlining
             gotoifnot_elim_pass!(opt)
             basic_dce_pass!(opt)
             void_use_elim_pass!(opt)
-            if !enable_new_optimizer[]
+            any_phi = any(x->isa(x, PhiNode) || (isa(x, Expr) && x.head == :(=) && isa(x.args[2], PhiNode)), opt.src.code)
+            if !any_phi && !enable_new_optimizer[]
                 copy_duplicated_expr_pass!(opt)
                 split_undef_flag_pass!(opt)
                 fold_constant_getfield_pass!(opt)
@@ -321,13 +317,13 @@ function optimize(me::InferenceState)
                 basic_dce_pass!(opt)
                 void_use_elim_pass!(opt)
             end
-        end
-        # Pop metadata before label reindexing
-        let code = opt.src.code::Array{Any,1}
-            meta_elim_pass!(code, coverage_enabled())
-            filter!(x -> x !== nothing, code)
-            force_noinline = peekmeta(code, :noinline)[1]
-            reindex_labels!(opt)
+            # Pop metadata before label reindexing
+            let code = opt.src.code::Array{Any,1}
+                meta_elim_pass!(code, coverage_enabled())
+                filter!(x -> x !== nothing, code)
+                force_noinline = peekmeta(code, :noinline)[1]
+                reindex_labels!(opt)
+            end
         end
         me.min_valid = opt.min_valid
         me.max_valid = opt.max_valid
@@ -1510,7 +1506,7 @@ function inlineable(@nospecialize(f), @nospecialize(ft), e::Expr, atypes::Vector
                     end
                 end
                 edges = Any[newlabels[edge::Int + 1] - 1 for edge in edges]
-                a.args[2] = PhiNode(edges, a.args[2].values)
+                a.args[2] = PhiNode(edges, copy_exprargs(a.args[2].values))
             elseif a.head === :meta && length(a.args) > 0
                 a1 = a.args[1]
                 if a1 === :push_loc
@@ -4234,6 +4230,7 @@ function reindex_labels!(body::Vector{Any})
             elseif el.head === :(=)
                 if isa(el.args[2], PhiNode)
                     edges = Any[mapping[edge::Int + 1] - 1 for edge in el.args[2].edges]
+                    @assert all(x->x >= 0, edges)
                     el.args[2] = PhiNode(convert(Vector{Any}, edges), el.args[2].values)
                 end
             end

base/compiler/ssair/domtree.jl

@@ -66,7 +66,7 @@ function construct_domtree(cfg)
         changed = false
         for n = 2:length(cfg.blocks)
             isempty(cfg.blocks[n].preds) && continue
-            firstp, rest = Iterators.peel(cfg.blocks[n].preds)
+            firstp, rest = Iterators.peel(Iterators.filter(p->p != 0, cfg.blocks[n].preds))
             new_doms = copy(dominators[firstp])
             for p in rest
                 intersect!(new_doms, dominators[p])

base/compiler/ssair/driver.jl

@@ -1,22 +1,34 @@
-struct LineInfoNode
-    mod::Module
-    method::Symbol
-    file::Symbol
-    line::Int
-    inlined_at::Int
-end
+using Core: LineInfoNode
 const NullLineInfo = LineInfoNode(@__MODULE__, Symbol(""), Symbol(""), 0, 0)
 
+if false
+    import Base: Base, @show
+else
+    macro show(s)
+        return :(println(stdout, $(QuoteNode(s)), " = ", $(esc(s))))
+    end
+end
+
 include("compiler/ssair/ir.jl")
 include("compiler/ssair/domtree.jl")
 include("compiler/ssair/slot2ssa.jl")
 include("compiler/ssair/queries.jl")
 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")
 
-macro show(s)
-    # return :(println($(QuoteNode(s)), " = ", $(esc(s))))
+function normalize_expr(stmt::Expr)
+    if stmt.head === :gotoifnot
+        return GotoIfNot(stmt.args...)
+    elseif stmt.head === :return
+        return ReturnNode((length(stmt.args) == 0 ? (nothing,) : stmt.args)...)
+    elseif stmt.head === :unreachable
+        return ReturnNode()
+    else
+        return stmt
+    end
 end
 
 function normalize(@nospecialize(stmt), meta::Vector{Any}, table::Vector{LineInfoNode}, loc::RefValue{Int})
@@ -62,12 +74,8 @@ function normalize(@nospecialize(stmt), meta::Vector{Any}, table::Vector{LineInf
             return nothing
         elseif stmt.head === :line
             return nothing # deprecated - we shouldn't encounter this
-        elseif stmt.head === :gotoifnot
-            return GotoIfNot(stmt.args...)
-        elseif stmt.head === :return
-            return ReturnNode((length(stmt.args) == 0 ? (nothing,) : stmt.args)...)
-        elseif stmt.head === :unreachable
-            return ReturnNode()
+        else
+            return normalize_expr(stmt)
         end
     elseif isa(stmt, LabelNode)
         return nothing
@@ -88,55 +96,61 @@ function normalize(@nospecialize(stmt), meta::Vector{Any}, table::Vector{LineInf
     return stmt
 end
 
-function run_passes(ci::CodeInfo, nargs::Int, linetable::Vector{LineInfoNode})
+function just_construct_ssa(ci::CodeInfo, code::Vector{Any}, nargs::Int, linetable::Vector{LineInfoNode})
     mod = linetable[1].mod
-    ci.code = copy(ci.code)
     # Go through and add an unreachable node after every
     # Union{} call. Then reindex labels.
     idx = 1
-    while idx <= length(ci.code)
-        stmt = ci.code[idx]
+    while idx <= length(code)
+        stmt = code[idx]
         if isexpr(stmt, :(=))
             stmt = stmt.args[2]
         end
         if isa(stmt, Expr) && stmt.typ === Union{}
-            if !(idx < length(ci.code) && isexpr(ci.code[idx+1], :unreachable))
-                insert!(ci.code, idx + 1, ReturnNode())
+            if !(idx < length(code) && isexpr(code[idx+1], :unreachable))
+                insert!(code, idx + 1, ReturnNode())
                 idx += 1
             end
         end
         idx += 1
     end
-    reindex_labels!(ci.code)
+    reindex_labels!(code)
     meta = Any[]
-    lines = fill(0, length(ci.code))
+    lines = fill(0, length(code))
     let loc = RefValue(1)
-        for i = 1:length(ci.code)
-            stmt = ci.code[i]
+        for i = 1:length(code)
+            stmt = code[i]
             stmt = normalize(stmt, meta, linetable, loc)
-            ci.code[i] = stmt
+            code[i] = stmt
             if !(stmt === nothing)
                 lines[i] = loc[]
             end
         end
     end
-    ci.code = strip_trailing_junk!(ci.code, lines)
-    cfg = compute_basic_blocks(ci.code)
-    defuse_insts = scan_slot_def_use(nargs, ci)
-    domtree = construct_domtree(cfg)
-    ir = let code = Any[nothing for _ = 1:length(ci.code)]
+    code = strip_trailing_junk!(code, lines)
+    cfg = compute_basic_blocks(code)
+    defuse_insts = scan_slot_def_use(nargs, ci, code)
+    @timeit "domtree 1" domtree = construct_domtree(cfg)
+    ir = let code = Any[nothing for _ = 1:length(code)]
              argtypes = ci.slottypes[1:(nargs+1)]
-            IRCode(code, lines, cfg, argtypes, mod, meta)
+            IRCode(code, Any[], lines, cfg, argtypes, mod, meta)
         end
-    ir = construct_ssa!(ci, ir, domtree, defuse_insts, nargs)
+    @timeit "construct_ssa" ir = construct_ssa!(ci, code, ir, domtree, defuse_insts, nargs)
+    return ir
+end
+
+function run_passes(ci::CodeInfo, nargs::Int, linetable::Vector{LineInfoNode}, sv::OptimizationState)
+    ir = just_construct_ssa(ci, copy(ci.code), nargs, linetable)
     # TODO: Domsorting can produce an updated domtree - no need to recompute here
-    domtree = construct_domtree(ir.cfg)
-    ir = compact!(ir)
-    verify_ir(ir)
-    ir = getfield_elim_pass!(ir, domtree)
-    ir = compact!(ir)
-    ir = type_lift_pass!(ir)
-    ir = compact!(ir)
-    verify_ir(ir)
+    @timeit "compact 1" ir = compact!(ir)
+    #@timeit "verify 1" verify_ir(ir)
+    @timeit "Inlining" ir = ssa_inlining_pass!(ir, nothing, linetable, sv)
+    #@timeit "verify 2" verify_ir(ir)
+    @timeit "domtree 2" domtree = construct_domtree(ir.cfg)
+    @timeit "SROA" ir = getfield_elim_pass!(ir, domtree)
+    @timeit "compact 2" ir = compact!(ir)
+    @timeit "type lift" ir = type_lift_pass!(ir)
+    @timeit "compact 3" ir = compact!(ir)
+    #@timeit "verify 3" verify_ir(ir)
     return ir
 end