Have the default target default to not using the Julia runtime.

Author: maleadt

src/driver.jl

@@ -321,7 +321,7 @@ const __llvm_initialized = Ref(false)
         @compiler_assert isempty(uses(dyn_marker)) job
         unsafe_delete!(ir, dyn_marker)
     end
-    
+
     @timeit_debug to "IR post-processing" begin
         # mark the kernel entry-point functions (optimization may need it)
         if job.source.kernel
@@ -334,7 +334,7 @@ const __llvm_initialized = Ref(false)
         if optimize
             @timeit_debug to "optimization" begin
                 optimize!(job, ir)
-        
+
                 # deferred codegen has some special optimization requirements,
                 # which also need to happen _after_ regular optimization.
                 # XXX: make these part of the optimizer pipeline?
@@ -376,7 +376,7 @@ const __llvm_initialized = Ref(false)
                 end
             end
         end
-        
+
         # finish the module
         #
         # we want to finish the module after optimization, so we cannot do so during

src/native.jl

@@ -8,7 +8,7 @@ Base.@kwdef struct NativeCompilerTarget <: AbstractCompilerTarget
     cpu::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUName())
     features::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUFeatures())
     llvm_always_inline::Bool=false # will mark the job function as always inline
-    jlruntime::Bool=true # Use Julia runtime for throwing errors, instead of the GPUCompiler support
+    jlruntime::Bool=false # Use Julia runtime for throwing errors, instead of the GPUCompiler support
 end
 llvm_triple(::NativeCompilerTarget) = Sys.MACHINE
 

test/definitions/native.jl

@@ -21,9 +21,10 @@ GPUCompiler.can_safepoint(@nospecialize(job::NativeCompilerJob)) = job.params.en
 
 function native_job(@nospecialize(f_type), @nospecialize(types);
                     kernel::Bool=false, entry_abi=:specfunc, entry_safepoint::Bool=false,
-                    always_inline=false, llvm_always_inline=true, kwargs...)
+                    always_inline=false, llvm_always_inline=true, jlruntime::Bool=false,
+                    kwargs...)
     source = FunctionSpec(f_type, Base.to_tuple_type(types), kernel)
-    target = NativeCompilerTarget(;llvm_always_inline)
+    target = NativeCompilerTarget(; llvm_always_inline, jlruntime)
     params = TestCompilerParams(entry_safepoint)
     CompilerJob(target, source, params, entry_abi, always_inline), kwargs
 end
@@ -253,7 +254,9 @@ module LazyCodegen
 
     import GPUCompiler: deferred_codegen_jobs
     @generated function deferred_codegen(f::F, ::Val{tt}) where {F,tt}
-        job, _ = native_job(F, tt)
+        # XXX: do we actually require the Julia runtime?
+        #      with jlruntime=false, we reach an unreachable.
+        job, _ = native_job(F, tt; jlruntime=true)
 
         addr = get_trampoline(job)
         trampoline = pointer(addr)