Add a test for kwcall with overlays. (#402)

Author: maleadt

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ['1.6', '1.7', '1.8', '^1.9.0-rc1']
+        version: ['1.6', '1.7', '1.8', '1.9.0-beta4']
         os: [ubuntu-latest, macOS-latest, windows-latest]
         arch: [x64]
     steps:
@@ -48,7 +48,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        branch: ['release-1.7', 'release-1.8', 'release-1.9', 'master']
+        branch: ['release-1.7', 'release-1.8', 'backports-release-1.9', 'master']
         os: [ubuntu-latest, macOS-latest]
         arch: [x64]
     steps:

test/definitions/native.jl

@@ -7,30 +7,33 @@ end
 
 # create a native test compiler, and generate reflection methods for it
 
+# local method table for device functions
+@static if isdefined(Base.Experimental, Symbol("@overlay"))
+Base.Experimental.@MethodTable(test_method_table)
+else
+const test_method_table = nothing
+end
+
 struct NativeCompilerParams <: AbstractCompilerParams
     entry_safepoint::Bool
-    NativeCompilerParams(entry_safepoint::Bool=false) = new(entry_safepoint)
+    method_table
+
+    NativeCompilerParams(entry_safepoint::Bool=false, method_table=test_method_table) =
+        new(entry_safepoint, method_table)
 end
-GPUCompiler.runtime_module(::CompilerJob{<:Any,NativeCompilerParams}) = TestRuntime
 
 NativeCompilerJob = CompilerJob{NativeCompilerTarget,NativeCompilerParams}
 
-# local method table for device functions
-@static if isdefined(Base.Experimental, Symbol("@overlay"))
-Base.Experimental.@MethodTable(method_table)
-else
-const method_table = nothing
-end
-
-GPUCompiler.method_table(@nospecialize(job::NativeCompilerJob)) = method_table
+GPUCompiler.method_table(@nospecialize(job::NativeCompilerJob)) = job.config.params.method_table
 GPUCompiler.can_safepoint(@nospecialize(job::NativeCompilerJob)) = job.config.params.entry_safepoint
+GPUCompiler.runtime_module(::NativeCompilerJob) = TestRuntime
 
 function native_job(@nospecialize(func), @nospecialize(types); kernel::Bool=false,
                     entry_abi=:specfunc, entry_safepoint::Bool=false, always_inline=false,
-                    kwargs...)
+                    method_table=test_method_table, kwargs...)
     source = FunctionSpec(typeof(func), Base.to_tuple_type(types))
     target = NativeCompilerTarget()
-    params = NativeCompilerParams(entry_safepoint)
+    params = NativeCompilerParams(entry_safepoint, method_table)
     config = CompilerConfig(target, params; kernel, entry_abi, always_inline)
     CompilerJob(config, source), kwargs
 end

test/native.jl

@@ -528,22 +528,27 @@ end
 
     mod = @eval module $(gensym())
         using ..GPUCompiler
-        import ..method_table
+
+        @static if isdefined(Base.Experimental, Symbol("@overlay"))
+        Base.Experimental.@MethodTable(method_table)
+        else
+        const method_table = nothing
+        end
 
         kernel() = child()
         child() = 0
 
         GPUCompiler.@override method_table child() = 1
     end
 
-    ir = sprint(io->native_code_llvm(io, mod.kernel, Tuple{}))
+    ir = sprint(io->native_code_llvm(io, mod.kernel, Tuple{}; mod.method_table))
     @test occursin("ret i64 1", ir)
 end
 
+if VERSION >= v"1.7"
 @testset "#366: semi-concrete interpretation + overlay methods = dynamic dispatch" begin
     mod = @eval module $(gensym())
         using ..GPUCompiler
-        import ..method_table
         using StaticArrays
 
         function kernel(width, height)
@@ -553,15 +558,40 @@ end
             return
         end
 
+        Base.Experimental.@MethodTable method_table
         GPUCompiler.@override method_table Base.isnan(x::Float32) =
             (ccall("extern __nv_isnanf", llvmcall, Int32, (Cfloat,), x)) != 0
     end
 
-    ir = sprint(io->native_code_llvm(io, mod.kernel, Tuple{Int, Int}; debuginfo=:none))
+    ir = sprint(io->native_code_llvm(io, mod.kernel, Tuple{Int, Int};
+                                     debuginfo=:none, mod.method_table))
     @test !occursin("apply_generic", ir)
     @test occursin("llvm.floor", ir)
 end
 
+@testset "JuliaLang/julia#48097: kwcall inference in the presence of overlay method" begin
+    mod = @eval module $(gensym())
+        using ..GPUCompiler
+        child(; kwargs...) = return
+        function parent()
+            child(; a=1f0, b=1.0)
+            return
+        end
+
+        Base.Experimental.@MethodTable method_table
+        Base.Experimental.@overlay method_table @noinline Core.throw_inexacterror(f::Symbol, ::Type{T}, val) where {T} =
+        return
+    end
+
+    ir = sprint(io->native_code_llvm(io, mod.parent, Tuple{};
+                                     debuginfo=:none, mod.method_table))
+    @test !occursin("jl_invoke", ir)
+    @test !occursin("apply_iterate", ir)
+    @test !occursin("inttoptr", ir)
+    @test occursin("ret void", ir)
+end
+end
+
 ############################################################################################
 
 end

test/testhelpers.jl

@@ -54,6 +54,5 @@ module TestRuntime
     report_exception_frame(idx, func, file, line) = return
 end
 
-struct TestCompilerParams <: AbstractCompilerParams
-end
+struct TestCompilerParams <: AbstractCompilerParams end
 GPUCompiler.runtime_module(::CompilerJob{<:Any,TestCompilerParams}) = TestRuntime