LLVM SPIR-V backend crashes on functions returning small static arrays (e.g. SMatrix{1,1,Float32})

[ChrisRackauckas-Claude]

Summary

The LLVM SPIR-V backend (llc from SPIRV_LLVM_Backend_jll) crashes with LLVM ERROR: Broken function found, compilation aborted! when compiling GPU kernels that call functions returning small static array types like SMatrix{1,1,Float32}.

The root cause is that SMatrix{1,1,Float32} gets lowered to LLVM type [1 x float], and the SPIR-V backend incorrectly transforms the return type to i32 during internal passes, causing the LLVM IR verifier to abort.

MWE

using OpenCL, pocl_jll, KernelAbstractions, StaticArrays

# A kernel that calls a function returning SMatrix{1,1,Float32}
# This gets lowered to `[1 x float]` in LLVM IR, which the SPIR-V backend miscompiles
@kernel function smatrix_return_kernel(out)
    i = @index(Global)
    A = SMatrix{1,1,Float32}(3.0f0)
    B = SMatrix{1,1,Float32}(2.0f0)
    C = A * B  # returns SMatrix{1,1,Float32}
    out[i] = C[1]
end

backend = OpenCL.OpenCLBackend()
out = KernelAbstractions.zeros(backend, Float32, 4)
kernel = smatrix_return_kernel(backend, 4)
kernel(out, ndrange=4)
KernelAbstractions.synchronize(backend)

Error output

LLVM ERROR: Broken function found, compilation aborted!
ERROR: LoadError: Failed to translate LLVM code to SPIR-V.
...
caused by: failed process: Process(`...llc ...`, ProcessSignaled(6)) [0]

Context

This was discovered via SciML/DiffEqGPU.jl, where stiff ODE solvers using autodiff=false call finite_diff_jac, which returns SMatrix types. The finite_diff.jl tests fail on all Julia versions (lts, 1, pre) when using the OpenCL backend. See https://github.com/SciML/DiffEqGPU.jl/actions/runs/22247943080/job/64365791848

The same kernels work correctly with CUDA, AMDGPU, and JLArrays backends. They also likely work with the Khronos SPIR-V translator (SPIRV_LLVM_Translator_jll), since this is specifically a bug in the LLVM native SPIR-V backend.

Environment

• Julia: 1.10, 1.12, nightly (all affected)
• OpenCL.jl: latest (MQ6HZ)
• GPUCompiler.jl: latest (OCZFZ)
• SPIRV_LLVM_Backend_jll: v20.1.5+3
• pocl_jll (CPU OpenCL implementation)

Possibly related upstream

This appears related to LLVM's handling of struct/array return types in the SPIR-V backend. The SPIRV_LLVM_Backend_jll already carries patches for similar issues (e.g. fix_insertvalue.patch for LLVM#127977, atomic_cmpxchg_64bit.patch for LLVM#152863), but no patch exists yet for this specific struct-return miscompilation.

[vchuravy]

Please post OpenCL.versioninfo()

[ChrisRackauckas-Claude]

Reproducing MWE

The original MWE in the issue description does not reproduce the bug because the function gets inlined, optimizing away the problematic [1 x float] return type. Here is a corrected MWE that reliably triggers the crash:

using OpenCL, pocl_jll, KernelAbstractions, StaticArrays

# The bug: the SPIR-V backend (llc from SPIRV_LLVM_Backend_jll) incorrectly transforms
# the LLVM return type `[1 x float]` to `i32` during an internal pass, causing the
# LLVM IR verifier to abort.
#
# The key trigger is a non-inlined function returning a single-element static array.
# @noinline prevents the optimizer from eliminating the [1 x float] return type.

@noinline function f_smatrix(x::Float32)
    return SMatrix{1, 1, Float32}(x * x)
end

@kernel function test_kernel(out)
    i = @index(Global)
    J = f_smatrix(Float32(i))
    out[i] = J[1, 1]
end

backend = OpenCL.OpenCLBackend()
out = KernelAbstractions.zeros(backend, Float32, 4)
kernel = test_kernel(backend, 4)
kernel(out, ndrange=4)
KernelAbstractions.synchronize(backend)

What triggers and what doesn't

Case	Result
@noinline function returning SMatrix{1,1,Float32}	FAILS — [1 x float] miscompiled to i32
@noinline function returning SVector{1,Float32}	FAILS — same [1 x float] issue
Inlineable function returning SMatrix{1,1,Float32}	PASSES — return type optimized away
@noinline function returning SMatrix{2,2,Float32}	PASSES — [4 x float] handled correctly
Simple kernel with A * B on SMatrix{1,1} (original MWE)	PASSES — everything gets inlined

The bug is specific to single-element static arrays ([1 x float] in LLVM IR) returned from non-inlined functions. In the DiffEqGPU.jl CI, this is triggered by finite_diff_jac which returns SMatrix{1,1,Float32} through a complex enough code path that LLVM cannot inline it away.

Error output

Function return type does not match operand type of return inst!
  ret [1 x float] %oldret
 i32 in function julia_f_smatrix_13063
LLVM ERROR: Broken function found, compilation aborted!

OpenCL.versioninfo()

OpenCL.jl version 0.10.9

Toolchain:
 - Julia v1.12.4
 - OpenCL: 2024.10.24+1
 - SPIRV_LLVM_Backend: 20.1.5+3

Julia packages:
- GPUArrays: 11.4.1
- GPUCompiler: 1.8.2
- KernelAbstractions: 0.9.40
- LLVM: 9.4.6
- SPIRVIntrinsics: 0.5.7

Available platforms: 1
 - Portable Computing Language
   OpenCL 3.0, PoCL 7.1  Linux, Release, RELOC, SPIR-V, LLVM 20.1.2jl, SLEEF, DISTRO, POCL_DEBUG
   · cpu-haswell-AMD EPYC 7502 32-Core Processor (svm:c+f, usm:h+d, bda, fp64, il)