From c1b11ac516e2ea0ec0e8a942868239ad09064661 Mon Sep 17 00:00:00 2001 From: Wanming Lin Date: Thu, 19 Dec 2019 11:22:51 +0800 Subject: [PATCH 1/2] [test] Add spec tests for integer min/max ops Tests are pulled from https://github.com/WAVM/WAVM/pull/242 --- test/core/simd/meta/README.md | 5 +- test/core/simd/meta/gen_tests.py | 2 + test/core/simd/meta/simd.py | 17 +- test/core/simd/meta/simd_integer_op.py | 65 +++ test/core/simd/meta/simd_lane_value.py | 32 ++ test/core/simd/meta/simd_lanewise_integer.py | 400 +++++++++++++++++++ test/core/simd/simd_i16x8.wast | 387 ++++++++++++++++++ test/core/simd/simd_i32x4.wast | 397 ++++++++++++++++++ test/core/simd/simd_i8x16.wast | 387 ++++++++++++++++++ 9 files changed, 1683 insertions(+), 9 deletions(-) create mode 100644 test/core/simd/meta/simd_integer_op.py create mode 100644 test/core/simd/meta/simd_lane_value.py create mode 100644 test/core/simd/meta/simd_lanewise_integer.py create mode 100644 test/core/simd/simd_i16x8.wast create mode 100644 test/core/simd/simd_i32x4.wast create mode 100644 test/core/simd/simd_i8x16.wast diff --git a/test/core/simd/meta/README.md b/test/core/simd/meta/README.md index cb0344874..f50efa78a 100644 --- a/test/core/simd/meta/README.md +++ b/test/core/simd/meta/README.md @@ -19,6 +19,9 @@ Currently it only support following simd test files generation. - 'simd_i16x8_sat_arith.wast' - 'simd_f32x4.wast' - 'simd_f64x2.wast' +- 'simd_i8x16.wast' +- 'simd_i16x8.wast' +- 'simd_i32x4.wast' Usage: @@ -27,4 +30,4 @@ Usage: $ python gen_tests.py -a ``` -More details documented in `gen_tests.py`. +This script requires Python 3.6+, more details are documented in `gen_tests.py`. diff --git a/test/core/simd/meta/gen_tests.py b/test/core/simd/meta/gen_tests.py index 04018ea7a..b80da39f5 100644 --- a/test/core/simd/meta/gen_tests.py +++ b/test/core/simd/meta/gen_tests.py @@ -2,6 +2,7 @@ """ This script is used for generating WebAssembly SIMD test cases. +It requires Python 3.6+. """ import sys import argparse @@ -24,6 +25,7 @@ 'simd_bitwise', 'simd_f32x4', 'simd_f64x2', + 'simd_lanewise_integer', ) diff --git a/test/core/simd/meta/simd.py b/test/core/simd/meta/simd.py index 991ad8994..99ba46d57 100644 --- a/test/core/simd/meta/simd.py +++ b/test/core/simd/meta/simd.py @@ -6,7 +6,7 @@ """ -class SIMD(object): +class SIMD: # Constant template CONST = '({value_type}.const {value})' @@ -14,25 +14,26 @@ class SIMD(object): # v128 Constant template V128_CONST = '(v128.const {lane_type} {value})' - def const(self, value, value_type): + @staticmethod + def const(value, value_type): """ generation constant data, [e.g. i32, i64, f32, f64] Params: value: constant data, string or list, lane_type: lane type, [i32, i64, f32, f64] """ - return self.CONST.format(value_type=value_type, value=''.join(value)) + return SIMD.CONST.format(value_type=value_type, value=''.join(value)) - def v128_const(self, value, lane_type): + @staticmethod + def v128_const(value, lane_type): """ generation v128 constant data, [e.g. i8x16, i16x8, i32x4, f32x4] Params: value: constant data, string or list, lane_type: lane type, [e.g. i8x16, i16x8, i32x4, f32x4] """ - if lane_type.lower().find('x') == -1: - return self.const(value, lane_type) + return SIMD.const(value, lane_type) lane_cnt = int(lane_type[1:].split('x')[1]) @@ -47,7 +48,7 @@ def v128_const(self, value, lane_type): # If it is an empty list, generate all constant data with 0x00 if len(value) == 0: - return self.v128_const('0x00', lane_type) + return SIMD.v128_const('0x00', lane_type) data_elem = [] @@ -80,4 +81,4 @@ def v128_const(self, value, lane_type): data_elem = ' '.join(data_elem) # Returns v128 constant text - return self.V128_CONST.format(lane_type=lane_type, value=data_elem) \ No newline at end of file + return SIMD.V128_CONST.format(lane_type=lane_type, value=data_elem) \ No newline at end of file diff --git a/test/core/simd/meta/simd_integer_op.py b/test/core/simd/meta/simd_integer_op.py new file mode 100644 index 000000000..e891c0e1d --- /dev/null +++ b/test/core/simd/meta/simd_integer_op.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 + +"""Common integer value operations""" + +from simd_lane_value import LaneValue + +class IntegerSimpleOp: + """Common integer simple ops: + min_s, min_u, max_s, max_u + """ + + @staticmethod + def binary_op(op: str, p1: str, p2: str, lane_width: int) -> str: + """Binary operation on p1 and p2 with the operation specified by op + + :param op: min_s, min_u, max_s, max_u + :param p1: integer value in hex + :param p2: integer value in hex + :lane_width: bit number of each lane in SIMD v128 + :return: + """ + if '0x' in p1: + base1 = 16 + else: + base1 = 10 + v1 = int(p1, base1) + + if '0x' in p2: + base2 = 16 + else: + base2 = 10 + v2 = int(p2, base2) + + if op in ['min_s', 'max_s']: + i1 = IntegerSimpleOp.get_valid_value(v1, lane_width) + i2 = IntegerSimpleOp.get_valid_value(v2, lane_width) + if op == 'min_s': + return p1 if i1 <= i2 else p2 + else: + return p1 if i1 >= i2 else p2 + + elif op in ['min_u', 'max_u']: + lane = LaneValue(lane_width) + i1 = v1 & lane.mask + i2 = v2 & lane.mask + + if op == 'min_u': + return p1 if i1 <= i2 else p2 + else: + return p1 if i1 >= i2 else p2 + + else: + raise Exception('Unknown binary operation') + + @staticmethod + def get_valid_value(value, lane_width): + """Get the valid integer value of value in the specified lane size. + """ + lane = LaneValue(lane_width) + value &= lane.mask + if value > lane.max: + return value - lane.mod + if value < lane.min: + return value + lane.mod + return value \ No newline at end of file diff --git a/test/core/simd/meta/simd_lane_value.py b/test/core/simd/meta/simd_lane_value.py new file mode 100644 index 000000000..fad246e04 --- /dev/null +++ b/test/core/simd/meta/simd_lane_value.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 + + +class LaneValue: + """This class stands for the value of signed integer represented by a lane in v128. + Suppose a bit number of the lane is n, then: + For signed integer: + minimum = -pow(2, n - 1), maximum = pow(2, n - 1) - 1 + The bit number of the lane can be 8, 16, 32, 64""" + def __init__(self, lane_width): + """lane_width: bit number of each lane in SIMD v128""" + self.lane_width = lane_width + + @property + def min(self): + return -pow(2, self.lane_width - 1) + + @property + def max(self): + return pow(2, self.lane_width - 1) - 1 + + @property + def mask(self): + return pow(2, self.lane_width) - 1 + + @property + def mod(self): + return pow(2, self.lane_width) + + @property + def quarter(self): + return pow(2, self.lane_width - 2) \ No newline at end of file diff --git a/test/core/simd/meta/simd_lanewise_integer.py b/test/core/simd/meta/simd_lanewise_integer.py new file mode 100644 index 000000000..078f0d902 --- /dev/null +++ b/test/core/simd/meta/simd_lanewise_integer.py @@ -0,0 +1,400 @@ +#!/usr/bin/env python3 + +""" +Generate [min_s, min_u, max_s, max_u] cases for i32x4, i16x8 and i8x16. +""" + +from simd import SIMD +from test_assert import AssertReturn +from simd_lane_value import LaneValue +from simd_integer_op import IntegerSimpleOp as IntOp + + +class SimdLaneWiseInteger: + LANE_TYPE = None + + LANE_VALUE = None + + BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u',) + + class_summary = """;; Tests for {lane_type} [min_s, min_u, max_s, max_u] operations.""" + + def __init__(self): + + self.LANE_VALUE = LaneValue(self.lane_width) + + @property + def lane_count(self): + """count of lanes""" + return int(self.LANE_TYPE.split('x')[1]) + + @property + def lane_width(self): + """width of a single lane""" + return int(self.LANE_TYPE.replace('i', '').split('x')[0]) + + @property + def get_test_data_with_const(self): + """test const vs const and param vs const""" + case_data = [ + [ + [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask], + [self.LANE_VALUE.mask, self.LANE_VALUE.quarter, self.LANE_VALUE.max, self.LANE_VALUE.min] + ], + [ + [0, 1, 2, 3], + [3, 2, 1, 0], + ] + ] + case_data = [[list(map(str, param_1)), list(map(str, param_2))] for param_1, param_2 in case_data] + + return case_data + + @property + def get_test_data_go_through_if(self): + """test different lanes go through different if-then clauses""" + case_data = [ + [ + [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask], + [self.LANE_VALUE.mask, self.LANE_VALUE.quarter, self.LANE_VALUE.max, self.LANE_VALUE.min] + ], + [ + [0, 1, 2, 128], + [0, 2, 1, 0x80], + ] + ] + case_data = [[list(map(str, param_1)), list(map(str, param_2))] for param_1, param_2 in case_data] + + return case_data + + @property + def get_test_data_opposite_sign_zero(self): + """test opposite signs of zero""" + case_data = [ + [ + ['-0', '-0', '+0', '+0'], + ['+0', '0', '-0', '0'], + ], + [ + ['-0', '-0', '-0', '-0'], + ['+0', '+0', '+0', '+0'], + ] + ] + + return case_data + + @property + def get_test_data(self): + """case data""" + + case_data = [ + + [ + ['0'] * self.lane_count, + ['0'] * self.lane_count, + ], + [ + ['0'] * self.lane_count, + ['-1'] * self.lane_count, + ], + [ + ['0', '0', '-1', '-1'], + ['0', '-1', '0', '-1'], + ], + [ + ['0'] * self.lane_count, + [hex(self.LANE_VALUE.mask)] * self.lane_count, + ], + + [ + ['1'] * self.lane_count, + ['1'] * self.lane_count, + ], + [ + [str(self.LANE_VALUE.mask)] * self.lane_count, + ['1'] * self.lane_count, + ], + [ + [str(self.LANE_VALUE.mask)] * self.lane_count, + ['128'] * self.lane_count, + ], + [ + [str(-self.LANE_VALUE.min)] * self.lane_count, + [str(self.LANE_VALUE.min)] * self.lane_count, + ], + [ + [hex(-self.LANE_VALUE.min)] * self.lane_count, + [str(self.LANE_VALUE.min)] * self.lane_count, + ], + [ + ['123'] * self.lane_count, + ['01_2_3'] * self.lane_count, + ], + [ + ['0x80'] * self.lane_count, + ['0x0_8_0'] * self.lane_count, + ], + + ] + + return case_data + + @property + def gen_funcs_normal(self): + """generate normal functions""" + binary_func_template = '\n (func (export "{lane_type}.{op}") (param v128 v128) (result v128) ({lane_type}.{op} (local.get 0) (local.get 1)))' + funcs = '' + for op in self.BINARY_OPS: + funcs += binary_func_template.format(lane_type=self.LANE_TYPE, op=op) + + return funcs + + @property + def gen_funcs_with_const(self): + """generate functions with const arguments""" + func_with_const = '\n (func (export "{lane_type}.{op}_with_const_{cnt}") (result v128) ({lane_type}.{op} {param_1} {param_2}))' + func_with_param_and_const = '\n (func (export "{lane_type}.{op}_with_const_{cnt}") (param v128) (result v128) ({lane_type}.{op} (local.get 0) {param_1}))' + funcs = '' + cnt = 0 + for op in self.BINARY_OPS: + for param_1, param_2 in self.get_test_data_with_const: + funcs += func_with_const.format(lane_type=self.LANE_TYPE, + op=op, + param_1=SIMD.v128_const(param_1, self.LANE_TYPE), + param_2=SIMD.v128_const(param_2, self.LANE_TYPE), + cnt=cnt) + cnt += 1 + + for op in self.BINARY_OPS: + for param_1, param_2 in self.get_test_data_with_const: + funcs += func_with_param_and_const.format(lane_type=self.LANE_TYPE, + op=op, + param_1=SIMD.v128_const(param_1, self.LANE_TYPE), + cnt=cnt) + cnt += 1 + + return funcs + + @property + def gen_test_case_with_const(self): + """generate tests calling function with const""" + cnt = 0 + cases = '\n\n;; Const vs const' + for op in self.BINARY_OPS: + for param_1, param_2 in self.get_test_data_with_const: + result = [] + for idx in range(0, len(param_1)): + result.append(IntOp.binary_op(op, param_1[idx], param_2[idx], self.lane_width)) + cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt), + [], + SIMD.v128_const(result, self.LANE_TYPE))) + cnt += 1 + + cases += '\n\n;; Param vs const' + for op in self.BINARY_OPS: + for param_1, param_2 in self.get_test_data_with_const: + result = [] + for idx in range(0, len(param_1)): + result.append(IntOp.binary_op(op, param_1[idx], param_2[idx], self.lane_width)) + cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt), + [SIMD.v128_const(param_2, self.LANE_TYPE)], + SIMD.v128_const(result, self.LANE_TYPE))) + cnt += 1 + + return cases + + @property + def gen_test_case(self): + """generate test cases""" + cases = '' + + def gen(case_data): + cases = '' + for op in self.BINARY_OPS: + for param_1, param_2 in case_data: + result = [] + for idx in range(0, len(param_1)): + result.append(IntOp.binary_op(op, param_1[idx], param_2[idx], self.lane_width)) + cases += '\n' + str(AssertReturn('{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op), + [SIMD.v128_const(param_1, self.LANE_TYPE), SIMD.v128_const(param_2, self.LANE_TYPE)], + SIMD.v128_const(result, self.LANE_TYPE))) + return cases + + cases += gen(self.get_test_data) + + cases += self.gen_test_case_with_const + + # test different lanes go through different if-then clauses + cases += '\n\n;; Test different lanes go through different if-then clauses' + cases += gen(self.get_test_data_go_through_if) + + # test opposite signs of zero + cases += '\n\n;; Test opposite signs of zero' + cases += gen(self.get_test_data_opposite_sign_zero) + + # unknown operators test cases + cases += self.gen_test_case_unknown_operators + + # type check test cases + cases += self.gen_test_case_type_check + + # empty argument test cases + cases += self.gen_test_case_empty_argument + + return cases + + @property + def gen_test_case_unknown_operators(self): + """generate unknown operators test cases""" + + if self.LANE_TYPE != 'i32x4': + return '' + + cases = '\n\n;; Unknown operators' + lane_types = ('f32x4', 'i64x2',) + assert_template = '(assert_malformed (module quote "(memory 1) (func (result v128) ({lane_type}.{op} {param_1} {param_2}))") "unknown operator")' + for lane_type in lane_types: + for op in self.BINARY_OPS: + cases += '\n' + assert_template.format(lane_type=lane_type, + op=op, + param_1=SIMD.v128_const('0', self.LANE_TYPE), + param_2=SIMD.v128_const('1', self.LANE_TYPE)) + + return cases + + @property + def gen_test_case_type_check(self): + """generate type check test cases""" + cases = '\n\n;; Type check' + assert_template = '(assert_invalid (module (func (result v128) ({lane_type}.{op} (i32.const 0) (f32.const 0.0)))) "type mismatch")' + for op in self.BINARY_OPS: + cases += '\n' + assert_template.format(lane_type=self.LANE_TYPE, op=op) + + return cases + + @property + def gen_funcs_combination(self): + """generate functions for combination test cases""" + funcs = '\n\n;; Combination' + funcs += '\n(module' + + assert_template = ' (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128 v128) (result v128)' \ + ' ({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1))(local.get 2))' \ + ')' + + binary_ops = list(self.BINARY_OPS) + binary_ops.reverse() + for op1 in self.BINARY_OPS: + for op2 in binary_ops: + funcs += '\n' + assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2) + + funcs += '\n)' + return funcs + + @property + def gen_test_case_combination(self): + """generate combination test cases""" + + cases = '\n' + + binary_ops = list(self.BINARY_OPS) + binary_ops.reverse() + for op1 in self.BINARY_OPS: + for op2 in binary_ops: + + result = [] + ret = IntOp.binary_op(op2, '0', '1', self.lane_width) + ret = IntOp.binary_op(op1, ret, '2', self.lane_width) + result.append(ret) + + cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2), + [SIMD.v128_const('0', self.LANE_TYPE), + SIMD.v128_const('1', self.LANE_TYPE), + SIMD.v128_const('2', self.LANE_TYPE)], + SIMD.v128_const(result, self.LANE_TYPE))) + cases += '\n' + return cases + + @property + def gen_test_case_empty_argument(self): + """generate empty argument test cases""" + + assert_1st_empyt_template = '(assert_invalid' \ + '\n (module' \ + '\n (func ${lane_type}.{op}-1st-arg-empty (result v128)' \ + '\n ({lane_type}.{op} {param_1})' \ + '\n )' \ + '\n )' \ + '\n "type mismatch"' \ + '\n)' + assert_all_empty_template = '(assert_invalid' \ + '\n (module' \ + '\n (func ${lane_type}.{op}-all-args-empty (result v128)' \ + '\n ({lane_type}.{op})' \ + '\n )' \ + '\n )' \ + '\n "type mismatch"' \ + '\n)' + + cases = '' + + cases += '\n\n;; Test operation with empty argument\n' + for op in self.BINARY_OPS: + cases += assert_1st_empyt_template.format(lane_type=self.LANE_TYPE, op=op, param_1=SIMD.v128_const('0', self.LANE_TYPE)) + cases += assert_all_empty_template.format(lane_type=self.LANE_TYPE, op=op) + + return cases + + @property + def gen_funcs(self): + """generate functions""" + funcs = '' + funcs += '\n\n(module' + funcs += self.gen_funcs_normal + funcs += self.gen_funcs_with_const + funcs += '\n)\n' + + return funcs + + def get_all_cases(self): + """generate all test cases""" + cases = self.class_summary.format(lane_type=self.LANE_TYPE) \ + + self.gen_funcs \ + + self.gen_test_case \ + + self.gen_funcs_combination \ + + self.gen_test_case_combination + + return cases + + def gen_test_cases(self): + """generate case file""" + wast_filename = '../simd_{lane_type}.wast'.format(lane_type=self.LANE_TYPE) + with open(wast_filename, 'w') as fp: + fp.write(self.get_all_cases()) + + +class Simdi32x4Case(SimdLaneWiseInteger): + LANE_TYPE = 'i32x4' + + +class Simdi16x8Case(SimdLaneWiseInteger): + LANE_TYPE = 'i16x8' + + +class Simdi8x16Case(SimdLaneWiseInteger): + LANE_TYPE = 'i8x16' + + +def gen_test_cases(): + simd_i32x4_case = Simdi32x4Case() + simd_i32x4_case.gen_test_cases() + + simd_i16x8_case = Simdi16x8Case() + simd_i16x8_case.gen_test_cases() + + simd_i8x16_case = Simdi8x16Case() + simd_i8x16_case.gen_test_cases() + + +if __name__ == '__main__': + gen_test_cases() \ No newline at end of file diff --git a/test/core/simd/simd_i16x8.wast b/test/core/simd/simd_i16x8.wast new file mode 100644 index 000000000..4d57c977d --- /dev/null +++ b/test/core/simd/simd_i16x8.wast @@ -0,0 +1,387 @@ +;; Tests for i16x8 [min_s, min_u, max_s, max_u] operations. + +(module + (func (export "i16x8.min_s") (param v128 v128) (result v128) (i16x8.min_s (local.get 0) (local.get 1))) + (func (export "i16x8.min_u") (param v128 v128) (result v128) (i16x8.min_u (local.get 0) (local.get 1))) + (func (export "i16x8.max_s") (param v128 v128) (result v128) (i16x8.max_s (local.get 0) (local.get 1))) + (func (export "i16x8.max_u") (param v128 v128) (result v128) (i16x8.max_u (local.get 0) (local.get 1))) + (func (export "i16x8.min_s_with_const_0") (result v128) (i16x8.min_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.min_s_with_const_1") (result v128) (i16x8.min_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.min_u_with_const_2") (result v128) (i16x8.min_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.min_u_with_const_3") (result v128) (i16x8.min_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.max_s_with_const_4") (result v128) (i16x8.max_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.max_s_with_const_5") (result v128) (i16x8.max_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.max_u_with_const_6") (result v128) (i16x8.max_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.max_u_with_const_7") (result v128) (i16x8.max_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.min_s_with_const_8") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.min_s_with_const_9") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.min_u_with_const_10") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.min_u_with_const_11") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.max_s_with_const_12") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.max_s_with_const_13") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.max_u_with_const_14") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.max_u_with_const_15") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) +) + +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 -1 -1)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 -1 -1)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + +;; Const vs const +(assert_return (invoke "i16x8.min_s_with_const_0") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_s_with_const_1") (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.min_u_with_const_2") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_u_with_const_3") (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.max_s_with_const_4") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_s_with_const_5") (v128.const i16x8 3 3 2 2 2 2 3 3)) +(assert_return (invoke "i16x8.max_u_with_const_6") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_u_with_const_7") (v128.const i16x8 3 3 2 2 2 2 3 3)) + +;; Param vs const +(assert_return (invoke "i16x8.min_s_with_const_8" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_s_with_const_9" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.min_u_with_const_10" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_u_with_const_11" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.max_s_with_const_12" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_s_with_const_13" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 3 3 2 2 2 2 3 3)) +(assert_return (invoke "i16x8.max_u_with_const_14" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_u_with_const_15" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 3 3 2 2 2 2 3 3)) + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 1 1 1 1 128 128)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 1 1 1 1 128 128)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 2 2 2 2 128 128)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 2 2 2 2 128 128)) + +;; Test opposite signs of zero +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) + +;; Type check +(assert_invalid (module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument +(assert_invalid + (module + (func $i16x8.min_s-1st-arg-empty (result v128) + (i16x8.min_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.min_s-all-args-empty (result v128) + (i16x8.min_s) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.min_u-1st-arg-empty (result v128) + (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.min_u-all-args-empty (result v128) + (i16x8.min_u) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.max_s-1st-arg-empty (result v128) + (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.max_s-all-args-empty (result v128) + (i16x8.max_s) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.max_u-1st-arg-empty (result v128) + (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i16x8.max_u-all-args-empty (result v128) + (i16x8.max_u) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) +) + +(assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) \ No newline at end of file diff --git a/test/core/simd/simd_i32x4.wast b/test/core/simd/simd_i32x4.wast new file mode 100644 index 000000000..07db6d225 --- /dev/null +++ b/test/core/simd/simd_i32x4.wast @@ -0,0 +1,397 @@ +;; Tests for i32x4 [min_s, min_u, max_s, max_u] operations. + +(module + (func (export "i32x4.min_s") (param v128 v128) (result v128) (i32x4.min_s (local.get 0) (local.get 1))) + (func (export "i32x4.min_u") (param v128 v128) (result v128) (i32x4.min_u (local.get 0) (local.get 1))) + (func (export "i32x4.max_s") (param v128 v128) (result v128) (i32x4.max_s (local.get 0) (local.get 1))) + (func (export "i32x4.max_u") (param v128 v128) (result v128) (i32x4.max_u (local.get 0) (local.get 1))) + (func (export "i32x4.min_s_with_const_0") (result v128) (i32x4.min_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.min_s_with_const_1") (result v128) (i32x4.min_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.min_u_with_const_2") (result v128) (i32x4.min_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.min_u_with_const_3") (result v128) (i32x4.min_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.max_s_with_const_4") (result v128) (i32x4.max_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.max_s_with_const_5") (result v128) (i32x4.max_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.max_u_with_const_6") (result v128) (i32x4.max_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.max_u_with_const_7") (result v128) (i32x4.max_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.min_s_with_const_8") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.min_s_with_const_9") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 0 1 2 3))) + (func (export "i32x4.min_u_with_const_10") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.min_u_with_const_11") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 0 1 2 3))) + (func (export "i32x4.max_s_with_const_12") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.max_s_with_const_13") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 0 1 2 3))) + (func (export "i32x4.max_u_with_const_14") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.max_u_with_const_15") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 0 1 2 3))) +) + +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 128 128 128 128)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 128 128 128 128)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) + +;; Const vs const +(assert_return (invoke "i32x4.min_s_with_const_0") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_s_with_const_1") (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.min_u_with_const_2") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_u_with_const_3") (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.max_s_with_const_4") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_s_with_const_5") (v128.const i32x4 3 2 2 3)) +(assert_return (invoke "i32x4.max_u_with_const_6") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_u_with_const_7") (v128.const i32x4 3 2 2 3)) + +;; Param vs const +(assert_return (invoke "i32x4.min_s_with_const_8" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_s_with_const_9" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.min_u_with_const_10" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_u_with_const_11" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.max_s_with_const_12" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_s_with_const_13" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 3 2 2 3)) +(assert_return (invoke "i32x4.max_u_with_const_14" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_u_with_const_15" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 3 2 2 3)) + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 1 1 128)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 1 1 128)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 2 2 128)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 2 2 128)) + +;; Test opposite signs of zero +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) + +;; Unknown operators +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") + +;; Type check +(assert_invalid (module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument +(assert_invalid + (module + (func $i32x4.min_s-1st-arg-empty (result v128) + (i32x4.min_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.min_s-all-args-empty (result v128) + (i32x4.min_s) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.min_u-1st-arg-empty (result v128) + (i32x4.min_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.min_u-all-args-empty (result v128) + (i32x4.min_u) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.max_s-1st-arg-empty (result v128) + (i32x4.max_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.max_s-all-args-empty (result v128) + (i32x4.max_s) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.max_u-1st-arg-empty (result v128) + (i32x4.max_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i32x4.max_u-all-args-empty (result v128) + (i32x4.max_u) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) +) + +(assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_s-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_s-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_s-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) \ No newline at end of file diff --git a/test/core/simd/simd_i8x16.wast b/test/core/simd/simd_i8x16.wast new file mode 100644 index 000000000..2fe6f4c61 --- /dev/null +++ b/test/core/simd/simd_i8x16.wast @@ -0,0 +1,387 @@ +;; Tests for i8x16 [min_s, min_u, max_s, max_u] operations. + +(module + (func (export "i8x16.min_s") (param v128 v128) (result v128) (i8x16.min_s (local.get 0) (local.get 1))) + (func (export "i8x16.min_u") (param v128 v128) (result v128) (i8x16.min_u (local.get 0) (local.get 1))) + (func (export "i8x16.max_s") (param v128 v128) (result v128) (i8x16.max_s (local.get 0) (local.get 1))) + (func (export "i8x16.max_u") (param v128 v128) (result v128) (i8x16.max_u (local.get 0) (local.get 1))) + (func (export "i8x16.min_s_with_const_0") (result v128) (i8x16.min_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.min_s_with_const_1") (result v128) (i8x16.min_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.min_u_with_const_2") (result v128) (i8x16.min_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.min_u_with_const_3") (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.max_s_with_const_4") (result v128) (i8x16.max_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.max_s_with_const_5") (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.max_u_with_const_6") (result v128) (i8x16.max_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.max_u_with_const_7") (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.min_s_with_const_8") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.min_s_with_const_9") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.min_u_with_const_10") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.min_u_with_const_11") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.max_s_with_const_12") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.max_s_with_const_13") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.max_u_with_const_14") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.max_u_with_const_15") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) +) + +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + +;; Const vs const +(assert_return (invoke "i8x16.min_s_with_const_0") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_s_with_const_1") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.min_u_with_const_2") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_u_with_const_3") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.max_s_with_const_4") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_s_with_const_5") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) +(assert_return (invoke "i8x16.max_u_with_const_6") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_u_with_const_7") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) + +;; Param vs const +(assert_return (invoke "i8x16.min_s_with_const_8" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_s_with_const_9" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.min_u_with_const_10" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_u_with_const_11" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.max_s_with_const_12" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_s_with_const_13" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) +(assert_return (invoke "i8x16.max_u_with_const_14" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_u_with_const_15" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128)) + +;; Test opposite signs of zero +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) + +;; Type check +(assert_invalid (module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument +(assert_invalid + (module + (func $i8x16.min_s-1st-arg-empty (result v128) + (i8x16.min_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.min_s-all-args-empty (result v128) + (i8x16.min_s) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.min_u-1st-arg-empty (result v128) + (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.min_u-all-args-empty (result v128) + (i8x16.min_u) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.max_s-1st-arg-empty (result v128) + (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.max_s-all-args-empty (result v128) + (i8x16.max_s) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.max_u-1st-arg-empty (result v128) + (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +)(assert_invalid + (module + (func $i8x16.max_u-all-args-empty (result v128) + (i8x16.max_u) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) +) + +(assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) \ No newline at end of file From 5420581586314b202e585bd850d16a2f3405e312 Mon Sep 17 00:00:00 2001 From: Wanming Lin Date: Fri, 20 Dec 2019 15:33:10 +0800 Subject: [PATCH 2/2] Addressed comments --- test/core/simd/meta/simd_integer_op.py | 23 +++++---- test/core/simd/meta/simd_lanewise_integer.py | 8 +-- test/core/simd/simd_i16x8.wast | 54 +++++++++++--------- test/core/simd/simd_i32x4.wast | 54 +++++++++++--------- test/core/simd/simd_i8x16.wast | 54 +++++++++++--------- 5 files changed, 109 insertions(+), 84 deletions(-) diff --git a/test/core/simd/meta/simd_integer_op.py b/test/core/simd/meta/simd_integer_op.py index e891c0e1d..b3d14062c 100644 --- a/test/core/simd/meta/simd_integer_op.py +++ b/test/core/simd/meta/simd_integer_op.py @@ -14,8 +14,8 @@ def binary_op(op: str, p1: str, p2: str, lane_width: int) -> str: """Binary operation on p1 and p2 with the operation specified by op :param op: min_s, min_u, max_s, max_u - :param p1: integer value in hex - :param p2: integer value in hex + :param p1: a hex or decimal integer literal string + :param p2: a hex or decimal integer literal string :lane_width: bit number of each lane in SIMD v128 :return: """ @@ -40,10 +40,8 @@ def binary_op(op: str, p1: str, p2: str, lane_width: int) -> str: return p1 if i1 >= i2 else p2 elif op in ['min_u', 'max_u']: - lane = LaneValue(lane_width) - i1 = v1 & lane.mask - i2 = v2 & lane.mask - + i1 = IntegerSimpleOp.get_valid_value(v1, lane_width, signed=False) + i2 = IntegerSimpleOp.get_valid_value(v2, lane_width, signed=False) if op == 'min_u': return p1 if i1 <= i2 else p2 else: @@ -53,13 +51,16 @@ def binary_op(op: str, p1: str, p2: str, lane_width: int) -> str: raise Exception('Unknown binary operation') @staticmethod - def get_valid_value(value, lane_width): + def get_valid_value(value, lane_width, signed=True): """Get the valid integer value of value in the specified lane size. """ lane = LaneValue(lane_width) value &= lane.mask - if value > lane.max: - return value - lane.mod - if value < lane.min: - return value + lane.mod + + if signed: + if value > lane.max: + return value - lane.mod + if value < lane.min: + return value + lane.mod + return value \ No newline at end of file diff --git a/test/core/simd/meta/simd_lanewise_integer.py b/test/core/simd/meta/simd_lanewise_integer.py index 078f0d902..024d37ce1 100644 --- a/test/core/simd/meta/simd_lanewise_integer.py +++ b/test/core/simd/meta/simd_lanewise_integer.py @@ -278,8 +278,8 @@ def gen_funcs_combination(self): funcs = '\n\n;; Combination' funcs += '\n(module' - assert_template = ' (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128 v128) (result v128)' \ - ' ({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1))(local.get 2))' \ + assert_template = ' (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128 v128) (result v128) ' \ + '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1))(local.get 2))' \ ')' binary_ops = list(self.BINARY_OPS) @@ -319,7 +319,7 @@ def gen_test_case_combination(self): def gen_test_case_empty_argument(self): """generate empty argument test cases""" - assert_1st_empyt_template = '(assert_invalid' \ + assert_1st_empyt_template = '\n(assert_invalid' \ '\n (module' \ '\n (func ${lane_type}.{op}-1st-arg-empty (result v128)' \ '\n ({lane_type}.{op} {param_1})' \ @@ -327,7 +327,7 @@ def gen_test_case_empty_argument(self): '\n )' \ '\n "type mismatch"' \ '\n)' - assert_all_empty_template = '(assert_invalid' \ + assert_all_empty_template = '\n(assert_invalid' \ '\n (module' \ '\n (func ${lane_type}.{op}-all-args-empty (result v128)' \ '\n ({lane_type}.{op})' \ diff --git a/test/core/simd/simd_i16x8.wast b/test/core/simd/simd_i16x8.wast index 4d57c977d..a77afe129 100644 --- a/test/core/simd/simd_i16x8.wast +++ b/test/core/simd/simd_i16x8.wast @@ -243,6 +243,7 @@ (assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") ;; Test operation with empty argument + (assert_invalid (module (func $i16x8.min_s-1st-arg-empty (result v128) @@ -250,49 +251,56 @@ ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.min_s-all-args-empty (result v128) (i16x8.min_s) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.min_u-1st-arg-empty (result v128) (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.min_u-all-args-empty (result v128) (i16x8.min_u) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.max_s-1st-arg-empty (result v128) (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.max_s-all-args-empty (result v128) (i16x8.max_s) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.max_u-1st-arg-empty (result v128) (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i16x8.max_u-all-args-empty (result v128) (i16x8.max_u) @@ -303,22 +311,22 @@ ;; Combination (module - (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) ) (assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) diff --git a/test/core/simd/simd_i32x4.wast b/test/core/simd/simd_i32x4.wast index 07db6d225..046b49e48 100644 --- a/test/core/simd/simd_i32x4.wast +++ b/test/core/simd/simd_i32x4.wast @@ -253,6 +253,7 @@ (assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") ;; Test operation with empty argument + (assert_invalid (module (func $i32x4.min_s-1st-arg-empty (result v128) @@ -260,49 +261,56 @@ ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.min_s-all-args-empty (result v128) (i32x4.min_s) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.min_u-1st-arg-empty (result v128) (i32x4.min_u (v128.const i32x4 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.min_u-all-args-empty (result v128) (i32x4.min_u) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.max_s-1st-arg-empty (result v128) (i32x4.max_s (v128.const i32x4 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.max_s-all-args-empty (result v128) (i32x4.max_s) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.max_u-1st-arg-empty (result v128) (i32x4.max_u (v128.const i32x4 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i32x4.max_u-all-args-empty (result v128) (i32x4.max_u) @@ -313,22 +321,22 @@ ;; Combination (module - (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) ) (assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0) diff --git a/test/core/simd/simd_i8x16.wast b/test/core/simd/simd_i8x16.wast index 2fe6f4c61..0a41d4583 100644 --- a/test/core/simd/simd_i8x16.wast +++ b/test/core/simd/simd_i8x16.wast @@ -243,6 +243,7 @@ (assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") ;; Test operation with empty argument + (assert_invalid (module (func $i8x16.min_s-1st-arg-empty (result v128) @@ -250,49 +251,56 @@ ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.min_s-all-args-empty (result v128) (i8x16.min_s) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.min_u-1st-arg-empty (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.min_u-all-args-empty (result v128) (i8x16.min_u) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.max_s-1st-arg-empty (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.max_s-all-args-empty (result v128) (i8x16.max_s) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.max_u-1st-arg-empty (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) ) ) "type mismatch" -)(assert_invalid +) +(assert_invalid (module (func $i8x16.max_u-all-args-empty (result v128) (i8x16.max_u) @@ -303,22 +311,22 @@ ;; Combination (module - (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) - (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) ) (assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)