Remove fallback for identify mechanism, always perform checks.

Author: maleadt

src/core/instructions.jl

@@ -10,13 +10,11 @@ identify(::Type{Instruction}, ref::API.LLVMValueRef) =
     identify(Instruction, Val{API.LLVMGetInstructionOpcode(ref)}())
 identify(::Type{Instruction}, ::Val{K}) where {K} = error("Unknown instruction kind $K")
 
-@inline function check(::Type{T}, ref::API.LLVMValueRef) where T<:Instruction
+@inline function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Instruction
     ref==C_NULL && throw(UndefRefError())
-    if Base.JLOptions().debug_level >= 2
-        T′ = identify(Instruction, ref)
-        if T != T′
-            error("invalid conversion of $T′ instruction reference to $T")
-        end
+    T′ = identify(Instruction, ref)
+    if T != T′
+        error("invalid conversion of $T′ instruction reference to $T")
     end
 end
 

src/core/type.jl

@@ -9,13 +9,11 @@ identify(::Type{LLVMType}, ref::API.LLVMTypeRef) =
     identify(LLVMType, Val{API.LLVMGetTypeKind(ref)}())
 identify(::Type{LLVMType}, ::Val{K}) where {K} = error("Unknown type kind $K")
 
-@inline function check(::Type{T}, ref::API.LLVMTypeRef) where T<:LLVMType
+@inline function refcheck(::Type{T}, ref::API.LLVMTypeRef) where T<:LLVMType
     ref==C_NULL && throw(UndefRefError())
-    if Base.JLOptions().debug_level >= 2
-        T′ = identify(LLVMType, ref)
-        if T != T′
-            error("invalid conversion of $T′ type reference to $T")
-        end
+    T′ = identify(LLVMType, ref)
+    if T != T′
+        error("invalid conversion of $T′ type reference to $T")
     end
 end
 

src/core/value.jl

@@ -12,13 +12,11 @@ identify(::Type{Value}, ref::API.LLVMValueRef) =
     identify(Value, Val{API.LLVMGetValueKind(ref)}())
 identify(::Type{Value}, ::Val{K}) where {K} = error("Unknown value kind $K")
 
-@inline function check(::Type{T}, ref::API.LLVMValueRef) where T<:Value
+@inline function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Value
     ref==C_NULL && throw(UndefRefError())
-    if Base.JLOptions().debug_level >= 2
-        T′ = identify(Value, ref)
-        if T != T′
-            error("invalid conversion of $T′ value reference to $T")
-        end
+    T′ = identify(Value, ref)
+    if T != T′
+        error("invalid conversion of $T′ value reference to $T")
     end
 end
 

src/pass.jl

@@ -22,7 +22,10 @@ export ModulePass
             return runner(mod)::Core.Bool
         end
 
-        return new(API.LLVMCreateModulePass(name, callback), callback)
+        ref = API.LLVMCreateModulePass(name, callback)
+        refcheck(ModulePass, ref)
+
+        return new(ref, callback)
     end
 end
 
@@ -43,7 +46,10 @@ export FunctionPass
             return runner(fn)::Core.Bool
         end
 
-        return new(API.LLVMCreateFunctionPass(name, callback), callback)
+        ref = API.LLVMCreateFunctionPass(name, callback)
+        refcheck(FunctionPass, ref)
+
+        return new(ref, callback)
     end
 end
 
@@ -66,7 +72,10 @@ export BasicBlockPass
             return runner(bb)::Core.Bool
         end
 
-        return new(API.LLVMCreateBasicBlockPass(name, callback), callback)
+        ref = API.LLVMCreateBasicBlockPass(name, callback)
+        refcheck(BasicBlockPass, ref)
+
+        return new(ref, callback)
     end
 end
 

src/util.jl

@@ -11,14 +11,8 @@ end
 
 # llvm.org/docs/doxygen/html/group__LLVMCSupportTypes.html
 
-# abstract implementations
-identify(::Type{T}, ref) where {T} = T(ref)
-@inline function check(::Type, ref::Ptr)
-    ref==C_NULL && throw(UndefRefError())
-end
-
 # macro that adds an inner constructor to a type definition,
-# calling `check` on the ref field argument
+# calling `refcheck` on the ref field argument
 macro checked(typedef)
     # decode structure definition
     if Meta.isexpr(typedef, :macrocall)
@@ -61,12 +55,17 @@ macro checked(typedef)
 
     # insert checked constructor
     push!(body.args, :(
-        $typename($(field_defs...)) = (check($typename, ref); new($(field_names...)))
+        $typename($(field_defs...)) = (refcheck($typename, ref); new($(field_names...)))
     ))
 
     return esc(typedef)
 end
 
+# the most basic check is asserting that we don't use a null pointer
+@inline function refcheck(::Type, ref::Ptr)
+    ref==C_NULL && throw(UndefRefError())
+end
+
 
 ## runtime ccall wrapper
 

test/core.jl

@@ -24,9 +24,7 @@ Context() do ctx
     @test typeof(typ.ref) == LLVM.API.LLVMTypeRef                 # untyped
 
     @test typeof(LLVM.IntegerType(typ.ref)) == LLVM.IntegerType   # type reconstructed
-    if Base.JLOptions().debug_level >= 2
-        @test_throws ErrorException LLVM.FunctionType(typ.ref)    # wrong type
-    end
+    @test_throws ErrorException LLVM.FunctionType(typ.ref)        # wrong type
     @test_throws UndefRefError LLVM.FunctionType(LLVM.API.LLVMTypeRef(C_NULL))
 
     @test typeof(typ.ref) == LLVM.API.LLVMTypeRef
@@ -203,12 +201,10 @@ LLVM.Module("SomeModule", ctx) do mod
     @test typeof(val.ref) == LLVM.API.LLVMValueRef                # untyped
 
     @test typeof(LLVM.Instruction(val.ref)) == LLVM.AllocaInst    # type reconstructed
-    if Base.JLOptions().debug_level >= 2
-        @test_throws ErrorException LLVM.Function(val.ref)        # wrong
-    end
+    @test_throws ErrorException LLVM.Function(val.ref)            # wrong
     @test_throws UndefRefError LLVM.Function(LLVM.API.LLVMValueRef(C_NULL))
 
-    @test typeof(Value(val.ref)) == LLVM.AllocaInst              # type reconstructed
+    @test typeof(Value(val.ref)) == LLVM.AllocaInst               # type reconstructed
     @test_throws UndefRefError Value(LLVM.API.LLVMValueRef(C_NULL))
 
     show(devnull, val)