use and boost inlining_cost

Author: aviatesk

base/compiler/abstractinterpretation.jl

@@ -1286,8 +1286,6 @@ function const_prop_methodinstance_heuristic(interp::AbstractInterpreter,
     elseif is_stmt_noinline(flag)
         # this call won't be inlined, thus this constant-prop' will most likely be unfruitful
         return false
-    elseif any_const_prop_profitable_args(effects, arginfo.argtypes)
-        return true
     end
     # Peek at the inferred result for the method to determine if the optimizer
     # was able to cut it down to something simple (inlineable in particular).
@@ -1297,8 +1295,9 @@ function const_prop_methodinstance_heuristic(interp::AbstractInterpreter,
     if isa(code, CodeInstance)
         inferred = @atomic :monotonic code.inferred
         rt = code.rettype
+        boost = any_const_prop_profitable_args(effects, arginfo.argtypes)
         # TODO propagate a specific `CallInfo` that conveys information about this call
-        iinfo = InliningInfo(rt, mi, arginfo.argtypes, NoCallInfo(), IR_FLAG_NULL)
+        iinfo = InliningInfo(rt, mi, arginfo.argtypes, NoCallInfo(), IR_FLAG_NULL, boost)
         if inlining_policy(interp, inferred, iinfo) !== nothing
             return true
         end

base/compiler/optimize.jl

@@ -57,7 +57,8 @@ is_source_inferred(@nospecialize src::MaybeCompressed) =
 struct InlineabilityInfo
     rt
     mi::MethodInstance
-    InlineabilityInfo(@nospecialize(rt), mi::MethodInstance) = new(rt, mi)
+    boost::Bool
+    InlineabilityInfo(@nospecialize(rt), mi::MethodInstance, boost::Bool=false) = new(rt, mi, boost)
 end
 
 """
@@ -76,7 +77,7 @@ function is_inlineable(interp::AbstractInterpreter, @nospecialize(src::MaybeComp
     params = OptimizationParams(interp)
     cost_threshold = default = params.inline_cost_threshold
     # if the method is declared as `@inline`, increase the cost threshold 20x
-    if is_declared_inline(src)
+    if is_declared_inline(src) || ibinfo.boost
         cost_threshold += 19*default
     end
     if ibinfo !== nothing
@@ -106,9 +107,10 @@ struct InliningInfo
     argtypes::Vector{Any}
     info::CallInfo
     stmt_flag::UInt8
+    boost::Bool
     function InliningInfo(@nospecialize(rt), mi::MethodInstance, argtypes::Vector{Any},
-                          @nospecialize(info::CallInfo), stmt_flag::UInt8)
-        return new(rt, mi, argtypes, info, stmt_flag)
+                          @nospecialize(info::CallInfo), stmt_flag::UInt8, boost::Bool=false)
+        return new(rt, mi, argtypes, info, stmt_flag, boost)
     end
 end
 
@@ -121,7 +123,8 @@ inlined by the inlining algorithm, otherwise return `nothing`.
 function inlining_policy(interp::AbstractInterpreter, @nospecialize(src), iinfo::InliningInfo)
     if isa(src, MaybeCompressed)
         if is_source_inferred(src)
-            if is_stmt_inline(iinfo.stmt_flag) || is_inlineable(interp, src, InlineabilityInfo(iinfo.rt, iinfo.mi))
+            if (is_stmt_inline(iinfo.stmt_flag) ||
+                is_inlineable(interp, src, InlineabilityInfo(iinfo.rt, iinfo.mi, iinfo.boost)))
                 return src
             end
         end

base/compiler/typeinfer.jl

@@ -346,12 +346,14 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
                         relocatability, precompile)
 end
 
-function maybe_compress_codeinfo(interp::AbstractInterpreter, mi::MethodInstance, ci::CodeInfo)
+function maybe_compress_codeinfo(interp::AbstractInterpreter, mi::MethodInstance, ci::CodeInfo,
+                                 ipo_effects::Effects)
     def = mi.def
     isa(def, Method) || return ci
     if may_discard_trees(interp)
         cache_the_tree = ci.inferred && (
             is_inlineable(interp, ci, InlineabilityInfo(ci.rettype, mi)) ||
+            ipo_effects.const_prop_profitable_args !== NO_PROFITABLE_ARGS || # TODO remove me?
             isa_compileable_sig(mi))
     else
         cache_the_tree = true
@@ -381,7 +383,7 @@ function transform_result_for_cache(interp::AbstractInterpreter,
     if inferred_result isa CodeInfo
         inferred_result.min_world = first(valid_worlds)
         inferred_result.max_world = last(valid_worlds)
-        inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result)
+        inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result, result.effects)
     end
     # The global cache can only handle objects that codegen understands
     if !isa(inferred_result, MaybeCompressed)