These all have long function call chains, so that some remain intact when Mesas GLSLOptimizeConservatively flag is set. This allows us to exercise the GLSL IR -> NIR path for functions and NIRs function inlining code. --- ...tion-chain16-in-array-indirect.shader_test | 74 +++++++++++++++++++ ...ion-chain16-in-array-indirect2.shader_test | 74 +++++++++++++++++++ ...glsl-function-chain16-in-array.shader_test | 70 ++++++++++++++++++ ...lsl-function-chain16-in-array2.shader_test | 70 ++++++++++++++++++ ...sl-function-chain16-in-swizzle.shader_test | 64 ++++++++++++++++ .../glsl-function-chain16-in.shader_test | 64 ++++++++++++++++ ...function-chain16-inout-swizzle.shader_test | 64 ++++++++++++++++ ...l-function-chain16-out-swizzle.shader_test | 64 ++++++++++++++++ .../glsl-function-chain16-out.shader_test | 64 ++++++++++++++++ 9 files changed, 608 insertions(+) create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect2.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array2.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-swizzle.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-inout-swizzle.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out-swizzle.shader_test create mode 100644 tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out.shader_test
diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect.shader_test new file mode 100644 index 000000000..19dac8bd9 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect.shader_test @@ -0,0 +1,74 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +float f01(in float f[4]); +float f02(in float f[4]); +float f06(in float f[4]); +float f10(in float f[4]); +float f14(in float f[4]); +void main() +{ + float g[4]; + + g[0] = 0.0; + g[1] = 1.0; + g[2] = 0.0; + g[3] = 0.1; + + f01(g); + gl_FragColor = vec4(f01(g), g[0], g[2], g[1]); +} +float f01(in float f[4]) {return f02(f);} +float f05(in float f[4]) {return f06(f);} +float f09(in float f[4]) {return f10(f);} +float f13(in float f[4]) {return f14(f);} + +[fragment shader] +float f03(in float f[4]); +float f07(in float f[4]); +float f11(in float f[4]); +float f15(in float f[4]); +float f02(in float f[4]) {return f03(f);} +float f06(in float f[4]) {return f07(f);} +float f10(in float f[4]) {return f11(f);} +float f14(in float f[4]) {return f15(f);} + +[fragment shader] +float f04(in float f[4]); +float f08(in float f[4]); +float f12(in float f[4]); +float f16(in float f[4]); +float f03(in float f[4]) {return f04(f);} +float f07(in float f[4]) {return f08(f);} +float f11(in float f[4]) {return f12(f);} +float f15(in float f[4]) {return f16(f);} + +[fragment shader] +uniform int i; + +float f05(in float f[4]); +float f09(in float f[4]); +float f13(in float f[4]); +float f04(in float f[4]) {return f05(f);} +float f08(in float f[4]) {return f09(f);} +float f12(in float f[4]) {return f13(f);} +float f16(in float f[4]) {return f[i] + 0.1;} + + +[test] +uniform int i 3 + +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect2.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect2.shader_test new file mode 100644 index 000000000..ea3b20efb --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array-indirect2.shader_test @@ -0,0 +1,74 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +float f01(in float f[4]); +float f02(in float f[4]); +float f06(in float f[4]); +float f10(in float f[4]); +float f14(in float f[4]); +void main() +{ + float g[4]; + + g[0] = 0.0; + g[1] = 1.0; + g[2] = 0.0; + g[3] = 0.1; + + f01(g); + gl_FragColor = vec4(f01(g), g[0], g[2], g[1]); +} +float f01(in float f[4]) {return f02(f);} +float f05(in float f[4]) {return f06(f);} +float f09(in float f[4]) {return f10(f);} +float f13(in float f[4]) {return f14(f);} + +[fragment shader] +float f03(in float f[4]); +float f07(in float f[4]); +float f11(in float f[4]); +float f15(in float f[4]); +float f02(in float f[4]) {return f03(f);} +float f06(in float f[4]) {return f07(f);} +float f10(in float f[4]) {return f11(f);} +float f14(in float f[4]) {return f15(f);} + +[fragment shader] +uniform int i; + +float f04(in float f[4]); +float f08(in float f[4]); +float f12(in float f[4]); +float f16(in float f); +float f03(in float f[4]) {return f04(f);} +float f07(in float f[4]) {return f08(f);} +float f11(in float f[4]) {return f12(f);} +float f15(in float f[4]) {return f16(f[i]);} + +[fragment shader] +float f05(in float f[4]); +float f09(in float f[4]); +float f13(in float f[4]); +float f04(in float f[4]) {return f05(f);} +float f08(in float f[4]) {return f09(f);} +float f12(in float f[4]) {return f13(f);} +float f16(in float f) {return f + 0.1;} + + +[test] +uniform int i 3 + +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array.shader_test new file mode 100644 index 000000000..f3134c878 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array.shader_test @@ -0,0 +1,70 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +float f01(in float f[4]); +float f02(in float f[4]); +float f06(in float f[4]); +float f10(in float f[4]); +float f14(in float f[4]); +void main() +{ + float g[4]; + + g[0] = 0.0; + g[1] = 1.0; + g[2] = 0.0; + g[3] = 0.1; + + f01(g); + gl_FragColor = vec4(f01(g), g[0], g[2], g[1]); +} +float f01(in float f[4]) {return f02(f);} +float f05(in float f[4]) {return f06(f);} +float f09(in float f[4]) {return f10(f);} +float f13(in float f[4]) {return f14(f);} + +[fragment shader] +float f03(in float f[4]); +float f07(in float f[4]); +float f11(in float f[4]); +float f15(in float f[4]); +float f02(in float f[4]) {return f03(f);} +float f06(in float f[4]) {return f07(f);} +float f10(in float f[4]) {return f11(f);} +float f14(in float f[4]) {return f15(f);} + +[fragment shader] +float f04(in float f[4]); +float f08(in float f[4]); +float f12(in float f[4]); +float f16(in float f[4]); +float f03(in float f[4]) {return f04(f);} +float f07(in float f[4]) {return f08(f);} +float f11(in float f[4]) {return f12(f);} +float f15(in float f[4]) {return f16(f);} + +[fragment shader] +float f05(in float f[4]); +float f09(in float f[4]); +float f13(in float f[4]); +float f04(in float f[4]) {return f05(f);} +float f08(in float f[4]) {return f09(f);} +float f12(in float f[4]) {return f13(f);} +float f16(in float f[4]) {return f[3] + 0.1;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array2.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array2.shader_test new file mode 100644 index 000000000..b0d373218 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-array2.shader_test @@ -0,0 +1,70 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +float f01(in float f[4]); +float f02(in float f[4]); +float f06(in float f[4]); +float f10(in float f[4]); +float f14(in float f[4]); +void main() +{ + float g[4]; + + g[0] = 0.0; + g[1] = 1.0; + g[2] = 0.0; + g[3] = 0.1; + + f01(g); + gl_FragColor = vec4(f01(g), g[0], g[2], g[1]); +} +float f01(in float f[4]) {return f02(f);} +float f05(in float f[4]) {return f06(f);} +float f09(in float f[4]) {return f10(f);} +float f13(in float f[4]) {return f14(f);} + +[fragment shader] +float f03(in float f[4]); +float f07(in float f[4]); +float f11(in float f[4]); +float f15(in float f[4]); +float f02(in float f[4]) {return f03(f);} +float f06(in float f[4]) {return f07(f);} +float f10(in float f[4]) {return f11(f);} +float f14(in float f[4]) {return f15(f);} + +[fragment shader] +float f04(in float f[4]); +float f08(in float f[4]); +float f12(in float f[4]); +float f16(in float f); +float f03(in float f[4]) {return f04(f);} +float f07(in float f[4]) {return f08(f);} +float f11(in float f[4]) {return f12(f);} +float f15(in float f[4]) {return f16(f[3]);} + +[fragment shader] +float f05(in float f[4]); +float f09(in float f[4]); +float f13(in float f[4]); +float f04(in float f[4]) {return f05(f);} +float f08(in float f[4]) {return f09(f);} +float f12(in float f[4]) {return f13(f);} +float f16(in float f) {return f + 0.1;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-swizzle.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-swizzle.shader_test new file mode 100644 index 000000000..aa80b4300 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in-swizzle.shader_test @@ -0,0 +1,64 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +float f01(in vec4 f); +float f02(in vec4 f); +float f06(in vec4 f); +float f10(in vec4 f); +float f14(in vec4 f); +void main() +{ + vec4 g = vec4(0, 0.1, 0, 1.0); + f01(g); + gl_FragColor = vec4(f01(g), g.x, g.z, g.w); +} +float f01(in vec4 f) {return f02(f);} +float f05(in vec4 f) {return f06(f);} +float f09(in vec4 f) {return f10(f);} +float f13(in vec4 f) {return f14(f);} + +[fragment shader] +float f03(in vec4 f); +float f07(in vec4 f); +float f11(in vec4 f); +float f15(in vec4 f); +float f02(in vec4 f) {return f03(f);} +float f06(in vec4 f) {return f07(f);} +float f10(in vec4 f) {return f11(f);} +float f14(in vec4 f) {return f15(f);} + +[fragment shader] +float f04(in vec4 f); +float f08(in vec4 f); +float f12(in vec4 f); +float f16(in float f); +float f03(in vec4 f) {return f04(f);} +float f07(in vec4 f) {return f08(f);} +float f11(in vec4 f) {return f12(f);} +float f15(in vec4 f) {return f16(f.y);} + +[fragment shader] +float f05(in vec4 f); +float f09(in vec4 f); +float f13(in vec4 f); +float f04(in vec4 f) {return f05(f);} +float f08(in vec4 f) {return f09(f);} +float f12(in vec4 f) {return f13(f);} +float f16(in float f) {return f + 0.1;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in.shader_test new file mode 100644 index 000000000..73d45ca17 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-in.shader_test @@ -0,0 +1,64 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +float f01(in vec4 f); +float f02(in vec4 f); +float f06(in vec4 f); +float f10(in vec4 f); +float f14(in vec4 f); +void main() +{ + vec4 g = vec4(0, 0.1, 0, 1.0); + f01(g); + gl_FragColor = vec4(f01(g), g.x, g.z, g.w); +} +float f01(in vec4 f) {return f02(f);} +float f05(in vec4 f) {return f06(f);} +float f09(in vec4 f) {return f10(f);} +float f13(in vec4 f) {return f14(f);} + +[fragment shader] +float f03(in vec4 f); +float f07(in vec4 f); +float f11(in vec4 f); +float f15(in vec4 f); +float f02(in vec4 f) {return f03(f);} +float f06(in vec4 f) {return f07(f);} +float f10(in vec4 f) {return f11(f);} +float f14(in vec4 f) {return f15(f);} + +[fragment shader] +float f04(in vec4 f); +float f08(in vec4 f); +float f12(in vec4 f); +float f16(in vec4 f); +float f03(in vec4 f) {return f04(f);} +float f07(in vec4 f) {return f08(f);} +float f11(in vec4 f) {return f12(f);} +float f15(in vec4 f) {return f16(f);} + +[fragment shader] +float f05(in vec4 f); +float f09(in vec4 f); +float f13(in vec4 f); +float f04(in vec4 f) {return f05(f);} +float f08(in vec4 f) {return f09(f);} +float f12(in vec4 f) {return f13(f);} +float f16(in vec4 f) {return f.y + 0.1;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-inout-swizzle.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-inout-swizzle.shader_test new file mode 100644 index 000000000..7bb6fe075 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-inout-swizzle.shader_test @@ -0,0 +1,64 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +void f01(inout vec4 f); +void f02(inout vec4 f); +void f06(inout vec4 f); +void f10(inout vec4 f); +void f14(inout vec4 f); +void main() +{ + vec4 g = vec4(0.1, 0, 0, 1.0); + f01(g); + gl_FragColor = g; +} +void f01(inout vec4 f) {f02(f);} +void f05(inout vec4 f) {f06(f);} +void f09(inout vec4 f) {f10(f);} +void f13(inout vec4 f) {f14(f);} + +[fragment shader] +void f03(inout vec4 f); +void f07(inout vec4 f); +void f11(inout vec4 f); +void f15(inout vec4 f); +void f02(inout vec4 f) {f03(f);} +void f06(inout vec4 f) {f07(f);} +void f10(inout vec4 f) {f11(f);} +void f14(inout vec4 f) {f15(f);} + +[fragment shader] +void f04(inout vec4 f); +void f08(inout vec4 f); +void f12(inout vec4 f); +void f16(inout float f); +void f03(inout vec4 f) {f04(f);} +void f07(inout vec4 f) {f08(f);} +void f11(inout vec4 f) {f12(f);} +void f15(inout vec4 f) {f16(f.x);} + +[fragment shader] +void f05(inout vec4 f); +void f09(inout vec4 f); +void f13(inout vec4 f); +void f04(inout vec4 f) {f05(f);} +void f08(inout vec4 f) {f09(f);} +void f12(inout vec4 f) {f13(f);} +void f16(inout float f) {f+=0.1;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0.2 0 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out-swizzle.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out-swizzle.shader_test new file mode 100644 index 000000000..ef3220f0a --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out-swizzle.shader_test @@ -0,0 +1,64 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +void f01(inout vec4 f); +void f02(inout vec4 f); +void f06(inout vec4 f); +void f10(inout vec4 f); +void f14(inout vec4 f); +void main() +{ + vec4 g = vec4(0.0, 0.3, 0, 1.0); + f01(g); + gl_FragColor = g; +} +void f01(inout vec4 f) {f02(f);} +void f05(inout vec4 f) {f06(f);} +void f09(inout vec4 f) {f10(f);} +void f13(inout vec4 f) {f14(f);} + +[fragment shader] +void f03(inout vec4 f); +void f07(inout vec4 f); +void f11(inout vec4 f); +void f15(inout vec4 f); +void f02(inout vec4 f) {f03(f);} +void f06(inout vec4 f) {f07(f);} +void f10(inout vec4 f) {f11(f);} +void f14(inout vec4 f) {f15(f);} + +[fragment shader] +void f04(inout vec4 f); +void f08(inout vec4 f); +void f12(inout vec4 f); +void f16(inout float f); +void f03(inout vec4 f) {f04(f);} +void f07(inout vec4 f) {f08(f);} +void f11(inout vec4 f) {f12(f);} +void f15(inout vec4 f) {f16(f.y);} + +[fragment shader] +void f05(inout vec4 f); +void f09(inout vec4 f); +void f13(inout vec4 f); +void f04(inout vec4 f) {f05(f);} +void f08(inout vec4 f) {f09(f);} +void f12(inout vec4 f) {f13(f);} +void f16(inout float f) {f=0.2;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0 0.2 0 1.0 diff --git a/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out.shader_test b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out.shader_test new file mode 100644 index 000000000..f60a1fe09 --- /dev/null +++ b/tests/spec/glsl-1.10/execution/function-calls/glsl-function-chain16-out.shader_test @@ -0,0 +1,64 @@ +# This tests we inline functions correctly. Chaining the functions helps +# us reach the GLSL IR -> NIR code with some functions intact when the +# conservative optimise flag is set in Mesa. This allows us to test the +# GLSL IR -> NIR conversion code for functions and the NIR function inlining +# code. +[require] +GLSL >= 1.10 + +[vertex shader] +void main() +{ + gl_Position = gl_Vertex; +} + +[fragment shader] +void f01(inout float f); +void f02(inout float f); +void f06(inout float f); +void f10(inout float f); +void f14(inout float f); +void main() +{ + float g = 0.3; + f01(g); + gl_FragColor = vec4(0.0, g, 0, 1.0); +} +void f01(inout float f) {f02(f);} +void f05(inout float f) {f06(f);} +void f09(inout float f) {f10(f);} +void f13(inout float f) {f14(f);} + +[fragment shader] +void f03(inout float f); +void f07(inout float f); +void f11(inout float f); +void f15(inout float f); +void f02(inout float f) {f03(f);} +void f06(inout float f) {f07(f);} +void f10(inout float f) {f11(f);} +void f14(inout float f) {f15(f);} + +[fragment shader] +void f04(inout float f); +void f08(inout float f); +void f12(inout float f); +void f16(inout float f); +void f03(inout float f) {f04(f);} +void f07(inout float f) {f08(f);} +void f11(inout float f) {f12(f);} +void f15(inout float f) {f16(f);} + +[fragment shader] +void f05(inout float f); +void f09(inout float f); +void f13(inout float f); +void f04(inout float f) {f05(f);} +void f08(inout float f) {f09(f);} +void f12(inout float f) {f13(f);} +void f16(inout float f) {f=0.2;} + + +[test] +draw rect -1 -1 2 2 +probe all rgba 0 0.2 0 1.0 -- 2.17.0 _______________________________________________ Piglit mailing list Piglit@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/piglit