llvmcall(Function*) does not survive precompilation

[maleadt]

Bug.jl:

module Bug

# from test/llvmcall.jl
function julia_to_llvm(@nospecialize x)
    isboxed = Ref{UInt8}()
    ccall(:julia_type_to_llvm,Ptr{Cvoid},(Any,Ref{UInt8}),x,isboxed)
end
const AnyTy = julia_to_llvm(Any)

const libllvmcalltest = joinpath(Sys.BINDIR, Base.LIBDIR, "libllvmcalltest")
const the_f = ccall((:MakeIdentityFunction, libllvmcalltest), Ptr{Cvoid}, (Ptr{Cvoid},), AnyTy)

@eval identity(x) = Base.llvmcall($(the_f), Any, Tuple{Any}, x)

end

main.jl:

using InteractiveUtils
using Bug

code_warntype(Bug.identity, Tuple{Any})
Bug.identity(nothing)

Crashes depending on precompilation:

$ JULIA_DEBUG=all JULIA_LOAD_PATH="@::." jj --compiled-modules=no main.jl
Body::Any
1 ─ %1 = Base.llvmcall::Core.Compiler.Const(llvmcall, false)
│   %2 = (%1)(Ptr{Nothing} @0x000056204b539648, Bug.Any, Tuple{Any}, x)::Any
└──      return %2

$ JULIA_DEBUG=all JULIA_LOAD_PATH="@::." jj test.jl
┌ Debug: Precompiling Bug [top-level]
└ @ Base loading.jl:1186
Body::Any
1 ─ %1 = Base.llvmcall::Core.Compiler.Const(llvmcall, false)
│   %2 = (%1)(Ptr{Nothing} @0x0000000000000000, Bug.Any, Tuple{Any}, x)::Any
└──      return %2
julia: /home/tbesard/Julia/julia-dev/deps/srccache/llvm-6.0.1/include/llvm/Support/Casting.h:106: static bool llvm::isa_impl_cl<llvm::GlobalVariable, const llvm::GlobalValue *>::doit(const From *) [To = llvm::GlobalVariable, From = const llvm::GlobalValue *]: Assertion `Val && "isa<> used on a null pointer"' failed.

A NULL function handle obviously crashes immediately, so the exact backtrace isn't interesting. Reproduces on both 1.0 and master. Looks like #25041 but the handle really is a literal here.
Ref JuliaGPU/CUDAnative.jl#303

[vtjnash]

Yes, this is what https://github.com/vtjnash/julep/wiki/0002:-Enhanced-llvmcall is intended to fix (note that it's the first item on the list of primary issues with the current design), and also might help #25984 get moving again

[maleadt]

Uh, of course, not sure what I was thinking. Would it make sense to prevent precompilation of methods with llvmcall, in the meantime? No since the literal Function* is a precompiled global const.

[maleadt]

My original MWE was oversimplified. I'm actually doing something like:

module Bug

function julia_to_llvm(@nospecialize x)
    isboxed = Ref{UInt8}()
    ccall(:julia_type_to_llvm,Ptr{Cvoid},(Any,Ref{UInt8}),x,isboxed)
end

@generated function indirect_llvmcall()
    AnyTy = julia_to_llvm(Any)
    the_f = ccall((:MakeIdentityFunction, "usr/lib/libllvmcalltest"), Ptr{Cvoid},
                  (Ptr{Cvoid},), AnyTy)
    quote
        Base.@_inline_meta
        Base.llvmcall($the_f, Any, Tuple{Any}, nothing)
    end
end
test() = indirect_llvmcall()

end

Which works, because the Function* is looked up as part of the @generated function, so it isn't precompiled. However, during some unrelated other change I introduced a global call to return_types, which now causes the function containing the llvmcall to be precompiled:

module Bug
...
Base.return_types(test, Tuple{})
...
end

So I can work around this limitation by not calling return_types.