Perform kind lookups using a global dict, not dispatch.

Author: maleadt

src/core/basicblock.jl

@@ -5,7 +5,7 @@ export BasicBlock, unsafe_delete!,
 @checked struct BasicBlock <: Value
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMBasicBlockValueKind}) = BasicBlock
+value_kinds[API.LLVMBasicBlockValueKind] = BasicBlock
 
 BasicBlock(ref::API.LLVMBasicBlockRef) = BasicBlock(API.LLVMBasicBlockAsValue(ref))
 Base.unsafe_convert(::Type{API.LLVMBasicBlockRef}, bb::BasicBlock) = API.LLVMValueAsBasicBlock(bb)

src/core/function.jl

@@ -5,7 +5,7 @@ export unsafe_delete!,
        entry
 
 # forward declaration of Function in src/core/basicblock.jl
-identify(::Type{Value}, ::Val{API.LLVMFunctionValueKind}) = Function
+value_kinds[API.LLVMFunctionValueKind] = Function
 
 Function(mod::Module, name::String, ft::FunctionType) =
     Function(API.LLVMAddFunction(mod, name, ft))
@@ -81,7 +81,7 @@ export Argument, parameters
 @checked struct Argument <: Value
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMArgumentValueKind}) = Argument
+value_kinds[API.LLVMArgumentValueKind] = Argument
 
 struct FunctionParameterSet <: AbstractVector{Argument}
     f::Function

src/core/instructions.jl

@@ -4,11 +4,14 @@ export Instruction, unsafe_delete!,
        predicate_int, predicate_real
 
 # forward definition of Instruction in src/core/value/constant.jl
-identify(::Type{Value}, ::Val{API.LLVMInstructionValueKind}) = Instruction
+value_kinds[API.LLVMInstructionValueKind] = Instruction
 
-identify(::Type{Instruction}, ref::API.LLVMValueRef) =
-    identify(Instruction, Val{API.LLVMGetInstructionOpcode(ref)}())
-identify(::Type{Instruction}, ::Val{K}) where {K} = error("Unknown instruction kind $K")
+const instruction_opcodes = Dict{API.LLVMOpcode, Type{<:Instruction}}()
+function identify(::Type{Instruction}, ref::API.LLVMValueRef)
+    opcode = API.LLVMGetInstructionOpcode(ref)
+    haskey(instruction_opcodes, opcode) || error("Unknown instruction opcode $opcode")
+    return instruction_opcodes[opcode]
+end
 
 @inline function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Instruction
     ref==C_NULL && throw(UndefRefError())
@@ -115,7 +118,7 @@ for op in opcodes
         @checked struct $typename <: Instruction
             ref::API.LLVMValueRef
         end
-        identify(::Type{Instruction}, ::Val{API.$enum}) = $typename
+        instruction_opcodes[API.$enum] = $typename
     end
 end
 

src/core/metadata.jl

@@ -5,9 +5,12 @@ abstract type Metadata end
 
 Base.unsafe_convert(::Type{API.LLVMMetadataRef}, md::Metadata) = md.ref
 
-identify(::Type{Metadata}, ref::API.LLVMMetadataRef) =
-    identify(Metadata, Val{API.LLVMGetMetadataKind(ref)}())
-identify(::Type{Metadata}, ::Val{K}) where {K} = error("Unknown metadata kind $K")
+const metadata_kinds = Dict{API.LLVMMetadataKind, Type{<:Metadata}}()
+function identify(::Type{Metadata}, ref::API.LLVMMetadataRef)
+    kind = API.LLVMGetMetadataKind(ref)
+    haskey(metadata_kinds, kind) || error("Unknown metadata kind $kind")
+    return metadata_kinds[kind]
+end
 
 @inline function refcheck(::Type{T}, ref::API.LLVMMetadataRef) where T<:Metadata
     ref==C_NULL && throw(UndefRefError())
@@ -37,7 +40,7 @@ end
 @checked struct MetadataAsValue <: Value
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMMetadataAsValueValueKind}) = MetadataAsValue
+value_kinds[API.LLVMMetadataAsValueValueKind] = MetadataAsValue
 
 Value(md::Metadata; ctx::Context) = MetadataAsValue(API.LLVMMetadataAsValue(ctx, md))
 
@@ -52,12 +55,12 @@ abstract type ValueAsMetadata <: Metadata end
 @checked struct ConstantAsMetadata <: ValueAsMetadata
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMConstantAsMetadataMetadataKind}) = ConstantAsMetadata
+metadata_kinds[API.LLVMConstantAsMetadataMetadataKind] = ConstantAsMetadata
 
 @checked struct LocalAsMetadata <: ValueAsMetadata
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMLocalAsMetadataMetadataKind}) = LocalAsMetadata
+metadata_kinds[API.LLVMLocalAsMetadataMetadataKind] = LocalAsMetadata
 
 # NOTE: this can be used to both pack e.g. constants as metadata, and to extract the
 #       metadata from an MetadataAsValue, so we don't type-assert narrowly here
@@ -73,7 +76,7 @@ export MDString
 @checked struct MDString <: Metadata
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMMDStringMetadataKind}) = MDString
+metadata_kinds[API.LLVMMDStringMetadataKind] = MDString
 
 MDString(val::String; ctx::Context) =
     MDString(API.LLVMMDStringInContext2(ctx, val, length(val)))
@@ -106,7 +109,7 @@ export MDTuple
 @checked struct MDTuple <: MDNode
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMMDTupleMetadataKind}) = MDTuple
+metadata_kinds[API.LLVMMDTupleMetadataKind] = MDTuple
 
 # MDTuples are commonly referred to as MDNodes, so keep that name
 MDNode(mds::Vector{<:Metadata}; ctx::Context) =

src/core/type.jl

@@ -7,9 +7,12 @@ Base.eltype(typ::LLVMType) = Any
 
 Base.unsafe_convert(::Type{API.LLVMTypeRef}, typ::LLVMType) = typ.ref
 
-identify(::Type{LLVMType}, ref::API.LLVMTypeRef) =
-    identify(LLVMType, Val{API.LLVMGetTypeKind(ref)}())
-identify(::Type{LLVMType}, ::Val{K}) where {K} = error("Unknown type kind $K")
+const type_kinds = Dict{API.LLVMTypeKind, Type{<:LLVMType}}()
+function identify(::Type{LLVMType}, ref::API.LLVMTypeRef)
+    kind = API.LLVMGetTypeKind(ref)
+    haskey(type_kinds, kind) || error("Unknown type kind $kind")
+    return type_kinds[kind]
+end
 
 @inline function refcheck(::Type{T}, ref::API.LLVMTypeRef) where T<:LLVMType
     ref==C_NULL && throw(UndefRefError())
@@ -45,7 +48,7 @@ export width
 @checked struct IntegerType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMIntegerTypeKind}) = IntegerType
+type_kinds[API.LLVMIntegerTypeKind] = IntegerType
 
 for T in [:Int1, :Int8, :Int16, :Int32, :Int64, :Int128]
     jl_fname = Symbol(T, :Type)
@@ -79,7 +82,7 @@ for T in [:Half, :Float, :Double]
         @checked struct $api_typename <: FloatingPointType
             ref::API.LLVMTypeRef
         end
-        identify(::Type{LLVMType}, ::Val{API.$enumkind}) = $api_typename
+        type_kinds[API.$enumkind] = $api_typename
 
         $jl_fname(ctx::Context) =
             $api_typename(API.$(Symbol(api_fname, :InContext))(ctx))
@@ -94,7 +97,7 @@ export isvararg, return_type, parameters
 @checked struct FunctionType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMFunctionTypeKind}) = FunctionType
+type_kinds[API.LLVMFunctionTypeKind] = FunctionType
 
 FunctionType(rettyp::LLVMType, params::Vector{<:LLVMType}=LLVMType[];
              vararg::Core.Bool=false) =
@@ -133,7 +136,7 @@ Base.eltype(typ::SequentialType) = LLVMType(API.LLVMGetElementType(typ))
 @checked struct PointerType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMPointerTypeKind}) = PointerType
+type_kinds[API.LLVMPointerTypeKind] = PointerType
 
 function PointerType(eltyp::LLVMType, addrspace=0)
     return PointerType(API.LLVMPointerType(eltyp, addrspace))
@@ -146,7 +149,7 @@ addrspace(ptrtyp::PointerType) =
 @checked struct ArrayType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMArrayTypeKind}) = ArrayType
+type_kinds[API.LLVMArrayTypeKind] = ArrayType
 
 function ArrayType(eltyp::LLVMType, count)
     return ArrayType(API.LLVMArrayType(eltyp, count))
@@ -160,7 +163,7 @@ Base.isempty(@nospecialize(T::ArrayType)) = length(T) == 0 || isempty(eltype(T))
 @checked struct VectorType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMVectorTypeKind}) = VectorType
+type_kinds[API.LLVMVectorTypeKind] = VectorType
 
 function VectorType(eltyp::LLVMType, count)
     return VectorType(API.LLVMVectorType(eltyp, count))
@@ -176,7 +179,7 @@ export name, ispacked, isopaque, elements!
 @checked struct StructType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMStructTypeKind}) = StructType
+type_kinds[API.LLVMStructTypeKind] = StructType
 
 function StructType(name::String; ctx::Context)
     return StructType(API.LLVMStructCreateNamed(ctx, name))
@@ -237,28 +240,28 @@ end
 @checked struct VoidType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMVoidTypeKind}) = VoidType
+type_kinds[API.LLVMVoidTypeKind] = VoidType
 
 VoidType(ctx::Context) = VoidType(API.LLVMVoidTypeInContext(ctx))
 
 @checked struct LabelType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMLabelTypeKind}) = LabelType
+type_kinds[API.LLVMLabelTypeKind] = LabelType
 
 LabelType(ctx::Context) = LabelType(API.LLVMLabelTypeInContext(ctx))
 
 @checked struct MetadataType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMMetadataTypeKind}) = MetadataType
+type_kinds[API.LLVMMetadataTypeKind] = MetadataType
 
 MetadataType(ctx::Context) = MetadataType(API.LLVMMetadataTypeInContext(ctx))
 
 @checked struct TokenType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMTokenTypeKind}) = TokenType
+type_kinds[API.LLVMTokenTypeKind] = TokenType
 
 TokenType(ctx::Context) = TokenType(API.LLVMTokenTypeInContext(ctx))
 

src/core/value.jl

@@ -8,9 +8,12 @@ abstract type Value end
 
 Base.unsafe_convert(::Type{API.LLVMValueRef}, val::Value) = val.ref
 
-identify(::Type{Value}, ref::API.LLVMValueRef) =
-    identify(Value, Val{API.LLVMGetValueKind(ref)}())
-identify(::Type{Value}, ::Val{K}) where {K} = error("Unknown value kind $K")
+const value_kinds = Dict{API.LLVMValueKind, Type{<:Value}}()
+function identify(::Type{Value}, ref::API.LLVMValueRef)
+    kind = API.LLVMGetValueKind(ref)
+    haskey(value_kinds, kind) || error("Unknown value kind $kind")
+    return value_kinds[kind]
+end
 
 @inline function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Value
     ref==C_NULL && throw(UndefRefError())

src/core/value/constant.jl

@@ -19,15 +19,15 @@ abstract type Instruction <: User end
 @checked struct PointerNull <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantPointerNullValueKind}) = PointerNull
+value_kinds[API.LLVMConstantPointerNullValueKind] = PointerNull
 
 PointerNull(typ::PointerType) = PointerNull(API.LLVMConstPointerNull(typ))
 
 
 @checked struct UndefValue <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMUndefValueValueKind}) = UndefValue
+value_kinds[API.LLVMUndefValueValueKind] = UndefValue
 
 UndefValue(typ::LLVMType) = UndefValue(API.LLVMGetUndef(typ))
 
@@ -39,7 +39,7 @@ export ConstantInt, ConstantFP
 @checked struct ConstantInt <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantIntValueKind}) = ConstantInt
+value_kinds[API.LLVMConstantIntValueKind] = ConstantInt
 
 # NOTE: fixed set for dispatch, also because we can't rely on sizeof(T)==width(T)
 const WideInteger = Union{Int64, UInt64}
@@ -83,7 +83,7 @@ Base.convert(::Type{Core.Bool}, val::ConstantInt) = convert(Int, val) != 0
 @checked struct ConstantFP <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantFPValueKind}) = ConstantFP
+value_kinds[API.LLVMConstantFPValueKind] = ConstantFP
 
 ConstantFP(typ::FloatingPointType, val::Real) =
     ConstantFP(API.LLVMConstReal(typ, Cdouble(val)))
@@ -106,7 +106,7 @@ export ConstantAggregateZero
 @checked struct ConstantAggregateZero <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantAggregateZeroValueKind}) = ConstantAggregateZero
+value_kinds[API.LLVMConstantAggregateZeroValueKind] = ConstantAggregateZero
 
 # array interface
 # FIXME: can we reuse the ::ConstantArray functionality with ConstantAggregateZero values?
@@ -127,8 +127,8 @@ abstract type ConstantAggregate <: Constant end
 @checked struct ConstantArray <: ConstantAggregate
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantArrayValueKind}) = ConstantArray
-identify(::Type{Value}, ::Val{API.LLVMConstantDataArrayValueKind}) = ConstantArray
+value_kinds[API.LLVMConstantArrayValueKind] = ConstantArray
+value_kinds[API.LLVMConstantDataArrayValueKind] = ConstantArray
 
 ConstantArrayOrAggregateZero(value) = Value(value)::Union{ConstantArray,ConstantAggregateZero}
 
@@ -205,7 +205,7 @@ end
 @checked struct ConstantStruct <: ConstantAggregate
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantStructValueKind}) = ConstantStruct
+value_kinds[API.LLVMConstantStructValueKind] = ConstantStruct
 
 ConstantStructOrAggregateZero(value) = Value(value)::Union{ConstantStruct,ConstantAggregateZero}
 
@@ -256,7 +256,7 @@ end
 @checked struct ConstantVector <: ConstantAggregate
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantVectorValueKind}) = ConstantVector
+value_kinds[API.LLVMConstantVectorValueKind] = ConstantVector
 
 
 ## constant expressions
@@ -266,15 +266,15 @@ export ConstantExpr, ConstantAggregate, ConstantArray, ConstantStruct, ConstantV
 @checked struct ConstantExpr <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMConstantExprValueKind}) = ConstantExpr
+value_kinds[API.LLVMConstantExprValueKind] = ConstantExpr
 
 
 ## inline assembly
 
 @checked struct InlineAsm <: Constant
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMInlineAsmValueKind}) = InlineAsm
+value_kinds[API.LLVMInlineAsmValueKind] = InlineAsm
 
 InlineAsm(typ::FunctionType, asm::String, constraints::String,
           side_effects::Core.Bool, align_stack::Core.Bool=false) =
@@ -352,7 +352,7 @@ export GlobalVariable, unsafe_delete!,
 @checked struct GlobalVariable <: GlobalObject
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMGlobalVariableValueKind}) = GlobalVariable
+value_kinds[API.LLVMGlobalVariableValueKind] = GlobalVariable
 
 GlobalVariable(mod::Module, typ::LLVMType, name::String) =
     GlobalVariable(API.LLVMAddGlobal(mod, typ, name))

src/debuginfo.jl

@@ -5,7 +5,7 @@ export DILocation
 @checked struct DILocation <: MDNode
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMDILocationMetadataKind}) = DILocation
+metadata_kinds[API.LLVMDILocationMetadataKind] = DILocation
 
 line(location::DILocation) = Int(API.LLVMDILocationGetLine(location))
 column(location::DILocation) = Int(API.LLVMDILocationGetColumn(location))
@@ -41,7 +41,7 @@ for var in (:Local, :Global)
         @checked struct $var_name <: DIVariable
             ref::API.LLVMMetadataRef
         end
-        identify(::Type{Metadata}, ::Val{API.$var_kind}) = $var_name
+        metadata_kinds[API.$var_kind] = $var_name
     end
 end
 
@@ -77,7 +77,7 @@ export DIFile
 @checked struct DIFile <: DIScope
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMDIFileMetadataKind}) = DIFile
+metadata_kinds[API.LLVMDIFileMetadataKind] = DIFile
 
 function directory(file::DIFile)
     len = Ref{Cuint}()
@@ -111,7 +111,7 @@ for typ in (:Basic, :Derived, :Composite, :Subroutine)
         @checked struct $typ_name <: DIType
             ref::API.LLVMMetadataRef
         end
-        identify(::Type{Metadata}, ::Val{API.$typ_kind}) = $typ_name
+        metadata_kinds[API.$typ_kind] = $typ_name
     end
 end
 
@@ -134,7 +134,7 @@ export DISubProgram
 @checked struct DISubProgram <: DIScope
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMDISubprogramMetadataKind}) = DISubProgram
+metadata_kinds[API.LLVMDISubprogramMetadataKind] = DISubProgram
 
 line(subprogram::DISubProgram) = Int(API.LLVMDISubprogramGetLine(subprogram))