Merge #332

332: Various fixes r=maleadt a=maleadt



Co-authored-by: Tim Besard <[email protected]>

Author: bors[bot]

.gitlab-ci.yml

@@ -29,6 +29,7 @@ test:dev:
     - trying
 
 coverage:
+  allow_failure: true
   only:
     - master
     - staging

src/compiler/debug.jl

@@ -22,7 +22,8 @@ function backtrace(inst::LLVM.Instruction, bt = StackTraces.StackFrame[])
 
     # move up the call chain
     f = LLVM.parent(LLVM.parent(inst))
-    callers = uses(f)
+    ## functions can be used as a *value* in eg. constant expressions, so filter those out
+    callers = filter(val -> isa(user(val), LLVM.CallInst), collect(uses(f)))
     if !isempty(callers)
         # figure out the call sites of this instruction
         call_sites = unique(callers) do call

src/compiler/irgen.jl

@@ -181,7 +181,7 @@ function irgen(ctx::CompilerContext)
 
         add!(pm, ModulePass("LowerThrow", lower_throw!))
         add!(pm, FunctionPass("HideUnreachable", hide_unreachable!))
-        add!(pm, FunctionPass("HideTrap", hide_trap!))
+        add!(pm, ModulePass("HideTrap", hide_trap!))
         always_inliner!(pm)
         verifier!(pm)
         run!(pm, mod)
@@ -423,25 +423,26 @@ end
 # HACK: this pass removes calls to `trap` and replaces them with inline assembly
 #
 # if LLVM knows we're trapping, code is marked `unreachable` (see `hide_unreachable!`).
-function hide_trap!(fun::LLVM.Function)
+function hide_trap!(mod::LLVM.Module)
     ctx = global_ctx::CompilerContext
-    mod = LLVM.parent(fun)
     changed = false
 
     # inline assembly to exit a thread, hiding control flow from LLVM
     exit_ft = LLVM.FunctionType(LLVM.VoidType(JuliaContext()))
     exit = InlineAsm(exit_ft, "trap;", "", true)
 
-    for bb in blocks(fun)
-        # replace calls to `trap` with inline assembly
-        for inst in instructions(bb)
-            if isa(inst, LLVM.CallInst) && LLVM.name(called_value(inst)) == "llvm.trap"
+    if haskey(functions(mod), "llvm.trap")
+        trap = functions(mod)["llvm.trap"]
+
+        for use in uses(trap)
+            val = user(use)
+            if isa(val, LLVM.CallInst)
                 let builder = Builder(JuliaContext())
-                    position!(builder, inst)
+                    position!(builder, val)
                     call!(builder, exit)
                     dispose(builder)
                 end
-                unsafe_delete!(bb, inst)
+                unsafe_delete!(LLVM.parent(val), val)
                 changed = true
             end
         end

src/compiler/mcgen.jl

@@ -63,14 +63,14 @@ function resolve_cpu_references!(mod::LLVM.Module)
             function replace_bindings!(value)
                 changed = false
                 for use in uses(value)
-                    target = user(use)
-                    if isa(target, LLVM.ConstantExpr)
+                    val = user(use)
+                    if isa(val, LLVM.ConstantExpr)
                         # recurse
-                        changed |= replace_bindings!(target)
-                    elseif isa(target, LLVM.LoadInst)
+                        changed |= replace_bindings!(val)
+                    elseif isa(val, LLVM.LoadInst)
                         # resolve
-                        replace_uses!(target, dereferenced)
-                        unsafe_delete!(LLVM.parent(target), target)
+                        replace_uses!(val, dereferenced)
+                        unsafe_delete!(LLVM.parent(val), val)
                         # FIXME: iterator invalidation?
                         changed = true
                     end

src/compiler/optim.jl

@@ -299,7 +299,7 @@ function lower_gc_frame!(fun::LLVM.Function)
         barrier = functions(mod)["julia.write_barrier"]
 
         for use in uses(barrier)
-            call = user(use)
+            call = user(use)::LLVM.CallInst
             unsafe_delete!(LLVM.parent(call), call)
             changed = true
         end
@@ -325,11 +325,11 @@ function lower_ptls!(mod::LLVM.Module)
         ptls_getter = functions(mod)["julia.ptls_states"]
 
         for use in uses(ptls_getter)
-            call = user(use)
-            if !isempty(uses(call))
+            val = user(use)
+            if !isempty(uses(val))
                 error("Thread local storage is not implemented")
             end
-            unsafe_delete!(LLVM.parent(call), call)
+            unsafe_delete!(LLVM.parent(val), val)
             changed = true
         end
 

test/device/execution.jl

@@ -524,15 +524,15 @@ 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 was thrown during kernel execution", out)
-    @test occursin(r"Run Julia on debug level 2 for device stack traces", out)
+    @test occursin("ERROR: a exception was thrown during kernel execution", out)
+    @test occursin("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 was thrown during kernel execution", out)
+    @test occursin("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
@@ -555,7 +555,7 @@ 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("ERROR: a exception was thrown during kernel execution", out)
     @test occursin("foo at none:1", out)
     @test occursin("bar at none:2", out)
 end