Only compute effect_free once (#40066)

This is a revival of #33753. While this is useful in itself,
my real goal here is to be able to make use of the computed
effect-freeness earlier to allow removal of calls that the
compiler has shown to be effect-free, but are too large to
inline. This moves in that direction, by making
effect-freeness an SSA flag that an appropriate pass can
then set and that it propagated appropriately by inlining
(since unlike effect-freeness on builtins which is easy
to compute, effect-freeness on generic function calls
requires interprocedural information that we throw
away after inlining into the outer function). While
I'm at it, also refactor the instruction insertion
interface, to make them all use a common type, rather
than random assortments of subsets of the possible fields.

Author: Keno

base/compiler/compiler.jl

@@ -99,6 +99,10 @@ using .Order
 include("sort.jl")
 using .Sort
 
+# We don't include some.jl, but this definition is still useful.
+something(x::Nothing, y...) = something(y...)
+something(x::Any, y...) = x
+
 ############
 # compiler #
 ############

base/compiler/optimize.jl

@@ -132,7 +132,12 @@ const SLOT_ASSIGNEDONCE = 16 # slot is assigned to only once
 const SLOT_USEDUNDEF    = 32 # slot has uses that might raise UndefVarError
 # const SLOT_CALLED      = 64
 
-const IR_FLAG_INBOUNDS = 0x01
+# This statement was marked as @inbounds by the user. If replaced by inlining,
+# any contained boundschecks may be removed
+const IR_FLAG_INBOUNDS       = 0x01
+# This statement may be removed if its result is unused. In particular it must
+# thus be both pure and effect free.
+const IR_FLAG_EFFECT_FREE    = 0x01 << 4
 
 # known to be always effect-free (in particular nothrow)
 const _PURE_BUILTINS = Any[tuple, svec, ===, typeof, nfields]

base/compiler/ssair/inlining.jl

@@ -324,8 +324,8 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
     if is_opaque
         # Replace the first argument by a load of the capture environment
         argexprs[1] = insert_node_here!(compact,
-            Expr(:call, GlobalRef(Core, :getfield), argexprs[1], :captures),
-            spec.ir.argtypes[1], compact.result[idx][:line])
+            NewInstruction(Expr(:call, GlobalRef(Core, :getfield), argexprs[1], QuoteNode(:captures)),
+            spec.ir.argtypes[1], compact.result[idx][:line]))
     end
     flag = compact.result[idx][:flag]
     boundscheck_idx = boundscheck
@@ -386,8 +386,8 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                         inline_compact.result[idx′][:type] = (isa(val, Argument) || isa(val, Expr)) ?
                             compact_exprtype(compact, val) :
                             compact_exprtype(inline_compact, val)
-                        insert_node_here!(inline_compact, GotoNode(post_bb_id),
-                                          Any, compact.result[idx′][:line],
+                        insert_node_here!(inline_compact, NewInstruction(GotoNode(post_bb_id),
+                                          Any, compact.result[idx′][:line]),
                                           true)
                         push!(pn.values, SSAValue(idx′))
                     else
@@ -419,7 +419,8 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
         if length(pn.edges) == 1
             return_value = pn.values[1]
         else
-            return_value = insert_node_here!(compact, pn, compact_exprtype(compact, SSAValue(idx)), compact.result[idx][:line])
+            return_value = insert_node_here!(compact,
+                NewInstruction(pn, compact_exprtype(compact, SSAValue(idx)), compact.result[idx][:line]))
         end
     end
     return_value
@@ -448,15 +449,15 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
             a <: m && continue
             # Generate isa check
             isa_expr = Expr(:call, isa, argexprs[i], m)
-            ssa = insert_node_here!(compact, isa_expr, Bool, line)
+            ssa = insert_node_here!(compact, NewInstruction(isa_expr, Bool, line))
             if cond === true
                 cond = ssa
             else
                 and_expr = Expr(:call, and_int, cond, ssa)
-                cond = insert_node_here!(compact, and_expr, Bool, line)
+                cond = insert_node_here!(compact, NewInstruction(and_expr, Bool, line))
             end
         end
-        insert_node_here!(compact, GotoIfNot(cond, next_cond_bb), Union{}, line)
+        insert_node_here!(compact, NewInstruction(GotoIfNot(cond, next_cond_bb), Union{}, line))
         bb = next_cond_bb - 1
         finish_current_bb!(compact, 0)
         argexprs′ = argexprs
@@ -466,45 +467,49 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
                 a, m = atype.parameters[i], metharg.parameters[i]
                 (isa(argexprs[i], SSAValue) || isa(argexprs[i], Argument)) || continue
                 if !(a <: m)
-                    argexprs′[i] = insert_node_here!(compact, PiNode(argexprs′[i], m),
-                                                     m, line)
+                    argexprs′[i] = insert_node_here!(compact,
+                        NewInstruction(PiNode(argexprs′[i], m), m, line))
                 end
             end
         end
         if isa(case, InliningTodo)
             val = ir_inline_item!(compact, idx, argexprs′, linetable, case, boundscheck, todo_bbs)
         elseif isa(case, MethodInstance)
-            val = insert_node_here!(compact, Expr(:invoke, case, argexprs′...), typ, line)
+            val = insert_node_here!(compact,
+                NewInstruction(Expr(:invoke, case, argexprs′...), typ, line))
         else
             case = case::ConstantCase
             val = case.val
         end
         if !isempty(compact.result_bbs[bb].preds)
             push!(pn.edges, bb)
             push!(pn.values, val)
-            insert_node_here!(compact, GotoNode(join_bb), Union{}, line)
+            insert_node_here!(compact,
+                NewInstruction(GotoNode(join_bb), Union{}, line))
         else
-            insert_node_here!(compact, ReturnNode(), Union{}, line)
+            insert_node_here!(compact,
+                NewInstruction(ReturnNode(), Union{}, line))
         end
         finish_current_bb!(compact, 0)
     end
     bb += 1
     # We're now in the fall through block, decide what to do
     if item.fully_covered
         e = Expr(:call, GlobalRef(Core, :throw), fatal_type_bound_error)
-        insert_node_here!(compact, e, Union{}, line)
-        insert_node_here!(compact, ReturnNode(), Union{}, line)
+        insert_node_here!(compact, NewInstruction(e, Union{}, line))
+        insert_node_here!(compact, NewInstruction(ReturnNode(), Union{}, line))
         finish_current_bb!(compact, 0)
     else
-        ssa = insert_node_here!(compact, stmt, typ, line)
+        ssa = insert_node_here!(compact, NewInstruction(stmt, typ, line))
         push!(pn.edges, bb)
         push!(pn.values, ssa)
-        insert_node_here!(compact, GotoNode(join_bb), Union{}, line)
+        insert_node_here!(compact, NewInstruction(GotoNode(join_bb), Union{}, line))
         finish_current_bb!(compact, 0)
     end
 
     # We're now in the join block.
-    compact.ssa_rename[compact.idx-1] = insert_node_here!(compact, pn, typ, line)
+    compact.ssa_rename[compact.idx-1] = insert_node_here!(compact,
+        NewInstruction(pn, typ, line))
     nothing
 end
 
@@ -553,8 +558,9 @@ function batch_inline!(todo::Vector{Pair{Int, Any}}, ir::IRCode, linetable::Vect
                 # At the moment we will allow globalrefs in argument position, turn those into ssa values
                 for aidx in 1:length(argexprs)
                     aexpr = argexprs[aidx]
-                    if isa(aexpr, GlobalRef) || isa(aexpr, Expr)
-                        argexprs[aidx] = insert_node_here!(compact, aexpr, compact_exprtype(compact, aexpr), compact.result[idx][:line])
+                    if isa(aexpr, Expr)
+                        argexprs[aidx] = insert_node_here!(compact,
+                            NewInstruction(aexpr, compact_exprtype(compact, aexpr), compact.result[idx][:line]))
                     end
                 end
                 if isa(item, InliningTodo)
@@ -630,7 +636,7 @@ function rewrite_apply_exprargs!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::
                     new_argexpr = quoted(def_atype.val)
                 else
                     new_call = Expr(:call, GlobalRef(Core, :getfield), def, j)
-                    new_argexpr = insert_node!(ir, idx, def_atype, new_call)
+                    new_argexpr = insert_node!(ir, idx, NewInstruction(new_call, def_atype))
                 end
                 push!(new_argexprs, new_argexpr)
                 push!(new_atypes, def_atype)
@@ -640,7 +646,7 @@ function rewrite_apply_exprargs!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::
             for i = 1:length(thisarginfo.each)
                 call = thisarginfo.each[i]
                 new_stmt = Expr(:call, argexprs[2], def, state...)
-                state1 = insert_node!(ir, idx, call.rt, new_stmt)
+                state1 = insert_node!(ir, idx, NewInstruction(new_stmt, call.rt))
                 new_sig = with_atype(call_sig(ir, new_stmt)::Signature)
                 info = call.info
                 handled = false
@@ -661,12 +667,14 @@ function rewrite_apply_exprargs!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::
                 end
                 if i != length(thisarginfo.each)
                     valT = getfield_tfunc(call.rt, Const(1))
-                    val_extracted = insert_node!(ir, idx, valT,
-                        Expr(:call, GlobalRef(Core, :getfield), state1, 1))
+                    val_extracted = insert_node!(ir, idx, NewInstruction(
+                        Expr(:call, GlobalRef(Core, :getfield), state1, 1),
+                        valT))
                     push!(new_argexprs, val_extracted)
                     push!(new_atypes, valT)
-                    state_extracted = insert_node!(ir, idx, getfield_tfunc(call.rt, Const(2)),
-                        Expr(:call, GlobalRef(Core, :getfield), state1, 2))
+                    state_extracted = insert_node!(ir, idx, NewInstruction(
+                        Expr(:call, GlobalRef(Core, :getfield), state1, 2),
+                        getfield_tfunc(call.rt, Const(2))))
                     state = Core.svec(state_extracted)
                 end
             end
@@ -933,7 +941,7 @@ function inline_splatnew!(ir::IRCode, idx::Int)
             for j = 1:n
                 atype = getfield_tfunc(tt, Const(j))
                 new_call = Expr(:call, Core.getfield, tup, j)
-                new_argexpr = insert_node!(ir, idx, atype, new_call)
+                new_argexpr = insert_node!(ir, idx, NewInstruction(new_call, atype))
                 push!(new_argexprs, new_argexpr)
             end
             stmt.head = :new
@@ -1081,17 +1089,32 @@ function narrow_opaque_closure!(ir::IRCode, stmt::Expr, @nospecialize(info), sta
     end
 end
 
+# As a matter of convenience, this pass also computes effect-freenes.
+# For primitives, we do that right here. For proper calls, we will
+# discover this when we consult the caches.
+function check_effect_free!(ir::IRCode, @nospecialize(stmt), @nospecialize(calltype), idx::Int)
+    if stmt_effect_free(stmt, calltype, ir, ir.sptypes)
+        ir.stmts[idx][:flag] |= IR_FLAG_EFFECT_FREE
+    end
+end
+
 # Handles all analysis and inlining of intrinsics and builtins. In particular,
 # this method does not access the method table or otherwise process generic
 # functions.
 function process_simple!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int, state::InliningState)
     stmt = ir.stmts[idx][:inst]
-    stmt isa Expr || return nothing
-    if stmt.head === :splatnew
-        inline_splatnew!(ir, idx)
+    calltype = ir.stmts[idx][:type]
+    if !(stmt isa Expr)
+        check_effect_free!(ir, stmt, calltype, idx)
         return nothing
-    elseif stmt.head === :new_opaque_closure
-        narrow_opaque_closure!(ir, stmt, ir.stmts[idx][:info], state)
+    end
+    if stmt.head !== :call
+        if stmt.head === :splatnew
+            inline_splatnew!(ir, idx)
+        elseif stmt.head === :new_opaque_closure
+            narrow_opaque_closure!(ir, stmt, ir.stmts[idx][:info], state)
+        end
+        check_effect_free!(ir, stmt, calltype, idx)
         return nothing
     end
 
@@ -1105,13 +1128,14 @@ function process_simple!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int, sta
     sig === nothing && return nothing
 
     # Check if we match any of the early inliners
-    calltype = ir.stmts[idx][:type]
     res = early_inline_special_case(ir, sig, stmt, state.params, calltype)
     if res !== nothing
         ir.stmts[idx][:inst] = res
         return nothing
     end
 
+    check_effect_free!(ir, stmt, calltype, idx)
+
     if sig.f !== Core.invoke && is_builtin(sig)
         # No inlining for builtins (other invoke/apply)
         return nothing
@@ -1121,8 +1145,10 @@ function process_simple!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int, sta
 
     # Special case inliners for regular functions
     if late_inline_special_case!(ir, sig, idx, stmt, state.params) || is_return_type(sig.f)
+        check_effect_free!(ir, ir.stmts[idx][:inst], calltype, idx)
         return nothing
     end
+
     return sig
 end
 
@@ -1256,6 +1282,7 @@ function assemble_inline_todo!(ir::IRCode, state::InliningState)
                 ir.stmts[idx][:inst] = quoted(calltype.val)
                 continue
             end
+            ir.stmts[idx][:flag] |= IR_FLAG_EFFECT_FREE
             info = info.info
         end
 
@@ -1306,7 +1333,7 @@ end
 function mk_tuplecall!(compact::IncrementalCompact, args::Vector{Any}, line_idx::Int32)
     e = Expr(:call, TOP_TUPLE, args...)
     etyp = tuple_tfunc(Any[compact_exprtype(compact, args[i]) for i in 1:length(args)])
-    return insert_node_here!(compact, e, etyp, line_idx)
+    return insert_node_here!(compact, NewInstruction(e, etyp, line_idx))
 end
 
 function linear_inline_eligible(ir::IRCode)
@@ -1371,7 +1398,7 @@ function late_inline_special_case!(ir::IRCode, sig::Signature, idx::Int, stmt::E
             return true
         end
         cmp_call = Expr(:call, GlobalRef(Core, :(===)), stmt.args[2], stmt.args[3])
-        cmp_call_ssa = insert_node!(ir, idx, Bool, cmp_call)
+        cmp_call_ssa = insert_node!(ir, idx, effect_free(NewInstruction(cmp_call, Bool)))
         not_call = Expr(:call, GlobalRef(Core.Intrinsics, :not_int), cmp_call_ssa)
         ir[SSAValue(idx)] = not_call
         return true