arb_gpu_shader_int64: generate int64 conversion tests.arb_gpu_shader_int64

This is "ported" from the fp64 conversion generator, it
probably has a lot of stuff left over it shouldn't, but it
does generate the tests I expected to test 64-bit integer
conversions both implicit and explicit.

Signed-off-by: Dave Airlie <airlied@redhat.com>

15 files changed, 784 insertions, 0 deletions

diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
index 0b9048fb1..f50253406 100644
--- a/generated_tests/CMakeLists.txt
+++ b/generated_tests/CMakeLists.txt
@@ -153,6 +153,23 @@ piglit_make_generated_tests(
 	templates/gen_conversion_fp64/shader_base.mako
 	)
 piglit_make_generated_tests(
+	conversion_int64.list
+	gen_conversion_int64.py
+	templates/gen_conversion_int64/base.mako
+	templates/gen_conversion_int64/compiler.frag.mako
+	templates/gen_conversion_int64/compiler.geom.mako
+	templates/gen_conversion_int64/compiler.vert.mako
+	templates/gen_conversion_int64/compiler_base.mako
+	templates/gen_conversion_int64/execution.frag.shader_test.mako
+	templates/gen_conversion_int64/execution.geom.shader_test.mako
+	templates/gen_conversion_int64/execution.vert.shader_test.mako
+	templates/gen_conversion_int64/execution_base.mako
+	templates/gen_conversion_int64/shader.frag.mako
+	templates/gen_conversion_int64/shader.geom.mako
+	templates/gen_conversion_int64/shader.vert.mako
+	templates/gen_conversion_int64/shader_base.mako
+	)
+piglit_make_generated_tests(
 	shader_precision_tests.list
 	gen_shader_precision_tests.py
 	builtin_function.py
@@ -247,6 +264,7 @@ add_custom_target(gen-gl-tests
 			vp-tex.list
 			variable_index_write_tests.list
 			vs_in_fp64.list
+			conversion_int64.list
 )
 
 # Create a custom target for generating OpenCL tests
diff --git a/generated_tests/gen_conversion_int64.py b/generated_tests/gen_conversion_int64.py
new file mode 100644
index 000000000..bbe38e9d9
--- /dev/null
+++ b/generated_tests/gen_conversion_int64.py
@@ -0,0 +1,569 @@
+# coding=utf-8
+#
+# Copyright © 2016 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.
+
+"""Generate int64 types conversion tests."""
+
+from __future__ import print_function, division, absolute_import
+import abc
+import argparse
+import itertools
+import os
+import struct
+
+import numpy as np
+
+from templates import template_dir
+from modules import utils
+
+TEMPLATES = template_dir(os.path.basename(os.path.splitext(__file__)[0]))
+
+# pylint: disable=bad-whitespace,line-too-long,bad-continuation
+DOUBLE_INFS                 = ['0xfff0000000000000', # -inf
+                               '0x7ff0000000000000'] # +inf
+
+DOUBLE_NEG_ZERO             = ['0x8000000000000000'] # Negative underflow (-0.0)
+
+DOUBLE_POS_ZERO             = ['0x0000000000000000'] # Positive underflow (+0.0)
+
+# Double values causing an underflow to zero in any other type
+DOUBLE_DENORMAL_VALUES      = ['0x800fffffffffffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
+                               '0x8000000000000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
+                               '0x0000000000000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
+                               '0x000fffffffffffff'] # Positive maximum denormalized -- Denormalized may be flushed to 0
+
+DOUBLE_NORMAL_VALUES        = ['0x8010000000000000', # Negative minimum normalized
+                               '0x0010000000000000'] # Positive minimum normalized
+
+# Double +/-inf
+DOUBLE_FLOAT_INFS           = ['0xc7effffff0000000', # Negative overflow (-inf)
+                               '0x47effffff0000000'] # Positive overflow (+inf)
+
+DOUBLE_FLOAT_VALUES         = ['0xc7efffffefffffff', # Negative maximum normalized
+                               '0xc170000000000000', # -16777216.0
+                               '0xc014000000000000', # -5.0
+                               '0xbfff25ce60000000', # -1.9467300176620483
+                               '0xb80fffffe0000000', # Negative minimum normalized
+                               '0xb69fffffffffffff', # Negative underflow
+                               '0x369fffffffffffff', # Positive underflow
+                               '0x380fffffe0000000', # Positive minimum normalized
+                               '0x3fff25ce60000000', # +1.9467300176620483
+                               '0x4014000000000000', # +5.0
+                               '0x4170000000000000', # +16777216.0
+                               '0x47efffffefffffff'] # Positive maximum normalized
+
+DOUBLE_UINT_VALUES          = ['0xbfeccccccccccccd', # -0.9
+                               #'0x8010000000000000', # Negative minimum normalized          -- Already checked
+                               #'0x800fffffffffffff', # Negative maximum denormalized        -- Already checked
+                               #'0x8000000000000001', # Negative minimum denormalized        -- Already checked
+                               #'0x8000000000000000', # Negative minimum        (-0)         -- Already checked
+                               #'0x0000000000000000', # Positive minimum        (+0)         -- Already checked
+                               '0x3fff25ce60000000', # +1.9467300176620483
+                               '0x4014000000000000', # +5.0
+                               '0x4170000000000000', # +16777216.0
+                               '0x41dfffffffc00000', # Signed int low frontier (+2147483647)
+                               '0x41e0000000000000', # Signed int up frontier  (+2147483648)
+                               '0x41efffffffe00000'] # Maximum                 (+4294967295)
+
+DOUBLE_INT_VALUES           = ['0xc1e0000000000000', # Minimum          (-2147483648)
+                               '0xc170000000000000', # -16777216.0
+                               '0xc014000000000000', # -5.0
+                               '0xbfff25ce60000000', # -1.9467300176620483
+                               #'0x8000000000000000', # Negative minimum        (-0)         -- Already checked
+                               #'0x0000000000000000', # Minimum                 (+0)         -- Already checked
+                               '0x3fff25ce60000000', # +1.9467300176620483
+                               '0x4014000000000000', # +5.0
+                               '0x4170000000000000', # +16777216.0
+                               '0x41dfffffffc00000'] # Maximum          (+2147483647)
+
+DOUBLE_BOOL_VALUES          = [#'0x8010000000000000', # Minimum negative True value -- Already checked
+                               #'0x0000000000000000', # False                       -- Already checked
+                               #'0x0010000000000000', # Minimum positive True value -- Already checked
+                              ]
+
+FLOAT_INFS                  = ['0xff800000', # -inf
+                               '0x7f800000'] # +inf
+
+FLOAT_NEG_ZERO              = ['0x80000000'] # Negative underflow (-0.0)
+
+FLOAT_POS_ZERO              = ['0x00000000'] # Positive underflow (+0.0)
+
+FLOAT_NEG_VALUES            = ['0xcb800000', # -16777216.0
+                               '0xc0a00000', # -5.0
+                               '0xbff92e73', # -1.9467300176620483
+                               '0x80800000'] # Negative minimum normalized
+
+FLOAT_POS_VALUES             = [#'0x807fffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
+                               #'0x80000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
+                               #'0x00000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
+                               #'0x007fffff', # Positive maximum denormalized -- Denormalized may be flushed to 0
+                               '0x00800000', # Positive minimum normalized
+                               '0x3ff92e73', # +1.9467300176620483
+                               '0x40a00000', # +5.0
+                               '0x4b800000'] # +16777216.0
+
+UINT_VALUES                 = ['0', # Minimum
+                               '5',
+                               '2147483647', # Signed int low frontier
+                               '2147483648', # Signed int up frontier
+                               '4294967295'] # Maximum
+
+INT_VALUES                  = ['-2147483648', # Minimum
+                               '-5',
+                               '-1',
+                               '0',
+                               '1',
+                               '5',
+                               '2147483647'] # Maximum
+
+UINT64_VALUES               = ['0', # Minimum
+                               '5',
+                               '18446744073709551615'] # Maximum
+
+INT64_VALUES               = ['-9223372036854775806',# Minimum
+                              '-5',
+                              '0'
+                              '5',
+                              '9223372036854775807'] # Maximum
+
+BOOL_VALUES                 = ['0', # False
+                               '1'] # True
+# pylint: enable=bad-whitespace,line-too-long,bad-continuation
+
+def get_dir_name(ver, test_type):
+    """Returns the directory name to save tests given a GLSL version and a
+       test type.
+    """
+
+    assert isinstance(ver, str)
+    assert isinstance(test_type, str)
+    if ver.startswith('GL_'):
+        feature_dir = ver[3:].lower()
+    else:
+        feature_dir = 'glsl-{}.{}'.format(ver[0], ver[1:])
+
+    return os.path.join('spec', feature_dir, test_type,
+                        'conversion')
+
+
+class TestTuple(object):
+    """A float64 derived and other type derived tuple to generate the
+       needed conversion tests.
+    """
+
+    @staticmethod
+    def float_to_hex(fvalue):
+        """Returns the hexadecimal representation from a float32 value."""
+        assert isinstance(fvalue, np.float32)
+        return hex(struct.unpack('<I', struct.pack('<f', fvalue))[0])
+
+    @staticmethod
+    def double_to_hex(fvalue):
+        """Returns the hexadecimal representation from a float64 value."""
+        assert isinstance(fvalue, float)
+        return hex(struct.unpack('<Q', struct.pack('<d', fvalue))[0]).rstrip("L")
+
+    @staticmethod
+    def hex_to_float(hstr):
+        """Returns a float32 value from its hexadecimal representation."""
+        assert isinstance(hstr, str)
+        return struct.unpack('<f', struct.pack('<I', int(hstr, 16)))[0]
+
+    @staticmethod
+    def hex_to_double(hstr):
+        """Returns a float64 value from its hexadecimal representation."""
+        assert isinstance(hstr, str)
+        return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0]
+
+    @staticmethod
+    def hex_to_int64(hstr):
+        """Returns a 64-bit integer value from its hexadecimal representation."""
+
+        assert isinstance(hstr, str)
+        return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0]
+
+    @staticmethod
+    def float_hex_to_int64(hstr):
+        """Returns the float64 hexadecimal representation from a float32
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        double_value = TestTuple.hex_to_float(hstr)
+        return str(int(double_value))
+
+    @staticmethod
+    def float_hex_to_uint64(hstr):
+        """Returns the float64 hexadecimal representation from a float32
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        double_value = TestTuple.hex_to_float(hstr)
+        int_value = int(double_value) & 0xfffffffffffffff
+        return struct.unpack('<Q', struct.pack('<q', int_value))[0]
+
+    @staticmethod
+    def double_hex_to_int64(hstr):
+        """Returns the float64 hexadecimal representation from a float32
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        double_value = TestTuple.hex_to_double(hstr)
+        return str(int(double_value))
+
+    @staticmethod
+    def double_hex_to_uint64(hstr):
+        """Returns the float64 hexadecimal representation from a float32
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        double_value = TestTuple.hex_to_double(hstr)
+        int_value = int(double_value) & 0xfffffffffffffff
+        return struct.unpack('<Q', struct.pack('<q', int_value))[0]
+
+    @staticmethod
+    def int_str_to_int64_str(istr):
+        """Returns a int64 string from an int32 string."""
+        assert isinstance(istr, str)
+        return str((istr))
+
+    @staticmethod
+    def int64_to_bool_str(hstr):
+        """Returns a bool string from a int64."""
+        assert isinstance(hstr, str)
+        return '1' if int(hstr) != 0 else '0'
+
+    @staticmethod
+    def int64_to_int_str(int64_val):
+        """Returns an int32 string from a float64 hexadecimal
+           representation.
+        """
+        return struct.unpack('<i', struct.pack('<L', int(int64_val) & 0xffffffff))[0]
+
+    @staticmethod
+    def int64_to_uint_str(int64_val):
+        """Returns an uint32 string from a float64 hexadecimal
+           representation.
+        """
+        return struct.unpack('<i', struct.pack('<L', int(int64_val) & 0xffffffff))[0]
+
+    @staticmethod
+    def int64_to_float_str(hstr):
+        """Returns the float32 hexadecimal representation from a float64
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        float_double = np.float32(hstr);
+        return TestTuple.float_to_hex(float_double)
+
+    @staticmethod
+    def int64_to_double_str(hstr):
+        """Returns the float64 hexadecimal representation from a int64
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        float_double = np.float64(hstr);
+        return TestTuple.double_to_hex(float_double)
+
+    def __init__(self, ver, stage,
+                 first_dimension, second_dimension,
+                 basic_type, output_type, names_only):
+        assert stage in ('vert', 'geom', 'frag')
+        assert first_dimension in ('1', '2', '3', '4')
+        assert second_dimension in ('1', '2', '3', '4')
+        assert isinstance(names_only, bool)
+
+        self._ver = ver
+        self._stage = stage
+        self._basic_type = basic_type
+        self._names_only = names_only
+        self._output_type = output_type
+        self._conversion_type = ''
+        self._uniform_type = ''
+        self._amount = int(first_dimension) * int(second_dimension)
+        self._filenames = []
+
+        if first_dimension != '1':
+            dimensional_type = 'mat' + first_dimension
+            if first_dimension != second_dimension:
+                dimensional_type += 'x' + second_dimension
+        elif second_dimension != '1':
+            dimensional_type = 'vec' + second_dimension
+        else:
+            dimensional_type = ''
+
+        if dimensional_type == '':
+            if basic_type == 'b':
+                self._conversion_type = 'bool'
+                self._uniform_type = 'int'
+            elif basic_type == 'i':
+                self._conversion_type = 'int'
+            elif basic_type == 'u':
+                self._conversion_type = 'uint'
+            elif basic_type == 'f':
+                self._conversion_type = 'float'
+            elif basic_type == 'd':
+                self._conversion_type = 'double'
+
+            if output_type == 'u64':
+                self._bit64_type = 'uint64_t'
+            elif output_type == 'i64':
+                self._bit64_type = 'int64_t'
+            if self._uniform_type == '':
+                self._uniform_type = self._conversion_type
+        else:
+            self._conversion_type = (basic_type if basic_type != 'f' else '') + dimensional_type
+            if basic_type == 'b':
+                self._uniform_type = 'i' + dimensional_type
+            else:
+                self._uniform_type = self._conversion_type
+            if output_type == 'u64':
+                self._bit64_type = 'u64' + dimensional_type
+            elif output_type == 'i64':
+                self._bit64_type = 'i64' + dimensional_type
+
+    @abc.abstractmethod
+    def _gen_to_bit64(self):
+        """Generates the test files for conversions to 64-bit integer."""
+
+    @abc.abstractmethod
+    def _gen_from_bit64(self):
+        """Generates the test files for conversions from 64-bit integers."""
+
+    @property
+    def filenames(self):
+        """Returns the test file names this tuple will generate."""
+        if self._filenames == []:
+            tmp = self._names_only
+            self._names_only = True
+            self.generate_test_files()
+            self._names_only = tmp
+        return self._filenames
+
+    def generate_test_files(self):
+        """Generate the GLSL parser tests."""
+        self._filenames = []
+
+        self._gen_to_bit64()
+        self._gen_from_bit64()
+
+
+class RegularTestTuple(TestTuple):
+    """Derived class for conversion tests using regular values within the
+       edges of the used types.
+    """
+
+    @staticmethod
+    def all_tests(names_only):
+        """Returns all the possible contained conversion test instances."""
+
+        assert isinstance(names_only, bool)
+        stages = ['frag'] #, 'geom', 'frag']
+        dimensions = ['1', '2', '3', '4']
+        basic_types = ['b', 'u', 'i', 'f', 'd']
+        glsl_ver = ['GL_ARB_gpu_shader_int64']
+        output_types = ['i64', 'u64']
+
+        if not names_only:
+            test_types = ['compiler', 'execution']
+            for ver, test_type in itertools.product(glsl_ver, test_types):
+                utils.safe_makedirs(get_dir_name(ver, test_type))
+
+        for ver, stage, second_dimension, basic_type, output_type in itertools.product(
+                glsl_ver,
+                stages,
+                dimensions,
+                basic_types, output_types):
+            first_dimension = '1'
+            if not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f')):
+                yield RegularTestTuple(ver, stage,
+                                       first_dimension, second_dimension,
+                                       basic_type, output_type, names_only)
+
+    def __init__(self, ver, stage,
+                 first_dimension, second_dimension,
+                 basic_type, output_type, names_only):
+        assert ver in ('GL_ARB_gpu_shader_int64')
+        assert basic_type in ('b', 'u', 'i', 'f', 'd')
+        assert not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f'))
+        assert output_type in ('i64', 'u64')
+        super(RegularTestTuple, self).__init__(ver, stage,
+                                               first_dimension, second_dimension,
+                                               basic_type, output_type, names_only)
+
+    def _gen_comp_test(self, from_type, to_type, converted_from):
+        filename = os.path.join(
+            get_dir_name(self._ver, 'compiler'),
+            '{}-conversion-implicit-{}-{}-bad.{}'.format(self._stage, from_type, to_type,
+                                                         self._stage))
+
+        self._filenames.append(filename)
+
+        if not self._names_only:
+            with open(filename, 'w') as test_file:
+                test_file.write(TEMPLATES.get_template(
+                    'compiler.{}.mako'.format(self._stage)).render_unicode(
+                        ver=self._ver,
+                        from_type=from_type,
+                        to_type=to_type,
+                        converted_from=converted_from))
+
+    def _gen_exec_test(self, from_type, to_type,
+                       uniform_from_type, uniform_to_type,
+                       explicit, converted_from, conversions):
+        filename = os.path.join(
+            get_dir_name(self._ver, 'execution'),
+            '{}-conversion-{}-{}-{}.shader_test'.format(self._stage, explicit,
+                                                        from_type, to_type))
+
+        self._filenames.append(filename)
+
+        if not self._names_only:
+            with open(filename, 'w') as test_file:
+                test_file.write(TEMPLATES.get_template(
+                    'execution.{}.shader_test.mako'.format(self._stage)).render_unicode(
+                        ver=self._ver,
+                        amount=self._amount,
+                        from_type=from_type,
+                        to_type=to_type,
+                        converted_from=converted_from,
+                        uniform_from_type=uniform_from_type,
+                        uniform_to_type=uniform_to_type,
+                        conversions=conversions))
+
+    def _gen_to_bit64(self):
+        converted_from = 'from'
+        explicit = 'implicit'
+
+        if self._basic_type == 'b':
+            explicit = 'explicit'
+            self._gen_comp_test(self._conversion_type, self._bit64_type,
+                                converted_from)
+            converted_from = self._bit64_type + '(from)'
+            conversion_values = BOOL_VALUES
+            conversion_function = TestTuple.int_str_to_int64_str
+        elif self._basic_type == 'i':
+            conversion_values = INT_VALUES
+            conversion_function = TestTuple.int_str_to_int64_str
+        elif self._basic_type == 'u':
+            if self._output_type == 'i64':
+                explicit = 'explicit'
+                self._gen_comp_test(self._conversion_type, self._bit64_type,
+                                    converted_from)
+                converted_from = self._bit64_type + '(from)'
+            conversion_values = UINT_VALUES
+            conversion_function = TestTuple.int_str_to_int64_str
+        elif self._basic_type == 'f':
+            explicit = 'explicit'
+            self._gen_comp_test(self._conversion_type, self._bit64_type,
+                                converted_from)
+            converted_from = self._bit64_type + '(from)'
+            if self._output_type == 'i64':
+                conversion_values = FLOAT_POS_ZERO + FLOAT_NEG_ZERO + FLOAT_POS_VALUES + FLOAT_NEG_VALUES
+                conversion_function = TestTuple.float_hex_to_int64
+            elif self._output_type == 'u64':
+                conversion_values = FLOAT_POS_ZERO + FLOAT_POS_VALUES
+                conversion_function = TestTuple.float_hex_to_uint64
+        elif self._basic_type == 'd':
+            explicit = 'explicit'
+            self._gen_comp_test(self._conversion_type, self._bit64_type,
+                                converted_from)
+            converted_from = self._bit64_type + '(from)'
+            if self._output_type == 'i64':
+                conversion_values = DOUBLE_INT_VALUES
+                conversion_function = TestTuple.double_hex_to_int64
+            else:
+                conversion_values = DOUBLE_UINT_VALUES
+                conversion_function = TestTuple.double_hex_to_uint64
+
+
+        conversions = []
+        for value in conversion_values:
+            to_value = conversion_function(value)
+            item = {'from': value, 'to': to_value}
+            conversions.append(item)
+
+        self._gen_exec_test(self._conversion_type, self._bit64_type,
+                            self._uniform_type, self._bit64_type,
+                            explicit, converted_from, conversions)
+
+    def _gen_from_bit64(self):
+        converted_from = 'from'
+        explicit = 'implicit'
+
+        if self._basic_type != 'd':
+            explicit = 'explicit'
+            self._gen_comp_test(self._bit64_type, self._conversion_type,
+                                converted_from)
+
+        converted_from = self._conversion_type + '(from)'
+
+        if self._output_type == 'u64':
+            conversion_values = UINT64_VALUES
+        elif self._output_type == 'i64':
+            conversion_values = INT64_VALUES
+
+        if self._basic_type == 'b':
+            conversion_function = TestTuple.int64_to_bool_str
+        elif self._basic_type == 'i':
+            conversion_function = TestTuple.int64_to_int_str
+        elif self._basic_type == 'u':
+            conversion_function = TestTuple.int64_to_uint_str
+        elif self._basic_type == 'f':
+            conversion_function = TestTuple.int64_to_float_str
+        elif self._basic_type == 'd':
+            conversion_function = TestTuple.int64_to_double_str
+
+        conversions = []
+        for value in conversion_values:
+            to_value = conversion_function(value)
+            item = {'from': value, 'to': to_value}
+            conversions.append(item)
+
+        self._gen_exec_test(self._bit64_type, self._conversion_type,
+                            self._bit64_type, self._uniform_type,
+                            explicit, converted_from, conversions)
+
+
+def main():
+    """Main function."""
+
+    parser = argparse.ArgumentParser(
+        description="Generate shader tests that check the conversions from and "
+        "to int64")
+    parser.add_argument(
+        '--names-only',
+        dest='names_only',
+        action='store_true',
+        default=False,
+        help="Don't output files, just generate a list of filenames to stdout")
+    args = parser.parse_args()
+
+    np.seterr(divide='ignore')
+
+    for test in (list(RegularTestTuple.all_tests(args.names_only))):
+        test.generate_test_files()
+        for filename in test.filenames:
+            print(filename)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/generated_tests/templates/gen_conversion_int64/base.mako b/generated_tests/templates/gen_conversion_int64/base.mako
new file mode 100644
index 000000000..2d9162ee3
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/base.mako
@@ -0,0 +1,12 @@
+## coding=utf-8
+<%def name="versioning()"><%
+    if ver == 'GL_ARB_gpu_shader_int64':
+        glsl_version_int = '400'
+    else:
+        glsl_version_int = ver
+
+    glsl_version = '{}.{}'.format(glsl_version_int[0], glsl_version_int[1:3])
+
+    return (glsl_version, glsl_version_int)
+%></%def>\
+${next.body()}\
diff --git a/generated_tests/templates/gen_conversion_int64/compiler.frag.mako b/generated_tests/templates/gen_conversion_int64/compiler.frag.mako
new file mode 100644
index 000000000..2ae22df92
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/compiler.frag.mako
@@ -0,0 +1,3 @@
+## coding=utf-8
+<%inherit file="compiler_base.mako"/>\
+<%include file="shader.frag.mako"/>\
diff --git a/generated_tests/templates/gen_conversion_int64/compiler.geom.mako b/generated_tests/templates/gen_conversion_int64/compiler.geom.mako
new file mode 100644
index 000000000..1e2e340fb
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/compiler.geom.mako
@@ -0,0 +1,3 @@
+## coding=utf-8
+<%inherit file="compiler_base.mako"/>\
+<%include file="shader.geom.mako"/>\
diff --git a/generated_tests/templates/gen_conversion_int64/compiler.vert.mako b/generated_tests/templates/gen_conversion_int64/compiler.vert.mako
new file mode 100644
index 000000000..d9148f14c
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/compiler.vert.mako
@@ -0,0 +1,3 @@
+## coding=utf-8
+<%inherit file="compiler_base.mako"/>\
+<%include file="shader.vert.mako"/>\
diff --git a/generated_tests/templates/gen_conversion_int64/compiler_base.mako b/generated_tests/templates/gen_conversion_int64/compiler_base.mako
new file mode 100644
index 000000000..6eb9a9203
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/compiler_base.mako
@@ -0,0 +1,25 @@
+## coding=utf-8
+<%inherit file="base.mako"/>\
+<%
+    (glsl_version, glsl_version_int) = self.versioning()
+%>\
+/* [config]
+ * expect_result: fail
+ * glsl_version: ${glsl_version}
+% if ver == 'GL_ARB_gpu_shader_int64':
+ * require_extensions: ${ver}
+ * [end config]
+ *
+ * ${ver} spec states:
+ *
+ *     "No implicit conversions are
+ *      provided to convert from unsigned to signed integer types, from
+ *      floating-point to integer types, or from higher-precision to
+ *      lower-precision types.  There are no implicit array or structure
+ *      conversions."
+% else:
+ * [end config]
+% endif
+ */
+
+${next.body()}\
diff --git a/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako
new file mode 100644
index 000000000..60507eed3
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako
@@ -0,0 +1,7 @@
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader passthrough]
+
+[fragment shader]
+<%include file="shader.frag.mako"/>
diff --git a/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako
new file mode 100644
index 000000000..a4d41a611
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako
@@ -0,0 +1,27 @@
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader]
+#version 400
+
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+	vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+<%include file="shader.geom.mako"/>
+[fragment shader]
+#version 400
+
+in vec4 fs_color;
+out vec4 color;
+
+void main()
+{
+	color = fs_color;
+}
+
diff --git a/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako
new file mode 100644
index 000000000..08657c4d0
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako
@@ -0,0 +1,16 @@
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader]
+<%include file="shader.vert.mako"/>
+[fragment shader]
+#version 400
+
+in vec4 fs_color;
+out vec4 color;
+
+void main()
+{
+	color = fs_color;
+}
+
diff --git a/generated_tests/templates/gen_conversion_int64/execution_base.mako b/generated_tests/templates/gen_conversion_int64/execution_base.mako
new file mode 100644
index 000000000..f6ea2e341
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/execution_base.mako
@@ -0,0 +1,31 @@
+## coding=utf-8
+<%inherit file="base.mako"/>\
+<%
+    (glsl_version, glsl_version_int) = self.versioning()
+%>\
+<%! from six.moves import range %>\
+[require]
+GLSL >= ${glsl_version}
+% if ver == 'GL_ARB_gpu_shader_int64':
+${ver}
+% endif
+${next.body()}\
+[test]
+clear color 0.0 0.0 0.0 0.0
+
+% for conversion in conversions:
+clear
+uniform ${uniform_from_type} from \
+% for i in range(amount):
+${conversion['from']} \
+% endfor
+
+uniform ${uniform_to_type} to \
+% for i in range(amount):
+${conversion['to']} \
+% endfor
+
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
+
+% endfor
diff --git a/generated_tests/templates/gen_conversion_int64/shader.frag.mako b/generated_tests/templates/gen_conversion_int64/shader.frag.mako
new file mode 100644
index 000000000..7a8b07c4e
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/shader.frag.mako
@@ -0,0 +1,16 @@
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+out vec4 color;
+
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+	${to_type} converted = ${converted_from};
+	bool match = converted == to;
+	color = match ? GREEN : RED;
+}
diff --git a/generated_tests/templates/gen_conversion_int64/shader.geom.mako b/generated_tests/templates/gen_conversion_int64/shader.geom.mako
new file mode 100644
index 000000000..bf6406587
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/shader.geom.mako
@@ -0,0 +1,25 @@
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+in vec4 vertex_to_gs[3];
+out vec4 fs_color;
+
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+	${to_type} converted = ${converted_from};
+	bool match = converted == to;
+	fs_color = match ? GREEN : RED;
+
+	for (int i = 0; i < 3; i++) {
+		gl_Position = vertex_to_gs[i];
+		EmitVertex();
+	}
+}
diff --git a/generated_tests/templates/gen_conversion_int64/shader.vert.mako b/generated_tests/templates/gen_conversion_int64/shader.vert.mako
new file mode 100644
index 000000000..2f3553d87
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/shader.vert.mako
@@ -0,0 +1,18 @@
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+in vec4 piglit_vertex;
+out vec4 fs_color;
+
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+	gl_Position = piglit_vertex;
+	${to_type} converted = ${converted_from};
+	bool match = converted == to;
+	fs_color = match ? GREEN : RED;
+}
diff --git a/generated_tests/templates/gen_conversion_int64/shader_base.mako b/generated_tests/templates/gen_conversion_int64/shader_base.mako
new file mode 100644
index 000000000..64ad98541
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_int64/shader_base.mako
@@ -0,0 +1,11 @@
+## coding=utf-8
+<%inherit file="base.mako"/>\
+<%
+    (glsl_version, glsl_version_int) = self.versioning()
+%>\
+#version ${glsl_version_int}
+% if ver == 'GL_ARB_gpu_shader_int64':
+#extension GL_ARB_gpu_shader_int64 : require
+% endif
+
+${next.body()}\