Use plain vectors for storing LLVM kinds and opcodes.

Author: maleadt

src/core/basicblock.jl

@@ -5,7 +5,7 @@ export BasicBlock, unsafe_delete!,
 @checked struct BasicBlock <: Value
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMBasicBlockValueKind] = BasicBlock
+register(BasicBlock, API.LLVMBasicBlockValueKind)
 
 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
-value_kinds[API.LLVMFunctionValueKind] = Function
+register(Function, API.LLVMFunctionValueKind)
 
 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
-value_kinds[API.LLVMArgumentValueKind] = Argument
+register(Argument, API.LLVMArgumentValueKind)
 
 struct FunctionParameterSet <: AbstractVector{Argument}
     f::Function

src/core/instructions.jl

@@ -4,13 +4,17 @@ export Instruction, unsafe_delete!,
        predicate_int, predicate_real
 
 # forward definition of Instruction in src/core/value/constant.jl
-value_kinds[API.LLVMInstructionValueKind] = Instruction
+register(Instruction, API.LLVMInstructionValueKind)
 
-const instruction_opcodes = Dict{API.LLVMOpcode, Type{<:Instruction}}()
+const instruction_opcodes = Vector{Type}(fill(Nothing, typemax(API.LLVMOpcode)+1))
 function identify(::Type{Instruction}, ref::API.LLVMValueRef)
     opcode = API.LLVMGetInstructionOpcode(ref)
-    haskey(instruction_opcodes, opcode) || error("Unknown instruction opcode $opcode")
-    return instruction_opcodes[opcode]
+    typ = @inbounds instruction_opcodes[opcode+1]
+    typ === Nothing && error("Unknown type opcode $opcode")
+    return typ
+end
+function register(T::Type{<:Instruction}, opcode::API.LLVMOpcode)
+    instruction_opcodes[opcode+1] = T
 end
 
 function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Instruction
@@ -120,7 +124,7 @@ for op in opcodes
         @checked struct $typename <: Instruction
             ref::API.LLVMValueRef
         end
-        instruction_opcodes[API.$enum] = $typename
+        register($typename, API.$enum)
     end
 end
 

src/core/metadata.jl

@@ -5,11 +5,15 @@ abstract type Metadata end
 
 Base.unsafe_convert(::Type{API.LLVMMetadataRef}, md::Metadata) = md.ref
 
-const metadata_kinds = Dict{API.LLVMMetadataKind, Type{<:Metadata}}()
+const metadata_kinds = Vector{Type}(fill(Nothing, typemax(API.LLVMMetadataKind)+1))
 function identify(::Type{Metadata}, ref::API.LLVMMetadataRef)
     kind = API.LLVMGetMetadataKind(ref)
-    haskey(metadata_kinds, kind) || error("Unknown metadata kind $kind")
-    return metadata_kinds[kind]
+    typ = @inbounds metadata_kinds[kind+1]
+    typ === Nothing && error("Unknown metadata kind $kind")
+    return typ
+end
+function register(T::Type{<:Metadata}, kind::API.LLVMMetadataKind)
+    metadata_kinds[kind+1] = T
 end
 
 function refcheck(::Type{T}, ref::API.LLVMMetadataRef) where T<:Metadata
@@ -42,7 +46,7 @@ end
 @checked struct MetadataAsValue <: Value
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMMetadataAsValueValueKind] = MetadataAsValue
+register(MetadataAsValue, API.LLVMMetadataAsValueValueKind)
 
 Value(md::Metadata; ctx::Context) = MetadataAsValue(API.LLVMMetadataAsValue(ctx, md))
 
@@ -57,12 +61,12 @@ abstract type ValueAsMetadata <: Metadata end
 @checked struct ConstantAsMetadata <: ValueAsMetadata
     ref::API.LLVMMetadataRef
 end
-metadata_kinds[API.LLVMConstantAsMetadataMetadataKind] = ConstantAsMetadata
+register(ConstantAsMetadata, API.LLVMConstantAsMetadataMetadataKind)
 
 @checked struct LocalAsMetadata <: ValueAsMetadata
     ref::API.LLVMMetadataRef
 end
-metadata_kinds[API.LLVMLocalAsMetadataMetadataKind] = LocalAsMetadata
+register(LocalAsMetadata, API.LLVMLocalAsMetadataMetadataKind)
 
 # 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
@@ -78,7 +82,7 @@ export MDString
 @checked struct MDString <: Metadata
     ref::API.LLVMMetadataRef
 end
-metadata_kinds[API.LLVMMDStringMetadataKind] = MDString
+register(MDString, API.LLVMMDStringMetadataKind)
 
 MDString(val::String; ctx::Context) =
     MDString(API.LLVMMDStringInContext2(ctx, val, length(val)))
@@ -111,7 +115,7 @@ export MDTuple
 @checked struct MDTuple <: MDNode
     ref::API.LLVMMetadataRef
 end
-metadata_kinds[API.LLVMMDTupleMetadataKind] = MDTuple
+register(MDTuple, API.LLVMMDTupleMetadataKind)
 
 # MDTuples are commonly referred to as MDNodes, so keep that name
 MDNode(mds::Vector{<:Metadata}; ctx::Context) =

src/core/type.jl

@@ -7,11 +7,15 @@ Base.eltype(typ::LLVMType) = Any
 
 Base.unsafe_convert(::Type{API.LLVMTypeRef}, typ::LLVMType) = typ.ref
 
-const type_kinds = Dict{API.LLVMTypeKind, Type{<:LLVMType}}()
+const type_kinds = Vector{Type}(fill(Nothing, typemax(API.LLVMTypeKind)+1))
 function identify(::Type{LLVMType}, ref::API.LLVMTypeRef)
     kind = API.LLVMGetTypeKind(ref)
-    haskey(type_kinds, kind) || error("Unknown type kind $kind")
-    return type_kinds[kind]
+    typ = @inbounds type_kinds[kind+1]
+    typ === Nothing && error("Unknown type kind $kind")
+    return typ
+end
+function register(T::Type{<:LLVMType}, kind::API.LLVMTypeKind)
+    type_kinds[kind+1] = T
 end
 
 function refcheck(::Type{T}, ref::API.LLVMTypeRef) where T<:LLVMType
@@ -50,7 +54,7 @@ export width
 @checked struct IntegerType <: LLVMType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMIntegerTypeKind] = IntegerType
+register(IntegerType, API.LLVMIntegerTypeKind)
 
 for T in [:Int1, :Int8, :Int16, :Int32, :Int64, :Int128]
     jl_fname = Symbol(T, :Type)
@@ -84,7 +88,7 @@ for T in [:Half, :Float, :Double]
         @checked struct $api_typename <: FloatingPointType
             ref::API.LLVMTypeRef
         end
-        type_kinds[API.$enumkind] = $api_typename
+        register($api_typename, API.$enumkind)
 
         $jl_fname(ctx::Context) =
             $api_typename(API.$(Symbol(api_fname, :InContext))(ctx))
@@ -99,7 +103,7 @@ export isvararg, return_type, parameters
 @checked struct FunctionType <: LLVMType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMFunctionTypeKind] = FunctionType
+register(FunctionType, API.LLVMFunctionTypeKind)
 
 FunctionType(rettyp::LLVMType, params::Vector{<:LLVMType}=LLVMType[];
              vararg::Core.Bool=false) =
@@ -138,7 +142,7 @@ Base.eltype(typ::SequentialType) = LLVMType(API.LLVMGetElementType(typ))
 @checked struct PointerType <: SequentialType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMPointerTypeKind] = PointerType
+register(PointerType, API.LLVMPointerTypeKind)
 
 function PointerType(eltyp::LLVMType, addrspace=0)
     return PointerType(API.LLVMPointerType(eltyp, addrspace))
@@ -151,7 +155,7 @@ addrspace(ptrtyp::PointerType) =
 @checked struct ArrayType <: SequentialType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMArrayTypeKind] = ArrayType
+register(ArrayType, API.LLVMArrayTypeKind)
 
 function ArrayType(eltyp::LLVMType, count)
     return ArrayType(API.LLVMArrayType(eltyp, count))
@@ -165,7 +169,7 @@ Base.isempty(@nospecialize(T::ArrayType)) = length(T) == 0 || isempty(eltype(T))
 @checked struct VectorType <: SequentialType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMVectorTypeKind] = VectorType
+register(VectorType, API.LLVMVectorTypeKind)
 
 function VectorType(eltyp::LLVMType, count)
     return VectorType(API.LLVMVectorType(eltyp, count))
@@ -181,7 +185,7 @@ export name, ispacked, isopaque, elements!
 @checked struct StructType <: SequentialType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMStructTypeKind] = StructType
+register(StructType, API.LLVMStructTypeKind)
 
 function StructType(name::String; ctx::Context)
     return StructType(API.LLVMStructCreateNamed(ctx, name))
@@ -242,28 +246,28 @@ end
 @checked struct VoidType <: LLVMType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMVoidTypeKind] = VoidType
+register(VoidType, API.LLVMVoidTypeKind)
 
 VoidType(ctx::Context) = VoidType(API.LLVMVoidTypeInContext(ctx))
 
 @checked struct LabelType <: LLVMType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMLabelTypeKind] = LabelType
+register(LabelType, API.LLVMLabelTypeKind)
 
 LabelType(ctx::Context) = LabelType(API.LLVMLabelTypeInContext(ctx))
 
 @checked struct MetadataType <: LLVMType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMMetadataTypeKind] = MetadataType
+register(MetadataType, API.LLVMMetadataTypeKind)
 
 MetadataType(ctx::Context) = MetadataType(API.LLVMMetadataTypeInContext(ctx))
 
 @checked struct TokenType <: LLVMType
     ref::API.LLVMTypeRef
 end
-type_kinds[API.LLVMTokenTypeKind] = TokenType
+register(TokenType, API.LLVMTokenTypeKind)
 
 TokenType(ctx::Context) = TokenType(API.LLVMTokenTypeInContext(ctx))
 

src/core/value.jl

@@ -8,11 +8,15 @@ abstract type Value end
 
 Base.unsafe_convert(::Type{API.LLVMValueRef}, val::Value) = val.ref
 
-const value_kinds = Dict{API.LLVMValueKind, Type{<:Value}}()
+const value_kinds = Vector{Type}(fill(Nothing, typemax(API.LLVMValueKind)+1))
 function identify(::Type{Value}, ref::API.LLVMValueRef)
     kind = API.LLVMGetValueKind(ref)
-    haskey(value_kinds, kind) || error("Unknown value kind $kind")
-    return value_kinds[kind]
+    typ = @inbounds value_kinds[kind+1]
+    typ === Nothing && error("Unknown value kind $kind")
+    return typ
+end
+function register(T::Type{<:Value}, kind::API.LLVMValueKind)
+    value_kinds[kind+1] = T
 end
 
 function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Value

src/core/value/constant.jl

@@ -19,15 +19,15 @@ abstract type Instruction <: User end
 @checked struct PointerNull <: Constant
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMConstantPointerNullValueKind] = PointerNull
+register(PointerNull, API.LLVMConstantPointerNullValueKind)
 
 PointerNull(typ::PointerType) = PointerNull(API.LLVMConstPointerNull(typ))
 
 
 @checked struct UndefValue <: Constant
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMUndefValueValueKind] = UndefValue
+register(UndefValue, API.LLVMUndefValueValueKind)
 
 UndefValue(typ::LLVMType) = UndefValue(API.LLVMGetUndef(typ))
 
@@ -39,7 +39,7 @@ export ConstantInt, ConstantFP
 @checked struct ConstantInt <: Constant
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMConstantIntValueKind] = ConstantInt
+register(ConstantInt, API.LLVMConstantIntValueKind)
 
 # 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
-value_kinds[API.LLVMConstantFPValueKind] = ConstantFP
+register(ConstantFP, API.LLVMConstantFPValueKind)
 
 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
-value_kinds[API.LLVMConstantAggregateZeroValueKind] = ConstantAggregateZero
+register(ConstantAggregateZero, API.LLVMConstantAggregateZeroValueKind)
 
 # 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
-value_kinds[API.LLVMConstantArrayValueKind] = ConstantArray
-value_kinds[API.LLVMConstantDataArrayValueKind] = ConstantArray
+register(ConstantArray, API.LLVMConstantArrayValueKind)
+register(ConstantArray, API.LLVMConstantDataArrayValueKind)
 
 ConstantArrayOrAggregateZero(value) = Value(value)::Union{ConstantArray,ConstantAggregateZero}
 
@@ -205,7 +205,7 @@ end
 @checked struct ConstantStruct <: ConstantAggregate
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMConstantStructValueKind] = ConstantStruct
+register(ConstantStruct, API.LLVMConstantStructValueKind)
 
 ConstantStructOrAggregateZero(value) = Value(value)::Union{ConstantStruct,ConstantAggregateZero}
 
@@ -256,7 +256,7 @@ end
 @checked struct ConstantVector <: ConstantAggregate
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMConstantVectorValueKind] = ConstantVector
+register(ConstantVector, API.LLVMConstantVectorValueKind)
 
 
 ## constant expressions
@@ -266,15 +266,15 @@ export ConstantExpr, ConstantAggregate, ConstantArray, ConstantStruct, ConstantV
 @checked struct ConstantExpr <: Constant
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMConstantExprValueKind] = ConstantExpr
+register(ConstantExpr, API.LLVMConstantExprValueKind)
 
 
 ## inline assembly
 
 @checked struct InlineAsm <: Constant
     ref::API.LLVMValueRef
 end
-value_kinds[API.LLVMInlineAsmValueKind] = InlineAsm
+register(InlineAsm, API.LLVMInlineAsmValueKind)
 
 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
-value_kinds[API.LLVMGlobalVariableValueKind] = GlobalVariable
+register(GlobalVariable, API.LLVMGlobalVariableValueKind)
 
 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
-metadata_kinds[API.LLVMDILocationMetadataKind] = DILocation
+register(DILocation, API.LLVMDILocationMetadataKind)
 
 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
-        metadata_kinds[API.$var_kind] = $var_name
+        register($var_name, API.$var_kind)
     end
 end
 
@@ -77,7 +77,7 @@ export DIFile
 @checked struct DIFile <: DIScope
     ref::API.LLVMMetadataRef
 end
-metadata_kinds[API.LLVMDIFileMetadataKind] = DIFile
+register(DIFile, API.LLVMDIFileMetadataKind)
 
 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
-        metadata_kinds[API.$typ_kind] = $typ_name
+        register($typ_name, API.$typ_kind)
     end
 end
 
@@ -134,7 +134,7 @@ export DISubProgram
 @checked struct DISubProgram <: DIScope
     ref::API.LLVMMetadataRef
 end
-metadata_kinds[API.LLVMDISubprogramMetadataKind] = DISubProgram
+register(DISubProgram, API.LLVMDISubprogramMetadataKind)
 
 line(subprogram::DISubProgram) = Int(API.LLVMDISubprogramGetLine(subprogram))