Fixup; get errors working (#61)

* tell llvm the correct types of objects; verify the IR after after modification

* Update src/code_loading.jl

Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>

* use julia's optimizer, enable tests for error handling

* make ManualMemory and StrideArraysCore available on other process

* run optimization twice so that reloc can happen on optimized code

* grab `jl_add_optimization_passes` from `libjulia-codegen` on newer versions

* don't test on windows for now, it's pointless

* remove unnecessary func

* add some comments

* reorganize

* catch an error pathway

Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>

Author: MasonProtter

.github/workflows/ci.yml

@@ -6,7 +6,6 @@ jobs:
   test:
     name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
     runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.os == 'windows-latest' }}
     strategy:
       fail-fast: false
       matrix:
@@ -16,7 +15,6 @@ jobs:
         os:
           - ubuntu-latest
           - macOS-latest
-          - windows-latest
         arch:
           - x64
     steps:

README.md

@@ -50,6 +50,5 @@ This package uses the [GPUCompiler package](https://github.com/JuliaGPU/GPUCompi
 * GC-tracked allocations and global variables do work with `compile`, but the way they are implemented is brittle and can be dangerous. Allocate with care.
 * GC-tracked allocations and global varaibles do *not* work with `compile_executable` (yet).
 * Type unstable code is not yet supported.
-* Throwing errors is not currently supported. In the meantime, consider wrapping possible errors with [ErrorTypes.jl](https://github.com/jakobnissen/ErrorTypes.jl)
 * Doesn't currently work on Windows.
 * If you find any other limitations, let us know. There's probably lots.

src/StaticCompiler.jl

@@ -1,8 +1,10 @@
 module StaticCompiler
 
 using GPUCompiler: GPUCompiler
-using LLVM: LLVM
-using Libdl: Libdl
+using LLVM
+using LLVM.Interop
+using LLVM: API
+using Libdl: Libdl, dlsym, dlopen
 using Base: RefValue
 using Serialization: serialize, deserialize
 using Clang_jll: clang
@@ -82,6 +84,7 @@ single method (the method determined by `types`).
 function compile(f, _tt, path::String = tempname();  name = GPUCompiler.safe_name(repr(f)), filename="obj",
                  strip_llvm = false,
                  strip_asm  = true,
+                 opt_level=3,
                  kwargs...)
     tt = Base.to_tuple_type(_tt)
     isconcretetype(tt) || error("input type signature $_tt is not concrete")
@@ -90,7 +93,7 @@ function compile(f, _tt, path::String = tempname();  name = GPUCompiler.safe_nam
     isconcretetype(rt) || error("$f on $_tt did not infer to a concrete type. Got $rt")
 
     f_wrap!(out::Ref, args::Ref{<:Tuple}) = (out[] = f(args[]...); nothing)
-    _, _, table = generate_shlib(f_wrap!, Tuple{RefValue{rt}, RefValue{tt}}, path, name; strip_llvm, strip_asm, filename, kwargs...)
+    _, _, table = generate_shlib(f_wrap!, Tuple{RefValue{rt}, RefValue{tt}}, path, name; opt_level, strip_llvm, strip_asm, filename, kwargs...)
 
     lf = LazyStaticCompiledFunction{rt, tt}(Symbol(f), path, name, filename, table)
     cjl_path = joinpath(path, "$filename.cjl")
@@ -99,6 +102,92 @@ function compile(f, _tt, path::String = tempname();  name = GPUCompiler.safe_nam
     (; f = instantiate(lf), path=abspath(path))
 end
 
+"""
+```julia
+generate_shlib(f, tt, path::String, name::String, filenamebase::String="obj"; kwargs...)
+```
+Low level interface for compiling a shared object / dynamically loaded library
+ (`.so` / `.dylib`) for function `f` given a tuple type `tt` characterizing
+the types of the arguments for which the function will be compiled.
+
+See also `StaticCompiler.generate_shlib_fptr`.
+
+### Examples
+```julia
+julia> function test(n)
+           r = 0.0
+           for i=1:n
+               r += log(sqrt(i))
+           end
+           return r/n
+       end
+test (generic function with 1 method)
+
+julia> path, name = StaticCompiler.generate_shlib(test, Tuple{Int64}, "./test")
+("./test", "test")
+
+shell> tree \$path
+./test
+|-- obj.o
+`-- obj.so
+
+0 directories, 2 files
+
+julia> test(100_000)
+5.256496109495593
+
+julia> ccall(StaticCompiler.generate_shlib_fptr(path, name), Float64, (Int64,), 100_000)
+5.256496109495593
+```
+"""
+function generate_shlib(f, tt, path::String = tempname(), name = GPUCompiler.safe_name(repr(f)), filenamebase::String="obj";
+                        strip_llvm = false,
+                        strip_asm  = true,
+                        opt_level=3,
+                        kwargs...)
+    mkpath(path)
+    obj_path = joinpath(path, "$filenamebase.o")
+    lib_path = joinpath(path, "$filenamebase.$(Libdl.dlext)")
+
+    job, kwargs = native_job(f, tt; name, kwargs...)
+    #Get LLVM to generated a module of code for us. We don't want GPUCompiler's optimization passes.
+    mod, meta = GPUCompiler.codegen(:llvm, job; strip=strip_llvm, only_entry=false, validate=false, optimize=false)
+    #use Julia's optimization pass on the LLVM code, but leave intrinsics alone
+    julia_opt_passes(mod, job; opt_level, lower_intrinsics=0)
+    # Scoop up all the pointers in the optimized module, and replace them with unitialized global variables.
+    # table is a dictionary where the keys are julia objects that are needed by the function, and the values
+    # of the dictionary are the names of their associated LLVM GlobalVariable names.
+    table = relocation_table!(mod)
+    # Now that we've removed all the pointers from the code, we can (hopefully) safely lower all the instrinsics
+    julia_opt_passes(mod, job; opt_level, lower_intrinsics=1)
+    # Make sure we didn't make any glaring errors
+    LLVM.verify(mod)
+    # Compile the LLVM module to native code and save it to disk
+    obj, _ = GPUCompiler.emit_asm(job, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
+    open(obj_path, "w") do io
+        write(io, obj)
+    end
+    path, name, table
+end
+
+function julia_opt_passes(mod, job; opt_level, lower_intrinsics)
+    triple = GPUCompiler.llvm_triple(job.target)
+    tm = GPUCompiler.llvm_machine(job.target)
+
+    lib_path = VERSION > v"1.8.0-DEV" ? "libjulia-codegen" :  "libjulia"
+    
+    dlopen(lib_path) do lib
+        opt_func = dlsym(lib, "jl_add_optimization_passes")
+        ModulePassManager() do pm
+            add_library_info!(pm, triple)
+            add_transform_info!(pm, tm)
+            ccall(opt_func, Cvoid,
+                  (LLVM.API.LLVMPassManagerRef, Cint, Cint),
+                  pm, opt_level, lower_intrinsics)
+            run!(pm, mod)
+        end
+    end
+end
 
 """
 ```julia
@@ -173,64 +262,6 @@ function compile_executable(f, _tt=(), path::String="./", name=GPUCompiler.safe_
     joinpath(abspath(path), filename)
 end
 
-"""
-```julia
-generate_shlib(f, tt, path::String, name::String, filenamebase::String="obj"; kwargs...)
-```
-Low level interface for compiling a shared object / dynamically loaded library
- (`.so` / `.dylib`) for function `f` given a tuple type `tt` characterizing
-the types of the arguments for which the function will be compiled.
-
-See also `StaticCompiler.generate_shlib_fptr`.
-
-### Examples
-```julia
-julia> function test(n)
-           r = 0.0
-           for i=1:n
-               r += log(sqrt(i))
-           end
-           return r/n
-       end
-test (generic function with 1 method)
-
-julia> path, name = StaticCompiler.generate_shlib(test, Tuple{Int64}, "./test")
-("./test", "test")
-
-shell> tree \$path
-./test
-|-- obj.o
-`-- obj.so
-
-0 directories, 2 files
-
-julia> test(100_000)
-5.256496109495593
-
-julia> ccall(StaticCompiler.generate_shlib_fptr(path, name), Float64, (Int64,), 100_000)
-5.256496109495593
-```
-"""
-function generate_shlib(f, tt, path::String = tempname(), name = GPUCompiler.safe_name(repr(f)), filenamebase::String="obj";
-                        strip_llvm = false,
-                        strip_asm  = true,
-                        kwargs...)
-    mkpath(path)
-    obj_path = joinpath(path, "$filenamebase.o")
-    lib_path = joinpath(path, "$filenamebase.$(Libdl.dlext)")
-
-    job, kwargs = native_job(f, tt; name, kwargs...)
-    mod, meta = GPUCompiler.codegen(:llvm, job; strip=strip_llvm, only_entry=false, validate=false)
-
-    table = relocation_table!(mod)
-    
-    obj, _ = GPUCompiler.emit_asm(job, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
-    
-    open(obj_path, "w") do io
-        write(io, obj)
-    end
-    path, name, table
-end
 
 
 function generate_shlib_fptr(f, tt, path::String=tempname(), name = GPUCompiler.safe_name(repr(f)), filenamebase::String="obj"; temp::Bool=true, kwargs...)

src/code_loading.jl

@@ -15,6 +15,15 @@ struct LazyStaticCompiledFunction{rt, tt}
     reloc::IdDict{Any,String}
 end
 
+"""
+    unsafe_pointer_from_objref(x)
+
+Sometimes Julia embeds immutables like `Base.string` into code, and julia
+will error if you call `pointer_from_objref(string)`, claiming that it
+doesn't have a pointer even though that's a lie.
+"""
+unsafe_pointer_from_objref(x) = ccall(:jl_value_ptr, Ptr{Cvoid}, (Any,), x)
+
 function instantiate(p::LazyStaticCompiledFunction{rt, tt}) where {rt, tt}
     # LLVM.load_library_permantly(dirname(Libdl.dlpath(Libdl.dlopen("libjulia"))))
     lljit = LLVM.LLJIT(;tm=LLVM.JITTargetMachine())
@@ -25,14 +34,7 @@ function instantiate(p::LazyStaticCompiledFunction{rt, tt}) where {rt, tt}
 
     # Set all the uninitialized global variables to point to julia values from the relocation table
     for (val, name) ∈ p.reloc
-        if !ismutable(val)
-            # Sometimes Julia embeds functions like `Base.string` into code, and this doesn't have a pointer
-            # so we need to give it one manually, and put the ref in the dict to make sure it doesn't expire.
-            delete!(p.reloc, val)
-            val = Ref(val)
-            p.reloc[val] = name
-        end
-        address = LLVM.API.LLVMOrcJITTargetAddress(reinterpret(UInt, pointer_from_objref(val)))
+        address = LLVM.API.LLVMOrcJITTargetAddress(reinterpret(UInt, unsafe_pointer_from_objref(val)))
 
         symbol = LLVM.API.LLVMJITEvaluatedSymbol(address, flags)
         gv = LLVM.API.LLVMJITCSymbolMapPair(LLVM.mangle(lljit, name), symbol)
@@ -54,6 +56,12 @@ function instantiate(p::LazyStaticCompiledFunction{rt, tt}) where {rt, tt}
     StaticCompiledFunction{rt, tt}(p.f, fptr, lljit, p.reloc)
 end
 
+function absolute_symbols(symbols)
+    ref = LLVM.API.LLVMOrcAbsoluteSymbols(symbols, length(symbols))
+    LLVM.MaterializationUnit(ref)
+end
+
+
 struct StaticCompiledFunction{rt, tt}
     f::Symbol
     ptr::Ptr{Nothing}

src/pointer_patching.jl

@@ -1,6 +1,5 @@
 function relocation_table!(mod)
     i64 = LLVM.IntType(64; ctx=LLVM.context(mod))
-    jl_t = LLVM.PointerType(LLVM.StructType(LLVM.LLVMType[]; ctx=LLVM.context(mod)))
     d = IdDict{Any, Tuple{String, LLVM.GlobalVariable}}()
 
     for func ∈ LLVM.functions(mod), bb ∈ LLVM.blocks(func), inst ∈ LLVM.instructions(bb)
@@ -121,23 +120,26 @@ function relocation_table!(mod)
 end
 
 function get_pointers!(d, mod, inst)
-    jl_t = LLVM.PointerType(LLVM.StructType(LLVM.LLVMType[]; ctx=LLVM.context(mod)))
+    jl_t = (LLVM.StructType(LLVM.LLVMType[]; ctx=LLVM.context(mod)))
     for (i, arg) ∈ enumerate(LLVM.operands(inst))
         if occursin("inttoptr", string(arg)) && arg isa LLVM.ConstantExpr
             op1 = LLVM.Value(LLVM.API.LLVMGetOperand(arg, 0))
+            if op1 isa LLVM.ConstantExpr
+                op1 = LLVM.Value(LLVM.API.LLVMGetOperand(op1, 0))
+            end
             ptr = Ptr{Cvoid}(convert(Int, op1))
-
             frames = ccall(:jl_lookup_code_address, Any, (Ptr{Cvoid}, Cint,), ptr, 0)
             if length(frames) >= 1
                 fn, file, line, linfo, fromC, inlined = last(frames)
-                if isempty(String(fn)) || fn == :jl_system_image_data
-                    val = unsafe_pointer_to_objref(ptr)                    
+                if (isempty(String(fn)) && isempty(String(file))) || fn == :jl_system_image_data
+                    val = unsafe_pointer_to_objref(ptr)
                     if val ∈ keys(d)
                         _, gv = d[val]
                         LLVM.API.LLVMSetOperand(inst, i-1, gv)
                     else
                         gv_name = GPUCompiler.safe_name(String(gensym(repr(Core.Typeof(val)))))
-                        gv = LLVM.GlobalVariable(mod, jl_t, gv_name)
+                        gv = LLVM.GlobalVariable(mod, llvmeltype(arg), gv_name, LLVM.addrspace(llvmtype(arg)))
+                       
                         LLVM.extinit!(gv, true)
                         LLVM.API.LLVMSetOperand(inst, i-1, gv)
 
@@ -151,10 +153,7 @@ function get_pointers!(d, mod, inst)
     end
 end
 
-function absolute_symbols(symbols)
-    ref = LLVM.API.LLVMOrcAbsoluteSymbols(symbols, length(symbols))
-    LLVM.MaterializationUnit(ref)
-end
+llvmeltype(x::LLVM.Value) = eltype(LLVM.llvmtype(x))
 
 function pointer_patching_diff(mod::LLVM.Module, path1=tempname(), path2=tempname(); show_reloc_table=false)
     s1 = string(mod)
@@ -168,7 +167,12 @@ function pointer_patching_diff(mod::LLVM.Module, path1=tempname(), path2=tempnam
     s2 = string(mod)
     write(path2, s2)
 
-    run(`diff $p1 $p2`)
+    try
+        # this always ends in an error for me for some reason
+        run(`diff $path1 $path2`)
+    catch e;
+        nothing
+    end
 end
 
 

src/target.jl

@@ -19,11 +19,9 @@ end
 GPUCompiler.runtime_slug(job::GPUCompiler.CompilerJob{NativeCompilerTarget}) = "native_$(job.target.cpu)-$(hash(job.target.features))"
 
 module StaticRuntime
-    # dummy methods
+    # the runtime library
     signal_exception() = return
-    # HACK: if malloc returns 0 or traps, all calling functions (like jl_box_*)
-    #       get reduced to a trap, which really messes with our test suite.
-    malloc(sz) = Ptr{Cvoid}(Int(0xDEADBEEF))
+    malloc(sz) = ccall("extern malloc", llvmcall, Csize_t, (Csize_t,), sz)
     report_oom(sz) = return
     report_exception(ex) = return
     report_exception_name(ex) = return
@@ -33,6 +31,11 @@ end
 struct StaticCompilerParams <: GPUCompiler.AbstractCompilerParams end
 
 GPUCompiler.runtime_module(::GPUCompiler.CompilerJob{<:Any,StaticCompilerParams}) = StaticRuntime
+GPUCompiler.runtime_module(::GPUCompiler.CompilerJob{NativeCompilerTarget}) = StaticRuntime
+GPUCompiler.runtime_module(::GPUCompiler.CompilerJob{NativeCompilerTarget, StaticCompilerParams}) = StaticRuntime
+
+GPUCompiler.can_throw(job::GPUCompiler.CompilerJob{<:Any,StaticCompilerParams}) = true
+GPUCompiler.can_throw(job::GPUCompiler.CompilerJob{NativeCompilerTarget, StaticCompilerParams}) = true
 GPUCompiler.can_throw(job::GPUCompiler.CompilerJob{NativeCompilerTarget}) = true
 
 function native_job(@nospecialize(func), @nospecialize(types); kernel::Bool=false, name=GPUCompiler.safe_name(repr(func)), kwargs...)

test/Project.toml

@@ -7,5 +7,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 LoopVectorization = "bdcacae8-1622-11e9-2a5c-532679323890"
 ManualMemory = "d125e4d3-2237-4719-b19c-fa641b8a4667"
 StrideArraysCore = "7792a7ef-975c-4747-a70f-980b88e8d1da"
-Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
-ErrorTypes = "7f495686-c6d2-4c77-9e8e-e4c865675f9d"
+Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"