From bde98275b0c981af72f964811e811caafba14d79 Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki Date: Wed, 1 Nov 2023 01:59:36 +0900 Subject: [PATCH] revisit #47137: avoid round-trip of locally-cached inferred source Built on top of #51958, with the improved performance of `cfg_simplify!`, let's give another try on JuliaLang/julia#47137. Tha aim is to retain locally cached inferred source as `IRCode`, eliminating the need for the inlining algorithm to round-trip it through `CodeInfo` representation. --- base/compiler/abstractinterpretation.jl | 1 + base/compiler/optimize.jl | 6 +++--- base/compiler/typeinfer.jl | 10 ++++++++-- 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl index 82aca46f3e7edd..25ccb1667591d2 100644 --- a/base/compiler/abstractinterpretation.jl +++ b/base/compiler/abstractinterpretation.jl @@ -1193,6 +1193,7 @@ function const_prop_call(interp::AbstractInterpreter, add_remark!(interp, sv, "[constprop] Could not retrieve the source") return nothing # this is probably a bad generated function (unsound), but just ignore it end + inf_result.must_be_codeinf = false frame.parent = sv if !typeinf(interp, frame) add_remark!(interp, sv, "[constprop] Fresh constant inference hit a cycle") diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl index 305c9b5c03b100..405286bda38de3 100644 --- a/base/compiler/optimize.jl +++ b/base/compiler/optimize.jl @@ -95,6 +95,7 @@ function inlining_policy(interp::AbstractInterpreter, return nothing end elseif isa(src, IRCode) + # n.b. the inlineability was computed within `finish!` return src elseif isa(src, SemiConcreteResult) if is_declared_noinline(mi.def::Method) @@ -196,10 +197,9 @@ include("compiler/ssair/passes.jl") include("compiler/ssair/irinterp.jl") function ir_to_codeinf!(opt::OptimizationState) - (; linfo, src) = opt - src = ir_to_codeinf!(src, opt.ir::IRCode) + src = ir_to_codeinf!(opt.src, opt.ir::IRCode) opt.ir = nothing - validate_code_in_debug_mode(linfo, src, "optimized") + validate_code_in_debug_mode(opt.linfo, src, "optimized") return src end diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl index d1f635d3be704d..4e8bd4f9fa06d5 100644 --- a/base/compiler/typeinfer.jl +++ b/base/compiler/typeinfer.jl @@ -227,8 +227,14 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState) store_backedges(result, caller.stmt_edges[1]) end opt = result.src - if opt isa OptimizationState && result.must_be_codeinf - result.src = opt = ir_to_codeinf!(opt) + if opt isa OptimizationState + if result.must_be_codeinf + result.src = opt = ir_to_codeinf!(opt) + else is_inlineable(opt.src) || is_stmt_inline(get_curr_ssaflag(caller.parent::InferenceState)) + # TODO Delay `cfg_simplify!` until when needed? + # Currently it results in segfault due to duplicated CFG simplification. + result.src = opt = cfg_simplify!(opt.ir::IRCode) + end end if opt isa CodeInfo opt.min_world = first(valid_worlds)