[Piglit] [PATCH] glsl-es: Verify restrictions on global variable initializers
Mark Janes
mark.a.janes at intel.com
Wed Oct 7 14:17:46 PDT 2015
Reviewed-by: Mark Janes <mark.a.janes at intel.com>
Tested-by: Mark Janes <mark.a.janes at intel.com>
Ian Romanick <idr at freedesktop.org> writes:
> From: Ian Romanick <ian.d.romanick at intel.com>
>
> Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
>
> "Declarations of globals without a storage qualifier, or with just
> the const qualifier, may include initializers, in which case they
> will be initialized before the first line of main() is executed.
> Such initializers must be a constant expression."
>
> The GLSL ES 3.00.4 spec has similar language. Desktop GLSL does not
> restrict initializers for global variables. Now it's okay for Matt to
> be irritated.
>
> Signed-off-by: Ian Romanick <ian.d.romanick at intel.com>
> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=92304
> Cc: Tapani Pälli <tapani.palli at intel.com>
> Cc: Mark Janes <mark.a.janes at intel.com>
> Cc: Marta Lofstedt <marta.lofstedt at intel.com>
> ---
> .../global-initializer/from-attribute.vert | 14 +++++++++
> .../compiler/global-initializer/from-constant.frag | 14 +++++++++
> .../compiler/global-initializer/from-constant.vert | 14 +++++++++
> .../compiler/global-initializer/from-global.frag | 14 +++++++++
> .../compiler/global-initializer/from-global.vert | 14 +++++++++
> .../compiler/global-initializer/from-sequence.frag | 14 +++++++++
> .../compiler/global-initializer/from-sequence.vert | 14 +++++++++
> .../compiler/global-initializer/from-uniform.frag | 14 +++++++++
> .../compiler/global-initializer/from-uniform.vert | 14 +++++++++
> .../compiler/global-initializer/from-varying.frag | 14 +++++++++
> .../global-initializer/from-attribute.vert | 26 ++++++++++++++++
> .../compiler/global-initializer/from-constant.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-constant.vert | 26 ++++++++++++++++
> .../compiler/global-initializer/from-global.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-global.vert | 26 ++++++++++++++++
> .../compiler/global-initializer/from-sequence.frag | 31 +++++++++++++++++++
> .../compiler/global-initializer/from-sequence.vert | 29 ++++++++++++++++++
> .../compiler/global-initializer/from-uniform.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-uniform.vert | 26 ++++++++++++++++
> .../compiler/global-initializer/from-varying.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-constant.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-constant.vert | 25 ++++++++++++++++
> .../compiler/global-initializer/from-global.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-global.vert | 25 ++++++++++++++++
> .../compiler/global-initializer/from-in.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-in.vert | 25 ++++++++++++++++
> .../compiler/global-initializer/from-sequence.frag | 35 ++++++++++++++++++++++
> .../compiler/global-initializer/from-sequence.vert | 32 ++++++++++++++++++++
> .../compiler/global-initializer/from-uniform.frag | 28 +++++++++++++++++
> .../compiler/global-initializer/from-uniform.vert | 25 ++++++++++++++++
> 30 files changed, 695 insertions(+)
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-attribute.vert
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-constant.frag
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-constant.vert
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-global.frag
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-global.vert
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.frag
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.vert
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.frag
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.vert
> create mode 100644 tests/spec/glsl-1.10/compiler/global-initializer/from-varying.frag
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-attribute.vert
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.frag
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.vert
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.frag
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.vert
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.frag
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.vert
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.frag
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.vert
> create mode 100644 tests/spec/glsl-es-1.00/compiler/global-initializer/from-varying.frag
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.frag
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.vert
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.frag
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.vert
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.frag
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.vert
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.frag
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.vert
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.frag
> create mode 100644 tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.vert
>
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-attribute.vert b/tests/spec/glsl-1.10/compiler/global-initializer/from-attribute.vert
> new file mode 100644
> index 0000000..dcc8b9a
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-attribute.vert
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +attribute float af;
> +float gf1 = 1.0;
> +float gf2 = af;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, af, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-constant.frag b/tests/spec/glsl-1.10/compiler/global-initializer/from-constant.frag
> new file mode 100644
> index 0000000..65d1df1
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-constant.frag
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = cf;
> +
> +void main()
> +{
> + gl_FragColor = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-constant.vert b/tests/spec/glsl-1.10/compiler/global-initializer/from-constant.vert
> new file mode 100644
> index 0000000..9dbe533
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-constant.vert
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = cf;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-global.frag b/tests/spec/glsl-1.10/compiler/global-initializer/from-global.frag
> new file mode 100644
> index 0000000..e88258f
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-global.frag
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = gf1;
> +
> +void main()
> +{
> + gl_FragColor = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-global.vert b/tests/spec/glsl-1.10/compiler/global-initializer/from-global.vert
> new file mode 100644
> index 0000000..0da7bca
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-global.vert
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = gf1;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.frag b/tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.frag
> new file mode 100644
> index 0000000..61c92ba
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.frag
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = (cf, 3.0);
> +
> +void main()
> +{
> + gl_FragColor = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.vert b/tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.vert
> new file mode 100644
> index 0000000..06c78ee
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-sequence.vert
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = (cf, 3.0);
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.frag b/tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.frag
> new file mode 100644
> index 0000000..5f26d13
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.frag
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +uniform float uf;
> +float gf1 = 1.0;
> +float gf2 = uf;
> +
> +void main()
> +{
> + gl_FragColor = vec4(gf1, gf2, uf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.vert b/tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.vert
> new file mode 100644
> index 0000000..b04b345
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-uniform.vert
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +uniform float uf;
> +float gf1 = 1.0;
> +float gf2 = uf;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, uf, 1.0);
> +}
> diff --git a/tests/spec/glsl-1.10/compiler/global-initializer/from-varying.frag b/tests/spec/glsl-1.10/compiler/global-initializer/from-varying.frag
> new file mode 100644
> index 0000000..e09085b
> --- /dev/null
> +++ b/tests/spec/glsl-1.10/compiler/global-initializer/from-varying.frag
> @@ -0,0 +1,14 @@
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.10
> + * [end config]
> + */
> +
> +varying float af;
> +float gf1 = 1.0;
> +float gf2 = af;
> +
> +void main()
> +{
> + gl_FragColor = vec4(gf1, gf2, af, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-attribute.vert b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-attribute.vert
> new file mode 100644
> index 0000000..3dd34af
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-attribute.vert
> @@ -0,0 +1,26 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +attribute float af;
> +float gf1 = 1.0;
> +float gf2 = af;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, af, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.frag b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.frag
> new file mode 100644
> index 0000000..b1fb3f5
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.frag
> @@ -0,0 +1,28 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = cf;
> +
> +void main()
> +{
> + gl_FragData[0] = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.vert b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.vert
> new file mode 100644
> index 0000000..24acf79
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-constant.vert
> @@ -0,0 +1,26 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = cf;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.frag b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.frag
> new file mode 100644
> index 0000000..deaee94
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.frag
> @@ -0,0 +1,28 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = gf1;
> +
> +void main()
> +{
> + gl_FragData[0] = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.vert b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.vert
> new file mode 100644
> index 0000000..9b90fe9
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-global.vert
> @@ -0,0 +1,26 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = gf1;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.frag b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.frag
> new file mode 100644
> index 0000000..858f766
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.frag
> @@ -0,0 +1,31 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + *
> + * While the sequence operator is specifically disallowed as a constant
> + * expression in GLSL ES 3.0 and later, it is allowed in GLSL ES 1.00.
> + */
> +
> +precision mediump float;
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = (cf, 3.0);
> +
> +void main()
> +{
> + gl_FragData[0] = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.vert b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.vert
> new file mode 100644
> index 0000000..dc41a6b
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-sequence.vert
> @@ -0,0 +1,29 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + *
> + * While the sequence operator is specifically disallowed as a constant
> + * expression in GLSL ES 3.0 and later, it is allowed in GLSL ES 1.00.
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = (cf, 3.0);
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.frag b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.frag
> new file mode 100644
> index 0000000..8f3d7fc
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.frag
> @@ -0,0 +1,28 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +uniform float uf;
> +float gf1 = 1.0;
> +float gf2 = uf;
> +
> +void main()
> +{
> + gl_FragData[0] = vec4(gf1, gf2, uf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.vert b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.vert
> new file mode 100644
> index 0000000..e6d921f
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-uniform.vert
> @@ -0,0 +1,26 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +uniform float uf;
> +float gf1 = 1.0;
> +float gf2 = uf;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, uf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-1.00/compiler/global-initializer/from-varying.frag b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-varying.frag
> new file mode 100644
> index 0000000..d1f4b28
> --- /dev/null
> +++ b/tests/spec/glsl-es-1.00/compiler/global-initializer/from-varying.frag
> @@ -0,0 +1,28 @@
> +#version 100
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 1.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 1.00.17 spec says:
> + *
> + * "Declarations of globals without a storage qualifier, or with just the
> + * const qualifier, may include initializers, in which case they will be
> + * initialized before the first line of main() is executed. Such
> + * initializers must be a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +varying float af;
> +float gf1 = 1.0;
> +float gf2 = af;
> +
> +void main()
> +{
> + gl_FragData[0] = vec4(gf1, gf2, af, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.frag b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.frag
> new file mode 100644
> index 0000000..cc7b3a2
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.frag
> @@ -0,0 +1,28 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = cf;
> +out vec4 fragdata;
> +
> +void main()
> +{
> + fragdata = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.vert b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.vert
> new file mode 100644
> index 0000000..6f887f6
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-constant.vert
> @@ -0,0 +1,25 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: pass
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = cf;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.frag b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.frag
> new file mode 100644
> index 0000000..8c39050
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.frag
> @@ -0,0 +1,28 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = gf1;
> +out vec4 fragdata;
> +
> +void main()
> +{
> + fragdata = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.vert b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.vert
> new file mode 100644
> index 0000000..398abdd
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-global.vert
> @@ -0,0 +1,25 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = gf1;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.frag b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.frag
> new file mode 100644
> index 0000000..f4dff6b
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.frag
> @@ -0,0 +1,28 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +in float af;
> +float gf1 = 1.0;
> +float gf2 = af;
> +out vec4 fragdata;
> +
> +void main()
> +{
> + fragdata = vec4(gf1, gf2, af, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.vert b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.vert
> new file mode 100644
> index 0000000..5348438
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-in.vert
> @@ -0,0 +1,25 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +in float af;
> +float gf1 = 1.0;
> +float gf2 = af;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, af, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.frag b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.frag
> new file mode 100644
> index 0000000..4ea82a1
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.frag
> @@ -0,0 +1,35 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + *
> + * Section 4.3.3 "Constant Expressions" of the OpenGL GLSL ES 3.00.4 spec
> + * says:
> + *
> + * "However, the sequence operator ( , ) and the assignment operators ( =,
> + * +=, ...) are not included in the operators that can create a constant
> + * expression."
> + */
> +
> +precision mediump float;
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = (cf, 3.0);
> +out vec4 fragdata;
> +
> +void main()
> +{
> + fragdata = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.vert b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.vert
> new file mode 100644
> index 0000000..4ff22d9
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-sequence.vert
> @@ -0,0 +1,32 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + *
> + * Section 4.3.3 "Constant Expressions" of the OpenGL GLSL ES 3.00.4 spec
> + * says:
> + *
> + * "However, the sequence operator ( , ) and the assignment operators ( =,
> + * +=, ...) are not included in the operators that can create a constant
> + * expression."
> + */
> +
> +const float cf = 2.0;
> +float gf1 = 1.0;
> +float gf2 = (cf, 3.0);
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, cf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.frag b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.frag
> new file mode 100644
> index 0000000..91d7fd3
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.frag
> @@ -0,0 +1,28 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +precision mediump float;
> +
> +uniform float uf;
> +float gf1 = 1.0;
> +float gf2 = uf;
> +out vec4 fragdata;
> +
> +void main()
> +{
> + fragdata = vec4(gf1, gf2, uf, 1.0);
> +}
> diff --git a/tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.vert b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.vert
> new file mode 100644
> index 0000000..7a6c82d
> --- /dev/null
> +++ b/tests/spec/glsl-es-3.00/compiler/global-initializer/from-uniform.vert
> @@ -0,0 +1,25 @@
> +#version 300 es
> +
> +/* [config]
> + * expect_result: fail
> + * glsl_version: 3.00
> + * [end config]
> + *
> + * Section 4.3 (Storage Qualifiers) of the OpenGL ES 3.00.4 spec says:
> + *
> + * "Initializers may only be used in declarations of globals with no
> + * storage qualifier or with a const qualifier. Such initializers must be
> + * a constant expression."
> + *
> + * This differs from desktop GLSL. A compiler that only has to support GLSL
> + * ES could possibly be some amount smaller due to this restriction.
> + */
> +
> +uniform float uf;
> +float gf1 = 1.0;
> +float gf2 = uf;
> +
> +void main()
> +{
> + gl_Position = vec4(gf1, gf2, uf, 1.0);
> +}
> --
> 2.1.0
More information about the Piglit
mailing list