Add some tests for LUT promotion.

Also, update other tests.

reference/opt/shaders-hlsl/frag/constant-composites.frag

@@ -30,7 +30,7 @@ void frag_main()
     lut = _16;
     foos = _28;
     FragColor = lut[_line].xxxx;
-    FragColor += (foos[_line].a * (foos[1 - _line].a)).xxxx;
+    FragColor += (foos[_line].a * foos[1 - _line].a).xxxx;
 }
 
 SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)

reference/opt/shaders-hlsl/frag/lut-promotion.frag

@@ -0,0 +1,57 @@
+static const float _16[16] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f };
+static const float4 _60[4] = { 0.0f.xxxx, 1.0f.xxxx, 8.0f.xxxx, 5.0f.xxxx };
+static const float4 _104[4] = { 20.0f.xxxx, 30.0f.xxxx, 50.0f.xxxx, 60.0f.xxxx };
+
+static float FragColor;
+static int index;
+
+struct SPIRV_Cross_Input
+{
+    nointerpolation int index : TEXCOORD0;
+};
+
+struct SPIRV_Cross_Output
+{
+    float FragColor : SV_Target0;
+};
+
+void frag_main()
+{
+    FragColor = _16[index];
+    if (index < 10)
+    {
+        FragColor += _16[index ^ 1];
+    }
+    else
+    {
+        FragColor += _16[index & 1];
+    }
+    bool _63 = index > 30;
+    if (_63)
+    {
+        FragColor += _60[index & 3].y;
+    }
+    else
+    {
+        FragColor += _60[index & 1].x;
+    }
+    float4 foobar[4] = _60;
+    if (_63)
+    {
+        foobar[1].z = 20.0f;
+    }
+    int _91 = index & 3;
+    FragColor += foobar[_91].z;
+    float4 baz[4] = _60;
+    baz = _104;
+    FragColor += baz[_91].z;
+}
+
+SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
+{
+    index = stage_input.index;
+    frag_main();
+    SPIRV_Cross_Output stage_output;
+    stage_output.FragColor = FragColor;
+    return stage_output;
+}

reference/opt/shaders-msl/frag/constant-array.frag

@@ -45,7 +45,7 @@ fragment main0_out main0(main0_in in [[stage_in]])
 {
     main0_out out = {};
     Foobar indexable[2] = {{10.0, 40.0}, {90.0, 70.0}};
-    out.FragColor = ((_37[in.index] + (_55[in.index][in.index + 1])) + float4(30.0)) + float4(indexable[in.index].a + indexable[in.index].b);
+    out.FragColor = ((_37[in.index] + _55[in.index][in.index + 1]) + float4(30.0)) + float4(indexable[in.index].a + indexable[in.index].b);
     return out;
 }
 

reference/opt/shaders-msl/frag/constant-composites.frag

@@ -44,7 +44,7 @@ fragment main0_out main0(main0_in in [[stage_in]])
     float lut[4] = {1.0, 4.0, 3.0, 2.0};
     Foo foos[2] = {{10.0, 20.0}, {30.0, 40.0}};
     out.FragColor = float4(lut[in.line]);
-    out.FragColor += float4(foos[in.line].a * (foos[1 - in.line].a));
+    out.FragColor += float4(foos[in.line].a * foos[1 - in.line].a);
     return out;
 }
 

reference/opt/shaders-msl/frag/lut-promotion.frag

@@ -0,0 +1,69 @@
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+constant float _16[16] = {1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0};
+constant float4 _60[4] = {float4(0.0), float4(1.0), float4(8.0), float4(5.0)};
+constant float4 _104[4] = {float4(20.0), float4(30.0), float4(50.0), float4(60.0)};
+
+struct main0_out
+{
+    float FragColor [[color(0)]];
+};
+
+struct main0_in
+{
+    int index [[user(locn0)]];
+};
+
+// Implementation of an array copy function to cover GLSL's ability to copy an array via assignment.
+template<typename T, uint N>
+void spvArrayCopy(thread T (&dst)[N], thread const T (&src)[N])
+{
+    for (uint i = 0; i < N; dst[i] = src[i], i++);
+}
+
+// An overload for constant arrays.
+template<typename T, uint N>
+void spvArrayCopyConstant(thread T (&dst)[N], constant T (&src)[N])
+{
+    for (uint i = 0; i < N; dst[i] = src[i], i++);
+}
+
+fragment main0_out main0(main0_in in [[stage_in]])
+{
+    main0_out out = {};
+    out.FragColor = _16[in.index];
+    if (in.index < 10)
+    {
+        out.FragColor += _16[in.index ^ 1];
+    }
+    else
+    {
+        out.FragColor += _16[in.index & 1];
+    }
+    bool _63 = in.index > 30;
+    if (_63)
+    {
+        out.FragColor += _60[in.index & 3].y;
+    }
+    else
+    {
+        out.FragColor += _60[in.index & 1].x;
+    }
+    float4 foobar[4] = {float4(0.0), float4(1.0), float4(8.0), float4(5.0)};
+    if (_63)
+    {
+        foobar[1].z = 20.0;
+    }
+    int _91 = in.index & 3;
+    out.FragColor += foobar[_91].z;
+    float4 baz[4] = {float4(0.0), float4(1.0), float4(8.0), float4(5.0)};
+    spvArrayCopyConstant(baz, _104);
+    out.FragColor += baz[_91].z;
+    return out;
+}
+

reference/opt/shaders/comp/generate_height.comp

@@ -48,8 +48,8 @@ void main()
     vec2 _387 = _316.xx;
     vec2 _392 = _316.yy;
     vec2 _395 = _392 * _137.distribution[_280].yx;
-    vec2 _421 = _392 * (_137.distribution[(_476 * _448) + _475]).yx;
-    vec2 _429 = ((_137.distribution[(_476 * _448) + _475]) * _387) + vec2(-_421.x, _421.y);
+    vec2 _421 = _392 * _137.distribution[(_476 * _448) + _475].yx;
+    vec2 _429 = (_137.distribution[(_476 * _448) + _475] * _387) + vec2(-_421.x, _421.y);
     _225.heights[_280] = packHalf2x16(((_137.distribution[_280] * _387) + vec2(-_395.x, _395.y)) + vec2(_429.x, -_429.y));
 }
 

reference/opt/shaders/flatten/copy.flatten.vert

@@ -19,7 +19,7 @@ void main()
     for (int _96 = 0; _96 < 4; )
     {
         vec3 _68 = aVertex.xyz - Light(UBO[_96 * 2 + 4].xyz, UBO[_96 * 2 + 4].w, UBO[_96 * 2 + 5]).Position;
-        vColor += (((UBO[_96 * 2 + 5]) * clamp(1.0 - (length(_68) / Light(UBO[_96 * 2 + 4].xyz, UBO[_96 * 2 + 4].w, UBO[_96 * 2 + 5]).Radius), 0.0, 1.0)) * dot(aNormal, normalize(_68)));
+        vColor += ((UBO[_96 * 2 + 5] * clamp(1.0 - (length(_68) / Light(UBO[_96 * 2 + 4].xyz, UBO[_96 * 2 + 4].w, UBO[_96 * 2 + 5]).Radius), 0.0, 1.0)) * dot(aNormal, normalize(_68)));
         _96++;
         continue;
     }

reference/opt/shaders/flatten/dynamic.flatten.vert

@@ -18,8 +18,8 @@ void main()
     vColor = vec4(0.0);
     for (int _82 = 0; _82 < 4; )
     {
-        vec3 _54 = aVertex.xyz - (UBO[_82 * 2 + 4].xyz);
-        vColor += (((UBO[_82 * 2 + 5]) * clamp(1.0 - (length(_54) / (UBO[_82 * 2 + 4].w)), 0.0, 1.0)) * dot(aNormal, normalize(_54)));
+        vec3 _54 = aVertex.xyz - UBO[_82 * 2 + 4].xyz;
+        vColor += ((UBO[_82 * 2 + 5] * clamp(1.0 - (length(_54) / UBO[_82 * 2 + 4].w), 0.0, 1.0)) * dot(aNormal, normalize(_54)));
         _82++;
         continue;
     }

reference/opt/shaders/flatten/multi-dimensional.desktop.flatten_dim.frag

@@ -25,6 +25,6 @@ void main()
             }
         }
     }
-    FragColor = ((values3[1 * 3 * 1 + 2 * 1 + 0]) + (values3[0 * 3 * 1 + 2 * 1 + 0])) + (values3[(vIndex + 1) * 3 * 1 + 2 * 1 + vIndex]);
+    FragColor = (values3[1 * 3 * 1 + 2 * 1 + 0] + values3[0 * 3 * 1 + 2 * 1 + 0]) + values3[(vIndex + 1) * 3 * 1 + 2 * 1 + vIndex];
 }
 

reference/opt/shaders/frag/constant-array.frag

@@ -17,6 +17,6 @@ layout(location = 0) flat in mediump int index;
 void main()
 {
     Foobar indexable[2] = Foobar[](Foobar(10.0, 40.0), Foobar(90.0, 70.0));
-    FragColor = ((_37[index] + (_55[index][index + 1])) + vec4(30.0)) + vec4(indexable[index].a + indexable[index].b);
+    FragColor = ((_37[index] + _55[index][index + 1]) + vec4(30.0)) + vec4(indexable[index].a + indexable[index].b);
 }
 

reference/opt/shaders/frag/constant-composites.frag

@@ -18,6 +18,6 @@ void main()
     lut = float[](1.0, 4.0, 3.0, 2.0);
     foos = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0));
     FragColor = vec4(lut[line]);
-    FragColor += vec4(foos[line].a * (foos[1 - line].a));
+    FragColor += vec4(foos[line].a * foos[1 - line].a);
 }
 

reference/opt/shaders/frag/lut-promotion.frag

@@ -0,0 +1,42 @@
+#version 310 es
+precision mediump float;
+precision highp int;
+
+const float _16[16] = float[](1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0);
+const vec4 _60[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+
+layout(location = 0) out float FragColor;
+layout(location = 0) flat in mediump int index;
+
+void main()
+{
+    FragColor = _16[index];
+    if (index < 10)
+    {
+        FragColor += _16[index ^ 1];
+    }
+    else
+    {
+        FragColor += _16[index & 1];
+    }
+    bool _63 = index > 30;
+    if (_63)
+    {
+        FragColor += _60[index & 3].y;
+    }
+    else
+    {
+        FragColor += _60[index & 1].x;
+    }
+    vec4 foobar[4] = _60;
+    if (_63)
+    {
+        foobar[1].z = 20.0;
+    }
+    mediump int _91 = index & 3;
+    FragColor += foobar[_91].z;
+    vec4 baz[4] = _60;
+    baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0));
+    FragColor += baz[_91].z;
+}
+

reference/shaders-hlsl/frag/constant-composites.frag

@@ -30,7 +30,7 @@ void frag_main()
     lut = _16;
     foos = _28;
     FragColor = lut[_line].xxxx;
-    FragColor += (foos[_line].a * (foos[1 - _line].a)).xxxx;
+    FragColor += (foos[_line].a * foos[1 - _line].a).xxxx;
 }
 
 SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)

reference/shaders-hlsl/frag/lut-promotion.frag

@@ -0,0 +1,55 @@
+static const float _16[16] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f };
+static const float4 _60[4] = { 0.0f.xxxx, 1.0f.xxxx, 8.0f.xxxx, 5.0f.xxxx };
+static const float4 _104[4] = { 20.0f.xxxx, 30.0f.xxxx, 50.0f.xxxx, 60.0f.xxxx };
+
+static float FragColor;
+static int index;
+
+struct SPIRV_Cross_Input
+{
+    nointerpolation int index : TEXCOORD0;
+};
+
+struct SPIRV_Cross_Output
+{
+    float FragColor : SV_Target0;
+};
+
+void frag_main()
+{
+    FragColor = _16[index];
+    if (index < 10)
+    {
+        FragColor += _16[index ^ 1];
+    }
+    else
+    {
+        FragColor += _16[index & 1];
+    }
+    if (index > 30)
+    {
+        FragColor += _60[index & 3].y;
+    }
+    else
+    {
+        FragColor += _60[index & 1].x;
+    }
+    float4 foobar[4] = _60;
+    if (index > 30)
+    {
+        foobar[1].z = 20.0f;
+    }
+    FragColor += foobar[index & 3].z;
+    float4 baz[4] = _60;
+    baz = _104;
+    FragColor += baz[index & 3].z;
+}
+
+SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
+{
+    index = stage_input.index;
+    frag_main();
+    SPIRV_Cross_Output stage_output;
+    stage_output.FragColor = FragColor;
+    return stage_output;
+}

reference/shaders-msl/frag/constant-array.frag

@@ -52,7 +52,7 @@ fragment main0_out main0(main0_in in [[stage_in]])
     Foobar param = {10.0, 20.0};
     Foobar indexable[2] = {{10.0, 40.0}, {90.0, 70.0}};
     Foobar param_1 = indexable[in.index];
-    out.FragColor = ((_37[in.index] + (_55[in.index][in.index + 1])) + resolve(param)) + resolve(param_1);
+    out.FragColor = ((_37[in.index] + _55[in.index][in.index + 1]) + resolve(param)) + resolve(param_1);
     return out;
 }
 

reference/shaders-msl/frag/constant-composites.frag

@@ -44,7 +44,7 @@ fragment main0_out main0(main0_in in [[stage_in]])
     float lut[4] = {1.0, 4.0, 3.0, 2.0};
     Foo foos[2] = {{10.0, 20.0}, {30.0, 40.0}};
     out.FragColor = float4(lut[in.line]);
-    out.FragColor += float4(foos[in.line].a * (foos[1 - in.line].a));
+    out.FragColor += float4(foos[in.line].a * foos[1 - in.line].a);
     return out;
 }
 

reference/shaders-msl/frag/lut-promotion.frag

@@ -0,0 +1,67 @@
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+constant float _16[16] = {1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0};
+constant float4 _60[4] = {float4(0.0), float4(1.0), float4(8.0), float4(5.0)};
+constant float4 _104[4] = {float4(20.0), float4(30.0), float4(50.0), float4(60.0)};
+
+struct main0_out
+{
+    float FragColor [[color(0)]];
+};
+
+struct main0_in
+{
+    int index [[user(locn0)]];
+};
+
+// Implementation of an array copy function to cover GLSL's ability to copy an array via assignment.
+template<typename T, uint N>
+void spvArrayCopy(thread T (&dst)[N], thread const T (&src)[N])
+{
+    for (uint i = 0; i < N; dst[i] = src[i], i++);
+}
+
+// An overload for constant arrays.
+template<typename T, uint N>
+void spvArrayCopyConstant(thread T (&dst)[N], constant T (&src)[N])
+{
+    for (uint i = 0; i < N; dst[i] = src[i], i++);
+}
+
+fragment main0_out main0(main0_in in [[stage_in]])
+{
+    main0_out out = {};
+    out.FragColor = _16[in.index];
+    if (in.index < 10)
+    {
+        out.FragColor += _16[in.index ^ 1];
+    }
+    else
+    {
+        out.FragColor += _16[in.index & 1];
+    }
+    if (in.index > 30)
+    {
+        out.FragColor += _60[in.index & 3].y;
+    }
+    else
+    {
+        out.FragColor += _60[in.index & 1].x;
+    }
+    float4 foobar[4] = {float4(0.0), float4(1.0), float4(8.0), float4(5.0)};
+    if (in.index > 30)
+    {
+        foobar[1].z = 20.0;
+    }
+    out.FragColor += foobar[in.index & 3].z;
+    float4 baz[4] = {float4(0.0), float4(1.0), float4(8.0), float4(5.0)};
+    spvArrayCopyConstant(baz, _104);
+    out.FragColor += baz[in.index & 3].z;
+    return out;
+}
+

reference/shaders/flatten/copy.flatten.vert

@@ -23,7 +23,7 @@ void main()
         light.Radius = Light(UBO[i * 2 + 4].xyz, UBO[i * 2 + 4].w, UBO[i * 2 + 5]).Radius;
         light.Color = Light(UBO[i * 2 + 4].xyz, UBO[i * 2 + 4].w, UBO[i * 2 + 5]).Color;
         vec3 L = aVertex.xyz - light.Position;
-        vColor += (((UBO[i * 2 + 5]) * clamp(1.0 - (length(L) / light.Radius), 0.0, 1.0)) * dot(aNormal, normalize(L)));
+        vColor += ((UBO[i * 2 + 5] * clamp(1.0 - (length(L) / light.Radius), 0.0, 1.0)) * dot(aNormal, normalize(L)));
     }
 }
 

reference/shaders/flatten/dynamic.flatten.vert

@@ -18,8 +18,8 @@ void main()
     vColor = vec4(0.0);
     for (int i = 0; i < 4; i++)
     {
-        vec3 L = aVertex.xyz - (UBO[i * 2 + 4].xyz);
-        vColor += (((UBO[i * 2 + 5]) * clamp(1.0 - (length(L) / (UBO[i * 2 + 4].w)), 0.0, 1.0)) * dot(aNormal, normalize(L)));
+        vec3 L = aVertex.xyz - UBO[i * 2 + 4].xyz;
+        vColor += ((UBO[i * 2 + 5] * clamp(1.0 - (length(L) / UBO[i * 2 + 4].w), 0.0, 1.0)) * dot(aNormal, normalize(L)));
     }
 }
 

reference/shaders/flatten/multi-dimensional.desktop.flatten_dim.frag

@@ -19,6 +19,6 @@ void main()
             }
         }
     }
-    FragColor = ((values3[1 * 3 * 1 + 2 * 1 + 0]) + (values3[0 * 3 * 1 + 2 * 1 + 0])) + (values3[(vIndex + 1) * 3 * 1 + 2 * 1 + vIndex]);
+    FragColor = (values3[1 * 3 * 1 + 2 * 1 + 0] + values3[0 * 3 * 1 + 2 * 1 + 0]) + values3[(vIndex + 1) * 3 * 1 + 2 * 1 + vIndex];
 }
 

reference/shaders/frag/constant-array.frag

@@ -24,6 +24,6 @@ void main()
     Foobar param = Foobar(10.0, 20.0);
     Foobar indexable[2] = Foobar[](Foobar(10.0, 40.0), Foobar(90.0, 70.0));
     Foobar param_1 = indexable[index];
-    FragColor = ((_37[index] + (_55[index][index + 1])) + resolve(param)) + resolve(param_1);
+    FragColor = ((_37[index] + _55[index][index + 1]) + resolve(param)) + resolve(param_1);
 }
 

reference/shaders/frag/constant-composites.frag

@@ -18,6 +18,6 @@ void main()
     lut = float[](1.0, 4.0, 3.0, 2.0);
     foos = Foo[](Foo(10.0, 20.0), Foo(30.0, 40.0));
     FragColor = vec4(lut[line]);
-    FragColor += vec4(foos[line].a * (foos[1 - line].a));
+    FragColor += vec4(foos[line].a * foos[1 - line].a);
 }
 

reference/shaders/frag/lut-promotion.frag

@@ -0,0 +1,40 @@
+#version 310 es
+precision mediump float;
+precision highp int;
+
+const float _16[16] = float[](1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0);
+const vec4 _60[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+
+layout(location = 0) out float FragColor;
+layout(location = 0) flat in mediump int index;
+
+void main()
+{
+    FragColor = _16[index];
+    if (index < 10)
+    {
+        FragColor += _16[index ^ 1];
+    }
+    else
+    {
+        FragColor += _16[index & 1];
+    }
+    if (index > 30)
+    {
+        FragColor += _60[index & 3].y;
+    }
+    else
+    {
+        FragColor += _60[index & 1].x;
+    }
+    vec4 foobar[4] = _60;
+    if (index > 30)
+    {
+        foobar[1].z = 20.0;
+    }
+    FragColor += foobar[index & 3].z;
+    vec4 baz[4] = _60;
+    baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0));
+    FragColor += baz[index & 3].z;
+}
+

shaders-hlsl/frag/lut-promotion.frag

@@ -0,0 +1,44 @@
+#version 310 es
+precision mediump float;
+layout(location = 0) out float FragColor;
+layout(location = 0) flat in int index;
+
+const float LUT[16] = float[](
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0);
+
+void main()
+{
+	// Try reading LUTs, both in branches and not branch.
+	FragColor = LUT[index];
+	if (index < 10)
+		FragColor += LUT[index ^ 1];
+	else
+		FragColor += LUT[index & 1];
+
+	// Not declared as a LUT, but can be promoted to one.
+	vec4 foo[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	if (index > 30)
+	{
+		FragColor += foo[index & 3].y;
+	}
+	else
+	{
+		FragColor += foo[index & 1].x;
+	}
+
+	// Not declared as a LUT, but this cannot be promoted, because we have a partial write.
+	vec4 foobar[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	if (index > 30)
+	{
+		foobar[1].z = 20.0;
+	}
+	FragColor += foobar[index & 3].z;
+
+	// Not declared as a LUT, but this cannot be promoted, because we have two complete writes.
+	vec4 baz[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0));
+	FragColor += baz[index & 3].z;
+}

shaders-msl/frag/lut-promotion.frag

@@ -0,0 +1,44 @@
+#version 310 es
+precision mediump float;
+layout(location = 0) out float FragColor;
+layout(location = 0) flat in int index;
+
+const float LUT[16] = float[](
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0);
+
+void main()
+{
+	// Try reading LUTs, both in branches and not branch.
+	FragColor = LUT[index];
+	if (index < 10)
+		FragColor += LUT[index ^ 1];
+	else
+		FragColor += LUT[index & 1];
+
+	// Not declared as a LUT, but can be promoted to one.
+	vec4 foo[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	if (index > 30)
+	{
+		FragColor += foo[index & 3].y;
+	}
+	else
+	{
+		FragColor += foo[index & 1].x;
+	}
+
+	// Not declared as a LUT, but this cannot be promoted, because we have a partial write.
+	vec4 foobar[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	if (index > 30)
+	{
+		foobar[1].z = 20.0;
+	}
+	FragColor += foobar[index & 3].z;
+
+	// Not declared as a LUT, but this cannot be promoted, because we have two complete writes.
+	vec4 baz[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0));
+	FragColor += baz[index & 3].z;
+}

shaders/frag/lut-promotion.frag

@@ -0,0 +1,44 @@
+#version 310 es
+precision mediump float;
+layout(location = 0) out float FragColor;
+layout(location = 0) flat in int index;
+
+const float LUT[16] = float[](
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0,
+	1.0, 2.0, 3.0, 4.0);
+
+void main()
+{
+	// Try reading LUTs, both in branches and not branch.
+	FragColor = LUT[index];
+	if (index < 10)
+		FragColor += LUT[index ^ 1];
+	else
+		FragColor += LUT[index & 1];
+
+	// Not declared as a LUT, but can be promoted to one.
+	vec4 foo[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	if (index > 30)
+	{
+		FragColor += foo[index & 3].y;
+	}
+	else
+	{
+		FragColor += foo[index & 1].x;
+	}
+
+	// Not declared as a LUT, but this cannot be promoted, because we have a partial write.
+	vec4 foobar[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	if (index > 30)
+	{
+		foobar[1].z = 20.0;
+	}
+	FragColor += foobar[index & 3].z;
+
+	// Not declared as a LUT, but this cannot be promoted, because we have two complete writes.
+	vec4 baz[4] = vec4[](vec4(0.0), vec4(1.0), vec4(8.0), vec4(5.0));
+	baz = vec4[](vec4(20.0), vec4(30.0), vec4(50.0), vec4(60.0));
+	FragColor += baz[index & 3].z;
+}