Remove overzealous type conversions.

Author: maleadt

src/core/attributes.jl

@@ -53,8 +53,8 @@ value(attr::EnumAttribute) = API.LLVMGetEnumAttributeValue(ref(attr))
 ## string attribute
 
 StringAttribute(kind::String, value::String="", ctx::Context=GlobalContext()) =
-    StringAttribute(API.LLVMCreateStringAttribute(ref(ctx), kind, Cuint(length(kind)),
-                                                  value, Cuint(length(value))))
+    StringAttribute(API.LLVMCreateStringAttribute(ref(ctx), kind, length(kind),
+                                                  value, length(value)))
 
 function kind(attr::StringAttribute)
     len = Ref{Cuint}()

src/core/function.jl

@@ -18,7 +18,7 @@ personality!(f::Function, persfn::Function) = API.LLVMSetPersonalityFn(ref(f), r
 intrinsic_id(f::Function) = API.LLVMGetIntrinsicID(ref(f))
 
 callconv(f::Function) = API.LLVMGetFunctionCallConv(ref(f))
-callconv!(f::Function, cc) = API.LLVMSetFunctionCallConv(ref(f), Cuint(cc))
+callconv!(f::Function, cc) = API.LLVMSetFunctionCallConv(ref(f), cc)
 
 function gc(f::Function)
   ptr = API.LLVMGetGC(ref(f))
@@ -60,7 +60,7 @@ Base.delete!(iter::FunctionAttrSet, attr::EnumAttribute) =
 
 function Base.delete!(iter::FunctionAttrSet, attr::StringAttribute)
     k = kind(attr)
-    API.LLVMRemoveStringAttributeAtIndex(ref(iter.f), iter.idx, k, Cuint(length(k)))
+    API.LLVMRemoveStringAttributeAtIndex(ref(iter.f), iter.idx, k, length(k))
 end
 
 function Base.length(iter::FunctionAttrSet)
@@ -85,7 +85,7 @@ parameters(f::Function) = FunctionParameterSet(f)
 Base.eltype(::FunctionParameterSet) = Argument
 
 Base.getindex(iter::FunctionParameterSet, i) =
-  Argument(API.LLVMGetParam(ref(iter.f), Cuint(i-1)))
+  Argument(API.LLVMGetParam(ref(iter.f), i-1))
 
 function Base.iterate(iter::FunctionParameterSet, state=API.LLVMGetFirstParam(ref(iter.f)))
     state == C_NULL ? nothing : (Argument(state), API.LLVMGetNextParam(state))

src/core/instructions.jl

@@ -83,19 +83,19 @@ Base.isempty(md::InstructionMetadataDict) =
   !convert(Core.Bool, API.LLVMHasMetadata(ref(md.inst)))
 
 Base.haskey(md::InstructionMetadataDict, kind::MD) =
-  API.LLVMGetMetadata(ref(md.inst), Cuint(kind)) != C_NULL
+  API.LLVMGetMetadata(ref(md.inst), kind) != C_NULL
 
 function Base.getindex(md::InstructionMetadataDict, kind::MD)
-    objref = API.LLVMGetMetadata(ref(md.inst), Cuint(kind))
+    objref = API.LLVMGetMetadata(ref(md.inst), kind)
     objref == C_NULL && throw(KeyError(name))
     return MetadataAsValue(objref)
   end
 
 Base.setindex!(md::InstructionMetadataDict, node::MetadataAsValue, kind::MD) =
-    API.LLVMSetMetadata(ref(md.inst), Cuint(kind), ref(node))
+    API.LLVMSetMetadata(ref(md.inst), kind, ref(node))
 
 Base.delete!(md::InstructionMetadataDict, kind::MD) =
-    API.LLVMSetMetadata(ref(md.inst), Cuint(kind),
+    API.LLVMSetMetadata(ref(md.inst), kind,
                         convert(reftype(MetadataAsValue), C_NULL))
 
 
@@ -131,7 +131,7 @@ export callconv, callconv!,
 
 callconv(inst::Instruction) = API.LLVMGetInstructionCallConv(ref(inst))
 callconv!(inst::Instruction, cc) =
-    API.LLVMSetInstructionCallConv(ref(inst), Cuint(cc))
+    API.LLVMSetInstructionCallConv(ref(inst), cc)
 
 istailcall(inst::Instruction) = convert(Core.Bool, API.LLVMIsTailCall(ref(inst)))
 tailcall!(inst::Instruction, bool) = API.LLVMSetTailCall(ref(inst), convert(Bool, bool))
@@ -168,10 +168,10 @@ successors(term::Instruction) = TerminatorSuccessorSet(term)
 Base.eltype(::TerminatorSuccessorSet) = BasicBlock
 
 Base.getindex(iter::TerminatorSuccessorSet, i) =
-    BasicBlock(API.LLVMGetSuccessor(ref(iter.term), Cuint(i-1)))
+    BasicBlock(API.LLVMGetSuccessor(ref(iter.term), i-1))
 
 Base.setindex!(iter::TerminatorSuccessorSet, bb::BasicBlock, i) =
-    API.LLVMSetSuccessor(ref(iter.term), Cuint(i-1), blockref(bb))
+    API.LLVMSetSuccessor(ref(iter.term), i-1, blockref(bb))
 
 function Base.iterate(iter::TerminatorSuccessorSet, i=1)
     i >= length(iter) + 1 ? nothing : (iter[i], i+1)
@@ -197,13 +197,13 @@ incoming(phi::Instruction) = PhiIncomingSet(phi)
 Base.eltype(::PhiIncomingSet) = Tuple{Value,BasicBlock}
 
 Base.getindex(iter::PhiIncomingSet, i) =
-    tuple(Value(API.LLVMGetIncomingValue(ref(iter.phi), Cuint(i-1))),
-                BasicBlock(API.LLVMGetIncomingBlock(ref(iter.phi), Cuint(i-1))))
+    tuple(Value(API.LLVMGetIncomingValue(ref(iter.phi), i-1)),
+                BasicBlock(API.LLVMGetIncomingBlock(ref(iter.phi), i-1)))
 
 function Base.append!(iter::PhiIncomingSet, args::Vector{Tuple{V, BasicBlock}} where V <: Value)
     vals, blocks = zip(args...)
     API.LLVMAddIncoming(ref(iter.phi), collect(ref.(vals)),
-                        collect(ref.(blocks)), Cuint(length(args)))
+                        collect(ref.(blocks)), length(args))
 end
 
 Base.push!(iter::PhiIncomingSet, args::Tuple{<:Value, BasicBlock}) = append!(iter, [args])

src/core/metadata.jl

@@ -10,10 +10,10 @@ identify(::Type{Value}, ::Val{API.LLVMMetadataAsValueValueKind}) = MetadataAsVal
 
 const MDString = MetadataAsValue
 
-MDString(val::String) = MDString(API.LLVMMDString(val, Cuint(length(val))))
+MDString(val::String) = MDString(API.LLVMMDString(val, length(val)))
 
 MDString(val::String, ctx::Context) =
-    MDString(API.LLVMMDStringInContext(ref(ctx), val, Cuint(length(val))))
+    MDString(API.LLVMMDStringInContext(ref(ctx), val, length(val)))
 
 function Base.convert(::Type{String}, md::MDString)
     len = Ref{Cuint}()
@@ -26,11 +26,10 @@ end
 const MDNode = MetadataAsValue
 
 MDNode(vals::Vector{T}) where {T<:Value} =
-    MDNode(API.LLVMMDNode(ref.(vals), Cuint(length(vals))))
+    MDNode(API.LLVMMDNode(ref.(vals), length(vals)))
 
 MDNode(vals::Vector{T}, ctx::Context) where {T<:Value} =
-    MDNode(API.LLVMMDNodeInContext(ref(ctx), ref.(vals),
-                                   Cuint(length(vals))))
+    MDNode(API.LLVMMDNodeInContext(ref(ctx), ref.(vals), length(vals)))
 
 function operands(md::MDNode)
     nops = API.LLVMGetMDNodeNumOperands(ref(md))

src/core/type.jl

@@ -56,9 +56,9 @@ for T in [:Int1, :Int8, :Int16, :Int32, :Int64, :Int128]
     end
 end
 
-IntType(bits::Integer) = IntegerType(API.LLVMIntType(Cuint(bits)))
+IntType(bits::Integer) = IntegerType(API.LLVMIntType(bits))
 IntType(bits::Integer, ctx::Context) =
-    IntegerType(API.LLVMIntTypeInContext(ref(ctx), Cuint(bits)))
+    IntegerType(API.LLVMIntTypeInContext(ref(ctx), bits))
 
 width(inttyp::IntegerType) = API.LLVMGetIntTypeWidth(ref(inttyp))
 
@@ -100,7 +100,7 @@ identify(::Type{LLVMType}, ::Val{API.LLVMFunctionTypeKind}) = FunctionType
 
 FunctionType(rettyp::LLVMType, params::Vector{T}=LLVMType[], vararg::Core.Bool=false) where {T<:LLVMType} =
     FunctionType(API.LLVMFunctionType(ref(rettyp), ref.(params),
-                                      Cuint(length(params)), convert(Bool, vararg)))
+                                      length(params), convert(Bool, vararg)))
 
 isvararg(ft::FunctionType) =
     convert(Core.Bool, API.LLVMIsFunctionVarArg(ref(ft)))
@@ -137,8 +137,7 @@ end
 identify(::Type{LLVMType}, ::Val{API.LLVMPointerTypeKind}) = PointerType
 
 function PointerType(eltyp::LLVMType, addrspace=0)
-    return PointerType(API.LLVMPointerType(ref(eltyp),
-                                           Cuint(addrspace)))
+    return PointerType(API.LLVMPointerType(ref(eltyp), addrspace))
 end
 
 addrspace(ptrtyp::PointerType) =
@@ -151,7 +150,7 @@ end
 identify(::Type{LLVMType}, ::Val{API.LLVMArrayTypeKind}) = ArrayType
 
 function ArrayType(eltyp::LLVMType, count)
-    return ArrayType(API.LLVMArrayType(ref(eltyp), Cuint(count)))
+    return ArrayType(API.LLVMArrayType(ref(eltyp), count))
 end
 
 Base.length(arrtyp::ArrayType) = API.LLVMGetArrayLength(ref(arrtyp))
@@ -165,7 +164,7 @@ end
 identify(::Type{LLVMType}, ::Val{API.LLVMVectorTypeKind}) = VectorType
 
 function VectorType(eltyp::LLVMType, count)
-    return VectorType(API.LLVMVectorType(ref(eltyp), Cuint(count)))
+    return VectorType(API.LLVMVectorType(ref(eltyp), count))
 end
 
 Base.size(vectyp::VectorType) = API.LLVMGetVectorSize(ref(vectyp))
@@ -185,12 +184,12 @@ function StructType(name::String, ctx::Context=GlobalContext())
 end
 
 StructType(elems::Vector{T}, packed::Core.Bool=false) where {T<:LLVMType} =
-    StructType(API.LLVMStructType(ref.(elems), Cuint(length(elems)),
+    StructType(API.LLVMStructType(ref.(elems), length(elems),
                                   convert(Bool, packed)))
 
 StructType(elems::Vector{T}, ctx::Context, packed::Core.Bool=false) where {T<:LLVMType} =
     StructType(API.LLVMStructTypeInContext(ref(ctx), ref.(elems),
-                                           Cuint(length(elems)), convert(Bool, packed)))
+                                           length(elems), convert(Bool, packed)))
 
 name(structtyp::StructType) =
     unsafe_string(API.LLVMGetStructName(ref(structtyp)))
@@ -201,7 +200,7 @@ isopaque(structtyp::StructType) =
 
 elements!(structtyp::StructType, elems::Vector{T}, packed::Core.Bool=false) where {T<:LLVMType} =
     API.LLVMStructSetBody(ref(structtyp), ref.(elems),
-                          Cuint(length(elems)), convert(Bool, packed))
+                          length(elems), convert(Bool, packed))
 
 Base.isempty(@nospecialize(T::StructType)) =
     isempty(elements(T)) || all(isempty, elements(T))
@@ -219,7 +218,7 @@ elements(typ::StructType) = StructTypeElementSet(typ)
 Base.eltype(::StructTypeElementSet) = LLVMType
 
 Base.getindex(iter::StructTypeElementSet, i) =
-    LLVMType(API.LLVMStructGetTypeAtIndex(ref(iter.typ), Cuint(i-1)))
+    LLVMType(API.LLVMStructGetTypeAtIndex(ref(iter.typ), i-1))
 
 function Base.iterate(iter::StructTypeElementSet, i=1)
     i >= length(iter) + 1 ? nothing : (iter[i], i+1)

src/core/value/constant.jl

@@ -57,8 +57,7 @@ function ConstantInt(typ::IntegerType, val::Integer, signed=false)
     for i in 1:numwords
         words[i] = (val >> 64(i-1)) % Culonglong
     end
-    return ConstantInt(
-                     API.LLVMConstIntOfArbitraryPrecision(ref(typ), Cuint(numwords), words))
+    return ConstantInt(API.LLVMConstIntOfArbitraryPrecision(ref(typ), numwords, words))
 end
 
 # NOTE: fixed set where sizeof(T) does match the numerical width
@@ -157,7 +156,7 @@ isdeclaration(val::GlobalValue) = convert(Core.Bool, API.LLVMIsDeclaration(ref(v
 
 linkage(val::GlobalValue) = API.LLVMGetLinkage(ref(val))
 linkage!(val::GlobalValue, linkage::API.LLVMLinkage) =
-    API.LLVMSetLinkage(ref(val), Cuint(linkage))
+    API.LLVMSetLinkage(ref(val), linkage)
 
 function section(val::GlobalValue)
   #=
@@ -178,19 +177,19 @@ section!(val::GlobalValue, sec::String) = API.LLVMSetSection(ref(val), sec)
 
 visibility(val::GlobalValue) = API.LLVMGetVisibility(ref(val))
 visibility!(val::GlobalValue, viz::API.LLVMVisibility) =
-    API.LLVMSetVisibility(ref(val), Cuint(viz))
+    API.LLVMSetVisibility(ref(val), viz)
 
 dllstorage(val::GlobalValue) = API.LLVMGetDLLStorageClass(ref(val))
 dllstorage!(val::GlobalValue, storage::API.LLVMDLLStorageClass) =
-    API.LLVMSetDLLStorageClass(ref(val), Cuint(storage))
+    API.LLVMSetDLLStorageClass(ref(val), storage)
 
 unnamed_addr(val::GlobalValue) = convert(Core.Bool, API.LLVMHasUnnamedAddr(ref(val)))
 unnamed_addr!(val::GlobalValue, flag::Core.Bool) =
     API.LLVMSetUnnamedAddr(ref(val), convert(Bool, flag))
 
 const AlignedValue = Union{GlobalValue,Instruction}   # load, store, alloca
 alignment(val::AlignedValue) = API.LLVMGetAlignment(ref(val))
-alignment!(val::AlignedValue, bytes::Integer) = API.LLVMSetAlignment(ref(val), Cuint(bytes))
+alignment!(val::AlignedValue, bytes::Integer) = API.LLVMSetAlignment(ref(val), bytes)
 
 
 ## global variables
@@ -213,8 +212,8 @@ GlobalVariable(mod::Module, typ::LLVMType, name::String) =
     GlobalVariable(API.LLVMAddGlobal(ref(mod), ref(typ), name))
 
 GlobalVariable(mod::Module, typ::LLVMType, name::String, addrspace::Integer) =
-    GlobalVariable( API.LLVMAddGlobalInAddressSpace(ref(mod), ref(typ),
-                                                    name, Cuint(addrspace)))
+    GlobalVariable(API.LLVMAddGlobalInAddressSpace(ref(mod), ref(typ),
+                                                   name, addrspace))
 
 unsafe_delete!(::Module, gv::GlobalVariable) = API.LLVMDeleteGlobal(ref(gv))
 
@@ -233,7 +232,7 @@ constant!(gv::GlobalVariable, bool) =
 
 threadlocalmode(gv::GlobalVariable) = API.LLVMGetThreadLocalMode(ref(gv))
 threadlocalmode!(gv::GlobalVariable, mode) =
-  API.LLVMSetThreadLocalMode(ref(gv), Cuint(mode))
+  API.LLVMSetThreadLocalMode(ref(gv), mode)
 
 isextinit(gv::GlobalVariable) =
   convert(Core.Bool, API.LLVMIsExternallyInitialized(ref(gv)))

src/core/value/user.jl

@@ -15,10 +15,10 @@ operands(user::User) = UserOperandSet(user)
 Base.eltype(::UserOperandSet) = Value
 
 Base.getindex(iter::UserOperandSet, i::Integer) =   # TODO: otherwise unitrange indexing errors
-    Value(API.LLVMGetOperand(ref(iter.user), Cuint(i-1)))
+    Value(API.LLVMGetOperand(ref(iter.user), i-1))
 
 Base.setindex!(iter::UserOperandSet, val::Value, i) =
-    API.LLVMSetOperand(ref(iter.user), Cuint(i-1), ref(val))
+    API.LLVMSetOperand(ref(iter.user), i-1, ref(val))
 
 function Base.iterate(iter::UserOperandSet, i=1)
     i >= length(iter) + 1 ? nothing : (iter[i], i+1)

src/datalayout.jl

@@ -35,19 +35,18 @@ byteorder(data::DataLayout) = API.LLVMByteOrder(ref(data))
 
 pointersize(data::DataLayout) = API.LLVMPointerSize(ref(data))
 pointersize(data::DataLayout, addrspace::Integer) =
-    API.LLVMPointerSizeForAS(ref(data), Cuint(addrspace))
+    API.LLVMPointerSizeForAS(ref(data), addrspace)
 
 intptr(data::DataLayout) = IntegerType(API.LLVMIntPtrType(ref(data)))
 intptr(data::DataLayout, addrspace::Integer) =
-    IntegerType(API.LLVMIntPtrTypeForAS(ref(data), Cuint(addrspace)))
+    IntegerType(API.LLVMIntPtrTypeForAS(ref(data), addrspace))
 intptr(data::DataLayout, ctx::Context) =
     IntegerType(API.LLVMIntPtrTypeInContext(ref(ctx), ref(data)))
 intptr(data::DataLayout, addrspace::Integer, ctx::Context) =
-    IntegerType(API.LLVMIntPtrTypeForASInContext(ref(ctx), ref(data),
-                                                            Cuint(addrspace)))
+    IntegerType(API.LLVMIntPtrTypeForASInContext(ref(ctx), ref(data), addrspace))
 
 Base.sizeof(data::DataLayout, typ::LLVMType) =
-    Cuint(API.LLVMSizeOfTypeInBits(ref(data), ref(typ)) / 8)
+    Int(API.LLVMSizeOfTypeInBits(ref(data), ref(typ)) / 8)
 storage_size(data::DataLayout, typ::LLVMType) = API.LLVMStoreSizeOfType(ref(data), ref(typ))
 abi_size(data::DataLayout, typ::LLVMType) = API.LLVMABISizeOfType(ref(data), ref(typ))
 
@@ -57,11 +56,11 @@ frame_alignment(data::DataLayout, typ::LLVMType) =
     API.LLVMCallFrameAlignmentOfType(ref(data), ref(typ))
 preferred_alignment(data::DataLayout, typ::LLVMType) =
     API.LLVMPreferredAlignmentOfType(ref(data), ref(typ))
-preferred_alignment(data::DataLayout, var::GlobalVariable) = 
+preferred_alignment(data::DataLayout, var::GlobalVariable) =
     API.LLVMPreferredAlignmentOfGlobal(ref(data), ref(var))
 
 element_at(data::DataLayout, typ::StructType, offset::Integer) =
     API.LLVMElementAtOffset(ref(data), ref(typ), Culonglong(offset))
 
 offsetof(data::DataLayout, typ::StructType, element::Integer) =
-    API.LLVMOffsetOfElement(ref(data), ref(typ), Cuint(element))
+    API.LLVMOffsetOfElement(ref(data), ref(typ), element)

src/execution.jl

@@ -94,7 +94,7 @@ function JIT(mod::Module, optlevel::API.LLVMCodeGenOptLevel=API.LLVMCodeGenLevel
     out_ref = Ref{API.LLVMExecutionEngineRef}()
     out_error = Ref{Cstring}()
     status = convert(Core.Bool, API.LLVMCreateJITCompilerForModule(out_ref, ref(mod),
-                                                             Cuint(optlevel), out_error))
+                                                                   optlevel, out_error))
 
     if status
         error = unsafe_string(out_error[])
@@ -129,7 +129,7 @@ end
 
 Base.run(engine::ExecutionEngine, f::Function, args::Vector{GenericValue}=GenericValue[]) =
     GenericValue(API.LLVMRunFunction(ref(engine), ref(f),
-                                     Cuint(length(args)), ref.(args)))
+                                     length(args), ref.(args)))
 
 
 # ExectutionEngine function lookup