Constructors for ConstantStruct and multidimensional ConstantArrays

Nested structs are currently not supported via the `ConstantStruct(value, packed::Core.Bool=false)`, `ConstantStruct(value, ctx::Context=GlobalContext(), packed::Core.Bool=false)`
and `ConstantStruct(value, typ::LLVMType)` constructors. After some testing and looking at the generated LLVM IR of some C code using nested structs, it appears
like nested structs need to be named. This is an issue because we can't know the LLVM name of a nested struct type via a Julia value. Of course we could define our own struct
types for nested structs, but this leads to other issues like making sure the name does not clash, and duplicated definitions of the same struct (e.g. when calling `ConstStruct`
multiple times with the same struct value). Nested structs can still be created via the "lower-level" constructors if necessary.

As for multidimensional arrays: it doesn't seem to be possible to read from them via `LLVMGetElementAsConstant`, so this is not supported.

Author: S-D-R

src/core/value/constant.jl

@@ -123,13 +123,22 @@ end
 identify(::Type{Value}, ::Val{API.LLVMConstantArrayValueKind}) = ConstantArray
 identify(::Type{Value}, ::Val{API.LLVMConstantDataArrayValueKind}) = ConstantArray
 
-ConstantArray(typ::LLVMType, data::Vector{T}) where {T<:Constant} =
-    ConstantArray(API.LLVMConstArray(typ, data, length(data)))
-ConstantArray(typ::IntegerType, data::Vector{T}) where {T<:Integer} =
-    ConstantArray(typ, map(x->ConstantInt(convert(T,x),context(typ)), data))
-ConstantArray(typ::FloatingPointType, data::Vector{T}) where {T<:AbstractFloat} =
-    ConstantArray(typ, map(x->ConstantFP(convert(T,x),context(typ)), data))
+function ConstantArray(typ::LLVMType, data::AbstractArray{T,N}) where {T<:Constant,N}
+    if N == 1
+        return ConstantArray(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))
+
+    return ConstantArray(API.LLVMConstArray(ca_typ, ca_vec, length(ca_vec)))
+end
+ConstantArray(typ::IntegerType, data::AbstractArray{T,N}) where {T<:Integer,N} =
+    ConstantArray(typ, map(x->ConstantInt(typ, x), data))
+ConstantArray(typ::FloatingPointType, data::AbstractArray{T,N}) where {T<:AbstractFloat,N} =
+    ConstantArray(typ, map(x->ConstantFP(typ, x), data))
 
+# NOTE: getindex is not supported for multidimensionsal constant arrays
 Base.getindex(ca::ConstantArray, idx::Integer) =
     API.LLVMGetElementAsConstant(ca, idx-1)
 Base.length(ca::ConstantArray) = length(llvmtype(ca))
@@ -144,6 +153,52 @@ Base.convert(::Type{Array{T,1}}, ca::ConstantArray) where {T<:AbstractFloat} =
 end
 identify(::Type{Value}, ::Val{API.LLVMConstantStructValueKind}) = ConstantStruct
 
+ConstantStruct(constant_vals::Vector{T}, packed::Core.Bool=false) where {T<:Constant} =
+    ConstantStruct(API.LLVMConstStruct(constant_vals, length(constant_vals), convert(Bool, packed)))
+ConstantStruct(constant_vals::Vector{T}, ctx::Context, packed::Core.Bool=false) where {T<:Constant} =
+    ConstantStruct(API.LLVMConstStructInContext(ctx, constant_vals, length(constant_vals), convert(Bool, packed)))
+ConstantStruct(constant_vals::Vector{T}, typ::LLVMType) where {T<:Constant} =
+    ConstantStruct(API.LLVMConstNamedStruct(typ, constant_vals, length(constant_vals)))
+
+function struct_to_constants(value, ctx::Context)
+    constants = Vector{Constant}()
+
+    for fieldname in fieldnames(typeof(value))
+        field = getfield(value, fieldname)
+
+        if isa(field, Core.Bool)
+            typ = LLVM.Int1Type(ctx)
+            push!(constants, ConstantInt(typ, Int(field)))
+        elseif isa(field, Integer)
+            push!(constants, ConstantInt(field, ctx))
+        elseif isa(field, AbstractFloat)
+            push!(constants, ConstantFP(field, ctx))
+        else # TODO: nested structs?
+            throw(ArgumentError("only structs with boolean, integer and floating point fields are allowed"))
+        end
+    end
+
+    return constants
+end
+
+function ConstantStruct(value, packed::Core.Bool=false)
+    isbits(value) || throw(ArgumentError("`value` must be isbits"))
+    constants = struct_to_constants(value, GlobalContext())
+    return ConstantStruct(constants, packed)
+end
+
+function ConstantStruct(value, ctx::Context, packed::Core.Bool=false)
+    isbits(value) || throw(ArgumentError("`value` must be isbits"))
+    constants = struct_to_constants(value, ctx)
+    return ConstantStruct(constants, ctx, packed)
+end
+
+function ConstantStruct(value, typ::LLVMType)
+    isbits(value) || throw(ArgumentError("`value` must be isbits"))
+    constants = struct_to_constants(value, context(typ))
+    return ConstantStruct(constants, typ)
+end
+
 @checked struct ConstantVector <: ConstantAggregate
     ref::API.LLVMValueRef
 end

test/core.jl

@@ -1,3 +1,9 @@
+struct TestStruct
+    x::Bool
+    y::Int64
+    z::Float16
+end
+
 @testset "core" begin
 
 @testset "context" begin
@@ -393,6 +399,54 @@ Context() do ctx
         @test convert(Float32, ConstantFP(ca[1]))::Float32 == 1.1f0
         @test convert(Vector{Float32}, ca) == vec
     end
+    let
+        typ = LLVM.Int64Type(ctx)
+        vec = fill(5, 3, 4, 5, 6)
+        ca = ConstantArray(typ, vec)
+        @test length(ca) == size(vec, 1)
+        @test llvmtype(ca) == LLVM.ArrayType(LLVM.ArrayType(LLVM.ArrayType(LLVM.ArrayType(LLVM.Int64Type(ctx), 6), 5), 4), 3)
+        # NOTE: can't test content of the array because the API does not support reading from multidimensional arrays
+    end
+
+    end
+
+    @testset "struct constants" begin
+    
+    let
+        test_struct = TestStruct(true, -99, 1.5)
+        constant_struct = ConstantStruct(test_struct, ctx)
+        constant_struct_type = llvmtype(constant_struct)
+        
+        @test typeof(constant_struct_type) == LLVM.StructType
+        @test context(constant_struct_type) == ctx
+        @test !ispacked(constant_struct_type)
+        @test !isopaque(constant_struct_type)
+
+        @test collect(elements(constant_struct_type)) == [LLVM.Int1Type(ctx), LLVM.Int64Type(ctx), LLVM.HalfType(ctx)]
+        
+        expected_operands = [
+            ConstantInt(LLVM.Int1Type(ctx), Int(true)),
+            ConstantInt(LLVM.Int64Type(ctx), -99),
+            ConstantFP(LLVM.HalfType(ctx), 1.5)
+        ]
+        @test collect(operands(constant_struct)) == expected_operands
+    end
+    let
+        named_struct_type = LLVM.StructType("named_struct", ctx)
+        elements!(named_struct_type, [LLVM.Int1Type(ctx), LLVM.Int64Type(ctx), LLVM.HalfType(ctx)], true)
+
+        test_struct = TestStruct(false, 52, -2.5)
+        constant_struct = ConstantStruct(test_struct, named_struct_type)
+
+        @test llvmtype(constant_struct) == named_struct_type
+
+        expected_operands = [
+            ConstantInt(LLVM.Int1Type(ctx), Int(false)),
+            ConstantInt(LLVM.Int64Type(ctx), 52),
+            ConstantFP(LLVM.HalfType(ctx), -2.5)
+        ]
+        @test collect(operands(constant_struct)) == expected_operands
+    end
 
     end
 end