MSL: textureGatherOffsets broken for Metal 3.2+

[pablode]

Consider this fragment shader:

#version 460

layout(binding = 0) uniform sampler2D someTex;

layout (location = 0) out vec4 fragColor;

void main()
{
    const ivec2 OFFSETS[4] = ivec2[](ivec2(-1, 0), ivec2(0, 1), ivec2(1, 0), ivec2(0, -1));
   
    vec4 fetches = textureGatherOffsets(someTex, ivec2(0), OFFSETS, 0);
    
    fragColor = fetches;
}

We can compile it with Metal 3.0:

➜  glslangValidator --target-env vulkan1.1 -o shader.spv shader.frag
shader.frag
➜  spirv-cross shader.spv --msl-version 30000 --msl --output shader.metal
➜  xcrun -sdk macosx metal -std=metal3.0 -c -o shader.air shader.metal

However with Metal 3.2 and above, we get this compilation error:

➜  spirv-cross shader.spv --msl-version 40000 --msl --output shader.metal
➜  xcrun -sdk macosx metal -std=metal4.0 -c -o shader.air shader.metal  
shader.metal:147:22: error: no matching function for call to 'spvGatherConstOffsets'
    float4 fetches = spvGatherConstOffsets(someTex, someTexSmplr, _30, component::x, float2(0.0));
                     ^~~~~~~~~~~~~~~~~~~~~
shader.metal:61:18: note: candidate template ignored: could not match 'device Tex<T, access::sample, void>' against 'texture2d<float>'
inline vec<T, 4> spvGatherConstOffsets(const device Tex<T>& t, sampler s, Toff coffsets, component c, Tp... params) METAL_CONST_ARG(c)
                 ^
shader.metal:87:18: note: candidate template ignored: could not match 'constant Tex<T, access::sample, void>' against 'texture2d<float>'
inline vec<T, 4> spvGatherConstOffsets(const constant Tex<T>& t, sampler s, Toff coffsets, component c, Tp... params) METAL_CONST_ARG(c)
                 ^
shader.metal:113:18: note: candidate template ignored: could not match 'void' against 0
inline vec<T, 4> spvGatherConstOffsets(const thread Tex<T>& t, sampler s, Toff coffsets, component c, Tp... params) METAL_CONST_ARG(c)
                 ^
1 error generated

System Info:
Mac mini (Apple M2 Pro), macOS Tahoe 26.0.1

[HansKristian-Work]

Shader playground is not being helpful and the offline compilers don't work for me. Can you explain what needs to be changed in the generated code to make it compile?

[HansKristian-Work]

Got the offline compiler to work, and I don't understand what the problem is. I compiled that GLSL to SPIR-V and got MSL:

#pragma clang diagnostic ignored "-Wmissing-prototypes"
#pragma clang diagnostic ignored "-Wmissing-braces"

#include <metal_stdlib>
#include <simd/simd.h>

using namespace metal;

template<typename T, size_t Num>
struct spvUnsafeArray
{
    T elements[Num ? Num : 1];
    
    thread T& operator [] (size_t pos) thread
    {
        return elements[pos];
    }
    constexpr const thread T& operator [] (size_t pos) const thread
    {
        return elements[pos];
    }
    
    device T& operator [] (size_t pos) device
    {
        return elements[pos];
    }
    constexpr const device T& operator [] (size_t pos) const device
    {
        return elements[pos];
    }
    
    constexpr const constant T& operator [] (size_t pos) const constant
    {
        return elements[pos];
    }
    
    threadgroup T& operator [] (size_t pos) threadgroup
    {
        return elements[pos];
    }
    constexpr const threadgroup T& operator [] (size_t pos) const threadgroup
    {
        return elements[pos];
    }
};

template<typename Tex, typename... Tp>
using spvGatherReturn = decltype(declval<Tex>().gather(declval<sampler>(), declval<Tp>()...));

// Wrapper function that processes a device texture gather with a constant offset array.
template<typename Tex, typename Toff, typename... Tp>
inline spvGatherReturn<Tex, Tp...> spvGatherConstOffsets(const device Tex& t, sampler s, Toff coffsets, component c, Tp... params) METAL_CONST_ARG(c)
{
    spvGatherReturn<Tex, Tp...> rslts[4];
    for (uint i = 0; i < 4; i++)
    {
        switch (c)
        {
            case component::x:
                rslts[i] = t.gather(s, params..., coffsets[i], component::x);
                break;
            case component::y:
                rslts[i] = t.gather(s, params..., coffsets[i], component::y);
                break;
            case component::z:
                rslts[i] = t.gather(s, params..., coffsets[i], component::z);
                break;
            case component::w:
                rslts[i] = t.gather(s, params..., coffsets[i], component::w);
                break;
        }
    }
    return spvGatherReturn<Tex, Tp...>(rslts[0].w, rslts[1].w, rslts[2].w, rslts[3].w);
}

// Wrapper function that processes a constant texture gather with a constant offset array.
template<typename Tex, typename Toff, typename... Tp>
inline spvGatherReturn<Tex, Tp...> spvGatherConstOffsets(const constant Tex& t, sampler s, Toff coffsets, component c, Tp... params) METAL_CONST_ARG(c)
{
    spvGatherReturn<Tex, Tp...> rslts[4];
    for (uint i = 0; i < 4; i++)
    {
        switch (c)
        {
            case component::x:
                rslts[i] = t.gather(s, params..., coffsets[i], component::x);
                break;
            case component::y:
                rslts[i] = t.gather(s, params..., coffsets[i], component::y);
                break;
            case component::z:
                rslts[i] = t.gather(s, params..., coffsets[i], component::z);
                break;
            case component::w:
                rslts[i] = t.gather(s, params..., coffsets[i], component::w);
                break;
        }
    }
    return spvGatherReturn<Tex, Tp...>(rslts[0].w, rslts[1].w, rslts[2].w, rslts[3].w);
}

// Wrapper function that processes a thread texture gather with a constant offset array.
template<typename Tex, typename Toff, typename... Tp>
inline spvGatherReturn<Tex, Tp...> spvGatherConstOffsets(const thread Tex& t, sampler s, Toff coffsets, component c, Tp... params) METAL_CONST_ARG(c)
{
    spvGatherReturn<Tex, Tp...> rslts[4];
    for (uint i = 0; i < 4; i++)
    {
        switch (c)
        {
            case component::x:
                rslts[i] = t.gather(s, params..., coffsets[i], component::x);
                break;
            case component::y:
                rslts[i] = t.gather(s, params..., coffsets[i], component::y);
                break;
            case component::z:
                rslts[i] = t.gather(s, params..., coffsets[i], component::z);
                break;
            case component::w:
                rslts[i] = t.gather(s, params..., coffsets[i], component::w);
                break;
        }
    }
    return spvGatherReturn<Tex, Tp...>(rslts[0].w, rslts[1].w, rslts[2].w, rslts[3].w);
}

constant spvUnsafeArray<int2, 4> _30 = spvUnsafeArray<int2, 4>({ int2(-1, 0), int2(0, 1), int2(1, 0), int2(0, -1) });

struct main0_out
{
    float4 fragColor [[color(0)]];
};

fragment main0_out main0(texture2d<float> someTex [[texture(0)]], sampler someTexSmplr [[sampler(0)]])
{
    main0_out out = {};
    float4 fetches = spvGatherConstOffsets(someTex, someTexSmplr, _30, component::x, float2(0.0));
    out.fragColor = fetches;
    return out;
}

This compiles fine with:

metal.exe -std=metal3.2 -x metal /tmp/test.msl -c -o shader.air

and metal4.0.

[HansKristian-Work]

I need reproducing .spv and the exact .msl that fails.

[pablode]

Indeed, it seems like my local installation was messed up and I was using an outdated version of SPIRV-Cross (without the fix from March). Sorry for the noise!