Merge pull request #79 from gbaraldi/xfunc-shlib

Multiple function shared lib

Author: MasonProtter

src/StaticCompiler.jl

@@ -435,7 +435,6 @@ function generate_shlib(f, tt, path::String = tempname(), name = GPUCompiler.saf
     path, name
 end
 
-
 function native_code_llvm(@nospecialize(func), @nospecialize(types); kwargs...)
     job, kwargs = native_job(func, types; kwargs...)
     GPUCompiler.code_llvm(stdout, job; kwargs...)
@@ -460,9 +459,83 @@ function native_code_native(@nospecialize(f), @nospecialize(tt), name = GPUCompi
     GPUCompiler.code_native(stdout, job; kwargs...)
 end
 
+#Return an LLVM module for multiple functions
+function native_llvm_module(funcs::Array; demangle = false, kwargs...)
+    f,tt = funcs[1]
+    mod = native_llvm_module(f,tt, kwargs...)
+    if length(funcs) > 1
+        for func in funcs[2:end]
+            @show f,tt = func
+            tmod = native_llvm_module(f,tt, kwargs...)
+            link!(mod,tmod)
+        end
+    end
+    if demangle
+        for func in functions(mod)
+            fname = name(func)
+            if fname[1:6] == "julia_"
+                name!(func,fname[7:end])
+            end
+        end
+    end
+    LLVM.ModulePassManager() do pass_manager #remove duplicate functions
+        LLVM.merge_functions!(pass_manager)
+        LLVM.run!(pass_manager, mod)
+    end
+    return mod
+end
 
+function generate_obj(funcs::Array, path::String = tempname(), filenamebase::String="obj";
+                        demangle =false,
+                        strip_llvm = false,
+                        strip_asm  = true,
+                        opt_level=3,
+                        kwargs...)
+    f,tt = funcs[1]
+    mkpath(path)
+    obj_path = joinpath(path, "$filenamebase.o")
+    fakejob, kwargs = native_job(f,tt, kwargs...)
+    mod = native_llvm_module(funcs; demangle = demangle, kwargs...)
+    obj, _ = GPUCompiler.emit_asm(fakejob, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
+    open(obj_path, "w") do io
+        write(io, obj)
+    end
+    path, obj_path
+end
 
+function generate_shlib(funcs::Array, path::String = tempname(), filename::String="libfoo"; demangle=false, kwargs...)
 
+    lib_path = joinpath(path, "$filename.$(Libdl.dlext)")
+
+    _,obj_path = generate_obj(funcs, path, filename; demangle=demangle, kwargs...)
+    # Pick a Clang
+    cc = Sys.isapple() ? `cc` : clang()
+    # Compile!
+    run(`$cc -shared -o $lib_path $obj_path`)
+
+    path, name
+end
+
+function compile_shlib(funcs::Array, path::String="./";
+    filename="libfoo",
+    demangle=false,
+    kwargs...)
+    for func in funcs
+        f, types = func
+        tt = Base.to_tuple_type(types)
+        isconcretetype(tt) || error("input type signature $types is not concrete")
+
+        rt = only(native_code_typed(f, tt))[2]
+        isconcretetype(rt) || error("$f$types did not infer to a concrete type. Got $rt")
+    end
+
+# Would be nice to use a compiler pass or something to check if there are any heap allocations or references to globals
+# Keep an eye on https://github.com/JuliaLang/julia/pull/43747 for this
+
+    generate_shlib(funcs, path, filename; demangle=demangle, kwargs...)
+
+    joinpath(abspath(path), filename * "." * Libdl.dlext)
+end
 
 
 end # module

test/testcore.jl

@@ -292,3 +292,29 @@ end
     @test isa(r, Base.Process)
     @test r.exitcode == 0
 end
+
+@noinline square(n) = n*n
+
+function squaresquare(n)
+    square(square(n))
+end
+
+function squaresquaresquare(n)
+    square(squaresquare(n))
+end
+
+@testset "Multiple Function Dylibs" begin
+
+
+    funcs = [(squaresquare,(Float64,)), (squaresquaresquare,(Float64,))]
+    filepath = compile_shlib(funcs, demangle=true)
+
+    ptr = Libdl.dlopen(filepath, Libdl.RTLD_LOCAL)
+
+    fptr2 = Libdl.dlsym(ptr, "squaresquare")
+    @test ccall(fptr2, Float64, (Float64,), 10.) == squaresquare(10.)
+
+    fptr = Libdl.dlsym(ptr, "squaresquaresquare")
+    @test ccall(fptr, Float64, (Float64,), 10.) == squaresquaresquare(10.)
+    #Compile dylib
+end