Prettify the ConstantInt API.

Author: maleadt

src/core/value/constant.jl

@@ -6,23 +6,37 @@ export ConstantInt, ConstantFP
 
 @reftypedef proxy=Value kind=LLVMConstantIntValueKind immutable ConstantInt <: Constant end
 
-function ConstantInt{T<:Signed}(typ::IntegerType, val::T)
+# NOTE: fixed set for dispatch, and because we can't rely on sizeof(T)==width(T)
+typealias SmallInteger Union{Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64}
+function ConstantInt{T<:SmallInteger}(typ::IntegerType, val::T, signed=false)
     wideval = convert(Int, val)
-    return construct(ConstantInt,
-                     API.LLVMConstInt(ref(typ), reinterpret(Culonglong, wideval), True))
+    bits = reinterpret(Culonglong, wideval)
+    return construct(ConstantInt, API.LLVMConstInt(ref(typ), bits, BoolToLLVM(signed)))
 end
 
-function ConstantInt{T<:Unsigned}(typ::IntegerType, val::T)
-    wideval = convert(UInt, val)
+function ConstantInt{T<:Integer}(typ::IntegerType, val::T, signed=false)
+    valbits = ceil(Int, log2(abs(val))) + 1
+    numwords = ceil(Int, valbits / 64)
+    words = Vector{Culonglong}(numwords)
+    for i in 1:numwords
+        words[i] = (val >> 64(i-1)) % Culonglong
+    end
     return construct(ConstantInt,
-                     API.LLVMConstInt(ref(typ), reinterpret(Culonglong, wideval), False))
+                     API.LLVMConstIntOfArbitraryPrecision(ref(typ), Cuint(numwords), words))
+end
+
+# NOTE: fixed set where sizeof(T) does match the numerical width
+typealias SizeableIntegers Union{Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128}
+function ConstantInt{T<:Integer}(val::T, ctx::Context=GlobalContext())
+    typ = IntType(sizeof(T)*8, ctx)
+    return ConstantInt(typ, val, T<:Signed)
 end
 
-convert(::Type{UInt}, val::ConstantInt) =
-    API.LLVMConstIntGetZExtValue(ref(val))
+convert{T<:Unsigned}(::Type{T}, val::ConstantInt) =
+    convert(T, API.LLVMConstIntGetZExtValue(ref(val)))
 
-convert(::Type{Int}, val::ConstantInt) =
-    API.LLVMConstIntGetSExtValue(ref(val))
+convert{T<:Signed}(::Type{T}, val::ConstantInt) =
+    convert(T, API.LLVMConstIntGetSExtValue(ref(val)))
 
 
 @reftypedef proxy=Value kind=LLVMConstantFPValueKind immutable ConstantFP <: Constant end

test/core.jl

@@ -202,10 +202,10 @@ LLVM.Module("SomeModule", ctx) do mod
     position!(builder, entry)
 
     valueinst1 = add!(builder, parameters(fn)[1],
-                      ConstantInt(LLVM.Int32Type(ctx), 1))
+                      ConstantInt(Int32(1), ctx))
 
     userinst = add!(builder, valueinst1,
-                    ConstantInt(LLVM.Int32Type(ctx), 1))
+                    ConstantInt(Int32(1), ctx))
 
     # use iteration
     let usepairs = uses(valueinst1)
@@ -224,7 +224,7 @@ LLVM.Module("SomeModule", ctx) do mod
     end
 
     valueinst2 = add!(builder, parameters(fn)[1],
-                    ConstantInt(LLVM.Int32Type(ctx), 2))
+                    ConstantInt(Int32(2), ctx))
 
     replace_uses!(valueinst1, valueinst2)
     @test user.(collect(uses(valueinst2))) == [userinst]
@@ -236,17 +236,31 @@ end
 
 # scalar
 Context() do ctx
-    t1 = LLVM.Int32Type(ctx)
-    c1 = ConstantInt(t1, UInt32(1))
-    @test convert(UInt, c1) == 1
-    c2 = ConstantInt(t1, Int32(-1))
-    @test convert(Int, c2) == -1
-
-    # construction from wider ints
-    c3 = ConstantInt(t1, UInt(1))
-    @test convert(UInt, c3) == 1
-    c4 = ConstantInt(t1, -1)
-    @test convert(Int, c4) == -1
+    ## integer constants
+
+    # manual construction of small values
+    let
+        typ = LLVM.Int32Type(ctx)
+        constval = ConstantInt(typ, -1)
+        @test convert(Int, constval) == -1
+        @test convert(UInt32, constval) == typemax(UInt32)
+    end
+
+    # manual construction of large values
+    let
+        typ = LLVM.Int64Type(ctx)
+        constval = ConstantInt(typ, BigInt(2)^100-1)
+        @test convert(Int, constval) == -1
+    end
+
+    # automatic construction
+    let
+        constval = ConstantInt(UInt32(1))
+        @test convert(UInt, constval) == 1
+    end
+
+
+    ## floating point constants
 
     t2 = LLVM.DoubleType(ctx)
     c = ConstantFP(t2, 1.1)
@@ -295,7 +309,7 @@ LLVM.Module("SomeModule", ctx) do mod
     show(DevNull, gv)
 
     @test_throws NullException initializer(gv)
-    init = ConstantInt(LLVM.Int32Type(), 0)
+    init = ConstantInt(Int32(0))
     initializer!(gv, init)
     @test initializer(gv) == init