Merge pull request #207 from maleadt/vc/orc

Implement ORC api

Author: vchuravy

.appveyor.yml

@@ -5,6 +5,7 @@ environment:
   - julia_version: 1.2
   - julia_version: 1.3
   - julia_version: 1.4
+  - julia_version: 1.5
   - julia_version: latest
 
 platform:

COVERAGE.md

@@ -1135,19 +1135,19 @@ ErrorHandling
 ORC JIT
 -------
 
-- [ ] LLVMOrcCreateInstance
-- [ ] LLVMOrcGetErrorMsg
-- [ ] LLVMOrcGetMangledSymbol
-- [ ] LLVMOrcDisposeMangledSymbol
-- [ ] LLVMOrcCreateLazyCompileCallback
-- [ ] LLVMOrcCreateIndirectStub
-- [ ] LLVMOrcSetIndirectStubPointer
-- [ ] LLVMOrcAddEagerlyCompiledIR
-- [ ] LLVMOrcAddLazilyCompiledIR
-- [ ] LLVMOrcAddObjectFile
-- [ ] LLVMOrcRemoveModule
-- [ ] LLVMOrcGetSymbolAddress
-- [ ] LLVMOrcDisposeInstance
+- [x] LLVMOrcCreateInstance
+- [x] LLVMOrcGetErrorMsg
+- [x] LLVMOrcGetMangledSymbol
+- [x] LLVMOrcDisposeMangledSymbol
+- [x] LLVMOrcCreateLazyCompileCallback
+- [x] LLVMOrcCreateIndirectStub
+- [x] LLVMOrcSetIndirectStubPointer
+- [x] LLVMOrcAddEagerlyCompiledIR
+- [x] LLVMOrcAddLazilyCompiledIR
+- [x] LLVMOrcAddObjectFile
+- [x] LLVMOrcRemoveModule
+- [x] LLVMOrcGetSymbolAddress
+- [x] LLVMOrcDisposeInstance
 
 
 

examples/sum_orc.jl

@@ -0,0 +1,74 @@
+# same as `sum.jl`, but using the OrcJIT to compile the code and executing it via ccall.
+
+using Test
+
+using LLVM
+
+if !LLVM.has_orc_v1()
+    exit()
+end
+
+if length(ARGS) == 2
+    x, y = parse.([Int32], ARGS[1:2])
+else
+    x = Int32(1)
+    y = Int32(2)
+end
+
+Context() do ctx
+    # Setup jit
+    tm = JITTargetMachine()
+
+    orc = OrcJIT(tm)
+    register!(orc, GDBRegistrationListener())
+
+    param_types = [LLVM.Int32Type(ctx), LLVM.Int32Type(ctx)]
+    ret_type = LLVM.Int32Type(ctx)
+
+    name = mangle(orc, "sum_orc.jl")
+    mod = LLVM.Module("jit", ctx)
+    triple!(mod, triple(tm))
+
+    ft = LLVM.FunctionType(ret_type, param_types)
+    sum = LLVM.Function(mod, name, ft)
+
+    # generate IR
+    Builder(ctx) do builder
+        entry = BasicBlock(sum, "entry", ctx)
+        position!(builder, entry)
+
+        tmp = add!(builder, parameters(sum)[1], parameters(sum)[2], "tmp")
+        ret!(builder, tmp)
+    end
+
+    verify(mod)
+
+    ModulePassManager() do pm
+        add_library_info!(pm, triple(mod))
+        add_transform_info!(pm, tm)
+        run!(pm, mod)
+    end
+
+    verify(mod)
+
+    # For debugging:
+    #   asm = String(convert(Vector{UInt8}, emit(tm, mod, LLVM.API.LLVMAssemblyFile)))
+    #   write(stdout, asm)
+
+    jitted_mod = compile!(orc, mod)
+
+    addr = address(orc, name)
+    addr2 = addressin(orc, jitted_mod, name)
+    @test addr == addr2
+    @test addr.ptr != 0
+
+    unregister!(orc, GDBRegistrationListener())
+
+    # For debugging:
+    #   ccall(:jl_breakpoint, Cvoid, (Any,), pointer(addr))
+    # Then in GDB
+    #   b *(*(uint64_t*)v)
+    @eval call_sum(x, y) = ccall($(pointer(addr)), Int32, (Int32, Int32), x, y)
+end
+
+@test call_sum(x, y) == x + y

src/LLVM.jl

@@ -44,6 +44,9 @@ include("bitcode.jl")
 include("transform.jl")
 include("debuginfo.jl")
 
+has_orc_v1() = v"8" <= LLVM.version() < v"12"
+include("orc.jl")
+
 include("interop.jl")
 
 include("deprecated.jl")

src/orc.jl

@@ -0,0 +1,143 @@
+export OrcJIT, OrcModule, OrcTargetAddress
+export JITEventListener, GDBRegistrationListener, IntelJITEventListener,
+       OProfileJITEventListener, PerfJITEventListener
+export dispose, errormsg, compile!, remove!, add!,
+       mangle, address, addressin, create_stub!, set_stub!,
+       register!, unregister!, callback!
+export JITTargetMachine
+
+@checked struct OrcJIT 
+    ref::API.LLVMOrcJITStackRef
+end
+
+Base.unsafe_convert(::Type{API.LLVMOrcJITStackRef}, orc::OrcJIT) = orc.ref
+
+"""
+    OrcJIT(::TargetMachine)
+
+Creates a OrcJIT stack based on the provided target machine.
+
+!!! warning
+    Takes ownership of the provided target machine.
+"""
+function OrcJIT(tm::TargetMachine)
+    OrcJIT(API.LLVMOrcCreateInstance(tm))
+end
+
+function dispose(orc::OrcJIT)
+    API.LLVMOrcDisposeInstance(orc)
+end
+
+function errormsg(orc::OrcJIT)
+    # The error message is owned by `orc`, and will
+    # be disposed along-side the OrcJIT. 
+    unsafe_string(LLVM.API.LLVMOrcGetErrorMsg(orc))
+end
+
+struct OrcModule 
+    handle::API.LLVMOrcModuleHandle
+end
+Base.convert(::Type{API.LLVMOrcModuleHandle}, mod::OrcModule) = mod.handle
+
+function compile!(orc::OrcJIT, mod::Module, resolver = C_NULL, ctx = C_NULL; lazy=false)
+    r_mod = Ref{API.LLVMOrcModuleHandle}()
+    if lazy
+        API.LLVMOrcAddLazilyCompiledIR(orc, r_mod, mod, resolver, ctx)
+    else
+        API.LLVMOrcAddEagerlyCompiledIR(orc, r_mod, mod, resolver, ctx)
+    end
+    OrcModule(r_mod[])
+end
+
+function Base.delete!(orc::OrcJIT, mod::OrcModule)
+    LLVM.API.LLVMOrcRemoveModule(orc, mod)
+end
+
+function add!(orc::OrcJIT, obj::MemoryBuffer, resolver = C_NULL, ctx = C_NULL)
+    r_mod = Ref{API.LLVMOrcModuleHandle}()
+    API.LLVMOrcAddObjectFile(orc, r_mod, obj, resolver, ctx)
+    return OrcModule(r_mod[])
+end
+
+function mangle(orc::OrcJIT, name)
+    r_symbol = Ref{Cstring}()
+    LLVM.API.LLVMOrcGetMangledSymbol(orc, r_symbol, name)
+    symbol = unsafe_string(r_symbol[])
+    LLVM.API.LLVMOrcDisposeMangledSymbol(r_symbol[])
+    return symbol
+end
+
+struct OrcTargetAddress
+    ptr::API.LLVMOrcTargetAddress
+end
+Base.convert(::Type{API.LLVMOrcTargetAddress}, addr::OrcTargetAddress) = addr.ptr
+
+Base.pointer(addr::OrcTargetAddress) = reinterpret(Ptr{Cvoid}, addr.ptr % UInt) # LLVMOrcTargetAddress is UInt64 even on 32-bit
+
+OrcTargetAddress(ptr::Ptr{Cvoid}) = OrcTargetAddress(reinterpret(UInt, ptr))
+
+function create_stub!(orc::OrcJIT, name, initial)
+    LLVM.API.LLVMOrcCreateIndirectStub(orc, name, initial)
+end
+
+function set_stub!(orc::OrcJIT, name, new)
+    LLVM.API.LLVMOrcSetIndirectStubPointer(orc, name, new)
+end
+
+function address(orc::OrcJIT, name)
+    r_address = Ref{API.LLVMOrcTargetAddress}()
+    API.LLVMOrcGetSymbolAddress(orc, r_address, name)
+    OrcTargetAddress(r_address[])
+end
+
+function addressin(orc::OrcJIT, mod::OrcModule, name)
+    r_address = Ref{API.LLVMOrcTargetAddress}()
+    API.LLVMOrcGetSymbolAddressIn(orc, r_address, mod, name)
+    OrcTargetAddress(r_address[])
+end
+
+function callback!(orc::OrcJIT, callback, ctx)
+    r_address = Ref{API.LLVMOrcTargetAddress}()
+    LLVM.API.LLVMOrcLazyCompileCallback(orc, r_address, callback, ctx)
+    return OrcTargetAddress(r_address[])
+end
+
+@checked struct JITEventListener 
+    ref::API.LLVMJITEventListenerRef
+end
+Base.unsafe_convert(::Type{API.LLVMJITEventListenerRef}, listener::JITEventListener) = listener.ref
+
+function register!(orc::OrcJIT, listener::JITEventListener)
+    LLVM.API.LLVMOrcRegisterJITEventListener(orc, listener)
+end
+
+function unregister!(orc::OrcJIT, listener::JITEventListener)
+    LLVM.API.LLVMOrcUnregisterJITEventListener(orc, listener)
+end
+
+GDBRegistrationListener()  = JITEventListener(LLVM.API.LLVMCreateGDBRegistrationListener())
+IntelJITEventListener()    = JITEventListener(LLVM.API.LLVMCreateIntelJITEventListener())
+OProfileJITEventListener() = JITEventListener(LLVM.API.LLVMCreateOProfileJITEventListener())
+PerfJITEventListener()     = JITEventListener(LLVM.API.LLVMCreatePerfJITEventListener())
+
+function JITTargetMachine(;triple = LLVM.triple(),
+                           cpu = "", features = "",
+                           optlevel = LLVM.API.LLVMCodeGenLevelDefault)
+
+    # Force ELF on windows,
+    # Note: Without this call to normalize Orc get's confused
+    #       and chooses the x86_64 SysV ABI on Win x64
+    triple = LLVM.normalize(triple)
+    if Sys.iswindows()
+        triple *= "-elf"
+    end
+    target = LLVM.Target(triple=triple)
+    @debug "Configuring OrcJIT with" triple cpu features optlevel
+
+    tm = TargetMachine(target, triple, cpu, features,
+                       optlevel,
+                       LLVM.API.LLVMRelocStatic, # Generate simpler code for JIT
+                       LLVM.API.LLVMCodeModelJITDefault, # Required to init TM as JIT
+                       )
+    return tm 
+end

src/targetmachine.jl

@@ -31,6 +31,7 @@ end
 target(tm::TargetMachine) = Target(API.LLVMGetTargetMachineTarget(tm))
 triple(tm::TargetMachine) = unsafe_message(API.LLVMGetTargetMachineTriple(tm))
 triple() = unsafe_message(API.LLVMGetDefaultTargetTriple())
+normalize(triple) = unsafe_message(API.LLVMNormalizeTargetTriple(triple))
 cpu(tm::TargetMachine) = unsafe_message(API.LLVMGetTargetMachineCPU(tm))
 features(tm::TargetMachine) = unsafe_message(API.LLVMGetTargetMachineFeatureString(tm))
 

test/interop.jl

@@ -191,11 +191,11 @@ end
     @test unsafe_load(ptr) == 2
 
     ir = sprint(io->code_llvm(io, unsafe_load, Tuple{typeof(ptr)}))
-    if VERSION >= v"1.6-" && Sys.iswindows() && Sys.WORD_SIZE == 32
+    if VERSION >= v"1.5.2" && Sys.iswindows() && Sys.WORD_SIZE == 32
         # FIXME: Win32 nightly emits a i64*, even though bitstype_to_llvm uses T_int8
-        @test_broken contains(ir, r"@julia_unsafe_load_\d+\(i8\*\)")
+        @test_broken contains(ir, r"@julia_unsafe_load_\d+\(i8\*")
     else
-        @test contains(ir, r"@julia_unsafe_load_\d+\(i8\*\)")
+        @test contains(ir, r"@julia_unsafe_load_\d+\(i8\*")
     end
     @test contains(ir, r"load i64, i64\* %\d+, align 1")