SPIRV debug mapping updates to handle multiple overlapping mappings Issue #3264

Description

Capture the mappings into a type usage tree
Update elements of the tree as overlapping mappings are encountered, sub-elements of a previously mapped variable i.e. single component of a vector, single array element, member in a structure.
After processing all mappings convert the finalized type usage tree into source variable mappings.
Fixed bug in LocalMapping::isSourceSupersetOf where it would mis-identify a superset
Update struct member and array element names of SPIRV constants
- array names and struct member names are not set when constants are created (struct decoration data is not available)
- Fixes problem with incorrect register names when using struct, array initialisers.
Testing

Test HLSL shader compiled using DXC, Slang, glslang
Reproduction case in Issue #3264
Test HLSL Shader

struct v2f
{
    float4 pos : SV_POSITION;
    float4 col : COLOR0;
    float4 uv : TEXCOORD0;
};

struct Foo
{
    float f;
    int i;
};

struct Test
{
    float2 v2;
    float3 v3;
    float4 v4;
    column_major float2x3 m23; // 2 rows, 3 columns
    column_major float3x2 m32; // 3 rows, 2 columns
    float4x4 m44; // 4 rows, 4 columns
    int i;
    uint a[10];
    Foo nested;
    Foo nested_array[4];
};

struct TestTwo
{
    float2 v2;
    float3 v3;
    float4 v4;
};

Test TestValue(float fValue)
{
    Test test;
    test.v2.x = fValue;
    fValue += 1.0;
    test.v2.y = fValue;
    fValue += 1.0;

    test.v3.x = fValue;
    fValue += 1.0;
    test.v3.y = fValue;
    fValue += 1.0;
    test.v3.z = fValue;
    fValue += 1.0;

    test.v4.x = fValue;
    fValue += 1.0;
    test.v4.y = fValue;
    fValue += 1.0;
    test.v4.z = fValue;
    fValue += 1.0;
    test.v4.w = fValue;
    fValue += 1.0;

    // 2 rows, 3 columns
    test.m23[0].x = fValue;
    fValue += 1.0;
    test.m23[0].y = fValue;
    fValue += 1.0;
    test.m23[0].z = fValue;
    fValue += 1.0;

    test.m23[1].x = fValue;
    fValue += 1.0;
    test.m23[1].y = fValue;
    fValue += 1.0;
    test.m23[1].z = fValue;
    fValue += 1.0;

    // 3 rows, 2 columns
    test.m32[0].x = fValue;
    fValue += 1.0;
    test.m32[0].y = fValue;
    fValue += 1.0;

    test.m32[1].x = fValue;
    fValue += 1.0;
    test.m32[1].y = fValue;
    fValue += 1.0;

    test.m32[2].x = fValue;
    fValue += 1.0;
    test.m32[2].y = fValue;
    fValue += 1.0;

    // 4 rows, 4 columns
    test.m44[0].x = fValue;
    fValue += 1.0;
    test.m44[0].y = fValue;
    fValue += 1.0;
    test.m44[0].z = fValue;
    fValue += 1.0;
    test.m44[0].w = fValue;
    fValue += 1.0;

    test.m44[1].x = fValue;
    fValue += 1.0;
    test.m44[1].y = fValue;
    fValue += 1.0;
    test.m44[1].z = fValue;
    fValue += 1.0;
    test.m44[1].w = fValue;
    fValue += 1.0;

    test.m44[2].x = fValue;
    fValue += 1.0;
    test.m44[2].y = fValue;
    fValue += 1.0;
    test.m44[2].z = fValue;
    fValue += 1.0;
    test.m44[2].w = fValue;
    fValue += 1.0;

    test.m44[3].x = fValue;
    fValue += 1.0;
    test.m44[3].y = fValue;
    fValue += 1.0;
    test.m44[3].z = fValue;
    fValue += 1.0;
    test.m44[3].w = fValue;
    fValue += 1.0;

    test.i = (int) fValue;
    fValue += 1.0;

    test.a[0] = (int) fValue;
    fValue += 1.0;
    test.a[1] = (int) fValue;
    fValue += 1.0;
    test.a[2] = (int) fValue;
    fValue += 1.0;
    test.a[3] = (int) fValue;
    fValue += 1.0;
    test.a[4] = (int) fValue;
    fValue += 1.0;
    test.a[5] = (int) fValue;
    fValue += 1.0;
    test.a[6] = (int) fValue;
    fValue += 1.0;
    test.a[7] = (int) fValue;
    fValue += 1.0;
    test.a[8] = (int) fValue;
    fValue += 1.0;
    test.a[9] = (int) fValue;
    fValue += 1.0;

    test.nested.f = fValue;
    fValue += 1.0;
    test.nested.i = (int) fValue;

    test.nested_array[0].f = fValue;
    fValue += 1.0;
    test.nested_array[0].i = (int) fValue;
    fValue += 1.0;
    test.nested_array[1].f = fValue;
    fValue += 1.0;
    test.nested_array[1].i = (int) fValue;
    fValue += 1.0;
    test.nested_array[2].f = fValue;
    fValue += 1.0;
    test.nested_array[2].i = (int) fValue;
    fValue += 1.0;
    test.nested_array[3].f = fValue;
    fValue += 1.0;
    test.nested_array[3].i = (int) fValue;
    fValue += 1.0;

    return test;
}

float TestHash(Test test)
{
    float fValue = 0.0;

    fValue += test.v2.x;
    fValue += test.v2.y;

    fValue += test.v3.x;
    fValue += test.v3.y;
    fValue += test.v3.z;

    fValue += test.v4.x;
    fValue += test.v4.y;
    fValue += test.v4.z;
    fValue += test.v4.w;

    // 2 rows, 3 columns
    fValue += test.m23[0].x;
    fValue += test.m23[0].y;
    fValue += test.m23[0].z;

    fValue += test.m23[1].x;
    fValue += test.m23[1].y;
    fValue += test.m23[1].z;

    // 3 rows, 2 columns
    fValue += test.m32[0].x;
    fValue += test.m32[0].y;

    fValue += test.m32[1].x;
    fValue += test.m32[1].y;

    fValue += test.m32[2].x;
    fValue += test.m32[2].y;

    // 4 rows, 4 columns
    fValue += test.m44[0].x;
    fValue += test.m44[0].y;
    fValue += test.m44[0].z;
    fValue += test.m44[0].w;

    fValue += test.m44[1].x;
    fValue += test.m44[1].y;
    fValue += test.m44[1].z;
    fValue += test.m44[1].w;

    fValue += test.m44[2].x;
    fValue += test.m44[2].y;
    fValue += test.m44[2].z;
    fValue += test.m44[2].w;

    fValue += test.m44[3].x;
    fValue += test.m44[3].y;
    fValue += test.m44[3].z;
    fValue += test.m44[3].w;

    fValue += (float) test.i;

    fValue += test.a[0];
    fValue += test.a[1];
    fValue += test.a[2];
    fValue += test.a[3];
    fValue += test.a[4];
    fValue += test.a[5];
    fValue += test.a[6];
    fValue += test.a[7];
    fValue += test.a[8];
    fValue += test.a[9];

    fValue += test.nested.f;
    fValue += (float) test.nested.i;

    fValue += test.nested_array[0].f;
    fValue += (float) test.nested_array[0].i;
    fValue += test.nested_array[1].f;
    fValue += (float) test.nested_array[1].i;
    fValue += test.nested_array[2].f;
    fValue += (float) test.nested_array[2].i;
    fValue += test.nested_array[3].f;
    fValue += (float) test.nested_array[3].i;

    return fValue;
}

Foo FooValue(float fValue)
{
    Foo foo;
    int iValue = (int) fValue;
    foo.f = fValue;
    foo.i = iValue;;
    return foo;
}

float Test1()
{
    // Test various mappings directly at different granularities:
    // Just one mapping for Test, not overridden
    Test test1 = (Test) 0;
    return TestHash(test1);
}

float Test2()
{
    Foo fooZero = (Foo) 0;
    // Map only Test::i and Test::nested, none of the other members
    Test test2;
    test2.i = 123;
    test2.nested = fooZero;

    test2 = (Test) 0;

    return TestHash(test2);
}

float Test3()
{
    uint test_a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    Foo test_nested_array[4] =
    {
        { 1.0, -1 },
        { 2.0, -2 },
        { 3.0, -3 },
        { 4.0, -4 }
    };

    // Non-overlapping mappings for all of Test's direct child members 1:1
    Test test3;
    test3.v2 = (float2) 2.0;
    test3.v3 = (float3) 3.0;
    test3.v4 = (float4) 4.0;
    test3.m23 = (float2x3) 5.0;
    test3.m32 = (float3x2) 6.0;
    test3.m44 = (float4x4) 7.0;
    test3.i = 321;
    test3.a = test_a;
    test3.nested = test_nested_array[2];
    test3.nested_array = test_nested_array;

    return TestHash(test3);
}

float Test4()
{
  // Non-overlapping mappings for every scalar value (e.g. down to Test::a[0] mapped separately from Test::a[1])
    Test test4;

    test4.v2.x = 1.0;
    test4.v2.y = 2.0;

    test4.v3.x = 3.0;
    test4.v3.y = 4.0;
    test4.v3.z = 5.0;

    test4.v4.x = 6.0;
    test4.v4.y = 7.0;
    test4.v4.z = 8.0;
    test4.v4.w = 9.0;

    test4.m23[0].x = 500.0;
    test4.m23[0].y = 501.0;
    test4.m23[0].z = 502.0;

    test4.m23[1].x = 503.0;
    test4.m23[1].y = 504.0;
    test4.m23[1].z = 505.0;

    test4.m32[0].x = 506.0;
    test4.m32[0].y = 507.0;

    test4.m32[1].x = 508.0;
    test4.m32[1].y = 509.0;

    test4.m32[2].x = 510.0;
    test4.m32[2].y = 511.0;

    test4.m44[0].x = 1000.0;
    test4.m44[0].y = 1001.0;
    test4.m44[0].z = 1002.0;
    test4.m44[0].w = 1003.0;

    test4.m44[1].x = 2000.0;
    test4.m44[1].y = 2001.0;
    test4.m44[1].z = 2002.0;
    test4.m44[1].w = 2003.0;

    test4.m44[2].x = 3000.0;
    test4.m44[2].y = 3001.0;
    test4.m44[2].z = 3002.0;
    test4.m44[2].w = 3003.0;

    test4.m44[3].x = 4000.0;
    test4.m44[3].y = 4001.0;
    test4.m44[3].z = 4002.0;
    test4.m44[3].w = 4003.0;

    test4.i = 456;

    test4.a[0] = 100;
    test4.a[1] = 101;
    test4.a[2] = 102;
    test4.a[3] = 103;
    test4.a[4] = 104;
    test4.a[5] = 105;
    test4.a[6] = 106;
    test4.a[7] = 107;
    test4.a[8] = 108;
    test4.a[9] = 109;

    test4.nested.f = 100.0;
    test4.nested.i = -100;

    test4.nested_array[0].f = 110.0;
    test4.nested_array[0].i = -101;
    test4.nested_array[1].f = 120.0;
    test4.nested_array[1].i = -102;
    test4.nested_array[2].f = 130.0;
    test4.nested_array[2].i = -103;
    test4.nested_array[3].f = 140.0;
    test4.nested_array[3].i = -104;

    return TestHash(test4);
}

float Test5()
{
    Test testZero = (Test) 0;
    // Map Test, then Test::i
    Test test5;
    test5 = testZero;
    test5.i = 1618;

    return TestHash(test5);
}

float Test6()
{
    Test testZero = (Test) 0;
    // Map Test, then Test::a[5]
    Test test6;
    test6 = testZero;
    test6.a[5] = 981;

    return TestHash(test6);
}

float Test7()
{
    Test testZero = (Test) 0;
    // Map Test, then Test::nested::f
    Test test7;
    test7 = testZero;
    test7.nested.f = 10.0;

    return TestHash(test7);
}

float Test8()
{
    Test testZero = (Test) 0;
    // Test overriding mappings that only become more granular:
    // Map Test, then Test::v, then Test::v.x
    Test test8;
    test8 = testZero;

    test8.v2 = float2(4.0, 3.0);
    test8.v2.y = 1000.0;

    test8.v3 = float3(5.0, 4.0, 3.0);
    test8.v3.y = 2000.0;

    test8.v4 = float4(6.0, 5.0, 4.0, 3.0);
    test8.v4.w = -400.0;

    return TestHash(test8);
}

float Test9()
{
    Test testZero = (Test) 0;
    // Map Test, then Test::v, then Test::v.x, Test::v.y, Test::v.z separately
    Test test9;
    test9 = testZero;

    test9.v2 = float2(4.0, 3.0);
    test9.v2.x = 900.0;

    test9.v3 = float3(6.0, 4.0, 3.0);
    test9.v3.y = 800.0;
    test9.v3.z = 700.0;

    test9.v4 = float4(6.0, 5.0, 4.0, 3.0);
    test9.v4.x = 900.0;
    test9.v4.y = 800.0;
    test9.v4.z = 700.0;

    return TestHash(test9);
}

float Test10()
{
    Test testZero = (Test) 0;
    uint test_a[10];
    test_a = testZero.a;
    Test test2;
    test2 = TestValue(101.0);

    // Map Test, then Test::a, then Test::a[5]
    Test test10;
    test10 = test2;
    test10.a = test_a;
    test10.a[5] = 341;

    return TestHash(test10);
}

float Test11()
{
    Test testZero = (Test) 0;
    // Test remappings that change granularity or override:
    // Map Test, then Test::i, then re-map Test::i to a different place
    Test test11;
    test11 = testZero;
    test11.i = 300;
    test11.i = 100;

    return TestHash(test11);
}

float Test12()
{
    Foo test_nested = (Foo) (-100.0);

    // Map Test, then Test::nested::f, then Test::nested
    Test test12;
    test12 = TestValue(2000.0);
    test12.nested.f = 101.0;
    test12.nested = test_nested;

    return TestHash(test12);
}

float Test13()
{
    Test testZero = (Test) 0;
    // Map Test::i, then Test::v, then Test
    Test test13;
    test13.i = 256;
    test13.v2 = float2(203.0, 2322.0);
    test13.v3 = float3(501.0, 203.0, 2322.0);
    test13.v4 = float4(106.0, 501.0, 203.0, 2322.0);
    test13 = testZero;

    return TestHash(test13);
}

float Test14()
{
    Foo test_nested = (Foo) 0;

    Test testZero = (Test) 0;
    // Map Test, then Test::nested, then Test::nested::f & Test::nested::i, then override with Test::nested
    Test test14;
    test14 = testZero;
    test14.nested = test_nested;
    test14.nested.f = 101.0;
    test14.nested.i = 501;
    test14.nested = test_nested;

    return TestHash(test14);
}

float Test15()
{
    Foo jake = (Foo) 0;
    jake.f = 101.0;
    jake.i = -200;

    float fValue = 0.0;
    fValue = jake.f * (float) jake.i;
    return fValue;
}

float Test16()
{
    Test test16;

    test16.m44[0].x = 1000.0;
    test16.m44[0].y = 1001.0;
    test16.m44[0].z = 1002.0;
    test16.m44[0].w = 1003.0;

    test16.i = 256;

    test16 = (Test) 0;

    return TestHash(test16);
}

float Test17()
{
    float fValue = 0.0;

    float2 v2;
    v2.x = fValue;
    fValue += 1.0;
    v2.y = fValue;
    fValue += 1.0;

    float3 v3;
    v3.x = fValue;
    fValue += 1.0;
    v3.y = fValue;
    fValue += 1.0;
    v3.z = fValue;
    fValue += 1.0;

    float2x3 m23; // 2 rows, 3 columns
    float3x2 m32; // 3 rows, 2 columns

    m23[0] = v3;
    v3.x = fValue;
    fValue += 1.0;
    v3.y = fValue;
    fValue += 1.0;
    v3.z = fValue;
    fValue += 1.0;
    m23[1] = v3;

    m32[0] = v2;
    v2.x = fValue;
    fValue += 1.0;
    v2.y = fValue;
    fValue += 1.0;
    m32[1] = v2;
    v2.x = fValue;
    fValue += 1.0;
    v2.y = fValue;
    fValue += 1.0;
    m32[2] = v2;

    fValue += m23[0].x;
    fValue += m23[0].y;
    fValue += m23[0].z;
    fValue += m23[1].x;
    fValue += m23[1].y;
    fValue += m23[1].z;

    fValue += m32[0].x;
    fValue += m32[0].y;
    fValue += m32[1].x;
    fValue += m32[1].y;
    fValue += m32[2].x;
    fValue += m32[2].y;

    return fValue;
}

float Test18()
{
    float fValue;
    fValue = 0.0;

    float2 v2;
    v2.x = fValue;
    fValue += 1.0;
    v2.y = fValue;
    fValue += 1.0;

    float2 a_v2[2];
    a_v2[0] = v2;
    a_v2[1] = v2 + v2;

    fValue += a_v2[0].x;
    fValue += a_v2[0].y;
    fValue += a_v2[1].x;
    fValue += a_v2[1].y;

    return fValue;
}

float Test19()
{
    float fValue = 0.0;

    float3 v3;
    v3.x = fValue;
    fValue += 1.0;
    v3.y = fValue;
    fValue += 1.0;
    v3.z = fValue;
    fValue += 1.0;

    float2x3 m23;
    m23[0] = v3;
    m23[1] = v3 + v3;

    float2x3 a_m23[3];
    a_m23[0] = m23;
    a_m23[1] = m23 + m23;
    a_m23[2] = m23 + m23 + m23;

    fValue += a_m23[0][0].x;
    fValue += a_m23[0][0].y;
    fValue += a_m23[0][0].z;
    fValue += a_m23[0][1].x;
    fValue += a_m23[0][1].y;
    fValue += a_m23[0][1].z;

    fValue += a_m23[1][0].x;
    fValue += a_m23[1][0].y;
    fValue += a_m23[1][0].z;
    fValue += a_m23[1][1].x;
    fValue += a_m23[1][1].y;
    fValue += a_m23[1][1].z;

    fValue += a_m23[2][0].x;
    fValue += a_m23[2][0].y;
    fValue += a_m23[2][0].z;
    fValue += a_m23[2][1].x;
    fValue += a_m23[2][1].y;
    fValue += a_m23[2][1].z;

    return fValue;
}

float Test20()
{
    float fValue = 0.0;

    float3 v3;
    v3.x = fValue;
    fValue += 1.0;
    v3.y = fValue;
    fValue += 1.0;
    v3.z = fValue;
    fValue += 1.0;

    row_major float2x3 m23_row;
    m23_row[0] = v3;
    m23_row[1] = v3 + v3;

    row_major float2x3 a_m23_row[3];
    a_m23_row[0] = m23_row;
    a_m23_row[1] = m23_row + m23_row;
    a_m23_row[2] = m23_row + m23_row + m23_row;

    column_major float2x3 m23_col;
    m23_col[0] = v3;
    m23_col[1] = v3 + v3;

    column_major float2x3 a_m23_col[3];
    a_m23_col[0] = m23_col;
    a_m23_col[1] = m23_col + m23_col;
    a_m23_col[2] = m23_col + m23_col + m23_col;

    fValue += m23_row[0].x;
    fValue += m23_row[0].y;
    fValue += m23_row[0].z;

    fValue += m23_col[0].x;
    fValue += m23_col[0].y;
    fValue += m23_col[0].z;

    return fValue;
}

float Test21()
{
    int iValue = 0;

    int a2[2];
    a2[0] = iValue++;
    a2[1] = iValue++;
    int a2_2[2];
    a2_2[0] = iValue++;
    a2_2[1] = iValue++;

    int a32[3][2];
    a32[1] = a2;

    a32[0][0] = iValue++;
    a32[0][1] = iValue++;
    a32[1][0] = iValue++;
    a32[1][1] = iValue++;
    a32[2][0] = iValue++;
    a32[2][1] = iValue++;

    int a4[4];
    a4[0] = iValue++;
    a4[1] = iValue++;
    a4[2] = iValue++;
    a4[3] = iValue++;

    int a432[4][3][2];
    a432[3] = a32;

    a432[2][1] = a2;
    a432[2][2] = a2_2;

    iValue += a32[0][0];
    iValue += a32[0][1];
    iValue += a32[1][0];
    iValue += a32[1][1];
    iValue += a32[2][0];
    iValue += a32[0][0];

    iValue += a432[0][0][1];
    iValue += a432[0][1][0];
    iValue += a432[0][1][1];
    iValue += a432[0][2][0];
    iValue += a432[0][2][1];
    iValue += a432[0][2][1];

    float fValue = (float) iValue;
    return fValue;
}

float Test22()
{
    int a4[4] = { 0, 1, 2, 3 };
    int iValue = 0;

    iValue += a4[0];
    iValue += a4[1];
    iValue += a4[2];
    iValue += a4[3];

    float fValue = (float) iValue;

    float2 v2 = { 1.0, 2.0 };
    float3 v3 = { 5.0, 6.0, 7.0 };
    float4 v4 = { 8.0, 9.0, 10.0, 11.0 };
    fValue += v2.x;
    fValue += v2.y;

    fValue += v3.x;
    fValue += v3.y;
    fValue += v3.z;

    fValue += v4.x;
    fValue += v4.y;
    fValue += v4.z;
    fValue += v4.w;

    return fValue;
}

float Test23()
{
    Test test23 = (Test) 0;

    float fValue = TestHash(test23);
    return fValue;
}

float Test24()
{
    float2x3 m23 =
    {
        1.0, 1.1, 1.2, // row 1
        2.0, 2.1, 2.2 // row 2
    };

    float fValue = 0.0f;
    fValue += m23._11;
    fValue += m23._12;
    fValue += m23._13;
    fValue += m23._21;
    fValue += m23._22;
    fValue += m23._23;

    return fValue;
}

float Test25()
{
    TestTwo test25;
    test25.v2 = float2(4.0, 3.0);
    test25.v2.y = 1000.0;

    test25.v3 = float3(5.0, 4.0, 3.0);
    test25.v3.y = 2000.0;

    test25.v4 = float4(6.0, 5.0, 4.0, 3.0);
    test25.v4.w = -400.0;

    test25.v2 = float2(4.0, 3.0);
    test25.v2.x = 900.0;

    test25.v3 = float3(6.0, 4.0, 3.0);
    test25.v3.y = 800.0;
    test25.v3.z = 700.0;

    test25.v4 = float4(6.0, 5.0, 4.0, 3.0);
    test25.v4.x = 900.0;
    test25.v4.y = 800.0;
    test25.v4.z = 700.0;

    float fValue = 0.0;

    fValue += test25.v2.x;
    fValue += test25.v2.y;

    fValue += test25.v3.x;
    fValue += test25.v3.y;
    fValue += test25.v3.z;

    fValue += test25.v4.x;
    fValue += test25.v4.y;
    fValue += test25.v4.z;
    fValue += test25.v4.w;

    return fValue;
}

float DoAllTests()
{
    float fValue = 0.0f;
    fValue += Test1();
    fValue += Test2();
    fValue += Test3();
    fValue += Test4();
    fValue += Test5();
    fValue += Test6();
    fValue += Test7();
    fValue += Test8();
    fValue += Test9();
    fValue += Test10();
    fValue += Test11();
    fValue += Test12();
    fValue += Test13();
    fValue += Test14();
    fValue += Test15();
    fValue += Test16();
    //fValue += Test17();
    fValue += Test18();
    fValue += Test19();
    fValue += Test20();
    fValue += Test21();
    fValue += Test22();
    fValue += Test23();
    fValue += Test24();
    fValue += Test25();

    return fValue;
}

float4 main(v2f IN) : SV_Target0
{
    float fValue = 0.0;
    fValue += DoAllTests();
    //fValue += Test8();
    //fValue += Test9();
    //fValue += Test25();
    float4 col = IN.col;
    col.r = fValue;

    return col;
}
baldurk / renderdoc

SPIRV debug mapping updates to handle multiple overlapping mappings Issue #3264 #3294

Description

Testing

Test HLSL Shader
