glsl-1.30: Reproduce a bug in the i965 backend optimizer

Submitted by Ian Romanick on Sept. 12, 2018, 11:29 p.m.

Details

Message ID 20180912232955.4286-1-idr@freedesktop.org
State New
Headers show
Series "glsl-1.30: Reproduce a bug in the i965 backend optimizer" ( rev: 1 ) in Piglit

Not browsing as part of any series.

Commit Message

Ian Romanick Sept. 12, 2018, 11:29 p.m.
From: Ian Romanick <ian.d.romanick@intel.com>

The optimizer recently added the ability to replace a compare with a
subtraction under certain circumstances.  This can fail for integers.
For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
less than zero, so the flags get set differently than for (a < b).

This really only affected the signed comparisons because the subtract
would always have a signed source types, so it wouldn't be seen as a
match for the compare with unsigned source types.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
Cc: Matt Turner <mattst88@gmail.com>
---
 tests/spec/CMakeLists.txt                          |  1 +
 .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
 .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
 .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
 .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
 5 files changed, 363 insertions(+)
 create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
 create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
 create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
 create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test

Patch hide | download patch | download mbox

diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
index 4df9d331d..28abf3634 100644
--- a/tests/spec/CMakeLists.txt
+++ b/tests/spec/CMakeLists.txt
@@ -2,6 +2,7 @@  add_subdirectory (amd_framebuffer_multisample_advanced)
 add_subdirectory (amd_depth_clamp_separate)
 add_subdirectory (amd_performance_monitor)
 add_subdirectory (amd_pinned_memory)
+add_subdirectory (amd_transform_feedback3_lines_triangles)
 add_subdirectory (arb_arrays_of_arrays)
 add_subdirectory (arb_base_instance)
 add_subdirectory (arb_bindless_texture)
diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
new file mode 100644
index 000000000..cdac53cdf
--- /dev/null
+++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
@@ -0,0 +1,85 @@ 
+[require]
+GL >= 3.0
+GLSL >= 1.30
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_EXT_shader_integer_mix: enable
+
+// { A, B, absoluteDifference(A, B) }
+uniform ivec3 data[40];
+
+out vec4 color;
+
+uint abs_diff(int a, int b)
+{
+    /* This can fail if the compiler replaces the (a < b) with the result of
+     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
+     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
+     * 0x7ffffffc.  That's not less than zero, so the flags get set
+     * differently than for (a < b).
+     */
+#ifndef GL_EXT_shader_integer_mix
+    return (a < b) ? uint(b - a) : uint(a - b);
+#else
+    return mix(uint(a - b), uint(b - a), a < b);
+#endif
+}
+
+void main()
+{
+    uint idx = uint(gl_FragCoord.x) % uint(data.length());
+    ivec3 v = data[idx];
+
+    if (abs_diff(v.x, v.y) == uint(v.z)) {
+	color = vec4(0.0, 1.0, 0.0, 1.0);
+    } else {
+	color = vec4(1.0, 0.0, 0.0, 1.0);
+    }
+}
+
+[test]
+uniform ivec3 data[0] 0x80000000 0x80000000 0x00000000
+uniform ivec3 data[1] 0x80000000 0x80000001 0x00000001
+uniform ivec3 data[2] 0x80000000 0xf8000000 0x78000000
+uniform ivec3 data[3] 0x80000000 0xf8000001 0x78000001
+uniform ivec3 data[4] 0x80000000 0xff800000 0x7f800000
+uniform ivec3 data[5] 0x80000000 0xff800001 0x7f800001
+uniform ivec3 data[6] 0x80000000 0xfff80000 0x7ff80000
+uniform ivec3 data[7] 0x80000000 0xfff80001 0x7ff80001
+uniform ivec3 data[8] 0x80000000 0xffff8000 0x7fff8000
+uniform ivec3 data[9] 0x80000000 0xffff8001 0x7fff8001
+uniform ivec3 data[10] 0x80000000 0xfffff800 0x7ffff800
+uniform ivec3 data[11] 0x80000000 0xfffff801 0x7ffff801
+uniform ivec3 data[12] 0x80000000 0xffffff80 0x7fffff80
+uniform ivec3 data[13] 0x80000000 0xffffff81 0x7fffff81
+uniform ivec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
+uniform ivec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
+uniform ivec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
+uniform ivec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
+uniform ivec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
+uniform ivec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
+uniform ivec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
+uniform ivec3 data[21] 0x80000000 0xffffffff 0x7fffffff
+uniform ivec3 data[22] 0x80000000 0x00000000 0x80000000
+uniform ivec3 data[23] 0x80000000 0x00000001 0x80000001
+uniform ivec3 data[24] 0x80000000 0x00000002 0x80000002
+uniform ivec3 data[25] 0x80000000 0x00000003 0x80000003
+uniform ivec3 data[26] 0x80000000 0x00000004 0x80000004
+uniform ivec3 data[27] 0x80000000 0x00000005 0x80000005
+uniform ivec3 data[28] 0x80000000 0x00000006 0x80000006
+uniform ivec3 data[29] 0x80000000 0x00000007 0x80000007
+uniform ivec3 data[30] 0x80000000 0x00000008 0x80000008
+uniform ivec3 data[31] 0x80000000 0x0000007f 0x8000007f
+uniform ivec3 data[32] 0x80000000 0x00000080 0x80000080
+uniform ivec3 data[33] 0x80000000 0x000007ff 0x800007ff
+uniform ivec3 data[34] 0x80000000 0x00000800 0x80000800
+uniform ivec3 data[35] 0x80000000 0x00007fff 0x80007fff
+uniform ivec3 data[36] 0x80000000 0x00008000 0x80008000
+uniform ivec3 data[37] 0x80000000 0x0007ffff 0x8007ffff
+uniform ivec3 data[38] 0x80000000 0x00080000 0x80080000
+uniform ivec3 data[39] 0x80000000 0x007fffff 0x807fffff
+
+draw rect -1 -1 2 2
+probe all rgb 0.0 1.0 0.0
diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
new file mode 100644
index 000000000..541c5c9ad
--- /dev/null
+++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
@@ -0,0 +1,85 @@ 
+[require]
+GL >= 3.0
+GLSL >= 1.30
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_EXT_shader_integer_mix: enable
+
+// { A, B, absoluteDifference(A, B) }
+uniform uvec3 data[40];
+
+out vec4 color;
+
+uint abs_diff(uint a, uint b)
+{
+    /* This can fail if the compiler replaces the (a < b) with the result of
+     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
+     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
+     * 0x7ffffffc.  That's not less than zero, so the flags get set
+     * differently than for (a < b).
+     */
+#ifndef GL_EXT_shader_integer_mix
+    return (a < b) ? b - a : a - b;
+#else
+    return mix(a - b, b - a, a < b);
+#endif
+}
+
+void main()
+{
+    uint idx = uint(gl_FragCoord.x) % uint(data.length());
+    uvec3 v = data[idx];
+
+    if (abs_diff(v.x, v.y) == uint(v.z)) {
+	color = vec4(0.0, 1.0, 0.0, 1.0);
+    } else {
+	color = vec4(1.0, 0.0, 0.0, 1.0);
+    }
+}
+
+[test]
+uniform uvec3 data[0] 0x80000000 0x80000000 0x00000000
+uniform uvec3 data[1] 0x80000000 0x80000001 0x00000001
+uniform uvec3 data[2] 0x80000000 0xf8000000 0x78000000
+uniform uvec3 data[3] 0x80000000 0xf8000001 0x78000001
+uniform uvec3 data[4] 0x80000000 0xff800000 0x7f800000
+uniform uvec3 data[5] 0x80000000 0xff800001 0x7f800001
+uniform uvec3 data[6] 0x80000000 0xfff80000 0x7ff80000
+uniform uvec3 data[7] 0x80000000 0xfff80001 0x7ff80001
+uniform uvec3 data[8] 0x80000000 0xffff8000 0x7fff8000
+uniform uvec3 data[9] 0x80000000 0xffff8001 0x7fff8001
+uniform uvec3 data[10] 0x80000000 0xfffff800 0x7ffff800
+uniform uvec3 data[11] 0x80000000 0xfffff801 0x7ffff801
+uniform uvec3 data[12] 0x80000000 0xffffff80 0x7fffff80
+uniform uvec3 data[13] 0x80000000 0xffffff81 0x7fffff81
+uniform uvec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
+uniform uvec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
+uniform uvec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
+uniform uvec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
+uniform uvec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
+uniform uvec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
+uniform uvec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
+uniform uvec3 data[21] 0x80000000 0xffffffff 0x7fffffff
+uniform uvec3 data[22] 0x80000000 0x00000000 0x80000000
+uniform uvec3 data[23] 0x80000000 0x00000001 0x7fffffff
+uniform uvec3 data[24] 0x80000000 0x00000002 0x7ffffffe
+uniform uvec3 data[25] 0x80000000 0x00000003 0x7ffffffd
+uniform uvec3 data[26] 0x80000000 0x00000004 0x7ffffffc
+uniform uvec3 data[27] 0x80000000 0x00000005 0x7ffffffb
+uniform uvec3 data[28] 0x80000000 0x00000006 0x7ffffffa
+uniform uvec3 data[29] 0x80000000 0x00000007 0x7ffffff9
+uniform uvec3 data[30] 0x80000000 0x00000008 0x7ffffff8
+uniform uvec3 data[31] 0x80000000 0x0000007f 0x7fffff81
+uniform uvec3 data[32] 0x80000000 0x00000080 0x7fffff80
+uniform uvec3 data[33] 0x80000000 0x000007ff 0x7ffff801
+uniform uvec3 data[34] 0x80000000 0x00000800 0x7ffff800
+uniform uvec3 data[35] 0x80000000 0x00007fff 0x7fff8001
+uniform uvec3 data[36] 0x80000000 0x00008000 0x7fff8000
+uniform uvec3 data[37] 0x80000000 0x0007ffff 0x7ff80001
+uniform uvec3 data[38] 0x80000000 0x00080000 0x7ff80000
+uniform uvec3 data[39] 0x80000000 0x007fffff 0x7f800001
+
+draw rect -1 -1 2 2
+probe all rgb 0.0 1.0 0.0
diff --git a/tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
new file mode 100644
index 000000000..5ef0b319a
--- /dev/null
+++ b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
@@ -0,0 +1,96 @@ 
+[require]
+GL >= 3.0
+GLSL >= 1.30
+
+[vertex shader]
+#extension GL_EXT_shader_integer_mix: enable
+
+// { A, B, absoluteDifference(A, B) }
+uniform ivec3 data[40];
+
+in vec4 piglit_vertex;
+out vec4 color;
+
+uint abs_diff(int a, int b)
+{
+    /* This can fail if the compiler replaces the (a < b) with the result of
+     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
+     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
+     * 0x7ffffffc.  That's not less than zero, so the flags get set
+     * differently than for (a < b).
+     */
+#ifndef GL_EXT_shader_integer_mix
+    return (a < b) ? uint(b - a) : uint(a - b);
+#else
+    return mix(uint(a - b), uint(b - a), a < b);
+#endif
+}
+
+void main()
+{
+    color = vec4(0.0, 1.0, 0.0, 1.0);
+
+    for (int i = 0; i < data.length(); i++) {
+	ivec3 v = data[i];
+
+	if (abs_diff(v.x, v.y) != uint(v.z))
+	    color = vec4(1.0, 0.0, 0.0, 1.0);
+    }
+
+    gl_Position = piglit_vertex;
+}
+
+
+[fragment shader]
+in vec4 color;
+out vec4 piglit_fragcolor;
+
+void main()
+{
+    piglit_fragcolor = color;
+}
+
+[test]
+uniform ivec3 data[0] 0x80000000 0x80000000 0x00000000
+uniform ivec3 data[1] 0x80000000 0x80000001 0x00000001
+uniform ivec3 data[2] 0x80000000 0xf8000000 0x78000000
+uniform ivec3 data[3] 0x80000000 0xf8000001 0x78000001
+uniform ivec3 data[4] 0x80000000 0xff800000 0x7f800000
+uniform ivec3 data[5] 0x80000000 0xff800001 0x7f800001
+uniform ivec3 data[6] 0x80000000 0xfff80000 0x7ff80000
+uniform ivec3 data[7] 0x80000000 0xfff80001 0x7ff80001
+uniform ivec3 data[8] 0x80000000 0xffff8000 0x7fff8000
+uniform ivec3 data[9] 0x80000000 0xffff8001 0x7fff8001
+uniform ivec3 data[10] 0x80000000 0xfffff800 0x7ffff800
+uniform ivec3 data[11] 0x80000000 0xfffff801 0x7ffff801
+uniform ivec3 data[12] 0x80000000 0xffffff80 0x7fffff80
+uniform ivec3 data[13] 0x80000000 0xffffff81 0x7fffff81
+uniform ivec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
+uniform ivec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
+uniform ivec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
+uniform ivec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
+uniform ivec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
+uniform ivec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
+uniform ivec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
+uniform ivec3 data[21] 0x80000000 0xffffffff 0x7fffffff
+uniform ivec3 data[22] 0x80000000 0x00000000 0x80000000
+uniform ivec3 data[23] 0x80000000 0x00000001 0x80000001
+uniform ivec3 data[24] 0x80000000 0x00000002 0x80000002
+uniform ivec3 data[25] 0x80000000 0x00000003 0x80000003
+uniform ivec3 data[26] 0x80000000 0x00000004 0x80000004
+uniform ivec3 data[27] 0x80000000 0x00000005 0x80000005
+uniform ivec3 data[28] 0x80000000 0x00000006 0x80000006
+uniform ivec3 data[29] 0x80000000 0x00000007 0x80000007
+uniform ivec3 data[30] 0x80000000 0x00000008 0x80000008
+uniform ivec3 data[31] 0x80000000 0x0000007f 0x8000007f
+uniform ivec3 data[32] 0x80000000 0x00000080 0x80000080
+uniform ivec3 data[33] 0x80000000 0x000007ff 0x800007ff
+uniform ivec3 data[34] 0x80000000 0x00000800 0x80000800
+uniform ivec3 data[35] 0x80000000 0x00007fff 0x80007fff
+uniform ivec3 data[36] 0x80000000 0x00008000 0x80008000
+uniform ivec3 data[37] 0x80000000 0x0007ffff 0x8007ffff
+uniform ivec3 data[38] 0x80000000 0x00080000 0x80080000
+uniform ivec3 data[39] 0x80000000 0x007fffff 0x807fffff
+
+draw rect -1 -1 2 2
+probe all rgb 0.0 1.0 0.0
diff --git a/tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
new file mode 100644
index 000000000..b6f5a69fb
--- /dev/null
+++ b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
@@ -0,0 +1,96 @@ 
+[require]
+GL >= 3.0
+GLSL >= 1.30
+
+[vertex shader]
+#extension GL_EXT_shader_integer_mix: enable
+
+// { A, B, absoluteDifference(A, B) }
+uniform uvec3 data[40];
+
+in vec4 piglit_vertex;
+out vec4 color;
+
+uint abs_diff(uint a, uint b)
+{
+    /* This can fail if the compiler replaces the (a < b) with the result of
+     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
+     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
+     * 0x7ffffffc.  That's not less than zero, so the flags get set
+     * differently than for (a < b).
+     */
+#ifndef GL_EXT_shader_integer_mix
+    return (a < b) ? b - a : a - b;
+#else
+    return mix(a - b, b - a, a < b);
+#endif
+}
+
+void main()
+{
+    color = vec4(0.0, 1.0, 0.0, 1.0);
+
+    for (int i = 0; i < data.length(); i++) {
+	uvec3 v = data[i];
+
+	if (abs_diff(v.x, v.y) != uint(v.z))
+	    color = vec4(1.0, 0.0, 0.0, 1.0);
+    }
+
+    gl_Position = piglit_vertex;
+}
+
+
+[fragment shader]
+in vec4 color;
+out vec4 piglit_fragcolor;
+
+void main()
+{
+    piglit_fragcolor = color;
+}
+
+[test]
+uniform uvec3 data[0] 0x80000000 0x80000000 0x00000000
+uniform uvec3 data[1] 0x80000000 0x80000001 0x00000001
+uniform uvec3 data[2] 0x80000000 0xf8000000 0x78000000
+uniform uvec3 data[3] 0x80000000 0xf8000001 0x78000001
+uniform uvec3 data[4] 0x80000000 0xff800000 0x7f800000
+uniform uvec3 data[5] 0x80000000 0xff800001 0x7f800001
+uniform uvec3 data[6] 0x80000000 0xfff80000 0x7ff80000
+uniform uvec3 data[7] 0x80000000 0xfff80001 0x7ff80001
+uniform uvec3 data[8] 0x80000000 0xffff8000 0x7fff8000
+uniform uvec3 data[9] 0x80000000 0xffff8001 0x7fff8001
+uniform uvec3 data[10] 0x80000000 0xfffff800 0x7ffff800
+uniform uvec3 data[11] 0x80000000 0xfffff801 0x7ffff801
+uniform uvec3 data[12] 0x80000000 0xffffff80 0x7fffff80
+uniform uvec3 data[13] 0x80000000 0xffffff81 0x7fffff81
+uniform uvec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
+uniform uvec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
+uniform uvec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
+uniform uvec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
+uniform uvec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
+uniform uvec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
+uniform uvec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
+uniform uvec3 data[21] 0x80000000 0xffffffff 0x7fffffff
+uniform uvec3 data[22] 0x80000000 0x00000000 0x80000000
+uniform uvec3 data[23] 0x80000000 0x00000001 0x7fffffff
+uniform uvec3 data[24] 0x80000000 0x00000002 0x7ffffffe
+uniform uvec3 data[25] 0x80000000 0x00000003 0x7ffffffd
+uniform uvec3 data[26] 0x80000000 0x00000004 0x7ffffffc
+uniform uvec3 data[27] 0x80000000 0x00000005 0x7ffffffb
+uniform uvec3 data[28] 0x80000000 0x00000006 0x7ffffffa
+uniform uvec3 data[29] 0x80000000 0x00000007 0x7ffffff9
+uniform uvec3 data[30] 0x80000000 0x00000008 0x7ffffff8
+uniform uvec3 data[31] 0x80000000 0x0000007f 0x7fffff81
+uniform uvec3 data[32] 0x80000000 0x00000080 0x7fffff80
+uniform uvec3 data[33] 0x80000000 0x000007ff 0x7ffff801
+uniform uvec3 data[34] 0x80000000 0x00000800 0x7ffff800
+uniform uvec3 data[35] 0x80000000 0x00007fff 0x7fff8001
+uniform uvec3 data[36] 0x80000000 0x00008000 0x7fff8000
+uniform uvec3 data[37] 0x80000000 0x0007ffff 0x7ff80001
+uniform uvec3 data[38] 0x80000000 0x00080000 0x7ff80000
+uniform uvec3 data[39] 0x80000000 0x007fffff 0x7f800001
+
+draw rect -1 -1 2 2
+probe all rgb 0.0 1.0 0.0

Comments

On Wed, Sep 12, 2018 at 7:29 PM, Ian Romanick <idr@freedesktop.org> wrote:
> From: Ian Romanick <ian.d.romanick@intel.com>
>
> The optimizer recently added the ability to replace a compare with a
> subtraction under certain circumstances.  This can fail for integers.
> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
> less than zero, so the flags get set differently than for (a < b).
>
> This really only affected the signed comparisons because the subtract
> would always have a signed source types, so it wouldn't be seen as a
> match for the compare with unsigned source types.
>
> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
> Cc: Matt Turner <mattst88@gmail.com>
> ---
>  tests/spec/CMakeLists.txt                          |  1 +
>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>  5 files changed, 363 insertions(+)
>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
>
> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
> index 4df9d331d..28abf3634 100644
> --- a/tests/spec/CMakeLists.txt
> +++ b/tests/spec/CMakeLists.txt
> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>  add_subdirectory (amd_depth_clamp_separate)
>  add_subdirectory (amd_performance_monitor)
>  add_subdirectory (amd_pinned_memory)
> +add_subdirectory (amd_transform_feedback3_lines_triangles)
>  add_subdirectory (arb_arrays_of_arrays)
>  add_subdirectory (arb_base_instance)
>  add_subdirectory (arb_bindless_texture)
> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
> new file mode 100644
> index 000000000..cdac53cdf
> --- /dev/null
> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
> @@ -0,0 +1,85 @@
> +[require]
> +GL >= 3.0
> +GLSL >= 1.30
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +#extension GL_EXT_shader_integer_mix: enable
> +
> +// { A, B, absoluteDifference(A, B) }
> +uniform ivec3 data[40];
> +
> +out vec4 color;
> +
> +uint abs_diff(int a, int b)
> +{
> +    /* This can fail if the compiler replaces the (a < b) with the result of
> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
> +     * differently than for (a < b).
> +     */
> +#ifndef GL_EXT_shader_integer_mix
> +    return (a < b) ? uint(b - a) : uint(a - b);
> +#else
> +    return mix(uint(a - b), uint(b - a), a < b);
> +#endif

Why bother with this? It'll end up testing different code depending on
the extensions that the driver supports, which seems like a really bad
idea.

  -ilia
On 09/12/2018 04:33 PM, Ilia Mirkin wrote:
> On Wed, Sep 12, 2018 at 7:29 PM, Ian Romanick <idr@freedesktop.org> wrote:
>> From: Ian Romanick <ian.d.romanick@intel.com>
>>
>> The optimizer recently added the ability to replace a compare with a
>> subtraction under certain circumstances.  This can fail for integers.
>> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
>> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
>> less than zero, so the flags get set differently than for (a < b).
>>
>> This really only affected the signed comparisons because the subtract
>> would always have a signed source types, so it wouldn't be seen as a
>> match for the compare with unsigned source types.
>>
>> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
>> Cc: Matt Turner <mattst88@gmail.com>
>> ---
>>  tests/spec/CMakeLists.txt                          |  1 +
>>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>>  5 files changed, 363 insertions(+)
>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
>>
>> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
>> index 4df9d331d..28abf3634 100644
>> --- a/tests/spec/CMakeLists.txt
>> +++ b/tests/spec/CMakeLists.txt
>> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>>  add_subdirectory (amd_depth_clamp_separate)
>>  add_subdirectory (amd_performance_monitor)
>>  add_subdirectory (amd_pinned_memory)
>> +add_subdirectory (amd_transform_feedback3_lines_triangles)
>>  add_subdirectory (arb_arrays_of_arrays)
>>  add_subdirectory (arb_base_instance)
>>  add_subdirectory (arb_bindless_texture)
>> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>> new file mode 100644
>> index 000000000..cdac53cdf
>> --- /dev/null
>> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>> @@ -0,0 +1,85 @@
>> +[require]
>> +GL >= 3.0
>> +GLSL >= 1.30
>> +
>> +[vertex shader passthrough]
>> +
>> +[fragment shader]
>> +#extension GL_EXT_shader_integer_mix: enable
>> +
>> +// { A, B, absoluteDifference(A, B) }
>> +uniform ivec3 data[40];
>> +
>> +out vec4 color;
>> +
>> +uint abs_diff(int a, int b)
>> +{
>> +    /* This can fail if the compiler replaces the (a < b) with the result of
>> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
>> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
>> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
>> +     * differently than for (a < b).
>> +     */
>> +#ifndef GL_EXT_shader_integer_mix
>> +    return (a < b) ? uint(b - a) : uint(a - b);
>> +#else
>> +    return mix(uint(a - b), uint(b - a), a < b);
>> +#endif
> 
> Why bother with this? It'll end up testing different code depending on
> the extensions that the driver supports, which seems like a really bad
> idea.

We only hit the bug in the mix() case because how how we lower flow
control to bcsel.  I thought about having it require
GL_EXT_shader_integer_mix.  That means that when a driver enabled that
extension the test could transition SKIP->FAIL which seems more likely
to be ignored than PASS->FAIL.  I guess now there's a possible
FAIL->PASS transition.  Meh.

I'm not married to it being either way.  I just want to reproduce the
bug that I added to the i965 driver a few months ago. :)

>   -ilia
On Wed, Sep 12, 2018 at 7:59 PM, Ian Romanick <idr@freedesktop.org> wrote:
> On 09/12/2018 04:33 PM, Ilia Mirkin wrote:
>> On Wed, Sep 12, 2018 at 7:29 PM, Ian Romanick <idr@freedesktop.org> wrote:
>>> From: Ian Romanick <ian.d.romanick@intel.com>
>>>
>>> The optimizer recently added the ability to replace a compare with a
>>> subtraction under certain circumstances.  This can fail for integers.
>>> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
>>> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
>>> less than zero, so the flags get set differently than for (a < b).
>>>
>>> This really only affected the signed comparisons because the subtract
>>> would always have a signed source types, so it wouldn't be seen as a
>>> match for the compare with unsigned source types.
>>>
>>> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
>>> Cc: Matt Turner <mattst88@gmail.com>
>>> ---
>>>  tests/spec/CMakeLists.txt                          |  1 +
>>>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>>>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>>>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>>>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>>>  5 files changed, 363 insertions(+)
>>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
>>>
>>> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
>>> index 4df9d331d..28abf3634 100644
>>> --- a/tests/spec/CMakeLists.txt
>>> +++ b/tests/spec/CMakeLists.txt
>>> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>>>  add_subdirectory (amd_depth_clamp_separate)
>>>  add_subdirectory (amd_performance_monitor)
>>>  add_subdirectory (amd_pinned_memory)
>>> +add_subdirectory (amd_transform_feedback3_lines_triangles)
>>>  add_subdirectory (arb_arrays_of_arrays)
>>>  add_subdirectory (arb_base_instance)
>>>  add_subdirectory (arb_bindless_texture)
>>> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>> new file mode 100644
>>> index 000000000..cdac53cdf
>>> --- /dev/null
>>> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>> @@ -0,0 +1,85 @@
>>> +[require]
>>> +GL >= 3.0
>>> +GLSL >= 1.30
>>> +
>>> +[vertex shader passthrough]
>>> +
>>> +[fragment shader]
>>> +#extension GL_EXT_shader_integer_mix: enable
>>> +
>>> +// { A, B, absoluteDifference(A, B) }
>>> +uniform ivec3 data[40];
>>> +
>>> +out vec4 color;
>>> +
>>> +uint abs_diff(int a, int b)
>>> +{
>>> +    /* This can fail if the compiler replaces the (a < b) with the result of
>>> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
>>> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
>>> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
>>> +     * differently than for (a < b).
>>> +     */
>>> +#ifndef GL_EXT_shader_integer_mix
>>> +    return (a < b) ? uint(b - a) : uint(a - b);
>>> +#else
>>> +    return mix(uint(a - b), uint(b - a), a < b);
>>> +#endif
>>
>> Why bother with this? It'll end up testing different code depending on
>> the extensions that the driver supports, which seems like a really bad
>> idea.
>
> We only hit the bug in the mix() case because how how we lower flow
> control to bcsel.  I thought about having it require
> GL_EXT_shader_integer_mix.  That means that when a driver enabled that
> extension the test could transition SKIP->FAIL which seems more likely
> to be ignored than PASS->FAIL.  I guess now there's a possible
> FAIL->PASS transition.  Meh.
>
> I'm not married to it being either way.  I just want to reproduce the
> bug that I added to the i965 driver a few months ago. :)

Hmm. Meh indeed. I dunno though -- skip -> fail when enabling an ext
seems pretty bad to me. I'd just require EXT_shader_integer_mix. In
practice, it's enabled everywhere GL 3.0 is (in mesa), so it's all a
bit academic.

  -ilia
On 09/12/2018 09:17 PM, Ilia Mirkin wrote:
> On Wed, Sep 12, 2018 at 7:59 PM, Ian Romanick <idr@freedesktop.org> wrote:
>> On 09/12/2018 04:33 PM, Ilia Mirkin wrote:
>>> On Wed, Sep 12, 2018 at 7:29 PM, Ian Romanick <idr@freedesktop.org> wrote:
>>>> From: Ian Romanick <ian.d.romanick@intel.com>
>>>>
>>>> The optimizer recently added the ability to replace a compare with a
>>>> subtraction under certain circumstances.  This can fail for integers.
>>>> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
>>>> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
>>>> less than zero, so the flags get set differently than for (a < b).
>>>>
>>>> This really only affected the signed comparisons because the subtract
>>>> would always have a signed source types, so it wouldn't be seen as a
>>>> match for the compare with unsigned source types.
>>>>
>>>> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
>>>> Cc: Matt Turner <mattst88@gmail.com>
>>>> ---
>>>>  tests/spec/CMakeLists.txt                          |  1 +
>>>>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>>>>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>>>>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>>>>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>>>>  5 files changed, 363 insertions(+)
>>>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>>>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>>>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
>>>>
>>>> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
>>>> index 4df9d331d..28abf3634 100644
>>>> --- a/tests/spec/CMakeLists.txt
>>>> +++ b/tests/spec/CMakeLists.txt
>>>> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>>>>  add_subdirectory (amd_depth_clamp_separate)
>>>>  add_subdirectory (amd_performance_monitor)
>>>>  add_subdirectory (amd_pinned_memory)
>>>> +add_subdirectory (amd_transform_feedback3_lines_triangles)
>>>>  add_subdirectory (arb_arrays_of_arrays)
>>>>  add_subdirectory (arb_base_instance)
>>>>  add_subdirectory (arb_bindless_texture)
>>>> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>> new file mode 100644
>>>> index 000000000..cdac53cdf
>>>> --- /dev/null
>>>> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>> @@ -0,0 +1,85 @@
>>>> +[require]
>>>> +GL >= 3.0
>>>> +GLSL >= 1.30
>>>> +
>>>> +[vertex shader passthrough]
>>>> +
>>>> +[fragment shader]
>>>> +#extension GL_EXT_shader_integer_mix: enable
>>>> +
>>>> +// { A, B, absoluteDifference(A, B) }
>>>> +uniform ivec3 data[40];
>>>> +
>>>> +out vec4 color;
>>>> +
>>>> +uint abs_diff(int a, int b)
>>>> +{
>>>> +    /* This can fail if the compiler replaces the (a < b) with the result of
>>>> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
>>>> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
>>>> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
>>>> +     * differently than for (a < b).
>>>> +     */
>>>> +#ifndef GL_EXT_shader_integer_mix
>>>> +    return (a < b) ? uint(b - a) : uint(a - b);
>>>> +#else
>>>> +    return mix(uint(a - b), uint(b - a), a < b);
>>>> +#endif
>>>
>>> Why bother with this? It'll end up testing different code depending on
>>> the extensions that the driver supports, which seems like a really bad
>>> idea.
>>
>> We only hit the bug in the mix() case because how how we lower flow
>> control to bcsel.  I thought about having it require
>> GL_EXT_shader_integer_mix.  That means that when a driver enabled that
>> extension the test could transition SKIP->FAIL which seems more likely
>> to be ignored than PASS->FAIL.  I guess now there's a possible
>> FAIL->PASS transition.  Meh.
>>
>> I'm not married to it being either way.  I just want to reproduce the
>> bug that I added to the i965 driver a few months ago. :)
> 
> Hmm. Meh indeed. I dunno though -- skip -> fail when enabling an ext
> seems pretty bad to me. I'd just require EXT_shader_integer_mix. In
> practice, it's enabled everywhere GL 3.0 is (in mesa), so it's all a
> bit academic.

Fair enough.  The bikeshedder in me has difficulty deciding where the
tests should live.  It requires extensions beyond GLSL 1.30, so
spec/glsl-1.30 doesn't seem good.  It's not really a
GL_EXT_shader_integer_mix test, so spec/ext_shader_integer_mix doesn't
seem good either. :)

>   -ilia
On Thu, Sep 13, 2018 at 8:26 PM, Ian Romanick <idr@freedesktop.org> wrote:
> On 09/12/2018 09:17 PM, Ilia Mirkin wrote:
>> On Wed, Sep 12, 2018 at 7:59 PM, Ian Romanick <idr@freedesktop.org> wrote:
>>> On 09/12/2018 04:33 PM, Ilia Mirkin wrote:
>>>> On Wed, Sep 12, 2018 at 7:29 PM, Ian Romanick <idr@freedesktop.org> wrote:
>>>>> From: Ian Romanick <ian.d.romanick@intel.com>
>>>>>
>>>>> The optimizer recently added the ability to replace a compare with a
>>>>> subtraction under certain circumstances.  This can fail for integers.
>>>>> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
>>>>> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
>>>>> less than zero, so the flags get set differently than for (a < b).
>>>>>
>>>>> This really only affected the signed comparisons because the subtract
>>>>> would always have a signed source types, so it wouldn't be seen as a
>>>>> match for the compare with unsigned source types.
>>>>>
>>>>> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
>>>>> Cc: Matt Turner <mattst88@gmail.com>
>>>>> ---
>>>>>  tests/spec/CMakeLists.txt                          |  1 +
>>>>>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>>>>>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>>>>>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>>>>>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>>>>>  5 files changed, 363 insertions(+)
>>>>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>>>>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>>>>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
>>>>>
>>>>> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
>>>>> index 4df9d331d..28abf3634 100644
>>>>> --- a/tests/spec/CMakeLists.txt
>>>>> +++ b/tests/spec/CMakeLists.txt
>>>>> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>>>>>  add_subdirectory (amd_depth_clamp_separate)
>>>>>  add_subdirectory (amd_performance_monitor)
>>>>>  add_subdirectory (amd_pinned_memory)
>>>>> +add_subdirectory (amd_transform_feedback3_lines_triangles)

This seems out of place, btw...

>>>>>  add_subdirectory (arb_arrays_of_arrays)
>>>>>  add_subdirectory (arb_base_instance)
>>>>>  add_subdirectory (arb_bindless_texture)
>>>>> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>>> new file mode 100644
>>>>> index 000000000..cdac53cdf
>>>>> --- /dev/null
>>>>> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>>>> @@ -0,0 +1,85 @@
>>>>> +[require]
>>>>> +GL >= 3.0
>>>>> +GLSL >= 1.30
>>>>> +
>>>>> +[vertex shader passthrough]
>>>>> +
>>>>> +[fragment shader]
>>>>> +#extension GL_EXT_shader_integer_mix: enable
>>>>> +
>>>>> +// { A, B, absoluteDifference(A, B) }
>>>>> +uniform ivec3 data[40];
>>>>> +
>>>>> +out vec4 color;
>>>>> +
>>>>> +uint abs_diff(int a, int b)
>>>>> +{
>>>>> +    /* This can fail if the compiler replaces the (a < b) with the result of
>>>>> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
>>>>> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
>>>>> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
>>>>> +     * differently than for (a < b).
>>>>> +     */
>>>>> +#ifndef GL_EXT_shader_integer_mix
>>>>> +    return (a < b) ? uint(b - a) : uint(a - b);
>>>>> +#else
>>>>> +    return mix(uint(a - b), uint(b - a), a < b);
>>>>> +#endif
>>>>
>>>> Why bother with this? It'll end up testing different code depending on
>>>> the extensions that the driver supports, which seems like a really bad
>>>> idea.
>>>
>>> We only hit the bug in the mix() case because how how we lower flow
>>> control to bcsel.  I thought about having it require
>>> GL_EXT_shader_integer_mix.  That means that when a driver enabled that
>>> extension the test could transition SKIP->FAIL which seems more likely
>>> to be ignored than PASS->FAIL.  I guess now there's a possible
>>> FAIL->PASS transition.  Meh.
>>>
>>> I'm not married to it being either way.  I just want to reproduce the
>>> bug that I added to the i965 driver a few months ago. :)
>>
>> Hmm. Meh indeed. I dunno though -- skip -> fail when enabling an ext
>> seems pretty bad to me. I'd just require EXT_shader_integer_mix. In
>> practice, it's enabled everywhere GL 3.0 is (in mesa), so it's all a
>> bit academic.
>
> Fair enough.  The bikeshedder in me has difficulty deciding where the
> tests should live.  It requires extensions beyond GLSL 1.30, so
> spec/glsl-1.30 doesn't seem good.  It's not really a
> GL_EXT_shader_integer_mix test, so spec/ext_shader_integer_mix doesn't
> seem good either. :)

tests/random/ :) That should make your OCD explode... anyways, with
the #ifdef and spurious add_subdirectory removed, this is all

Reviewed-by: Ilia Mirkin <imirkin@alum.mit.edu>

pretty much irrespective of where you put it.
Quoting Ian Romanick (2018-09-12 16:29:55)
> From: Ian Romanick <ian.d.romanick@intel.com>
> 
> The optimizer recently added the ability to replace a compare with a
> subtraction under certain circumstances.  This can fail for integers.
> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
> less than zero, so the flags get set differently than for (a < b).
> 
> This really only affected the signed comparisons because the subtract
> would always have a signed source types, so it wouldn't be seen as a
> match for the compare with unsigned source types.
> 
> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
> Cc: Matt Turner <mattst88@gmail.com>
> ---
>  tests/spec/CMakeLists.txt                          |  1 +
>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>  5 files changed, 363 insertions(+)
>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
> 
> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
> index 4df9d331d..28abf3634 100644
> --- a/tests/spec/CMakeLists.txt
> +++ b/tests/spec/CMakeLists.txt
> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>  add_subdirectory (amd_depth_clamp_separate)
>  add_subdirectory (amd_performance_monitor)
>  add_subdirectory (amd_pinned_memory)
> +add_subdirectory (amd_transform_feedback3_lines_triangles)

This seems like an unrelated change.

>  add_subdirectory (arb_arrays_of_arrays)
>  add_subdirectory (arb_base_instance)
>  add_subdirectory (arb_bindless_texture)
> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
> new file mode 100644
> index 000000000..cdac53cdf
> --- /dev/null
> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
> @@ -0,0 +1,85 @@
> +[require]
> +GL >= 3.0
> +GLSL >= 1.30
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +#extension GL_EXT_shader_integer_mix: enable
> +
> +// { A, B, absoluteDifference(A, B) }
> +uniform ivec3 data[40];
> +
> +out vec4 color;
> +
> +uint abs_diff(int a, int b)
> +{
> +    /* This can fail if the compiler replaces the (a < b) with the result of
> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
> +     * differently than for (a < b).
> +     */
> +#ifndef GL_EXT_shader_integer_mix
> +    return (a < b) ? uint(b - a) : uint(a - b);
> +#else
> +    return mix(uint(a - b), uint(b - a), a < b);
> +#endif
> +}
> +
> +void main()
> +{
> +    uint idx = uint(gl_FragCoord.x) % uint(data.length());
> +    ivec3 v = data[idx];
> +
> +    if (abs_diff(v.x, v.y) == uint(v.z)) {
> +       color = vec4(0.0, 1.0, 0.0, 1.0);
> +    } else {
> +       color = vec4(1.0, 0.0, 0.0, 1.0);
> +    }
> +}
> +
> +[test]
> +uniform ivec3 data[0] 0x80000000 0x80000000 0x00000000
> +uniform ivec3 data[1] 0x80000000 0x80000001 0x00000001
> +uniform ivec3 data[2] 0x80000000 0xf8000000 0x78000000
> +uniform ivec3 data[3] 0x80000000 0xf8000001 0x78000001
> +uniform ivec3 data[4] 0x80000000 0xff800000 0x7f800000
> +uniform ivec3 data[5] 0x80000000 0xff800001 0x7f800001
> +uniform ivec3 data[6] 0x80000000 0xfff80000 0x7ff80000
> +uniform ivec3 data[7] 0x80000000 0xfff80001 0x7ff80001
> +uniform ivec3 data[8] 0x80000000 0xffff8000 0x7fff8000
> +uniform ivec3 data[9] 0x80000000 0xffff8001 0x7fff8001
> +uniform ivec3 data[10] 0x80000000 0xfffff800 0x7ffff800
> +uniform ivec3 data[11] 0x80000000 0xfffff801 0x7ffff801
> +uniform ivec3 data[12] 0x80000000 0xffffff80 0x7fffff80
> +uniform ivec3 data[13] 0x80000000 0xffffff81 0x7fffff81
> +uniform ivec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
> +uniform ivec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
> +uniform ivec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
> +uniform ivec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
> +uniform ivec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
> +uniform ivec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
> +uniform ivec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
> +uniform ivec3 data[21] 0x80000000 0xffffffff 0x7fffffff
> +uniform ivec3 data[22] 0x80000000 0x00000000 0x80000000
> +uniform ivec3 data[23] 0x80000000 0x00000001 0x80000001
> +uniform ivec3 data[24] 0x80000000 0x00000002 0x80000002
> +uniform ivec3 data[25] 0x80000000 0x00000003 0x80000003
> +uniform ivec3 data[26] 0x80000000 0x00000004 0x80000004
> +uniform ivec3 data[27] 0x80000000 0x00000005 0x80000005
> +uniform ivec3 data[28] 0x80000000 0x00000006 0x80000006
> +uniform ivec3 data[29] 0x80000000 0x00000007 0x80000007
> +uniform ivec3 data[30] 0x80000000 0x00000008 0x80000008
> +uniform ivec3 data[31] 0x80000000 0x0000007f 0x8000007f
> +uniform ivec3 data[32] 0x80000000 0x00000080 0x80000080
> +uniform ivec3 data[33] 0x80000000 0x000007ff 0x800007ff
> +uniform ivec3 data[34] 0x80000000 0x00000800 0x80000800
> +uniform ivec3 data[35] 0x80000000 0x00007fff 0x80007fff
> +uniform ivec3 data[36] 0x80000000 0x00008000 0x80008000
> +uniform ivec3 data[37] 0x80000000 0x0007ffff 0x8007ffff
> +uniform ivec3 data[38] 0x80000000 0x00080000 0x80080000
> +uniform ivec3 data[39] 0x80000000 0x007fffff 0x807fffff
> +
> +draw rect -1 -1 2 2
> +probe all rgb 0.0 1.0 0.0
> diff --git a/tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
> new file mode 100644
> index 000000000..541c5c9ad
> --- /dev/null
> +++ b/tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
> @@ -0,0 +1,85 @@
> +[require]
> +GL >= 3.0
> +GLSL >= 1.30
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +#extension GL_EXT_shader_integer_mix: enable
> +
> +// { A, B, absoluteDifference(A, B) }
> +uniform uvec3 data[40];
> +
> +out vec4 color;
> +
> +uint abs_diff(uint a, uint b)
> +{
> +    /* This can fail if the compiler replaces the (a < b) with the result of
> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
> +     * differently than for (a < b).
> +     */
> +#ifndef GL_EXT_shader_integer_mix
> +    return (a < b) ? b - a : a - b;
> +#else
> +    return mix(a - b, b - a, a < b);
> +#endif
> +}
> +
> +void main()
> +{
> +    uint idx = uint(gl_FragCoord.x) % uint(data.length());
> +    uvec3 v = data[idx];
> +
> +    if (abs_diff(v.x, v.y) == uint(v.z)) {
> +       color = vec4(0.0, 1.0, 0.0, 1.0);
> +    } else {
> +       color = vec4(1.0, 0.0, 0.0, 1.0);
> +    }
> +}
> +
> +[test]
> +uniform uvec3 data[0] 0x80000000 0x80000000 0x00000000
> +uniform uvec3 data[1] 0x80000000 0x80000001 0x00000001
> +uniform uvec3 data[2] 0x80000000 0xf8000000 0x78000000
> +uniform uvec3 data[3] 0x80000000 0xf8000001 0x78000001
> +uniform uvec3 data[4] 0x80000000 0xff800000 0x7f800000
> +uniform uvec3 data[5] 0x80000000 0xff800001 0x7f800001
> +uniform uvec3 data[6] 0x80000000 0xfff80000 0x7ff80000
> +uniform uvec3 data[7] 0x80000000 0xfff80001 0x7ff80001
> +uniform uvec3 data[8] 0x80000000 0xffff8000 0x7fff8000
> +uniform uvec3 data[9] 0x80000000 0xffff8001 0x7fff8001
> +uniform uvec3 data[10] 0x80000000 0xfffff800 0x7ffff800
> +uniform uvec3 data[11] 0x80000000 0xfffff801 0x7ffff801
> +uniform uvec3 data[12] 0x80000000 0xffffff80 0x7fffff80
> +uniform uvec3 data[13] 0x80000000 0xffffff81 0x7fffff81
> +uniform uvec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
> +uniform uvec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
> +uniform uvec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
> +uniform uvec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
> +uniform uvec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
> +uniform uvec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
> +uniform uvec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
> +uniform uvec3 data[21] 0x80000000 0xffffffff 0x7fffffff
> +uniform uvec3 data[22] 0x80000000 0x00000000 0x80000000
> +uniform uvec3 data[23] 0x80000000 0x00000001 0x7fffffff
> +uniform uvec3 data[24] 0x80000000 0x00000002 0x7ffffffe
> +uniform uvec3 data[25] 0x80000000 0x00000003 0x7ffffffd
> +uniform uvec3 data[26] 0x80000000 0x00000004 0x7ffffffc
> +uniform uvec3 data[27] 0x80000000 0x00000005 0x7ffffffb
> +uniform uvec3 data[28] 0x80000000 0x00000006 0x7ffffffa
> +uniform uvec3 data[29] 0x80000000 0x00000007 0x7ffffff9
> +uniform uvec3 data[30] 0x80000000 0x00000008 0x7ffffff8
> +uniform uvec3 data[31] 0x80000000 0x0000007f 0x7fffff81
> +uniform uvec3 data[32] 0x80000000 0x00000080 0x7fffff80
> +uniform uvec3 data[33] 0x80000000 0x000007ff 0x7ffff801
> +uniform uvec3 data[34] 0x80000000 0x00000800 0x7ffff800
> +uniform uvec3 data[35] 0x80000000 0x00007fff 0x7fff8001
> +uniform uvec3 data[36] 0x80000000 0x00008000 0x7fff8000
> +uniform uvec3 data[37] 0x80000000 0x0007ffff 0x7ff80001
> +uniform uvec3 data[38] 0x80000000 0x00080000 0x7ff80000
> +uniform uvec3 data[39] 0x80000000 0x007fffff 0x7f800001
> +
> +draw rect -1 -1 2 2
> +probe all rgb 0.0 1.0 0.0
> diff --git a/tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
> new file mode 100644
> index 000000000..5ef0b319a
> --- /dev/null
> +++ b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
> @@ -0,0 +1,96 @@
> +[require]
> +GL >= 3.0
> +GLSL >= 1.30
> +
> +[vertex shader]
> +#extension GL_EXT_shader_integer_mix: enable
> +
> +// { A, B, absoluteDifference(A, B) }
> +uniform ivec3 data[40];
> +
> +in vec4 piglit_vertex;
> +out vec4 color;
> +
> +uint abs_diff(int a, int b)
> +{
> +    /* This can fail if the compiler replaces the (a < b) with the result of
> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
> +     * differently than for (a < b).
> +     */
> +#ifndef GL_EXT_shader_integer_mix
> +    return (a < b) ? uint(b - a) : uint(a - b);
> +#else
> +    return mix(uint(a - b), uint(b - a), a < b);
> +#endif
> +}
> +
> +void main()
> +{
> +    color = vec4(0.0, 1.0, 0.0, 1.0);
> +
> +    for (int i = 0; i < data.length(); i++) {
> +       ivec3 v = data[i];
> +
> +       if (abs_diff(v.x, v.y) != uint(v.z))
> +           color = vec4(1.0, 0.0, 0.0, 1.0);
> +    }
> +
> +    gl_Position = piglit_vertex;
> +}
> +
> +
> +[fragment shader]
> +in vec4 color;
> +out vec4 piglit_fragcolor;
> +
> +void main()
> +{
> +    piglit_fragcolor = color;
> +}
> +
> +[test]
> +uniform ivec3 data[0] 0x80000000 0x80000000 0x00000000
> +uniform ivec3 data[1] 0x80000000 0x80000001 0x00000001
> +uniform ivec3 data[2] 0x80000000 0xf8000000 0x78000000
> +uniform ivec3 data[3] 0x80000000 0xf8000001 0x78000001
> +uniform ivec3 data[4] 0x80000000 0xff800000 0x7f800000
> +uniform ivec3 data[5] 0x80000000 0xff800001 0x7f800001
> +uniform ivec3 data[6] 0x80000000 0xfff80000 0x7ff80000
> +uniform ivec3 data[7] 0x80000000 0xfff80001 0x7ff80001
> +uniform ivec3 data[8] 0x80000000 0xffff8000 0x7fff8000
> +uniform ivec3 data[9] 0x80000000 0xffff8001 0x7fff8001
> +uniform ivec3 data[10] 0x80000000 0xfffff800 0x7ffff800
> +uniform ivec3 data[11] 0x80000000 0xfffff801 0x7ffff801
> +uniform ivec3 data[12] 0x80000000 0xffffff80 0x7fffff80
> +uniform ivec3 data[13] 0x80000000 0xffffff81 0x7fffff81
> +uniform ivec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
> +uniform ivec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
> +uniform ivec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
> +uniform ivec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
> +uniform ivec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
> +uniform ivec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
> +uniform ivec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
> +uniform ivec3 data[21] 0x80000000 0xffffffff 0x7fffffff
> +uniform ivec3 data[22] 0x80000000 0x00000000 0x80000000
> +uniform ivec3 data[23] 0x80000000 0x00000001 0x80000001
> +uniform ivec3 data[24] 0x80000000 0x00000002 0x80000002
> +uniform ivec3 data[25] 0x80000000 0x00000003 0x80000003
> +uniform ivec3 data[26] 0x80000000 0x00000004 0x80000004
> +uniform ivec3 data[27] 0x80000000 0x00000005 0x80000005
> +uniform ivec3 data[28] 0x80000000 0x00000006 0x80000006
> +uniform ivec3 data[29] 0x80000000 0x00000007 0x80000007
> +uniform ivec3 data[30] 0x80000000 0x00000008 0x80000008
> +uniform ivec3 data[31] 0x80000000 0x0000007f 0x8000007f
> +uniform ivec3 data[32] 0x80000000 0x00000080 0x80000080
> +uniform ivec3 data[33] 0x80000000 0x000007ff 0x800007ff
> +uniform ivec3 data[34] 0x80000000 0x00000800 0x80000800
> +uniform ivec3 data[35] 0x80000000 0x00007fff 0x80007fff
> +uniform ivec3 data[36] 0x80000000 0x00008000 0x80008000
> +uniform ivec3 data[37] 0x80000000 0x0007ffff 0x8007ffff
> +uniform ivec3 data[38] 0x80000000 0x00080000 0x80080000
> +uniform ivec3 data[39] 0x80000000 0x007fffff 0x807fffff
> +
> +draw rect -1 -1 2 2
> +probe all rgb 0.0 1.0 0.0
> diff --git a/tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
> new file mode 100644
> index 000000000..b6f5a69fb
> --- /dev/null
> +++ b/tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
> @@ -0,0 +1,96 @@
> +[require]
> +GL >= 3.0
> +GLSL >= 1.30
> +
> +[vertex shader]
> +#extension GL_EXT_shader_integer_mix: enable
> +
> +// { A, B, absoluteDifference(A, B) }
> +uniform uvec3 data[40];
> +
> +in vec4 piglit_vertex;
> +out vec4 color;
> +
> +uint abs_diff(uint a, uint b)
> +{
> +    /* This can fail if the compiler replaces the (a < b) with the result of
> +     * one of the subtractions.  For inputs a = 0x80000000, b = 4,
> +     * int(0x80000000) < 4, but int(0x80000000)-4 overflows and results in
> +     * 0x7ffffffc.  That's not less than zero, so the flags get set
> +     * differently than for (a < b).
> +     */
> +#ifndef GL_EXT_shader_integer_mix
> +    return (a < b) ? b - a : a - b;
> +#else
> +    return mix(a - b, b - a, a < b);
> +#endif
> +}
> +
> +void main()
> +{
> +    color = vec4(0.0, 1.0, 0.0, 1.0);
> +
> +    for (int i = 0; i < data.length(); i++) {
> +       uvec3 v = data[i];
> +
> +       if (abs_diff(v.x, v.y) != uint(v.z))
> +           color = vec4(1.0, 0.0, 0.0, 1.0);
> +    }
> +
> +    gl_Position = piglit_vertex;
> +}
> +
> +
> +[fragment shader]
> +in vec4 color;
> +out vec4 piglit_fragcolor;
> +
> +void main()
> +{
> +    piglit_fragcolor = color;
> +}
> +
> +[test]
> +uniform uvec3 data[0] 0x80000000 0x80000000 0x00000000
> +uniform uvec3 data[1] 0x80000000 0x80000001 0x00000001
> +uniform uvec3 data[2] 0x80000000 0xf8000000 0x78000000
> +uniform uvec3 data[3] 0x80000000 0xf8000001 0x78000001
> +uniform uvec3 data[4] 0x80000000 0xff800000 0x7f800000
> +uniform uvec3 data[5] 0x80000000 0xff800001 0x7f800001
> +uniform uvec3 data[6] 0x80000000 0xfff80000 0x7ff80000
> +uniform uvec3 data[7] 0x80000000 0xfff80001 0x7ff80001
> +uniform uvec3 data[8] 0x80000000 0xffff8000 0x7fff8000
> +uniform uvec3 data[9] 0x80000000 0xffff8001 0x7fff8001
> +uniform uvec3 data[10] 0x80000000 0xfffff800 0x7ffff800
> +uniform uvec3 data[11] 0x80000000 0xfffff801 0x7ffff801
> +uniform uvec3 data[12] 0x80000000 0xffffff80 0x7fffff80
> +uniform uvec3 data[13] 0x80000000 0xffffff81 0x7fffff81
> +uniform uvec3 data[14] 0x80000000 0xfffffff8 0x7ffffff8
> +uniform uvec3 data[15] 0x80000000 0xfffffff9 0x7ffffff9
> +uniform uvec3 data[16] 0x80000000 0xfffffffa 0x7ffffffa
> +uniform uvec3 data[17] 0x80000000 0xfffffffb 0x7ffffffb
> +uniform uvec3 data[18] 0x80000000 0xfffffffc 0x7ffffffc
> +uniform uvec3 data[19] 0x80000000 0xfffffffd 0x7ffffffd
> +uniform uvec3 data[20] 0x80000000 0xfffffffe 0x7ffffffe
> +uniform uvec3 data[21] 0x80000000 0xffffffff 0x7fffffff
> +uniform uvec3 data[22] 0x80000000 0x00000000 0x80000000
> +uniform uvec3 data[23] 0x80000000 0x00000001 0x7fffffff
> +uniform uvec3 data[24] 0x80000000 0x00000002 0x7ffffffe
> +uniform uvec3 data[25] 0x80000000 0x00000003 0x7ffffffd
> +uniform uvec3 data[26] 0x80000000 0x00000004 0x7ffffffc
> +uniform uvec3 data[27] 0x80000000 0x00000005 0x7ffffffb
> +uniform uvec3 data[28] 0x80000000 0x00000006 0x7ffffffa
> +uniform uvec3 data[29] 0x80000000 0x00000007 0x7ffffff9
> +uniform uvec3 data[30] 0x80000000 0x00000008 0x7ffffff8
> +uniform uvec3 data[31] 0x80000000 0x0000007f 0x7fffff81
> +uniform uvec3 data[32] 0x80000000 0x00000080 0x7fffff80
> +uniform uvec3 data[33] 0x80000000 0x000007ff 0x7ffff801
> +uniform uvec3 data[34] 0x80000000 0x00000800 0x7ffff800
> +uniform uvec3 data[35] 0x80000000 0x00007fff 0x7fff8001
> +uniform uvec3 data[36] 0x80000000 0x00008000 0x7fff8000
> +uniform uvec3 data[37] 0x80000000 0x0007ffff 0x7ff80001
> +uniform uvec3 data[38] 0x80000000 0x00080000 0x7ff80000
> +uniform uvec3 data[39] 0x80000000 0x007fffff 0x7f800001
> +
> +draw rect -1 -1 2 2
> +probe all rgb 0.0 1.0 0.0
> -- 
> 2.14.4
> 
> _______________________________________________
> Piglit mailing list
> Piglit@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/piglit
On 09/14/2018 03:16 PM, Dylan Baker wrote:
> Quoting Ian Romanick (2018-09-12 16:29:55)
>> From: Ian Romanick <ian.d.romanick@intel.com>
>>
>> The optimizer recently added the ability to replace a compare with a
>> subtraction under certain circumstances.  This can fail for integers.
>> For inputs a = 0x80000000, b = 4, int(0x80000000) < 4, but
>> int(0x80000000) - 4 overflows and results in 0x7ffffffc.  That's not
>> less than zero, so the flags get set differently than for (a < b).
>>
>> This really only affected the signed comparisons because the subtract
>> would always have a signed source types, so it wouldn't be seen as a
>> match for the compare with unsigned source types.
>>
>> Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
>> Cc: Matt Turner <mattst88@gmail.com>
>> ---
>>  tests/spec/CMakeLists.txt                          |  1 +
>>  .../fs-absoluteDifference-int.shader_test          | 85 +++++++++++++++++++
>>  .../fs-absoluteDifference-uint.shader_test         | 85 +++++++++++++++++++
>>  .../vs-absoluteDifference-int.shader_test          | 96 ++++++++++++++++++++++
>>  .../vs-absoluteDifference-uint.shader_test         | 96 ++++++++++++++++++++++
>>  5 files changed, 363 insertions(+)
>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-int.shader_test
>>  create mode 100644 tests/spec/glsl-1.30/execution/fs-absoluteDifference-uint.shader_test
>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-int.shader_test
>>  create mode 100644 tests/spec/glsl-1.30/execution/vs-absoluteDifference-uint.shader_test
>>
>> diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
>> index 4df9d331d..28abf3634 100644
>> --- a/tests/spec/CMakeLists.txt
>> +++ b/tests/spec/CMakeLists.txt
>> @@ -2,6 +2,7 @@ add_subdirectory (amd_framebuffer_multisample_advanced)
>>  add_subdirectory (amd_depth_clamp_separate)
>>  add_subdirectory (amd_performance_monitor)
>>  add_subdirectory (amd_pinned_memory)
>> +add_subdirectory (amd_transform_feedback3_lines_triangles)
> 
> This seems like an unrelated change.

Yeah, Ilia noticed that too.  I've fixed it locally.