SPIR-V: Disallow Float16/Float64 if unsupported. (#429)

Author: maleadt

src/metal.jl

@@ -64,18 +64,8 @@ function process_entry!(job::CompilerJob{MetalCompilerTarget}, mod::LLVM.Module,
 end
 
 function validate_module(job::CompilerJob{MetalCompilerTarget}, mod::LLVM.Module)
-    errors = IRError[]
-
-    T_double = LLVM.DoubleType(context(mod))
-
-    for fun in functions(mod), bb in blocks(fun), inst in instructions(bb)
-        if value_type(inst) == T_double || any(param->value_type(param) == T_double, operands(inst))
-            bt = backtrace(inst)
-            push!(errors, ("use of double floating-point value", bt, inst))
-        end
-    end
-
-    return errors
+    # Metal never supports double precision
+    check_ir_values(mod, LLVM.DoubleType(context(mod)))
 end
 
 # TODO: why is this done in finish_module? maybe just in process_entry?

src/spirv.jl

@@ -13,6 +13,8 @@ const SPIRV_Tools_jll = LazyModule("SPIRV_Tools_jll", UUID("6ac6d60f-d740-5983-9
 export SPIRVCompilerTarget
 
 Base.@kwdef struct SPIRVCompilerTarget <: AbstractCompilerTarget
+    supports_fp16::Bool = true
+    supports_fp64::Bool = true
 end
 
 llvm_triple(::SPIRVCompilerTarget) = Int===Int64 ? "spir64-unknown-unknown" : "spirv-unknown-unknown"
@@ -73,6 +75,20 @@ function finish_module!(job::CompilerJob{SPIRVCompilerTarget}, mod::LLVM.Module,
     return entry
 end
 
+function validate_module(job::CompilerJob{SPIRVCompilerTarget}, mod::LLVM.Module)
+    errors = IRError[]
+
+    # support for half and double depends on the target
+    if !job.config.target.supports_fp16
+        append!(errors, check_ir_values(mod, LLVM.HalfType(context(mod))))
+    end
+    if !job.config.target.supports_fp64
+        append!(errors, check_ir_values(mod, LLVM.DoubleType(context(mod))))
+    end
+
+    return errors
+end
+
 @unlocked function mcgen(job::CompilerJob{SPIRVCompilerTarget}, mod::LLVM.Module,
                          format=LLVM.API.LLVMAssemblyFile)
     # The SPIRV Tools don't handle Julia's debug info, rejecting DW_LANG_Julia...

src/validation.jl

@@ -261,3 +261,17 @@ function check_ir!(job, errors::Vector{IRError}, inst::LLVM.CallInst)
 
     return errors
 end
+
+# helper function to check if a LLVM module uses values of a certain type
+function check_ir_values(mod::LLVM.Module, T_bad::LLVMType)
+    errors = IRError[]
+
+    for fun in functions(mod), bb in blocks(fun), inst in instructions(bb)
+        if value_type(inst) == T_bad || any(param->value_type(param) == T_bad, operands(inst))
+            bt = backtrace(inst)
+            push!(errors, ("unsupported use of $(T_bad) value", bt, inst))
+        end
+    end
+
+    return errors
+end

test/definitions/spirv.jl

@@ -8,9 +8,10 @@ end
 # create a SPIRV-based test compiler, and generate reflection methods for it
 
 function spirv_job(@nospecialize(func), @nospecialize(types);
-                   kernel::Bool=false, always_inline=false, kwargs...)
+                   kernel::Bool=false, always_inline=false,
+                   supports_fp16=true, supports_fp64=true, kwargs...)
     source = methodinstance(typeof(func), Base.to_tuple_type(types))
-    target = SPIRVCompilerTarget()
+    target = SPIRVCompilerTarget(; supports_fp16, supports_fp64)
     params = TestCompilerParams()
     config = CompilerConfig(target, params; kernel, always_inline)
     CompilerJob(source, config), kwargs

test/spirv.jl

@@ -37,6 +37,38 @@ end
 end
 end
 
+@testset "unsupported type detection" begin
+    function kernel(ptr, val)
+        unsafe_store!(ptr, val)
+        return
+    end
+
+    ir = sprint(io->spirv_code_llvm(io, kernel, Tuple{Ptr{Float16}, Float16}; validate=true))
+    @test occursin("store half", ir)
+
+    ir = sprint(io->spirv_code_llvm(io, kernel, Tuple{Ptr{Float32}, Float32}; validate=true))
+    @test occursin("store float", ir)
+
+    ir = sprint(io->spirv_code_llvm(io, kernel, Tuple{Ptr{Float64}, Float64}; validate=true))
+    @test occursin("store double", ir)
+
+    @test_throws_message(InvalidIRError,
+                         spirv_code_llvm(devnull, kernel, Tuple{Ptr{Float16}, Float16};
+                                         supports_fp16=false, validate=true)) do msg
+        occursin("unsupported unsupported use of half value", msg) &&
+        occursin("[1] unsafe_store!", msg) &&
+        occursin(r"\[2\] .*kernel", msg)
+    end
+
+    @test_throws_message(InvalidIRError,
+                         spirv_code_llvm(devnull, kernel, Tuple{Ptr{Float64}, Float64};
+                                         supports_fp64=false, validate=true)) do msg
+        occursin("unsupported unsupported use of double value", msg) &&
+        occursin("[1] unsafe_store!", msg) &&
+        occursin(r"\[2\] .*kernel", msg)
+    end
+end
+
 end
 
 ############################################################################################