For some reason, when compiling some simple shaders (with no uniforms), psDependencies ends up null in a bunch of places.

Caught a missing break;.

In addition, there were some misuses of vector iterators, that MSVC's debug mode caught (you can't take the address of the first item of a zero length vector, for example).

Problem

I get the following error when trying to compile my compute shader on iOS:

Compilation failed: 

program_source:60:20: error: use of undeclared identifier 'popCount'; did you mean 'popcount'?
        u_xlatu4 = popCount(u_xlati4);
                   ^~~~~~~~
                   popcount
/System/Library/PrivateFrameworks/GPUCompiler.framework/./Libraries/lib/clang/902.1/include/metal/metal_integer:174:14: note: 'popcount' declared here
METAL_FUNC T popcount(T x)

When looking at the function signature for popcount it is indeed all lower-case: https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf (search for "popcount")

Solution

Fix the problem in toMetalInstruction.cpp.

Is there any way for me to fix this locally in my build while I wait for this fix to propagate through the release cycle?

HLSL Code

SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 100

		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag

			#include "UnityCG.cginc"

			struct v2f
			{
				half4 pos : SV_POSITION;
			};

			v2f vert (appdata_full v)
			{
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				return o;
			}

			fixed4 frag (v2f i) : COLOR
			{
				return i.pos;
			}
			ENDCG
		}
	}

iOS Console Log

(Filename: /Users/builduser/buildslave/unity/build/artifacts/generated/common/runtime/DebugBindings.gen.cpp Line: 51)

Compilation failed: 

program_source:27:25: error: use of undeclared identifier 'mtl_FragCoord'
    output.SV_Target0 = mtl_FragCoord;
                        ^



#include <metal_stdlib>
#include <metal_texture>
using namespace metal;
#if !(__HAVE_FMA__)
#define fma(a,b,c) ((a) * (b) + (c))
#endif
#ifndef XLT_REMAP_O
#define XLT_REMAP_O {0, 1, 2, 3, 4, 5, 6, 7}
#endif
constexpr constant uint xlt_remap_o[] = XLT_REMAP_O;
struct Mtl_FragmentIn
{
    half4 mtl_FragCoord [[ user(mtl_FragCoord) ]] ;
};
struct Mtl_FragmentOut
{
    half4 SV_Target0 [[ color(xlt_remap_o[0]) ]];
};
fragment Mtl_FragmentOut xlatMtlMain(
    Mtl_FragmentIn input [[ stage_in ]])
{
    Mtl_FragmentOut output;
    output.SV_Target0 = mtl_FragCoord;
    return output;
}

Interestingly, mtl_FragCoord is properly defined when using Compile and show code menu in UnityEditor

-- Fragment shader for "metal":
Shader Disassembly:
#include <metal_stdlib>
#include <metal_texture>
using namespace metal;

#if !(__HAVE_FMA__)
#define fma(a,b,c) ((a) * (b) + (c))
#endif

#ifndef XLT_REMAP_O
#define XLT_REMAP_O {0, 1, 2, 3, 4, 5, 6, 7}
#endif
constexpr constant uint xlt_remap_o[] = XLT_REMAP_O;
struct Mtl_FragmentOut
{
    float4 SV_Target0 [[ color(xlt_remap_o[0]) ]];
};

fragment Mtl_FragmentOut xlatMtlMain(
    float4 mtl_FragCoord [[ position ]])
{
    Mtl_FragmentOut output;
    output.SV_Target0 = mtl_FragCoord;
    return output;
}

Hi, just seen Unity roadmap mentions "Tessellation for Metal" being on track for 2018.1 release.. so considering we should be seeing support for it in first public beta possibly coming this year it might be very well implemented by now.. would be nice if HLSLcc Metal tesselation support could be posted soon (christmas present for this year? :-) ).. thanks..

Would someone be able to clarify the need for the call to psContext->ClearDependencyData() in ToGLSL::Translate()? I'm trying to get separable shader stages working, but the pixel shader translation responds to this call by wiping out the GLSLCrossDependencyData struct before processing its declarations (so every varying gets put in the wrong location).

I'm sure there must be a reason for it, but I'm not sure what it is!

Thanks, Mike

Hi, just searching "Metal" in release notes up to b10 I see:

Enabled UAV writes on fragment shaders for Metal. Fixed some corner cases in Metal compute buffers with counters Added cube array Texture support to OSX Metal

Just asking if that improvements required changes to HLSLcc or outside of it.. if changes needed will be nice to have HLSLcc updated also but for me big change will be Metal tesselation support in HLSLcc.. hope it's in 2017.1 beta in April and HLSLcc get's it by April also..

Hi,

as the register type analysis of OPCODE_F32TOF16 and OPCODE_F16TOF32 are not implemented, the resulting translation into GLSL results in invalid GLSL as the target/source register type may be incorrect.

How can I fix the following error?

CMake Error at CMakeLists.txt:52 (set_target_properties): set_target_properties called with incorrect number of arguments.

Currently the cross compiler outputs combined image sampler in the glsl output. Is there any way to keep the Sampler and Texture separate? I looked at the flags and there seems to be no way to do this. Adding this will be really helpful

The stride size for a Shader Model 5.1 is 40 bytes and not 32 bytes like 5.0 and older. Seems like the fields before space remain the same. Just added two additional reads from the tokens. First field is spaces, second field is range id.

An OPCODE_NOT followed by a SVT_BOOL->SVT_INT conversion can result in the following when the needsBoolUpscale block is hit:

bool myBool = false;
int result = ~(myBool) * int(0xffffffffu);

This PR emits the correct GLSL, wrapping the upscale operation in parentheses:

int result = ~((myBool) * int(0xffffffffu));

It applies the same fix to generated Metal Shading Language.

Note: processing of INDEX_IMMEDIATE64_PLUS_RELATIVE will still fail later in an Assert(0) but that's better than silently mistaking it for OPERAND_INDEX_IMMEDIATE32

https://github.com/Unity-Technologies/HLSLcc/blob/3ea1fcd6bd0ac445bc078de0bf32f0950188577b/src/toMetalDeclaration.cpp#L262

This line states that NAME_PRIMITIVE_ID is not supported on Metal - but according to the language spec (page 92… why is this a PDF, Apple 😠) it's supported since Metal 2.2 on macOS and 2.3 on iOS - i.e. macOS 10.15 and iOS 14.0.

There's a few other places in the Metal translation with comments saying that primitive ID is not supported on Metal, which presumably would also have to be fixed.

According to the feature set tables this requires MTLGPUFamilyApple7, MTLGPUFamilyMac2 or MTLGPUFamilyMacCatalyst2 (I think). iPhone 12 and above and… no idea which Macs count for that. Not totally sure how that maps on to the targeting system in HLSLcc? Assuming there is some way of doing this..?

hi, I found a glsl/spirv shader code issue when doing bitfield packing in Unity, the same code works well in dx11(hlsl/dxbc), but things went wrong after converted to glsl/spirv by hlslcc. Shader code below is tested in Shader-Playground 'u_xlatu0.x' should not be overwritten in the first 'bitfieldExtract' and used as input for the second 'bitfieldExtract'

Hi,

I found 2 issues in the generated GLSL logic

The HLSL source:

cbuffer csInput_CB : register(b0)
{
    uint g_MaskDefault;
    uint g_MaskX;
    uint g_MaskY;
};

RWBuffer<uint> csOutput : register(u0);
// ------------------------------------------------------------------------------

void CalculateMask(inout uint mask, in uint index, in uint maskComponent)
{
    uint curBit = 1;
    mask = g_MaskDefault;

    [loop]
    for (uint i = 0; i < index; ++i)
    {
        [flatten]
        if ((index & 1) && (maskComponent & 1))
        {
            mask = curBit;
            break;
        }
        curBit <<= 1;
    }
}

// ------------------------------------------------------------------------------
[numthreads(1, 1, 1)]
void main(uint3 threadID : SV_DispatchThreadID)
{
    uint2 masks = 0;
    uint outputOffset = (threadID.x << 1);
    uint checkIndex = threadID.x + 1;

    CalculateMask(masks.x, checkIndex, g_MaskX);
    CalculateMask(masks.y, checkIndex, g_MaskY);

    uint count = countbits(masks.x) + countbits(masks.y);

    if (count > 0)
    {
        csOutput[outputOffset + 0] = masks.x;
        csOutput[outputOffset + 1] = masks.y;
    }
}

The generated GLSL source:

#version 430
#extension GL_ARB_shading_language_420pack : require

layout(location = 0) uniform 	uint g_MaskDefault;
uniform 	uint g_MaskX;
uniform 	uint g_MaskY;
writeonly layout(binding=0) uniform uimageBuffer csOutput;
ivec3 u_xlati0;
uint u_xlatu0;
uint u_xlatu1;
ivec3 u_xlati2;
uvec3 u_xlatu2;
bvec3 u_xlatb2;
uint u_xlatu3;
int u_xlati4;
int u_xlati5;
uint u_xlatu5;
bool u_xlatb5;
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main()
{
    u_xlatu0 = gl_GlobalInvocationID.x + 1u;
    u_xlati2.x = int(u_xlatu0 & 1u);
    u_xlati2.yz = ivec2(csInput_CBCS.uvec2(g_MaskX, g_MaskY) & uvec2(1u, 1u));
    u_xlatb2.xyz = notEqual(u_xlati2.xyzz, ivec4(0, 0, 0, 0)).xyz;
    u_xlatb2.x = u_xlatb2.y && u_xlatb2.x; 
    u_xlatb2.y = u_xlatb2.z && u_xlatb2.x;Incorrect
    u_xlatu2.z = csInput_CBCS.g_MaskDefault;
    u_xlatu1 = uint(1u);
    for(uint u_xlatu_loop_1 = uint(0u) ; u_xlatu_loop_1<u_xlatu0 ; u_xlatu_loop_1++)
    {
        u_xlatu5 = (u_xlatb2.x) ? u_xlatu1 : u_xlatu2.z;
        u_xlatu2.z = u_xlatu5;
        u_xlati5 = int(u_xlatb2.x);
        if(u_xlati5 != 0) {break;}
        u_xlatu1 = u_xlatu1 << 1u;
    }
    u_xlatu2.x = csInput_CBCS.g_MaskDefault;
    u_xlatu1 = uint(1u);
    for(uint u_xlatu_loop_2 = uint(0u) ; u_xlatu_loop_2<u_xlatu0 ; u_xlatu_loop_2++)
    {
        u_xlatu5 = (u_xlatb2.y) ? u_xlatu1 : u_xlatu2.x;
        u_xlatu2.x = u_xlatu5;
        u_xlati5 = int(u_xlatb2.y);
        if(u_xlati5 != 0) {break;}
        u_xlatu1 = u_xlatu1 << 1u;
    }
    u_xlati0.xz = bitCount(ivec4(u_xlatu2.zzxz));
    u_xlati0.x = u_xlati0.z + u_xlati0.x;
    if(u_xlati0.x != 0) {
        u_xlati0.x = int(gl_GlobalInvocationID.x) << 1;
        imageStore(csOutput, u_xlati0.x, u_xlatu2.zzzz);
        u_xlati4 = int(gl_GlobalInvocationID.x) * 2 + 1;
        imageStore(csOutput, int(u_xlati4), u_xlatu2.xxxx);
    //ENDIF
    }
    return;
}

Issue1: Incorrect reuse variables

'u_xlatb2.y' will get an incorrect result, as 'u_xlatb2.x' in the previous step has been changed. So the next logics which're using 'x_xlatb2.y', will get the error results

u_xlatu0 = gl_GlobalInvocationID.x + 1u; // u_xlatu0 --> checkIndex (in HLSL)
u_xlatb2.xyz = notEqual(u_xlati2.xyzz, ivec4(0, 0, 0, 0)).xyz; //  x --> (checkIndex&1), y --> (g_MaskX&1), z --> (g_MaskY&1)
u_xlatb2.x = u_xlatb2.y && u_xlatb2.x;  // u_xlatb2.x --> (checkIndex&1) && (g_MaskX&1)
u_xlatb2.y = u_xlatb2.z && u_xlatb2.x; // Error: u_xlatb2.y --> (checkIndex&1) && (g_MaskX&1) && (g_MaskY&1),
                                       // it should be (checkIndex&1) && (g_MaskY&1)

Issue2: countbits function convert

The bitCount argument is incorrect, when 'z' is 0 and 'x' greater 0, the 'u_xlati0' will get an incorrect result.

u_xlati0.xz = bitCount(ivec4(u_xlatu2.zzxz));

For the detail compilation information, please check Here

When declaring an input such as

// Input signature:
//
// Name                 Index   Mask Register SysValue  Format   Used
// -------------------- ----- ------ -------- -------- ------- ------
// SV_PrimitiveID           0    N/A   primID   PRIMID    uint    YES
gs_4_0
dcl_input vPrim

vPrim in dcl_input vPrim is encoded as 0x0, while primID in the input signature is encoded as 0xFFFFFFFF, so GetInputSignatureFromRegister will either return the wrong input signature when there are multiple, or null if SV_PrimitiveID is the only input signature.

I would expect there would need to be a new GetInputSignatureFromX method to resolve it properly, similiar to how GetOutputSignatureFromSystemValue works, but dcl_input vPrim does not have an eSpecialName.

An example of a shader that will trigger this bug:

Shader "Unlit/TestShader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma geometry geom

            struct appdata {

            };

            struct v2g {
            };

            struct g2f
            {
                float4 pos : SV_POSITION;
                float4 color: texcoord1;
                float3 normal : TEXCOORD2;
            };

            v2g vert(appdata v) 
            {
                v2g o = (v2g)0;
                return o;
            }

            [maxvertexcount(3)]
            void geom(triangle v2g IN[3], uint prim : SV_PrimitiveID, inout LineStream<g2f> tristream)
            {
                g2f o;
                for (int i = 0; i < 2; i++)
                {
                    o.pos = 0;
                    o.color = 0;
                    o.normal = 0;
                    tristream.Append(o);
                }
            }


            float4 frag(g2f i) : COLOR{

                float3 col = i.color;
                return fixed4(col, 1);
            }
            ENDCG
        }
    }
}