Rename llvmtype to value_type, remove llvmeltype.

Author: maleadt

src/core/value.jl

@@ -39,13 +39,12 @@ end
 
 ## general APIs
 
-export llvmtype, llvmeltype, name, name!, replace_uses!, replace_metadata_uses!, isconstant, isundef, ispoison, context
+export value_type, name, name!, replace_uses!, replace_metadata_uses!, isconstant, isundef, ispoison, context
 
-llvmtype(val::Value) = LLVMType(API.LLVMTypeOf(val))
-llvmeltype(val::Value) = eltype(llvmtype(val))
+value_type(val::Value) = LLVMType(API.LLVMTypeOf(val))
 
 # defer size queries to the LLVM type (where we'll error)
-Base.sizeof(val::Value) = sizeof(llvmtype(val))
+Base.sizeof(val::Value) = sizeof(value_type(val))
 
 name(val::Value) = unsafe_string(API.LLVMGetValueName(val))
 name!(val::Value, name::String) = API.LLVMSetValueName(val, name)
@@ -58,13 +57,13 @@ end
 replace_uses!(old::Value, new::Value) = API.LLVMReplaceAllUsesWith(old, new)
 
 function replace_metadata_uses!(old::Value, new::Value)
-    if llvmtype(old) == llvmtype(new)
+    if value_type(old) == value_type(new)
         API.LLVMReplaceAllMetadataUsesWith(old, new)
     else
         # NOTE: LLVM does not support replacing values of different types, either using
         #       regular RAUW or only on metadata. The latter should probably be supported.
         #       Instead, we replace by a bitcast to the old type.
-        compat_new = const_bitcast(new, llvmtype(old))
+        compat_new = const_bitcast(new, value_type(old))
         replace_metadata_uses!(old, compat_new)
 
         # the above is often invalid, e.g. for module-level metadata identifying functions.

src/core/value/constant.jl

@@ -133,8 +133,8 @@ abstract type ConstantDataSequential <: Constant end
 #      but cannot support that as explained above).
 
 # array interface
-Base.eltype(cda::ConstantDataSequential) = llvmeltype(cda)
-Base.length(cda::ConstantDataSequential) = length(llvmtype(cda))
+Base.eltype(cda::ConstantDataSequential) = eltype(value_type(cda))
+Base.length(cda::ConstantDataSequential) = length(value_type(cda))
 Base.size(cda::ConstantDataSequential) = (length(cda),)
 function Base.getindex(cda::ConstantDataSequential, idx::Integer)
     @boundscheck 1 <= idx <= length(cda) || throw(BoundsError(cda, idx))
@@ -191,7 +191,7 @@ register(ConstantAggregateZero, API.LLVMConstantAggregateZeroValueKind)
 # array interface
 # FIXME: can we reuse the ::ConstantArray functionality with ConstantAggregateZero values?
 #        probably works fine if we just get rid of the refcheck
-Base.eltype(caz::ConstantAggregateZero) = llvmeltype(caz)
+Base.eltype(caz::ConstantAggregateZero) = eltype(value_type(caz))
 Base.size(caz::ConstantAggregateZero) = (0,)
 Base.length(caz::ConstantAggregateZero) = 0
 Base.axes(caz::ConstantAggregateZero) = (Base.OneTo(0),)
@@ -215,15 +215,15 @@ register(ConstantArray, API.LLVMConstantArrayValueKind)
 
 # generic constructor taking an array of constants
 function ConstantArray(typ::LLVMType, data::AbstractArray{T,N}=T[]) where {T<:Constant,N}
-    @assert all(x->x==typ, llvmtype.(data))
+    @assert all(x->x==typ, value_type.(data))
 
     if N == 1
         # XXX: this can return a ConstDataArray (presumably as an optimization?)
         return Value(API.LLVMConstArray(typ, Array(data), length(data)))
     end
 
     ca_vec = map(x->ConstantArray(typ, x), eachslice(data, dims=1))
-    ca_typ = llvmtype(first(ca_vec))
+    ca_typ = value_type(first(ca_vec))
 
     return ConstantArray(API.LLVMConstArray(ca_typ, ca_vec, length(ca_vec)))
 end
@@ -252,10 +252,10 @@ function Base.collect(ca::ConstantArray)
 end
 
 # array interface
-Base.eltype(ca::ConstantArray) = llvmeltype(ca)
+Base.eltype(ca::ConstantArray) = eltype(value_type(ca))
 function Base.size(ca::ConstantArray)
     dims = Int[]
-    typ = llvmtype(ca)
+    typ = value_type(ca)
     while typ isa ArrayType
         push!(dims, length(typ))
         typ = eltype(typ)
@@ -326,13 +326,13 @@ function ConstantStruct(value::T, name=String(nameof(T)); ctx::Context,
         ConstantStruct(constants; ctx, packed)
     elseif haskey(types(ctx), name)
         typ = types(ctx)[name]
-        if collect(elements(typ)) != llvmtype.(constants)
-            throw(ArgumentError("Cannot create struct $name {$(join(llvmtype.(constants), ", "))} as it is already defined in this context as {$(join(elements(typ), ", "))}."))
+        if collect(elements(typ)) != value_type.(constants)
+            throw(ArgumentError("Cannot create struct $name {$(join(value_type.(constants), ", "))} as it is already defined in this context as {$(join(elements(typ), ", "))}."))
         end
         ConstantStruct(typ, constants)
     else
         typ = StructType(name; ctx)
-        elements!(typ, llvmtype.(constants))
+        elements!(typ, value_type.(constants))
         ConstantStruct(typ, constants)
     end
 end

src/interop/base.jl

@@ -109,7 +109,7 @@ function Base.convert(::Type{LLVMType}, typ::Type; ctx::Context,
         llvmtyp = let
             mod = parse(LLVM.Module, buf; ctx)
             gv = first(globals(mod))
-            llvmeltype(gv)
+            eltype(value_type(gv))
         end
     end
 

src/irbuilder.jl

@@ -55,7 +55,7 @@ debuglocation!(builder::Builder, inst::Instruction) =
 ## build methods
 
 # TODO/IDEAS:
-# - dynamic dispatch based on `llvmtype` (eg. disambiguating `add!` and `fadd!`)
+# - dynamic dispatch based on `value_type` (eg. disambiguating `add!` and `fadd!`)
 
 # NOTE: the return values for these operations are, according to the C API, always a Value.
 #       however, the C++ API learns us that we can be more strict.

src/utils.jl

@@ -50,7 +50,7 @@ function clone(f::Function; value_map::Dict{Value,Value}=Dict{Value,Value}())
     # the VMap. If so, we need to not add the arguments to the arg ty vector
     for arg in parameters(f)
         if !in(arg, keys(value_map))    # Haven't mapped the argument to anything yet?
-            push!(argtypes, llvmtype(arg))
+            push!(argtypes, value_type(arg))
         end
     end
 

test/core.jl

@@ -228,7 +228,7 @@ end
 
     show(devnull, val)
 
-    @test llvmtype(val) == LLVM.PointerType(typ)
+    @test value_type(val) == LLVM.PointerType(typ)
     @test_throws ErrorException sizeof(val)
     @test name(val) == "foo"
     @test !isconstant(val)
@@ -367,7 +367,7 @@ end
     end
     let
         constval = ConstantInt(false; ctx)
-        @test llvmtype(constval) == LLVM.Int1Type(ctx)
+        @test value_type(constval) == LLVM.Int1Type(ctx)
         @test !convert(Bool, constval)
 
         constval = ConstantInt(true; ctx)
@@ -459,7 +459,7 @@ end
     let
         test_struct = TestStruct(true, -99, 1.5)
         constant_struct = ConstantStruct(test_struct; ctx, anonymous=true)
-        constant_struct_type = llvmtype(constant_struct)
+        constant_struct_type = value_type(constant_struct)
 
         @test constant_struct_type isa LLVM.StructType
         @test context(constant_struct) == ctx
@@ -479,7 +479,7 @@ end
     let
         test_struct = TestStruct(false, 52, -2.5)
         constant_struct = ConstantStruct(test_struct; ctx)
-        constant_struct_type = llvmtype(constant_struct)
+        constant_struct_type = value_type(constant_struct)
 
         @test constant_struct_type isa LLVM.StructType
 
@@ -499,7 +499,7 @@ end
     let
         test_struct = TestSingleton()
         constant_struct = ConstantStruct(test_struct; ctx)
-        constant_struct_type = llvmtype(constant_struct)
+        constant_struct_type = value_type(constant_struct)
 
         @test isempty(operands(constant_struct))
     end
@@ -517,7 +517,7 @@ end
         eltyp = LLVM.Int32Type(ctx)
         cda = ConstantDataArray(eltyp, vec)
         @test cda isa ConstantDataArray
-        @test llvmtype(cda) == LLVM.ArrayType(eltyp, 4)
+        @test value_type(cda) == LLVM.ArrayType(eltyp, 4)
         @test collect(cda) == ConstantInt.(vec; ctx)
     end
 
@@ -697,7 +697,7 @@ end
         ce = const_ptrtoint(ptr, LLVM.Int32Type(ctx))::LLVM.Constant
         @check_ir ce "i32 0"
 
-        ce = const_inttoptr(ce, llvmtype(ptr))::LLVM.Constant
+        ce = const_inttoptr(ce, value_type(ptr))::LLVM.Constant
         if supports_typed_ptrs
             @check_ir ce "i32* null"
         else
@@ -815,7 +815,7 @@ end
 @dispose ctx=Context() mod=LLVM.Module("SomeModule"; ctx) begin
     gv = GlobalVariable(mod, LLVM.Int32Type(ctx), "SomeGlobal", 1)
 
-    @test addrspace(llvmtype(gv)) == 1
+    @test addrspace(value_type(gv)) == 1
 end
 
 end
@@ -1165,7 +1165,7 @@ end
     @test fn isa LLVM.Function
 
     if supports_typed_ptrs
-        @test llvmeltype(fn) == ft
+        @test eltype(value_type(fn)) == ft
     end
     @test isintrinsic(fn)
 
@@ -1192,7 +1192,7 @@ end
     fn = LLVM.Function(mod, intr, [LLVM.DoubleType(ctx)])
     @test fn isa LLVM.Function
     if supports_typed_ptrs
-        @test llvmeltype(fn) == ft
+        @test eltype(value_type(fn)) == ft
     end
     @test isintrinsic(fn)
 

test/instructions.jl

@@ -273,7 +273,7 @@
     @check_ir bitcastinst "bitcast i32 %0 to float"
     if supports_typed_ptrs
         i32ptr1 = parameters(fn)[5]
-        i32ptr1typ = llvmtype(i32ptr1)
+        i32ptr1typ = value_type(i32ptr1)
         i32ptr1typ2 = LLVM.PointerType(eltype(i32ptr1typ), 2)
         addrspacecastinst = addrspacecast!(builder, i32ptr1, i32ptr1typ2)
         @check_ir addrspacecastinst "addrspacecast i32* %4 to i32 addrspace(2)*"

test/utils.jl

@@ -28,7 +28,7 @@
         # basic clone
         let new_f = clone(f)
             @test new_f != f
-            @test llvmtype(new_f) == llvmtype(f)
+            @test value_type(new_f) == value_type(f)
             for (bb1, bb2) in zip(blocks(f), blocks(new_f))
                 for (inst1, inst2) in zip(instructions(bb2), instructions(bb2))
                     @test inst1 == inst2
@@ -85,9 +85,9 @@
 
             # the add should now be a 64-bit addition
             add = first(instructions(first(blocks(new_f))))
-            @test llvmtype(operands(add)[1]) == LLVM.Int64Type(ctx)
-            @test llvmtype(operands(add)[2]) == LLVM.Int64Type(ctx)
-            @test llvmtype(add) == LLVM.Int64Type(ctx)
+            @test value_type(operands(add)[1]) == LLVM.Int64Type(ctx)
+            @test value_type(operands(add)[2]) == LLVM.Int64Type(ctx)
+            @test value_type(add) == LLVM.Int64Type(ctx)
         end
     end
 end