Add support for OpaqueClosure

src/AllocCheck.jl

@@ -2,9 +2,9 @@ module AllocCheck
 
 import LLVM, GPUCompiler
 using GPUCompiler: JuliaContext, safe_name
-using LLVM: BasicBlock, ConstantExpr, ConstantInt, IRBuilder, UndefValue, blocks, br!,
-            called_operand, dispose, dominates, instructions, metadata, name, opcode,
-            operands, position!, ret!, successors, switch!, uses, user
+using LLVM: BasicBlock, ConstantExpr, ConstantInt, InlineAsm, IRBuilder, UndefValue,
+            blocks, br!, called_operand, dispose, dominates, instructions, metadata,
+            name, opcode, operands, position!, ret!, successors, switch!, uses, user
 
 include("static_backtrace.jl")
 include("abi_call.jl")

src/classify.jl

@@ -27,7 +27,7 @@ function classify_runtime_fn(name::AbstractString; ignore_throw::Bool)
                     "f__call_in_world", "f__call_in_world_total", "f_intrinsic_call", "f_invoke",
                     "f_opaque_closure_call", "apply", "apply_generic", "gf_invoke",
                     "gf_invoke_by_method", "gf_invoke_lookup_worlds", "invoke", "invoke_api",
-                    "jl_call", "jl_call0", "jl_call1", "jl_call2", "jl_call3")
+                    "call", "call0", "call1", "call2", "call3", "unknown_fptr")
         return (:dispatch, may_alloc)
     else
         return (:runtime, may_alloc)
@@ -37,13 +37,15 @@ end
 
 const generic_method_offsets = Dict{String,Int}(("jl_f__apply_latest" => 2, "ijl_f__apply_latest" => 2,
     "jl_f__call_latest" => 2, "ijl_f__call_latest" => 2, "jl_f_invoke" => 2, "jl_invoke" => 1,
-    "jl_apply_generic" => 1, "ijl_f_invoke" => 2, "ijl_invoke" => 1, "ijl_apply_generic" => 1))
+    "jl_apply_generic" => 1, "ijl_f_invoke" => 2, "ijl_invoke" => 1, "ijl_apply_generic" => 1,
+    "jl_unknown_fptr" => 0, "ijl_unknown_fptr" => 0))
 
 function resolve_dispatch_target(inst::LLVM.Instruction)
     @assert isa(inst, LLVM.CallInst)
     fun = LLVM.called_operand(inst)
     if isa(fun, LLVM.Function) && in(LLVM.name(fun), keys(generic_method_offsets))
         offset = generic_method_offsets[LLVM.name(fun)]
+        offset == 0 && return nothing
         flib = operands(inst)[offset]
         flib = unwrap_ptr_casts(flib)
         flib = look_through_loads(flib)
@@ -241,8 +243,16 @@ function rename_call!(call::LLVM.CallInst, mod::LLVM.Module)
         fn, file, line, linfo, fromC, inlined = last(frames)
 
         fname = string(fn)
+    elseif isa(callee, InlineAsm)
+        return # these are emitted for GC operations
+    elseif isa(callee, LLVM.Function)
+        return # function is already compile-time-known and expanded
     else
-        return
+        # Call to a runtime-determined function pointer, usually an OpaqueClosure
+        # or a ccall that we were not able to fully resolve.
+        #
+        # We label this as a DynamicDispatch to an unknown function target.
+        fname = "jl_unknown_fptr"
     end
 
     # Re-write function call to use a locally-created version with a nice name

test/runtests.jl

@@ -37,6 +37,15 @@ function run_gc_explicitly()
     GC.gc()
 end
 
+function call_jl_call(x::Int, y::Int)
+    return ccall(:jl_call2, Any, (#= Function =# Any, Any, Any), +, x, y)
+end
+
+const f = Base.Experimental.@opaque (x::Int, y::Int) -> x + y
+function call_opaque_closure(x::Int, y::Int)
+    return f(x, y)
+end
+
 @testset "Number of Allocations" begin
     @test length(check_allocs(mod, (Float64,Float64); ignore_throw=false)) == 0
     @test length(check_allocs(sin, (Float64,); ignore_throw=false)) > 0
@@ -58,6 +67,15 @@ end
     @test length(check_allocs(run_gc_explicitly, (); ignore_throw = false)) == 0
 
     @test_throws MethodError check_allocs(sin, (String,); ignore_throw=false)
+
+    allocs = check_allocs(call_jl_call, (Int, Int); ignore_throw = false)
+    @test length(allocs) == 2
+    @test all((alloc isa AllocationSite && allocs[1].type === Int64) ||
+              (alloc isa DynamicDispatch && allocs[2].fname === nothing)
+              for alloc in allocs)
+
+    allocs = check_allocs(call_opaque_closure, (Int, Int); ignore_throw = false)
+    @test length(allocs) > 0 && any(alloc isa DynamicDispatch for alloc in allocs)
 end
 
 @testset "@check_allocs macro (syntax)" begin
@@ -183,9 +201,16 @@ end
         @test  any(x isa AllocationSite && x.type == Memory        # uses jl_genericmemory_copy_slice
                    for x in check_allocs(copy, (Vector{Int},)))
 
-        @test  all(x isa AllocationSite && x.type == Memory{UInt8} # uses jl_string_to_genericmemory
+        @test  all(x isa DynamicDispatch || (x isa AllocationSite && x.type == Memory{UInt8}) # uses jl_string_to_genericmemory
                    for x in check_allocs(Base.array_new_memory, (Memory{UInt8}, Int)))
 
+        # Marked broken because the `Expr(:foreigncall, QuoteNode(:jl_alloc_string), ...)` should be resolved
+        # by AllocCheck.jl, but is instead (conservatively) marked as a DynamicDisaptch.
+        #
+        # We get thrown off by the `jl_load_and_lookup` machinery here.
+        @test_broken all(x isa AllocationSite && x.type == Memory{UInt8} # uses jl_string_to_genericmemory
+                         for x in check_allocs(Base.array_new_memory, (Memory{UInt8}, Int)))
+
         @test  all(x isa AllocationSite && x.type == Memory{Int}   # uses jl_alloc_genericmemory
                    for x in check_allocs(Base.array_new_memory, (Memory{Int}, Int)))