Method overrides cannot override kernels

[maleadt]

julia> kernel() = 0
kernel (generic function with 1 method)

julia> GPUCompiler.@override method_table kernel() = 1

julia> native_code_llvm(kernel, Tuple{})
;  @ REPL[1]:1 within `kernel`
; Function Attrs: alwaysinline
define i64 @julia_kernel_683() local_unnamed_addr #0 {
top:
  ret i64 0
}

The reason for this is that we implement Core.Compiler.method_table(interp::GPUInterpreter, sv::InferenceState), whereas for the outermost function Core.Compiler.method_table(interp::GPUInterpreter) seem to be called. But we can't implement that method, because that breaks InferenceState construction:

ERROR: LoadError: MethodError: no method matching convert(::Type{Core.Compiler.CachedMethodTable{Core.Compiler.InternalMethodTable}}, ::Core.Compiler.CachedMethodTable{Core.Compiler.OverlayMethodTable})
Closest candidates are:
  convert(::Type{Union{}}, ::Any) at essentials.jl:216
  convert(::Type{Any}, ::Any) at essentials.jl:217
  convert(::Type{T}, ::T) where T at essentials.jl:218
Stacktrace:
  [1] Core.Compiler.InferenceState(result::Core.Compiler.InferenceResult, src::Core.CodeInfo, cached::Bool, interp::GPUCompiler.GPUInterpreter)
    @ Core.Compiler ./compiler/inferencestate.jl:106

[maleadt]

This also doesn't work with the 1.6 world age-based overlay table, but for different reasons.

[vchuravy]

Note that you can hook that InferenceState constructor.

[maleadt]

Updated MWE:

using GPUCompiler

module TestRuntime
    # dummy methods
    signal_exception() = return
    malloc(sz) = C_NULL
    report_oom(sz) = return
    report_exception(ex) = return
    report_exception_name(ex) = return
    report_exception_frame(idx, func, file, line) = return
end

struct TestCompilerParams <: AbstractCompilerParams end
GPUCompiler.runtime_module(::CompilerJob{<:Any,TestCompilerParams}) = TestRuntime

kernel() = 1

Base.Experimental.@MethodTable(method_table)
GPUCompiler.method_table(::CompilerJob{<:Any,TestCompilerParams}) = method_table

Base.Experimental.@overlay method_table kernel() = 2

function main()
    source = methodinstance(typeof(kernel), Tuple{})
    target = NativeCompilerTarget()
    params = TestCompilerParams()
    config = CompilerConfig(target, params; kernel=false)
    job = CompilerJob(source, config)

    output = JuliaContext() do ctx
        string(GPUCompiler.compile(:llvm, job)[1])
    end

    println(output)
end

isinteractive() || main()

The underlying issue has also changed. One problem is that we're not passing a method table to methodinstance, because we generally only define that for the CompilerJob (which isn't defined at that point yet). But hacking that in (by adding a version of methodinstance that takes a method_table kwarg and passing that in from main) doesn't solve the issue, so something else is up.