[Piglit] [PATCH 06/25] arb_shader_image_load_store: Import GLSL parser test generator script.
Dylan Baker
baker.dylan.c at gmail.com
Sun Oct 5 16:00:13 PDT 2014
I have a couple of style nits and one request for you if you wouldn't
mind. I don't need to see a v2 since I think these are very simple.
1) Could you put two newlines between toplevel functions, that is our
style. (PEP8 style)
2) Could you put your constant data before your function definitions,
again, that's PEP8
3) could you not put a space between the brace and first character in
lists and dicts, same as above.
4) Could you use the print_function from the __future__ module instead
of the print statement, I've spent a bunch of time converting the rest
of the python code to use the print_function already.
I have a few comments, below, but all of those are just suggestions
Otherwise this looks pretty straight forward and decent.
With those changes, for the python code you have my r-b.
Reviewed-by: Dylan Baker <dylanx.c.baker at intel.com>
On Monday, October 06, 2014 12:00:36 AM Francisco Jerez wrote:
> ---
> generated_tests/CMakeLists.txt | 6 +-
> .../gen_shader_image_load_store_tests.py | 807 +++++++++++++++++++++
> 2 files changed, 812 insertions(+), 1 deletion(-)
> create mode 100644 generated_tests/gen_shader_image_load_store_tests.py
>
> diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
> index 6d27b3e..6f6d528 100644
> --- a/generated_tests/CMakeLists.txt
> +++ b/generated_tests/CMakeLists.txt
> @@ -91,6 +91,9 @@ piglit_make_generated_tests(
> constant_array_size_tests_fp64.list
> gen_constant_array_size_tests_fp64.py
> builtin_function_fp64.py)
> +piglit_make_generated_tests(
> + shader_image_load_store_tests.list
> + gen_shader_image_load_store_tests.py)
>
> # Add a "gen-tests" target that can be used to generate all the
> # tests without doing any other compilation.
> @@ -113,4 +116,5 @@ add_custom_target(gen-tests ALL
> uniform-initializer_tests.list
> interpolation-qualifier-built-in-variable.list
> builtin_uniform_tests_fp64.list
> - constant_array_size_tests_fp64.list)
> + constant_array_size_tests_fp64.list
> + shader_image_load_store_tests.list)
> diff --git a/generated_tests/gen_shader_image_load_store_tests.py b/generated_tests/gen_shader_image_load_store_tests.py
> new file mode 100644
> index 0000000..29992b2
> --- /dev/null
> +++ b/generated_tests/gen_shader_image_load_store_tests.py
> @@ -0,0 +1,807 @@
> +# coding=utf-8
> +#
> +# Copyright (C) 2014 Intel Corporation
> +#
> +# Permission is hereby granted, free of charge, to any person obtaining a
> +# copy of this software and associated documentation files (the "Software"),
> +# to deal in the Software without restriction, including without limitation
> +# the rights to use, copy, modify, merge, publish, distribute, sublicense,
> +# and/or sell copies of the Software, and to permit persons to whom the
> +# Software is furnished to do so, subject to the following conditions:
> +#
> +# The above copyright notice and this permission notice (including the next
> +# paragraph) shall be included in all copies or substantial portions of the
> +# Software.
> +#
> +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> +# IN THE SOFTWARE.
> +
> +import os.path
> +from mako.template import Template
> +from textwrap import dedent
> +
> +def gen_header(status):
> + """
> + Generate a GLSL program header.
> +
> + Generate header code for ARB_shader_image_load_store GLSL parser
> + tests that are expected to give status as result.
> + """
> + return dedent("""\
> + /*
> + * [config]
> + * expect_result: {0}
> + * glsl_version: 1.50
> + * require_extensions: GL_ARB_shader_image_load_store
> + * [end config]
> + */
> + #version 150
> + #extension GL_ARB_shader_image_load_store: require
> + """.format(status))
> +
> +def gen_vector_type(scalar, dim):
> + """
> + Generate a GLSL vector type name.
> +
> + Generate a GLSL vector type based on the given scalar type with the
> + specified number of dimensions.
> + """
> + vector_types = {
> + 'int': 'ivec',
> + 'uint': 'uvec',
> + 'float': 'vec',
> + }
> +
> + return ('{0}{1}'.format(vector_types[scalar], dim) if dim > 1
> + else scalar)
> +
> +def gen_scalar_args(arity):
> + """
> + Generate image builtin scalar arguments.
> +
> + Returns a generator of well-formed scalar arguments for an image
> + built-in of the given arity having t as argument type.
> + """
> + return lambda t: ', {0}(0)'.format(t) * arity
> +
> +def gen_vector_args(arity):
> + """
> + Generate image builtin vector arguments.
> +
> + Returns a generator of well-formed arguments for an image built-in
> + of the given arity having a 4-component vector of t as argument
> + type.
> + """
> + return lambda t: ', {0}(0)'.format(gen_vector_type(t, 4)) * arity
> +
> +def gen_address_args(dim):
> + """
> + Generate image address arguments.
> +
> + Returns a generator for the coordinate argument of an image
> + built-in expecting an address of the given dimensionality. If
> + fail is True the generated argument will have an arbitrary
> + incorrect dimensionality.
> + """
> + return (lambda fail = False: ', {0}(0)'.format(
> + gen_vector_type('int', dim if not fail else dim % 3 + 1)))
> +
> +def gen_address_args_ms(dim):
> + """Generate multisample image address arguments."""
> + return (lambda fail = False:
> + gen_address_args(dim)() + (', 0' if not fail else ''))
> +
> +def product(ps, *qss):
> + """
> + Generate the cartesian product of a number of lists of dictionaries.
> +
> + Each generated element will be the union of some combination of
> + elements from the iterable arguments. The resulting value of each
> + 'name' item will be the concatenation of names of the respective
> + element combination separated with dashes.
> + """
> + for q in (product(*qss) if qss else [{}]):
> + for p in ps:
> + r = dict(p, **q)
> + r['name'] = '-'.join(s['name'] for s in (p, q) if s.get('name'))
> + yield r
Is itertools.product() insufficient for this task?
> +
> +def gen(name, src, tests):
> + """
> + Expand a source template for the provided list of test definitions.
> +
> + Generate a GLSL parser test for each of the elements of the
> + 'tests' iterable, each of them should be a dictionary of
> + definitions that will be used as environment to render the source
> + template.
> +
> + The file name of each test will be the concatenation of the 'name'
> + argument with the 'name' item from the respective test dictionary.
> + """
> + template = Template(dedent(src))
> +
> + for t in product([{ 'name': name }], tests):
> + filename = os.path.join('spec',
> + 'ARB_shader_image_load_store',
> + 'compiler',
> + '{0}.{1}'.format(t['name'],
> + t['shader_stage']))
> + print filename
> +
> + dirname = os.path.dirname(filename)
> + if not os.path.exists(dirname):
> + os.makedirs(dirname)
> +
> + with open(filename, 'w') as f:
> + f.write(template.render(header = gen_header, **t))
> +
> +shader_stages = [
> + { 'shader_stage': 'frag' },
> + { 'shader_stage': 'vert' }
> +]
> +
> +image_atomic_builtins = [
> + {
> + 'name': 'atomic-add',
> + 'image_builtin': 'imageAtomicAdd',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-min',
> + 'image_builtin': 'imageAtomicMin',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-max',
> + 'image_builtin': 'imageAtomicMax',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-and',
> + 'image_builtin': 'imageAtomicAnd',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-or',
> + 'image_builtin': 'imageAtomicOr',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-xor',
> + 'image_builtin': 'imageAtomicXor',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-exchange',
> + 'image_builtin': 'imageAtomicExchange',
> + 'image_args': gen_scalar_args(1)
> + },
> + {
> + 'name': 'atomic-comp-swap',
> + 'image_builtin': 'imageAtomicCompSwap',
> + 'image_args': gen_scalar_args(2)
> + }
> +]
> +
> +image_load_builtin = [
> + {
> + 'name': 'load',
> + 'image_builtin': 'imageLoad',
> + 'image_args': gen_vector_args(0)
> + }
> +]
> +
> +image_store_builtin = [
> + {
> + 'name': 'store',
> + 'image_builtin': 'imageStore',
> + 'image_args': gen_vector_args(1)
> + }
> +]
> +
> +image_types = [
> + {
> + 'name': '1d',
> + 'image_type' : 'image1D',
> + 'image_addr': gen_address_args(1)
> + },
> + {
> + 'name' : '2d',
> + 'image_type' : 'image2D',
> + 'image_addr': gen_address_args(2)
> + },
> + {
> + 'name' : '3d',
> + 'image_type' : 'image3D',
> + 'image_addr': gen_address_args(3)
> + },
> + {
> + 'name' : '2d-rect',
> + 'image_type' : 'image2DRect',
> + 'image_addr': gen_address_args(2)
> + },
> + {
> + 'name' : 'cube',
> + 'image_type' : 'imageCube',
> + 'image_addr': gen_address_args(3)
> + },
> + {
> + 'name' : 'buffer',
> + 'image_type' : 'imageBuffer',
> + 'image_addr': gen_address_args(1)
> + },
> + {
> + 'name' : '1d-array',
> + 'image_type' : 'image1DArray',
> + 'image_addr': gen_address_args(2)
> + },
> + {
> + 'name' : '2d-array',
> + 'image_type' : 'image2DArray',
> + 'image_addr': gen_address_args(3)
> + },
> + {
> + 'name' : 'cube-array',
> + 'image_type' : 'imageCubeArray',
> + 'image_addr': gen_address_args(3)
> + },
> + {
> + 'name' : '2d-ms',
> + 'image_type' : 'image2DMS',
> + 'image_addr': gen_address_args_ms(2)
> + },
> + {
> + 'name' : '2d-ms-array',
> + 'image_type' : 'image2DMSArray',
> + 'image_addr': gen_address_args_ms(3)
> + }
> +]
> +
> +#
> +# Test the preprocessor defines.
> +#
> +gen('preprocessor', """
you might consider using """\ instead of just """ so you don't get a
newline at the start of each test file.
> + ${header('pass')}
> +
> + #if !defined GL_ARB_shader_image_load_store
> + # error GL_ARB_shader_image_load_store is not defined
> + #elif GL_ARB_shader_image_load_store != 1
> + # error GL_ARB_shader_image_load_store is not equal to 1
> + #endif
> +
> + void main()
> + {
> + }
> +""", shader_stages)
> +
> +#
> +# Test the early_fragment_tests layout qualifier.
> +#
> +gen('early-fragment-tests', """
> + ${header('pass' if shader_stage == 'frag' and hunk == 'in' else 'fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Fragment shaders also allow the following layout qualifier on 'in'
> + * only (not with variable declarations):
> + *
> + * layout-qualifier-id
> + * early_fragment_tests"
> + */
> + layout(early_fragment_tests) ${hunk};
> +
> + void main()
> + {
> + }
> +""", product(shader_stages, [
> + { 'name': 'in', 'hunk': 'in' },
> + { 'name': 'out', 'hunk': 'out' },
> + { 'name': 'uniform', 'hunk': 'uniform uint u' },
> + { 'name': 'in-var', 'hunk': 'in float f' },
> + { 'name': 'uniform-buffer', 'hunk': 'uniform b { image2D img; }' }
> +]))
> +
> +#
> +# Test image declarations.
> +#
> +gen('declaration-allowed', """
> + ${header('pass')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "[Images] can only be declared as function parameters or uniform
> + * variables."
> + */
> + layout(rgba32f) uniform ${image_type} img;
> + layout(rgba32ui) uniform u${image_type} uimg;
> + layout(rgba32i) uniform i${image_type} iimg;
> +
> + void f(${image_type} arg,
> + u${image_type} uarg,
> + i${image_type} iarg)
> + {
> + }
> +
> + void main()
> + {
> + }
> +""", product(image_types, shader_stages))
> +
> +gen('declaration-global', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "[Images] can only be declared as function parameters or uniform
> + * variables."
> + */
> + layout(rgba32f) ${qualifier} image2D img;
> +
> + void main()
> + {
> + }
> +""", product(shader_stages, [
> + { 'name': 'const', 'qualifier': 'const' },
> + { 'name': 'in', 'qualifier': 'in' },
> + { 'name': 'out', 'qualifier': 'out' }
> +]))
> +
> +gen('declaration-local', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "[Images] can only be declared as function parameters or uniform
> + * variables."
> + */
> + void main()
> + {
> + layout(rgba32f) image2D img;
> + }
> +""", shader_stages)
> +
> +gen('declaration-uniform-block', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Sets of uniforms, except for samplers and images, can be grouped
> + * into uniform blocks."
> + */
> + uniform b {
> + layout(rgba32f) image2D img;
> + };
> +
> + void main()
> + {
> + }
> +""", shader_stages)
> +
> +gen('declaration-argument', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Images cannot be treated as l-values; hence, they cannot be used
> + * as out or inout function parameters, nor can they be assigned
> + * into."
> + */
> + void f(${qualifier} image2D y)
> + {
> + }
> +
> + void main()
> + {
> + }
> +""", product(shader_stages, [
> + { 'name': 'inout', 'qualifier': 'inout' },
> + { 'name': 'out', 'qualifier': 'out' }
> +]))
> +
> +gen('declaration-initializer', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "[Images] cannot be declared with an initializer in a shader."
> + */
> + layout(rgba32f) uniform image2D img = 0;
> +
> + void main()
> + {
> + }
> +""", shader_stages)
> +
> +gen('declaration-format-qualifier', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "It is an error to declare an image variable where the format
> + * qualifier does not match the image variable type."
> + */
> + layout(${format}) uniform ${prefix}${image_type} img;
> +
> + void main()
> + {
> + }
> +""", product(image_types, shader_stages, [
> + { 'name': 'float',
> + 'format': 'rgba32f',
> + 'prefix': 'i' },
> + { 'name': 'int',
> + 'format': 'rgba32i',
> + 'prefix': 'u' },
> + { 'name': 'uint',
> + 'format': 'rgba32ui',
> + 'prefix': '' },
> +]))
> +
> +gen('declaration-format-qualifier-duplicate', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Only one format qualifier may be specified for any image variable
> + * declaration."
> + */
> + layout(rgba32f) layout(rgba32f) uniform image2D img;
> +
> + void main()
> + {
> + }
> +""", shader_stages)
> +
> +gen('declaration-format-qualifier-missing', """
> + ${header(status)}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Uniforms not qualified with "writeonly" must have a format
> + * layout qualifier."
> + */
> + ${qualifier} uniform image2D img;
> +
> + void main()
> + {
> + }
> +""", product(shader_stages, [
> + { 'name': 'writeonly',
> + 'qualifier': 'writeonly',
> + 'status': 'pass' },
> + { 'name': 'readonly',
> + 'qualifier': 'readonly',
> + 'status': 'fail' },
> + { 'name': 'readwrite',
> + 'qualifier': '',
> + 'status': 'fail' }
> +]))
> +
> +gen('declaration-memory-qualifier-sampler', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Only variables declared as image types [...] can be qualified
> + * with a memory qualifier. "
> + */
> + ${qualifier} uniform sampler2D s;
> +
> + void main()
> + {
> + }
> +""", product(shader_stages, [
> + { 'name': 'readonly', 'qualifier': 'readonly' },
> + { 'name': 'writeonly', 'qualifier': 'writeonly' },
> + { 'name': 'coherent', 'qualifier': 'coherent' },
> + { 'name': 'volatile', 'qualifier': 'volatile' },
> + { 'name': 'restrict', 'qualifier': 'restrict' }
> +]))
> +
> +#
> +# Test expressions involving images.
> +#
> +gen('expression-allowed', """
> + ${header('pass')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Except for array indexing, structure field selection, and
> + * parentheses, images are not allowed to be operands in
> + * expressions."
> + */
> + layout(rgba32f) uniform ${image_type} imgs[2];
> + uniform vec4 y;
> +
> + out vec4 color;
> +
> + void main()
> + {
> + color = y + imageLoad((imgs[1]) ${image_addr()});
> + }
> +""", product(image_types[:1], shader_stages))
> +
> +gen('expression', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Except for array indexing, structure field selection, and
> + * parentheses, images are not allowed to be operands in
> + * expressions."
> + */
> + layout(rgba32f) uniform image2D img;
> +
> + void main()
> + {
> + ${expression};
> + }
> +""", product(shader_stages, [
> + { 'name': 'arithmetic-1', 'expression': '-img' },
> + { 'name': 'arithmetic-2', 'expression': 'img + img' },
> + { 'name': 'arithmetic-3', 'expression': 'img - img' },
> + { 'name': 'arithmetic-4', 'expression': 'img * img' },
> + { 'name': 'arithmetic-5', 'expression': 'img / img' },
> + { 'name': 'arithmetic-6', 'expression': '++img' },
> + { 'name': 'arithmetic-7', 'expression': '--img' },
> + { 'name': 'arithmetic-8', 'expression': 'img++' },
> + { 'name': 'arithmetic-9', 'expression': 'img--' },
> + { 'name': 'assignment-1', 'expression': 'img ^= img' },
> + { 'name': 'assignment-2', 'expression': 'img |= img' },
> + { 'name': 'assignment-3', 'expression': 'img = img' },
> + { 'name': 'assignment-4', 'expression': 'img += img' },
> + { 'name': 'assignment-5', 'expression': 'img -= img' },
> + { 'name': 'assignment-6', 'expression': 'img *= img' },
> + { 'name': 'assignment-7', 'expression': 'img /= img' },
> + { 'name': 'assignment-8', 'expression': 'img %= img' },
> + { 'name': 'assignment-9', 'expression': 'img <<= img' },
> + { 'name': 'assignment-10', 'expression': 'img >>= img' },
> + { 'name': 'assignment-11', 'expression': 'img &= img' },
> + { 'name': 'binary-1', 'expression': '~img' },
> + { 'name': 'binary-2', 'expression': 'img << img' },
> + { 'name': 'binary-3', 'expression': 'img >> img' },
> + { 'name': 'binary-4', 'expression': 'img & img' },
> + { 'name': 'binary-5', 'expression': 'img | img' },
> + { 'name': 'binary-6', 'expression': 'img ^ img' },
> + { 'name': 'conversion-1', 'expression': 'float(img)' },
> + { 'name': 'conversion-2', 'expression': 'uint(img)' },
> + { 'name': 'conversion-3', 'expression': 'bool(img)' },
> + { 'name': 'conversion-4', 'expression': 'image2D(img)' },
> + { 'name': 'field-selection', 'expression': 'img.x' },
> + { 'name': 'function-call', 'expression': 'img()' },
> + { 'name': 'logical-1', 'expression': '!img' },
> + { 'name': 'logical-2', 'expression': 'img && img' },
> + { 'name': 'logical-3', 'expression': 'img || img' },
> + { 'name': 'logical-4', 'expression': 'img ^^ img' },
> + { 'name': 'relational-1', 'expression': 'img == img' },
> + { 'name': 'relational-2', 'expression': 'img != img' },
> + { 'name': 'relational-3', 'expression': 'img < img' },
> + { 'name': 'relational-4', 'expression': 'img > img' },
> + { 'name': 'relational-5', 'expression': 'img <= img' },
> + { 'name': 'relational-6', 'expression': 'img >= img' },
> + { 'name': 'selection', 'expression': 'true ? img : img' },
> + { 'name': 'subscript', 'expression': 'img[0]' }
> +]))
> +
> +#
> +# Test passing of image variables in function calls.
> +#
> +gen('call-argument-qualifiers', """
> + ${header(status)}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "The values of image variables qualified with 'coherent',
> + * 'volatile', 'restrict', 'readonly', or 'writeonly' may not be
> + * passed to functions whose formal parameters lack such
> + * qualifiers. [...] It is legal to have additional qualifiers on a
> + * formal parameter, but not to have fewer."
> + */
> + layout(rgba32f) ${actual_qualifier} uniform image2D x;
> +
> + void f(${formal_qualifier} image2D y)
> + {
> + }
> +
> + void main()
> + {
> + f(x);
> + }
> +""", product(shader_stages, [
> + { 'name': 'allowed-volatile',
> + 'actual_qualifier': 'volatile',
> + 'formal_qualifier': 'volatile coherent',
> + 'status': 'pass' },
> + { 'name': 'allowed-coherent',
> + 'actual_qualifier': 'coherent',
> + 'formal_qualifier': 'volatile coherent',
> + 'status': 'pass' },
> + { 'name': 'allowed-restrict',
> + 'actual_qualifier': 'restrict',
> + 'formal_qualifier': 'volatile restrict',
> + 'status': 'pass' },
> + { 'name': 'allowed-readonly',
> + 'actual_qualifier': 'readonly',
> + 'formal_qualifier': 'restrict readonly',
> + 'status': 'pass' },
> + { 'name': 'allowed-writeonly',
> + 'actual_qualifier': 'writeonly',
> + 'formal_qualifier': 'volatile writeonly',
> + 'status': 'pass' },
> + { 'name': 'disallowed-volatile',
> + 'actual_qualifier': 'volatile',
> + 'formal_qualifier': '',
> + 'status': 'fail' },
> + { 'name': 'disallowed-coherent',
> + 'actual_qualifier': 'coherent',
> + 'formal_qualifier': 'restrict',
> + 'status': 'fail' },
> + { 'name': 'disallowed-restrict',
> + 'actual_qualifier': 'restrict',
> + 'formal_qualifier': '',
> + 'status': 'fail' },
> + { 'name': 'disallowed-readonly',
> + 'actual_qualifier': 'readonly',
> + 'formal_qualifier': 'restrict writeonly',
> + 'status': 'fail' },
> + { 'name': 'disallowed-writeonly',
> + 'actual_qualifier': 'writeonly',
> + 'formal_qualifier': 'volatile readonly',
> + 'status': 'fail' }
> +]))
> +
> +gen('call-argument-type', """
> + ${header('pass' if image_type == 'image2D' else 'fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "As function parameters, images may only be passed to [arguments]
> + * of matching type."
> + */
> + layout(rgba32f) uniform image2D x;
> +
> + void f(${image_type} y)
> + {
> + }
> +
> + void main()
> + {
> + f(x);
> + }
> +""", product(image_types, shader_stages))
> +
> +#
> +# Test the language built-in constants and functions.
> +#
> +gen('builtin-constants', """
> + ${header('pass')}
> + /*
> + * Check that the builtin constants defined by the extension
> + * are present.
> + */
> + out ivec4 color;
> +
> + void main()
> + {
> + color.x = gl_MaxImageUnits +
> + gl_MaxCombinedImageUnitsAndFragmentOutputs +
> + gl_MaxImageSamples +
> + gl_MaxVertexImageUniforms +
> + gl_MaxTessControlImageUniforms +
> + gl_MaxTessEvaluationImageUniforms +
> + gl_MaxGeometryImageUniforms +
> + gl_MaxFragmentImageUniforms +
> + gl_MaxCombinedImageUniforms;
> + }
> +""", shader_stages)
> +
> +gen('builtin-image-argument-mismatch', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "Atomic memory operations are supported on only [...]: an image
> + * variable with signed integer components (iimage*) format qualifier
> + * of 'r32i', or an image variable with unsigned integer components
> + * (uimage*) and format qualifier of 'r32ui'."
> + *
> + * Call an atomic built-in with a floating point image data type.
> + */
> + layout(r32f) uniform ${image_type} img;
> +
> + void main()
> + {
> + ${image_builtin}(img ${image_addr()} ${image_args('float')});
> + }
> +""", product(image_atomic_builtins, image_types[:1], shader_stages))
> +
> +gen('builtin-data-argument-mismatch', """
> + ${header('fail')}
> + /*
> + * Call a signed integer atomic built-in with a mismatching
> + * argument data type.
> + */
> + layout(r32i) uniform i${image_type} img;
> +
> + void main()
> + {
> + ${image_builtin}(img ${image_addr()} ${image_args('uint')});
> + }
> +""", product(image_store_builtin + image_atomic_builtins,
> + image_types[:1], shader_stages))
> +
> +gen('builtin-address-argument-mismatch', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "The 'IMAGE_INFO' placeholder is replaced by one of the following
> + * parameter lists:
> + * gimage1D image, int coord
> + * gimage2D image, ivec2 coord
> + * gimage3D image, ivec3 coord
> + * gimage2DRect image, ivec2 coord
> + * gimageCube image, ivec3 coord
> + * gimageBuffer image, int coord
> + * gimage1DArray image, ivec2 coord
> + * gimage2DArray image, ivec3 coord
> + * gimageCubeArray image, ivec3 coord
> + * gimage2DMS image, ivec2 coord, int sample
> + * gimage2DMSArray image, ivec3 coord, int sample"
> + *
> + * Pass an argument as address coordinate that doesn't match the
> + * dimensionality of the specified image.
> + */
> + layout(r32i) uniform i${image_type} img;
> +
> + void main()
> + {
> + ${image_builtin}(img ${image_addr(fail = True)} ${image_args('int')});
> + }
> +""", product(image_load_builtin + image_store_builtin + image_atomic_builtins,
> + image_types, shader_stages))
> +
> +gen('builtin-qualifier-mismatch-readonly', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "It is an error to pass an image variable qualified with 'readonly'
> + * to imageStore() or other built-in functions that modify image
> + * memory."
> + *
> + * Call a built-in function on a readonly qualified image.
> + */
> + layout(r32i) readonly uniform i${image_type} img;
> +
> + void main()
> + {
> + ${image_builtin}(img ${image_addr()} ${image_args('int')});
> + }
> +""", product(image_store_builtin + image_atomic_builtins,
> + image_types[:1], shader_stages))
> +
> +gen('builtin-qualifier-mismatch-writeonly', """
> + ${header('fail')}
> + /*
> + * From the ARB_shader_image_load_store spec:
> + *
> + * "It is an error to pass an image variable qualified with 'writeonly'
> + * to imageLoad() or other built-in functions that read image
> + * memory."
> + *
> + * Call a built-in function on a writeonly qualified image.
> + */
> + layout(r32i) writeonly uniform i${image_type} img;
> +
> + void main()
> + {
> + ${image_builtin}(img ${image_addr()} ${image_args('int')});
> + }
> +""", product(image_load_builtin + image_atomic_builtins,
> + image_types[:1], shader_stages))
> --
> 2.1.1
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 473 bytes
Desc: This is a digitally signed message part.
URL: <http://lists.freedesktop.org/archives/piglit/attachments/20141005/69e6d2de/attachment-0001.sig>
More information about the Piglit
mailing list