Have the native target default to not using the Julia runtime. (#380)

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)

test/gcn.jl

@@ -155,21 +155,18 @@ end
     gcn_code_native(devnull, kernel, Tuple{Float64})
 end
 
-@test_broken "exception arguments"
-#= FIXME: _ZNK4llvm14TargetLowering20scalarizeVectorStoreEPNS_11StoreSDNodeERNS_12SelectionDAGE
-@testset "exception arguments" begin
+# FIXME: _ZNK4llvm14TargetLowering20scalarizeVectorStoreEPNS_11StoreSDNodeERNS_12SelectionDAGE
+false && @testset "exception arguments" begin
     function kernel(a)
         unsafe_store!(a, trunc(Int, unsafe_load(a)))
         return
     end
 
     gcn_code_native(devnull, kernel, Tuple{Ptr{Float64}})
 end
-=#
 
-@test_broken "GC and TLS lowering"
-#= FIXME: in function julia_inner_18528 void (%jl_value_t addrspace(10)*): invalid addrspacecast
-@testset "GC and TLS lowering" begin
+# FIXME: in function julia_inner_18528 void (%jl_value_t addrspace(10)*): invalid addrspacecast
+false && @testset "GC and TLS lowering" begin
     @eval mutable struct PleaseAllocate
         y::Csize_t
     end
@@ -206,7 +203,6 @@ end
 
     @test !occursin("gpu_gc_pool_alloc", asm)
 end
-=#
 
 @testset "float boxes" begin
     function kernel(a,b)