Add support for using the native runtime if available (#306)

* NativeCompilerTarget should support throwing

* don't link in the Runtime when the Julia runtime can be used

* use Julia's legalization when the Julia runtime is available

Author: vchuravy

Project.toml

@@ -14,6 +14,6 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
 [compat]
 ExprTools = "0.1"
-LLVM = "4.7"
+LLVM = "4.8"
 TimerOutputs = "0.5"
 julia = "1.6"

src/driver.jl

@@ -209,7 +209,7 @@ const __llvm_initialized = Ref(false)
 
     # always preload the runtime, and do so early; it cannot be part of any timing block
     # because it recurses into the compiler
-    if libraries
+    if !uses_julia_runtime(job) && libraries
         runtime = load_runtime(job; ctx)
         runtime_fns = LLVM.name.(defs(runtime))
         runtime_intrinsics = ["julia.gc_alloc_obj"]
@@ -222,7 +222,7 @@ const __llvm_initialized = Ref(false)
             @timeit_debug to "target libraries" link_libraries!(job, ir, undefined_fns)
 
             # GPU run-time library
-            if any(fn -> fn in runtime_fns || fn in runtime_intrinsics, undefined_fns)
+            if !uses_julia_runtime(job) && any(fn -> fn in runtime_fns || fn in runtime_intrinsics, undefined_fns)
                 @timeit_debug to "runtime library" link_library!(ir, runtime)
             end
         end

src/interface.jl

@@ -143,6 +143,12 @@ end
 
 ## interfaces and fallback definitions
 
+# Has the runtime available and does not require special handling
+uses_julia_runtime(@nospecialize(job::CompilerJob)) = false
+
+# Should emit PTLS lookup that can be relocated
+dump_native(@nospecialize(job::CompilerJob)) = false
+
 # the Julia module to look up target-specific runtime functions in (this includes both
 # target-specific functions from the GPU runtime library, like `malloc`, but also
 # replacements functions for operations like `Base.sin`)
@@ -157,7 +163,7 @@ get_interpreter(@nospecialize(job::CompilerJob)) =
 
 # does this target support throwing Julia exceptions with jl_throw?
 # if not, calls to throw will be replaced with calls to the GPU runtime
-can_throw(@nospecialize(job::CompilerJob)) = false
+can_throw(@nospecialize(job::CompilerJob)) = uses_julia_runtime(job)
 
 # generate a string that represents the type of compilation, for selecting a compiled
 # instance of the runtime library. this slug should encode everything that affects

src/native.jl

@@ -8,6 +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())
     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
 end
 
 llvm_triple(::NativeCompilerTarget) = Sys.MACHINE
@@ -33,4 +34,5 @@ end
 
 ## job
 
-runtime_slug(job::CompilerJob{NativeCompilerTarget}) = "native_$(job.target.cpu)-$(hash(job.target.features))"
+runtime_slug(job::CompilerJob{NativeCompilerTarget}) = "native_$(job.target.cpu)-$(hash(job.target.features))$(job.target.jlruntime ? "-jlrt" : "")"
+uses_julia_runtime(job::CompilerJob{NativeCompilerTarget}) = job.target.jlruntime

src/optim.jl

@@ -185,7 +185,9 @@ function optimize!(@nospecialize(job::CompilerJob), mod::LLVM.Module)
     ModulePassManager() do pm
         addTargetPasses!(pm, tm, triple)
 
-        add!(pm, FunctionPass("LowerGCFrame", lower_gc_frame!))
+        if !uses_julia_runtime(job)
+            add!(pm, FunctionPass("LowerGCFrame", lower_gc_frame!))
+        end
 
         if job.source.kernel
             # GC lowering is the last pass that may introduce calls to the runtime library,
@@ -194,16 +196,38 @@ function optimize!(@nospecialize(job::CompilerJob), mod::LLVM.Module)
             add!(pm, ModulePass("CleanupKernelState", cleanup_kernel_state!))
         end
 
-        # remove dead uses of ptls
-        aggressive_dce!(pm)
-        add!(pm, ModulePass("LowerPTLS", lower_ptls!))
+        if !uses_julia_runtime(job)
+            # remove dead uses of ptls
+            aggressive_dce!(pm)
+            add!(pm, ModulePass("LowerPTLS", lower_ptls!))
+        end
 
+        if uses_julia_runtime(job)
+            lower_exc_handlers!(pm)
+        end
         # the Julia GC lowering pass also has some clean-up that is required
         late_lower_gc_frame!(pm)
+        if uses_julia_runtime(job)
+            final_lower_gc!(pm)
+        end
 
         remove_ni!(pm)
         remove_julia_addrspaces!(pm)
 
+        if uses_julia_runtime(job)
+            # We need these two passes and the instcombine below
+            # after GC lowering to let LLVM do some constant propagation on the tags.
+            # and remove some unnecessary write barrier checks.
+            gvn!(pm)
+            sccp!(pm)
+            # Remove dead use of ptls
+            dce!(pm)
+            LLVM.Interop.lower_ptls!(pm, dump_native(job))
+            instruction_combining!(pm)
+            # Clean up write barrier and ptls lowering
+            cfgsimplification!(pm)
+        end
+
         # Julia's operand bundles confuse the inliner, so repeat here now they are gone.
         # FIXME: we should fix the inliner so that inlined code gets optimized early-on
         always_inliner!(pm)

test/definitions/native.jl

@@ -132,6 +132,24 @@ module LazyCodegen
         end
     else # LLVM >=12
 
+        function absolute_symbol_materialization(name, ptr)
+            address = LLVM.API.LLVMOrcJITTargetAddress(reinterpret(UInt, ptr))
+            flags = LLVM.API.LLVMJITSymbolFlags(LLVM.API.LLVMJITSymbolGenericFlagsExported, 0)
+            symbol = LLVM.API.LLVMJITEvaluatedSymbol(address, flags)
+            gv = LLVM.API.LLVMJITCSymbolMapPair(name, symbol)
+
+            return LLVM.absolute_symbols(Ref(gv))
+        end
+
+        function define_absolute_symbol(jd, name)
+            ptr = LLVM.find_symbol(name)
+            if ptr !== C_NULL
+                LLVM.define(jd, absolute_symbol_materialization(name, ptr))
+                return true
+            end
+            return false
+        end
+
         struct CompilerInstance
             jit::LLVM.LLJIT
             lctm::LLVM.LazyCallThroughManager
@@ -151,6 +169,10 @@ module LazyCodegen
             prefix = LLVM.get_prefix(lljit)
             dg = LLVM.CreateDynamicLibrarySearchGeneratorForProcess(prefix)
             add!(jd_main, dg)
+            if Sys.iswindows() && Int === Int64
+                # TODO can we check isGNU?
+                define_absolute_symbol(jd_main, mangle(lljit, "___chkstk_ms"))
+            end
 
             es = ExecutionSession(lljit)
 

test/native.jl

@@ -345,6 +345,10 @@ end
     else
         @test_broken call_delayed(complex, 1.0, 2.0) == 1.0+2.0im
     end
+
+    throws(arr, i) = arr[i]
+    @test call_delayed(throws, [1], 1) == 1
+    @test_throws BoundsError call_delayed(throws, [1], 0)
 end
 
 ############################################################################################