Merge pull request #329 from maleadt/tb/sdk_version

Add support for setting the module SDK Version metadata

Author: maleadt

deps/LLVMExtra/include/LLVMExtra.h

@@ -162,5 +162,8 @@ void LLVMReplaceMDNodeOperandWith(LLVMMetadataRef MD, unsigned I, LLVMMetadataRe
 LLVMBool LLVMContextSupportsTypedPointers(LLVMContextRef C);
 #endif
 
+// constant data
+LLVMValueRef LLVMConstDataArray(LLVMTypeRef ElementTy, const void *Data, unsigned NumElements);
+
 LLVM_C_EXTERN_C_END
 #endif

deps/LLVMExtra/lib/llvm-api.cpp

@@ -556,3 +556,8 @@ LLVMBool LLVMContextSupportsTypedPointers(LLVMContextRef C) {
   return unwrap(C)->supportsTypedPointers();
 }
 #endif
+
+LLVMValueRef LLVMConstDataArray(LLVMTypeRef ElementTy, const void *Data, unsigned NumElements) {
+    StringRef S((const char *)Data, NumElements * unwrap(ElementTy)->getPrimitiveSizeInBits() / 8);
+    return wrap(ConstantDataArray::getRaw(S, NumElements, unwrap(ElementTy)));
+}

deps/Project.toml

@@ -3,6 +3,7 @@ CMake_jll = "3f4e10e2-61f2-5801-8945-23b9d642d0e6"
 Git = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2"
 LLVMExtra_jll = "dad2f222-ce93-54a1-a47d-0025e8a3acab"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+Ninja_jll = "76642167-d241-5cee-8c94-7a494e8cb7b7"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Preferences = "21216c6a-2e73-6563-6e65-726566657250"
 Scratch = "6c6a2e73-6563-6170-7368-637461726353"

deps/build_local.jl

@@ -8,57 +8,67 @@ if haskey(ENV, "GITHUB_ACTIONS")
     println("::warning ::Using a locally-built LLVMExtra; A bump of LLVMExtra_jll will be required before releasing LLVM.jl.")
 end
 
-using Pkg, Scratch, Preferences, Libdl, CMake_jll
+using Pkg, Scratch, Preferences, Libdl, CMake_jll, Ninja_jll
 
 LLVM = Base.UUID("929cbde3-209d-540e-8aea-75f648917ca0")
 
-# 1. Ensure that an appropriate LLVM_full_jll is installed
+# get scratch directories
+scratch_dir = get_scratch!(LLVM, "build")
+isdir(scratch_dir) && rm(scratch_dir; recursive=true)
+source_dir = joinpath(@__DIR__, "LLVMExtra")
+
+# get build directory
+build_dir = if isempty(ARGS)
+    mktempdir()
+else
+    ARGS[1]
+end
+mkpath(build_dir)
+
+# download LLVM
 Pkg.activate(; temp=true)
 llvm_assertions = try
     cglobal((:_ZN4llvm24DisableABIBreakingChecksE, Base.libllvm_path()), Cvoid)
     false
 catch
     true
 end
+llvm_pkg_version = "$(Base.libllvm_version.major).$(Base.libllvm_version.minor)"
 LLVM = if llvm_assertions
-    Pkg.add(name="LLVM_full_assert_jll", version=Base.libllvm_version)
+    Pkg.add(name="LLVM_full_assert_jll", version=llvm_pkg_version)
     using LLVM_full_assert_jll
     LLVM_full_assert_jll
 else
-    Pkg.add(name="LLVM_full_jll", version=Base.libllvm_version)
+    Pkg.add(name="LLVM_full_jll", version=llvm_pkg_version)
     using LLVM_full_jll
     LLVM_full_jll
 end
 LLVM_DIR = joinpath(LLVM.artifact_dir, "lib", "cmake", "llvm")
 
-# 2. Get a scratch directory
-scratch_dir = get_scratch!(LLVM, "build")
-isdir(scratch_dir) && rm(scratch_dir; recursive=true)
-source_dir = joinpath(@__DIR__, "LLVMExtra")
-
-# Build!
-mktempdir() do build_dir
-    @info "Building" source_dir scratch_dir build_dir LLVM_DIR
-    run(`$(cmake()) -DLLVM_DIR=$(LLVM_DIR) -DCMAKE_INSTALL_PREFIX=$(scratch_dir) -B$(build_dir) -S$(source_dir)`)
-    run(`$(cmake()) --build $(build_dir)`)
-    run(`$(cmake()) --install $(build_dir)`)
+# build and install
+@info "Building" source_dir scratch_dir build_dir LLVM_DIR
+cmake() do cmake_path
+ninja() do ninja_path
+    run(`$cmake_path -GNinja -DLLVM_DIR=$(LLVM_DIR) -DCMAKE_INSTALL_PREFIX=$(scratch_dir) -B$(build_dir) -S$(source_dir)`)
+    run(`$ninja_path -C $(build_dir) install`)
+end
 end
 
-# Discover built libraries
+# discover built libraries
 built_libs = filter(readdir(joinpath(scratch_dir, "lib"))) do file
     endswith(file, ".$(Libdl.dlext)")
 end
 lib_path = joinpath(scratch_dir, "lib", only(built_libs))
 isfile(lib_path) || error("Could not find library $lib_path in build directory")
 
-# Tell LLVMExtra_jll to load our library instead of the default artifact one
+# tell LLVMExtra_jll to load our library instead of the default artifact one
 set_preferences!(
     joinpath(dirname(@__DIR__), "LocalPreferences.toml"),
     "LLVMExtra_jll",
     "libLLVMExtra_path" => lib_path;
     force=true,
 )
 
-# Copy the preferences to `test/` as well to work around Pkg.jl#2500
+# copy the preferences to `test/` as well to work around Pkg.jl#2500
 cp(joinpath(dirname(@__DIR__), "LocalPreferences.toml"),
    joinpath(dirname(@__DIR__), "test", "LocalPreferences.toml"); force=true)

lib/libLLVM_extra.jl

@@ -416,3 +416,7 @@ function LLVMContextSupportsTypedPointers(Ctx)
     ccall((:LLVMContextSupportsTypedPointers, libLLVMExtra), LLVMBool, (LLVMContextRef,), Ctx)
 end
 end
+
+function LLVMConstDataArray(ElementTy, Data, NumElements)
+    ccall((:LLVMConstDataArray, libLLVMExtra), LLVMValueRef, (LLVMTypeRef, Ptr{Cvoid}, Cuint), ElementTy, Data, NumElements)
+end

src/core/module.jl

@@ -267,3 +267,30 @@ function Base.setindex!(iter::ModuleFlagDict, val::Metadata,
                         (name, behavior)::Tuple{String, API.LLVMModuleFlagBehavior})
     API.LLVMAddModuleFlag(iter.mod, behavior, name, length(name), val)
 end
+
+
+## sdk version
+
+export sdk_version, sdk_version!
+
+function sdk_version!(mod::Module, version::VersionNumber)
+    entries = Int32[version.major]
+    if version.minor != 0 || version.patch != 0
+        push!(entries, version.minor)
+        if version.patch != 0
+            push!(entries, version.patch)
+        end
+        # cannot represent prerelease or build metadata
+    end
+    md = Metadata(ConstantDataArray(entries; ctx=context(mod)))
+
+    flags(mod)["SDK Version", LLVM.API.LLVMModuleFlagBehaviorWarning] = md
+end
+
+function sdk_version(mod::Module)
+    haskey(flags(mod), "SDK Version") || return nothing
+    md = flags(mod)["SDK Version"]
+    c = Value(md; ctx=context(mod))
+    entries = collect(c)
+    VersionNumber(map(val->convert(Int, val), entries)...)
+end

src/core/type.jl

@@ -163,7 +163,7 @@ function ArrayType(eltyp::LLVMType, count)
     return ArrayType(API.LLVMArrayType(eltyp, count))
 end
 
-Base.length(arrtyp::ArrayType) = API.LLVMGetArrayLength(arrtyp)
+Base.length(arrtyp::ArrayType) = Int(API.LLVMGetArrayLength(arrtyp))
 
 Base.isempty(@nospecialize(T::ArrayType)) = length(T) == 0 || isempty(eltype(T))
 

src/core/value/constant.jl

@@ -112,17 +112,67 @@ Base.convert(::Type{T}, val::ConstantFP) where {T<:AbstractFloat} =
     convert(T, API.LLVMConstRealGetDouble(val, Ref{API.LLVMBool}()))
 
 
-# sequential
+# sequential data
 
 export ConstantDataSequential, ConstantDataArray, ConstantDataVector
 
 abstract type ConstantDataSequential <: Constant end
 
+# ConstantData can only contain primitive types (1/2/4/8 byte integers, float/half),
+# as opposed to ConstantAggregate which can contain arbitrary LLVM values.
+#
+# however, LLVM seems to use both array types interchangeably, e.g., constructing
+# a ConstArray through LLVMConstArray may return a ConstantDataArray (presumably as an
+# optimization, when the data can be represented as densely packed primitive values).
+# because of that, ConstantDataArray and ConstantArray need to behave the same way,
+# concretely, indexing a ConstantDataArray has to return LLVM constant values...
+#
+# XXX: maybe we should just not expose ConstantDataArray then?
+#      one advantage of keeping them separate is that creating a ConstantDataArray
+#      is much cheaper (we should also be able to iterate much more efficiently,
+#      but cannot support that as explained above).
+
+# array interface
+Base.eltype(cda::ConstantDataSequential) = llvmeltype(cda)
+Base.length(cda::ConstantDataSequential) = length(llvmtype(cda))
+Base.size(cda::ConstantDataSequential) = (length(cda),)
+function Base.getindex(cda::ConstantDataSequential, idx::Integer)
+    @boundscheck 1 <= idx <= length(cda) || throw(BoundsError(cda, idx))
+    Value(API.LLVMGetElementAsConstant(cda, idx-1))
+end
+function Base.collect(cda::ConstantDataSequential)
+    constants = Array{Value}(undef, length(cda))
+    for i in 1:length(cda)
+        @inbounds constants[i] = cda[i]
+    end
+    return constants
+end
+
 @checked struct ConstantDataArray <: ConstantDataSequential
     ref::API.LLVMValueRef
 end
 register(ConstantDataArray, API.LLVMConstantDataArrayValueKind)
 
+function ConstantDataArray(typ::LLVMType, data::Array{T}) where {T <: Union{Integer, AbstractFloat}}
+    # TODO: can we look up the primitive size of the LLVM type?
+    #       use that to assert it matches the Julia element type.
+    return ConstantDataArray(API.LLVMConstDataArray(typ, data, length(data)))
+end
+
+# shorthands with arrays of plain Julia data
+# FIXME: duplicates the ConstantInt/ConstantFP conversion rules
+# XXX: X[X(...)] instead of X.(...) because of empty-container inference
+ConstantDataArray(data::AbstractVector{T}; ctx::Context) where {T<:Integer} =
+    ConstantDataArray(IntType(sizeof(T)*8; ctx), data)
+ConstantDataArray(data::AbstractVector{Core.Bool}; ctx::Context) =
+    ConstantDataArray(Int1Type(ctx), data)
+ConstantDataArray(data::AbstractVector{Float16}; ctx::Context) =
+    ConstantDataArray(HalfType(ctx), data)
+ConstantDataArray(data::AbstractVector{Float32}; ctx::Context) =
+    ConstantDataArray(FloatType(ctx), data)
+ConstantDataArray(data::AbstractVector{Float64}; ctx::Context) =
+    ConstantDataArray(DoubleType(ctx), data)
+
 @checked struct ConstantDataVector <: ConstantDataSequential
     ref::API.LLVMValueRef
 end
@@ -162,16 +212,14 @@ export ConstantArray
     ref::API.LLVMValueRef
 end
 register(ConstantArray, API.LLVMConstantArrayValueKind)
-register(ConstantArray, API.LLVMConstantDataArrayValueKind)
-
-ConstantArrayOrAggregateZero(value) = Value(value)::Union{ConstantArray,ConstantAggregateZero}
 
 # 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))
 
     if N == 1
-        return ConstantArrayOrAggregateZero(API.LLVMConstArray(typ, Array(data), length(data)))
+        # 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))
@@ -183,15 +231,15 @@ end
 # shorthands with arrays of plain Julia data
 # FIXME: duplicates the ConstantInt/ConstantFP conversion rules
 # XXX: X[X(...)] instead of X.(...) because of empty-container inference
-ConstantArray(data::AbstractArray{T,N}; ctx::Context) where {T<:Integer,N} =
+ConstantArray(data::AbstractArray{T}; ctx::Context) where {T<:Integer} =
     ConstantArray(IntType(sizeof(T)*8; ctx), ConstantInt[ConstantInt(x; ctx) for x in data])
-ConstantArray(data::AbstractArray{Core.Bool,N}; ctx::Context) where {N} =
+ConstantArray(data::AbstractArray{Core.Bool}; ctx::Context) =
     ConstantArray(Int1Type(ctx), ConstantInt[ConstantInt(x; ctx) for x in data])
-ConstantArray(data::AbstractArray{Float16,N}; ctx::Context) where {N} =
+ConstantArray(data::AbstractArray{Float16}; ctx::Context) =
     ConstantArray(HalfType(ctx), ConstantFP[ConstantFP(x; ctx) for x in data])
-ConstantArray(data::AbstractArray{Float32,N}; ctx::Context) where {N} =
+ConstantArray(data::AbstractArray{Float32}; ctx::Context) =
     ConstantArray(FloatType(ctx), ConstantFP[ConstantFP(x; ctx) for x in data])
-ConstantArray(data::AbstractArray{Float64,N}; ctx::Context) where {N} =
+ConstantArray(data::AbstractArray{Float64}; ctx::Context) =
     ConstantArray(DoubleType(ctx), ConstantFP[ConstantFP(x; ctx) for x in data])
 
 # convert back to known array types
@@ -226,7 +274,9 @@ function Base.getindex(ca::ConstantArray, idx::Integer...)
     I = CartesianIndices(size(ca))[idx...]
     for i in Tuple(I)
         if isempty(operands(ca))
-            ca = LLVM.Value(API.LLVMGetElementAsConstant(ca, i-1))
+            # XXX: is this valid? LLVMGetElementAsConstant is meant to be used with
+            #      Constant*Data*Arrays, not ConstantArrays
+            ca = Value(API.LLVMGetElementAsConstant(ca, i-1))
         else
             ca = (Base.@_propagate_inbounds_meta; operands(ca)[i])
         end

test/core.jl

@@ -412,29 +412,23 @@ end
     end
 
 
-    @testset "array constants" begin
+    @testset "array aggregate constants" begin
 
     # from Julia values
     let
-        vec = Int32[1,2,3,4]
+        vec = Int128[1,2,3,4]
         ca = ConstantArray(vec; ctx)
+        @test ca isa ConstantArray
         @test size(vec) == size(ca)
         @test length(vec) == length(ca)
         @test ca[1] == ConstantInt(vec[1]; ctx)
         @test collect(ca) == ConstantInt.(vec; ctx)
     end
-    let
-        vec = Float32[1.1f0,2.2f0,3.3f0,4.4f0]
-        ca = ConstantArray(vec; ctx)
-        @test size(vec) == size(ca)
-        @test length(vec) == length(ca)
-        @test ca[1] == ConstantFP(vec[1]; ctx)
-        @test collect(ca) == ConstantFP.(vec; ctx)
-    end
     let
         # tests for ConstantAggregateZero, constructed indirectly.
         # should behave similarly to ConstantArray since it can get returned there.
         ca = ConstantArray(Int[]; ctx)
+        @test ca isa ConstantAggregateZero
         @test size(ca) == (0,)
         @test length(ca) == 0
         @test isempty(collect(ca))
@@ -451,7 +445,7 @@ end
 
     end
 
-    @testset "struct constants" begin
+    @testset "struct aggregate constants" begin
 
     # from Julia values
     let
@@ -506,6 +500,36 @@ end
     end
 
     end
+
+
+    @testset "array data constants" begin
+
+    let
+        vec = Int32[1,2,3,4]
+        eltyp = LLVM.Int32Type(ctx)
+        cda = ConstantDataArray(eltyp, vec)
+        @test cda isa ConstantDataArray
+        @test llvmtype(cda) == LLVM.ArrayType(eltyp, 4)
+        @test collect(cda) == ConstantInt.(vec; ctx)
+    end
+
+    # from Julia values
+    for T in [Int8, Int16, Int32, Int64]
+        vec = T[1,2,3,4]
+        cda = ConstantDataArray(vec; ctx)
+        @test cda isa ConstantDataArray
+        @test size(vec) == size(cda)
+        @test collect(cda) == ConstantInt.(vec; ctx)
+    end
+    for T in [Float32, Float64]
+        vec = T[1,2,3,4]
+        cda = ConstantDataArray(vec; ctx)
+        @test cda isa ConstantDataArray
+        @test size(vec) == size(cda)
+        @test collect(cda) == ConstantFP.(vec; ctx)
+    end
+
+    end
 end
 
 # constant expressions
@@ -984,6 +1008,10 @@ end
 
     @test mod_flags["foobar"] == md
     @test_throws KeyError mod_flags["foobaz"]
+
+    @test sdk_version(mod) === nothing
+    sdk_version!(mod, v"1.2.3")
+    @test sdk_version(mod) == v"1.2.3"
 end
 
 # metadata iteration

test/runtests.jl

@@ -1,3 +1,13 @@
+# Work around JuliaLang/Pkg.jl#2500
+if VERSION < v"1.8-"
+    test_project = first(Base.load_path())
+    preferences_file = "LocalPreferences.toml"
+    test_preferences_file = joinpath(dirname(test_project), "LocalPreferences.toml")
+    if isfile(preferences_file) && !isfile(test_preferences_file)
+        cp(preferences_file, test_preferences_file)
+    end
+end
+
 using LLVM
 using Test