try to fix 1.7 (#6)

keep 1.6 compat and also adapt to v1.8 changes

Author: Roger-luo

.github/workflows/CI.yml

@@ -10,6 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
+          - '1.6'
           - '1'
           - 'nightly'
         os:

src/CompilerPluginTools.jl

@@ -113,7 +113,6 @@ using Core.Compiler:
     isconcretetype,
     widenconst,
     isdispatchtuple,
-    isinlineable,
     is_inlineable_constant,
     copy_exprargs,
     convert_to_ircode,
@@ -129,14 +128,14 @@ using Core.Compiler:
     # Julia passes
     compact!,
     ssa_inlining_pass!,
-    getfield_elim_pass!,
     adce_pass!,
     type_lift_pass!,
     verify_linetable,
     verify_ir,
     retrieve_code_info,
     slot2reg
 
+include("compat.jl")
 include("utils.jl")
 include("patches.jl")
 include("codeinfo.jl")

src/compat.jl

@@ -0,0 +1,3 @@
+@static if VERSION < v"1.7-"
+    ismutabletype(::Type{T}) where T = T.mutable
+end

src/interp.jl

@@ -38,10 +38,15 @@ Core.Compiler.add_remark!(::JuliaLikeInterpreter, ::Core.Compiler.InferenceState
 end
 
 function Core.Compiler.optimize(interp::JuliaLikeInterpreter, opt::OptimizationState, params::OptimizationParams, @nospecialize(result))
-    nargs = Int(opt.nargs) - 1
-    ir = Core.Compiler.run_passes(opt.src, nargs, opt)
+    @static if VERSION < v"1.8-"
+        nargs = Int(opt.nargs) - 1
+        ir = Core.Compiler.run_passes(opt.src, nargs, opt)
+    else
+        ir = Core.Compiler.run_passes(opt.src, opt)
+    end
+
     ir = optimize(interp, opt, ir)
-    if VERSION < v"1.7-DEV"
+    @static if VERSION < v"1.7-DEV"
         Core.Compiler.finish(opt, params, ir, result)
     else
         Core.Compiler.finish(interp, opt, params, ir, result)

src/ircode.jl

@@ -48,24 +48,39 @@ Return the `IRCode` object along with inferred return type.
 function code_ircode_by_mi(f, mi::MethodInstance; world=get_world_counter(), interp=NativeInterpreter(world))
     return typeinf_lock() do
         result = Core.Compiler.InferenceResult(mi)
-        frame = Core.Compiler.InferenceState(result, false, interp)
+        @static if VERSION < v"1.8-"
+            frame = Core.Compiler.InferenceState(result, false, interp)
+        else
+            frame = Core.Compiler.InferenceState(result, :local, interp)
+        end
         frame === nothing && return nothing
 
         if typeinf(interp, frame)
             opt_params = OptimizationParams(interp)
-            opt = OptimizationState(frame, opt_params, interp)
-            preserve_coverage = coverage_enabled(opt.mod)
-            ci = opt.src; nargs = opt.nargs - 1;
-            ir = convert_to_ircode(ci, copy_exprargs(ci.code), preserve_coverage, nargs, opt)
-            ir = slot2reg(ir, ci, nargs, opt)
+            sv = OptimizationState(frame, opt_params, interp)
+            preserve_coverage = coverage_enabled(sv.mod)
+            @static if VERSION < v"1.8-"
+                ci = sv.src; nargs = sv.nargs - 1;
+                ir = convert_to_ircode(ci, copy_exprargs(ci.code), preserve_coverage, nargs, sv)
+                ir = slot2reg(ir, ci, nargs, sv)
+            else
+                ci = sv.src
+                ir = convert_to_ircode(ci, sv)
+                ir = slot2reg(ir, ci, sv)
+            end
             # passes
-            ir = f(ir, opt)
-            opt.src.inferred = true
+            ir = f(ir, sv)
+            sv.src.inferred = true
         end
 
         frame.inferred || return nothing
-        # TODO(yhls): Fix this upstream
-        resize!(ir.argtypes, opt.nargs)
+        @static if VERSION < v"1.8-"
+            resize!(ir.argtypes, sv.nargs)
+        else
+            svdef = sv.linfo.def
+            nargs = isa(svdef, Method) ? Int(svdef.nargs) : 0
+            resize!(ir.argtypes, nargs)
+        end
         return ir => widenconst(result.result)
     end
 end

src/passes.jl

@@ -14,7 +14,13 @@ function default_julia_pass(ir::IRCode, sv::OptimizationState)
     ir = compact!(ir)
     ir = ssa_inlining_pass!(ir, ir.linetable, sv.inlining, sv.src.propagate_inbounds)
     ir = compact!(ir)
-    ir = getfield_elim_pass!(ir)
+
+    @static if VERSION < v"1.8-"
+        ir = Core.Compiler.getfield_elim_pass!(ir)
+    else
+        ir = Core.Compiler.sroa_pass!(ir)
+    end
+
     ir = adce_pass!(ir)
     ir = type_lift_pass!(ir)
     ir = compact!(ir)
@@ -77,9 +83,15 @@ function permute_stmts!(ir::IRCode, perm::Vector{Int})
     return ir
 end
 
+@static if VERSION < v"1.8-"
+    argtypes(sig::Signature) = sig.atypes
+else
+    argtypes(sig::Signature) = sig.argtypes
+end
+
 function is_allconst(sig::Signature)
     allconst = true
-    for atype in sig.atypes
+    for atype in argtypes(sig)
         if !isa(atype, Const)
             allconst = false
             break
@@ -101,7 +113,7 @@ end
 
 function is_const_call_inlineable(sig::Signature)
     is_allconst(sig) || return false
-    f, ft, atypes = sig.f, sig.ft, sig.atypes
+    f, ft, atypes = sig.f, sig.ft, argtypes(sig)
 
     if isa(f, IntrinsicFunction) && is_pure_intrinsic_infer(f) && intrinsic_nothrow(f, atypes[2:end])
         return true
@@ -143,7 +155,7 @@ function inline_const!(ir::IRCode)
                 sig = Core.Compiler.call_sig(ir, new_stmt)
                 sig === nothing && continue
                 if is_const_call_inlineable(sig)
-                    fargs = anymap(x::Const -> x.val, sig.atypes[2:end])
+                    fargs = anymap(x::Const -> x.val, argtypes(sig)[2:end])
                     val = sig.f(fargs...)
                     ir.stmts[i][:inst] = quoted(val)
                     ir.stmts[i][:type] = Const(val)
@@ -154,7 +166,7 @@ function inline_const!(ir::IRCode)
                 ir.stmts[i][:inst] = Expr(:invoke, mi, f, map(eval_global, args)...)
             @case Expr(:new, t, args...)
                 allconst = all(x->is_arg_allconst(ir, x), args)
-                allconst && isconcretetype(t) && !t.mutable || continue
+                allconst && isconcretetype(t) && !ismutabletype(t) || continue
                 args = anymap(arg->unwrap_arg(ir, arg), args)
                 val = ccall(:jl_new_structv, Any, (Any, Ptr{Cvoid}, UInt32), t, args, length(args))
                 ir.stmts[i][:inst] = quoted(val)

src/patches.jl

@@ -97,8 +97,10 @@ Base.getindex(ref::UseRef) = Core.Compiler.getindex(ref)
 Base.iterate(uses::UseRefIterator) = Core.Compiler.iterate(uses)
 Base.iterate(uses::UseRefIterator, st) = Core.Compiler.iterate(uses, st)
 
+@static if VERSION < v"1.8-"
 Base.iterate(p::Core.Compiler.Pair) = Core.Compiler.iterate(p)
 Base.iterate(p::Core.Compiler.Pair, st) = Core.Compiler.iterate(p, st)
+end
 
 Base.getindex(m::Core.Compiler.MethodLookupResult, idx::Int) = Core.Compiler.getindex(m, idx)
 

test/interp.jl

@@ -10,5 +10,5 @@ function CompilerPluginTools.optimize(interp::TestInterpreter, ir::IRCode)
     return ir
 end
 
-code_ircode(sin, (Float64, ); interp=TestInterpreter(NativeInterpreter()))
+code_ircode(sin, (Float64, ); interp=NativeInterpreter())
 code_ircode_by_signature(Tuple{typeof(sin), Float64}; interp=TestInterpreter(NativeInterpreter()))

test/passes.jl

@@ -13,7 +13,7 @@ end
         GlobalRef(Main, :GLOBAL_CONST)::Float64
         ReturnNode(SSAValue(1))::Float64
     end
-    
+
     ir = inline_const!(ir)
     @test ir.stmts[1][:inst] == 1.0
     @test ir.stmts[1][:type] == Const(1.0)
@@ -25,7 +25,7 @@ end
         Expr(:new, Foo, 2)::Foo
         ReturnNode(SSAValue(1))::Float64
     end
-    
+
     ir = inline_const!(ir)
 
     @test ir.stmts[2][:inst] == QuoteNode(Foo(2))
@@ -49,6 +49,14 @@ end
     @test ir.stmts[1][:type] == Const((1, 2, 3))
 end
 
+ir = @make_ircode begin
+    Expr(:call, Core.Intrinsics.abs_float, 1.0)::Float64
+    Expr(:new, Foo, 2)::Foo
+    ReturnNode(SSAValue(1))::Float64
+end
+
+ir = inline_const!(ir)
+
 @testset "permute_stmts!" begin
     ir = @make_ircode begin
         QuoteNode(1.0)::Const(1.0)