Merge pull request #331 from JuliaGPU/tb/lower_throw

Lower throw and friends in an LLVM pass.

Author: maleadt

src/compiler/irgen.jl

@@ -15,23 +15,6 @@ safe_fn(fn::String) = replace(fn, r"[^aA-zZ0-9_]"=>"_")
 safe_fn(f::Core.Function) = safe_fn(String(typeof(f).name.mt.name))
 safe_fn(f::LLVM.Function) = safe_fn(LLVM.name(f))
 
-# NOTE: we remove `throw_...` functions in the ThrowRemoval pass, but that relies on
-#       function names which is fragile. Remove actual calls to `jl_throw` here, to be safe.
-const exception_arguments = Vector{LLVM.Value}()
-function raise_exception(insblock::BasicBlock, ex::Value)
-    fun = LLVM.parent(insblock)
-    mod = LLVM.parent(fun)
-
-    let builder = Builder(JuliaContext())
-        position!(builder, insblock)
-        emit_exception!(builder, "unknown", ex)
-        dispose(builder)
-    end
-
-    # mark arguments that passed to `throw` for removal, as they are often GC-allocated.
-    push!(exception_arguments, ex)
-end
-
 # generate a pseudo-backtrace from a stack of methods being emitted
 function backtrace(ctx::CompilerContext, method_stack::Vector{Core.MethodInstance})
     bt = StackTraces.StackFrame[]
@@ -57,11 +40,6 @@ function compile_linfo(ctx::CompilerContext, linfo::Core.MethodInstance, world)
         ref = convert(LLVM.API.LLVMModuleRef, ref)
         module_setup(LLVM.Module(ref))
     end
-    function hook_raise_exception(insblock::Ptr{Cvoid}, ex::Ptr{Cvoid})
-        insblock = convert(LLVM.API.LLVMValueRef, insblock)
-        ex = convert(LLVM.API.LLVMValueRef, ex)
-        raise_exception(BasicBlock(insblock), Value(ex))
-    end
     dependencies = Vector{LLVM.Module}()
     function hook_module_activation(ref::Ptr{Cvoid})
         ref = convert(LLVM.API.LLVMModuleRef, ref)
@@ -103,7 +81,6 @@ function compile_linfo(ctx::CompilerContext, linfo::Core.MethodInstance, world)
                                 prefer_specsig     = true,
                                 module_setup       = hook_module_setup,
                                 module_activation  = hook_module_activation,
-                                raise_exception    = hook_raise_exception,
                                 emit_function      = hook_emit_function,
                                 emitted_function   = hook_emitted_function)
 
@@ -189,15 +166,6 @@ function irgen(ctx::CompilerContext)
         end
     end
 
-    # HACK: remove unused arguments to exception functions
-    for val in exception_arguments
-        if isa(val, LLVM.Instruction) && isempty(uses(val))
-            bb = LLVM.parent(val)
-            unsafe_delete!(bb, val)
-        end
-    end
-    empty!(exception_arguments)
-
     # rename the entry point
     llvmfn = replace(LLVM.name(entry), r"_\d+$"=>"")
     ## append a global unique counter
@@ -211,6 +179,7 @@ function irgen(ctx::CompilerContext)
         global global_ctx
         global_ctx = ctx
 
+        add!(pm, ModulePass("LowerThrow", lower_throw!))
         add!(pm, FunctionPass("HideUnreachable", hide_unreachable!))
         add!(pm, FunctionPass("HideTrap", hide_trap!))
         always_inliner!(pm)
@@ -221,6 +190,75 @@ function irgen(ctx::CompilerContext)
     return mod, entry
 end
 
+# this pass lowers `jl_throw` and friends to GPU-compatible exceptions.
+# this isn't strictly necessary, but has a couple of advantages:
+# - we can kill off unused exception arguments that otherwise would allocate or invoke
+# - we can fake debug information (lacking a stack unwinder)
+#
+# once we have thorough inference (ie. discarding `@nospecialize` and thus supporting
+# exception arguments) and proper debug info to unwind the stack, this pass can go.
+function lower_throw!(mod::LLVM.Module)
+    ctx = global_ctx::CompilerContext
+    changed = false
+
+    throw_functions = Dict{String,String}(
+        "jl_throw"                      => "exception",
+        "jl_error"                      => "error",
+        "jl_too_few_args"               => "too few arguments exception",
+        "jl_too_many_args"              => "too many arguments exception",
+        "jl_type_error_rt"              => "type error",
+        "jl_undefined_var_error"        => "undefined variable error",
+        "jl_bounds_error"               => "bounds error",
+        "jl_bounds_error_v"             => "bounds error",
+        "jl_bounds_error_int"           => "bounds error",
+        "jl_bounds_error_tuple_int"     => "bounds error",
+        "jl_bounds_error_unboxed_int"   => "bounds error",
+        "jl_bounds_error_ints"          => "bounds error",
+        "jl_eof_error"                  => "EOF error"
+    )
+
+    for (fn, name) in throw_functions
+        if haskey(functions(mod), fn)
+            f = functions(mod)[fn]
+
+            for use in uses(f)
+                call = user(use)::LLVM.CallInst
+
+                # replace the throw with a PTX-compatible exception
+                let builder = Builder(JuliaContext())
+                    position!(builder, call)
+                    emit_exception!(builder, name, call)
+                    dispose(builder)
+                end
+
+                # remove the call
+                call_args = collect(operands(call))[1:end-1] # last arg is function itself
+                unsafe_delete!(LLVM.parent(call), call)
+
+                # HACK: kill the exceptions' unused arguments
+                for arg in call_args
+                    # peek through casts
+                    if isa(arg, LLVM.AddrSpaceCastInst)
+                        cast = arg
+                        arg = first(operands(cast))
+                        isempty(uses(cast)) && unsafe_delete!(LLVM.parent(cast), cast)
+                    end
+
+                    if isa(arg, LLVM.Instruction) && isempty(uses(arg))
+                        unsafe_delete!(LLVM.parent(arg), arg)
+                    end
+                end
+
+                changed = true
+            end
+
+            @compiler_assert isempty(uses(f)) ctx
+         end
+     end
+
+    return changed
+end
+
 # report an exception in a GPU-compatible manner
 #
 # the exact behavior depends on the debug level. in all cases, a `trap` will be emitted, On

src/device/runtime_intrinsics.jl

@@ -79,7 +79,7 @@ end
 
 function report_exception(ex)
     @cuprintf("""
-        ERROR: a %s exception occurred during kernel execution.
+        ERROR: a %s was thrown during kernel execution.
                Run Julia on debug level 2 for device stack traces.
         """, ex)
     return
@@ -89,7 +89,7 @@ compile(report_exception, Nothing, (Ptr{Cchar},))
 
 function report_exception_name(ex)
     @cuprintf("""
-        ERROR: a %s exception occurred during kernel execution.
+        ERROR: a %s was thrown during kernel execution.
         Stacktrace:
         """, ex)
     return
@@ -103,14 +103,8 @@ end
 compile(report_exception_frame, Nothing, (Cint, Ptr{Cchar}, Ptr{Cchar}, Cint))
 compile(report_exception_name, Nothing, (Ptr{Cchar},))
 
-function bounds_error_unboxed_int(data, vt, i)
-    @cuprintf("ERROR: a bounds error occurred during kernel execution.")
-    # FIXME: have this call emit_exception somehow
-    return
-end
-
-compile(bounds_error_unboxed_int, Nothing, (Ptr{Cvoid}, Any, Csize_t);
-        llvm_name="jl_bounds_error_unboxed_int")
+# NOTE: no throw functions are provided here, but replaced by an LLVM pass instead
+#       in order to provide some debug information without stack unwinding.
 
 
 ## GC

test/device/execution.jl

@@ -524,21 +524,44 @@ let (code, out, err) = julia_script(script, `-g1`)
     @test code == 1
     @test occursin("ERROR: CUDA error: an illegal instruction was encountered", err) ||
           occursin("ERROR: CUDA error: unspecified launch failure", err)
-    @test occursin(r"ERROR: a .+ exception occurred during kernel execution", out)
+    @test occursin(r"ERROR: a exception was thrown during kernel execution", out)
     @test occursin(r"Run Julia on debug level 2 for device stack traces", out)
 end
 
 let (code, out, err) = julia_script(script, `-g2`)
     @test code == 1
     @test occursin("ERROR: CUDA error: an illegal instruction was encountered", err) ||
           occursin("ERROR: CUDA error: unspecified launch failure", err)
-    @test occursin(r"ERROR: a .+ exception occurred during kernel execution", out)
+    @test occursin(r"ERROR: a exception was thrown during kernel execution", out)
     @test occursin("[1] Type at float.jl", out)
     @test occursin("[2] kernel at none:2", out)
 end
 
 end
 
+@testset "#329" begin
+
+script = """
+    @noinline foo(a, i) = a[1] = i
+    bar(a) = (foo(a, 42); nothing)
+
+    ptr = CUDAnative.DevicePtr{Int,AS.Global}(convert(Ptr{Int}, C_NULL))
+    arr = CuDeviceArray{Int,1,AS.Global}((0,), ptr)
+    @cuda bar(arr)
+    CUDAdrv.synchronize()
+"""
+
+let (code, out, err) = julia_script(script, `-g2`)
+    @test code == 1
+    @test occursin("ERROR: CUDA error: an illegal instruction was encountered", err) ||
+          occursin("ERROR: CUDA error: unspecified launch failure", err)
+    @test occursin(r"ERROR: a exception was thrown during kernel execution", out)
+    @test occursin("foo at none:1", out)
+    @test occursin("bar at none:2", out)
+end
+
+end
+
 end
 
 ############################################################################################