diff --git a/test/core/simd/meta/README.md b/test/core/simd/meta/README.md index f50efa78a..032b4e4e5 100644 --- a/test/core/simd/meta/README.md +++ b/test/core/simd/meta/README.md @@ -9,8 +9,11 @@ Currently it only support following simd test files generation. - 'simd_f32x4_cmp.wast' - 'simd_f64x2_cmp.wast' - 'simd_i8x16_arith.wast' +- 'simd_i8x16_arith2.wast' - 'simd_i16x8_arith.wast' +- 'simd_i16x8_arith2.wast' - 'simd_i32x4_arith.wast' +- 'simd_i32x4_arith2.wast' - 'simd_f32x4_arith.wast' - 'simd_i64x2_arith.wast' - 'simd_f64x2_arith.wast' @@ -19,9 +22,6 @@ 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: diff --git a/test/core/simd/meta/simd_arithmetic.py b/test/core/simd/meta/simd_arithmetic.py index 0e84327b4..3ad596ebc 100644 --- a/test/core/simd/meta/simd_arithmetic.py +++ b/test/core/simd/meta/simd_arithmetic.py @@ -14,7 +14,7 @@ """ from simd import SIMD -from test_assert import AssertReturn +from test_assert import AssertReturn, AssertInvalid class LaneNumber: @@ -325,7 +325,40 @@ def get_invalid_cases(self): operand_1='i32.const 0', operand_2='f32.const 0.0')) - return '\n'.join(invalid_cases) + return '\n'.join(invalid_cases) + self.argument_empty_test() + + def argument_empty_test(self): + """Test cases with empty argument. + """ + cases = [] + + cases.append('\n\n;; Test operation with empty argument\n') + + case_data = { + 'op': '', + 'extended_name': 'arg-empty', + 'param_type': '', + 'result_type': '(result v128)', + 'params': '', + } + + for op in self.UNARY_OPS: + case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op) + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + for op in self.BINARY_OPS: + case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op) + case_data['extended_name'] = '1st-arg-empty' + case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE) + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + return '\n'.join(cases) def get_combine_cases(self): combine_cases = [';; combination\n(module'] @@ -413,4 +446,4 @@ def get_all_cases(self): def gen_test_cases(self): wast_filename = '../simd_{lane_type}_arith.wast'.format(lane_type=self.LANE_TYPE) with open(wast_filename, 'w') as fp: - fp.write(self.get_all_cases()) \ No newline at end of file + fp.write(self.get_all_cases()) diff --git a/test/core/simd/meta/simd_bitwise.py b/test/core/simd/meta/simd_bitwise.py index 5e8eb33a9..adba5ab6a 100644 --- a/test/core/simd/meta/simd_bitwise.py +++ b/test/core/simd/meta/simd_bitwise.py @@ -5,7 +5,7 @@ """ from simd import SIMD -from test_assert import AssertReturn +from test_assert import AssertReturn, AssertInvalid class SimdBitWise(SIMD): @@ -13,6 +13,10 @@ class SimdBitWise(SIMD): Generate common tests """ + UNARY_OPS = ('not',) + BINARY_OPS = ('and', 'or', 'xor', 'andnot',) + TERNARY_OPS = ('bitselect',) + # Test case template CASE_TXT = """;; Test all the bitwise operators on major boundary values and all special values. @@ -182,6 +186,7 @@ def get_combination_case(self): lst_nested_case_func = [] lst_in_block_case_assert = [] lst_nested_case_assert = [] + lst_argument_empty_case = [] for ipr in lst_ipr: @@ -242,9 +247,59 @@ def get_combination_case(self): '{assert_in_block_cases}' \ '{assert_of_nested_cases}' \ '\n(assert_return (invoke "as-param"))\n'.format(in_block_cases=''.join(lst_in_block_case_func), - nested_cases=''.join(lst_nested_case_func), - assert_in_block_cases=''.join(lst_in_block_case_assert), - assert_of_nested_cases=''.join(lst_nested_case_assert)) + nested_cases=''.join(lst_nested_case_func), + assert_in_block_cases=''.join(lst_in_block_case_assert), + assert_of_nested_cases=''.join(lst_nested_case_assert)) + + def get_argument_empty_case(self): + """ + Generate argument empty cases + """ + + cases = [] + + param_1 = SIMD.v128_const('0', 'i32x4') + + cases.append('\n\n;; Test operation with empty argument\n') + + case_data = { + 'op': '', + 'extended_name': 'arg-empty', + 'param_type': '', + 'result_type': '(result v128)', + 'params': '', + } + + for op in self.UNARY_OPS: + case_data['op'] = 'v128.' + op + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + for op in self.BINARY_OPS: + case_data['op'] = 'v128.' + op + case_data['extended_name'] = '1st-arg-empty' + case_data['params'] = param_1 + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + for op in self.TERNARY_OPS: + case_data['op'] = 'v128.' + op + case_data['extended_name'] = '1st-arg-empty' + case_data['params'] = param_1 + ' ' + param_1 + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + case_data['extended_name'] = 'two-args-empty' + case_data['params'] = param_1 + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + return '\n'.join(cases) + '\n' + def get_all_cases(self): """ @@ -254,7 +309,7 @@ def get_all_cases(self): case_data = {'normal_case': self.get_normal_case()} # Add tests for unkonow operators for i32x4 - return self.CASE_TXT.format(**case_data) + self.get_invalid_case() + self.get_combination_case() + return self.CASE_TXT.format(**case_data) + self.get_invalid_case() + self.get_combination_case() + self.get_argument_empty_case() def get_case_data(self): """ @@ -444,4 +499,4 @@ def gen_test_cases(): if __name__ == '__main__': - gen_test_cases() \ No newline at end of file + gen_test_cases() diff --git a/test/core/simd/meta/simd_compare.py b/test/core/simd/meta/simd_compare.py index 127d22849..584985082 100644 --- a/test/core/simd/meta/simd_compare.py +++ b/test/core/simd/meta/simd_compare.py @@ -9,7 +9,7 @@ import abc from simd import SIMD -from test_assert import AssertReturn +from test_assert import AssertReturn, AssertInvalid # Generate common comparison tests @@ -369,6 +369,33 @@ def get_normal_case(self): return '\n'.join(cases) + def argument_empty_test(self): + """Test cases with empty argument. + """ + cases = [] + + cases.append('\n;; Test operation with empty argument\n') + + case_data = { + 'op': '', + 'extended_name': 'arg-empty', + 'param_type': '', + 'result_type': '(result v128)', + 'params': '', + } + + for op in self.BINARY_OPS: + case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op) + case_data['extended_name'] = '1st-arg-empty' + case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE) + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + return '\n'.join(cases) + # Generate all test cases def get_all_cases(self): @@ -376,7 +403,7 @@ def get_all_cases(self): 'lane_type': self.LANE_TYPE} # Generate tests using the test template - return self.CASE_TXT.format(**case_data) + return self.CASE_TXT.format(**case_data) + self.argument_empty_test() # Generate test case file def gen_test_cases(self): diff --git a/test/core/simd/meta/simd_f32x4_cmp.py b/test/core/simd/meta/simd_f32x4_cmp.py index af7cd2a04..8b3b30b6b 100644 --- a/test/core/simd/meta/simd_f32x4_cmp.py +++ b/test/core/simd/meta/simd_f32x4_cmp.py @@ -16,6 +16,9 @@ class Simdf32x4CmpCase(SimdCmpCase): LANE_TYPE = 'f32x4' + + BINARY_OPS = ['eq', 'ne', 'lt', 'le', 'gt', 'ge'] + # Test template, using this template to generate tests with variable test datas. CASE_TXT = """;; Test all the {lane_type} comparison operators on major boundary values and all special values. @@ -501,4 +504,4 @@ def gen_test_cases(): if __name__ == '__main__': f32x4 = Simdf32x4CmpCase() - f32x4.gen_test_cases() \ No newline at end of file + f32x4.gen_test_cases() diff --git a/test/core/simd/meta/simd_i16x8_cmp.py b/test/core/simd/meta/simd_i16x8_cmp.py index 836cd88c7..c575cdd0e 100644 --- a/test/core/simd/meta/simd_i16x8_cmp.py +++ b/test/core/simd/meta/simd_i16x8_cmp.py @@ -14,6 +14,8 @@ class Simdi16x8CmpCase(SimdCmpCase): LANE_TYPE = 'i16x8' + BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u'] + # Overloads base class method and sets test data for i16x8. def get_case_data(self): @@ -820,4 +822,4 @@ def gen_test_cases(): if __name__ == '__main__': i16x8 = Simdi16x8CmpCase() - i16x8.gen_test_cases() \ No newline at end of file + i16x8.gen_test_cases() diff --git a/test/core/simd/meta/simd_i32x4_cmp.py b/test/core/simd/meta/simd_i32x4_cmp.py index c6c70a9d9..41a093ee6 100644 --- a/test/core/simd/meta/simd_i32x4_cmp.py +++ b/test/core/simd/meta/simd_i32x4_cmp.py @@ -14,6 +14,8 @@ class Simdi32x4CmpCase(SimdCmpCase): LANE_TYPE = 'i32x4' + BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u'] + # Overload base class method and set test data for i32x4. def get_case_data(self): @@ -832,4 +834,4 @@ def gen_test_cases(): if __name__ == '__main__': i32x4 = Simdi32x4CmpCase() - i32x4.gen_test_cases() \ No newline at end of file + i32x4.gen_test_cases() diff --git a/test/core/simd/meta/simd_i8x16_cmp.py b/test/core/simd/meta/simd_i8x16_cmp.py index 035507d6b..440d6087b 100644 --- a/test/core/simd/meta/simd_i8x16_cmp.py +++ b/test/core/simd/meta/simd_i8x16_cmp.py @@ -15,6 +15,8 @@ class Simdi8x16CmpCase(SimdCmpCase): # set lane type LANE_TYPE = 'i8x16' + BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u'] + # Overload base class method and set test data for i32x4. def get_case_data(self): diff --git a/test/core/simd/meta/simd_int_arith2.py b/test/core/simd/meta/simd_int_arith2.py index 3f7e3e4bf..d2b525790 100644 --- a/test/core/simd/meta/simd_int_arith2.py +++ b/test/core/simd/meta/simd_int_arith2.py @@ -5,7 +5,7 @@ """ from simd import SIMD -from test_assert import AssertReturn +from test_assert import AssertReturn, AssertInvalid from simd_lane_value import LaneValue from simd_integer_op import IntegerSimpleOp as IntOp @@ -319,31 +319,29 @@ def gen_test_case_combination(self): def gen_test_case_empty_argument(self): """generate empty argument test cases""" - 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})' \ - '\n )' \ - '\n )' \ - '\n "type mismatch"' \ - '\n)' - assert_all_empty_template = '\n(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 = '' + cases.append('\n\n;; Test operation with empty argument\n') + + case_data = { + 'op': '', + 'extended_name': 'arg-empty', + 'param_type': '', + 'result_type': '(result v128)', + 'params': '', + } - 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) + case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op) + case_data['extended_name'] = '1st-arg-empty' + case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE) + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) - return cases + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + return '\n'.join(cases) @property def gen_funcs(self): @@ -397,4 +395,4 @@ def gen_test_cases(): if __name__ == '__main__': - gen_test_cases() \ No newline at end of file + gen_test_cases() diff --git a/test/core/simd/meta/simd_sat_arith.py b/test/core/simd/meta/simd_sat_arith.py index c5aa27af3..14f406abe 100644 --- a/test/core/simd/meta/simd_sat_arith.py +++ b/test/core/simd/meta/simd_sat_arith.py @@ -42,6 +42,31 @@ def get_malformed_cases(self): return '\n'.join(malformed_cases) + def argument_empty_cases(self): + """Test cases with empty argument. + """ + cases = [] + + case_data = { + 'op': '', + 'extended_name': 'arg-empty', + 'param_type': '', + 'result_type': '(result v128)', + 'params': '', + } + + for op in self.BINARY_OPS: + case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op) + case_data['extended_name'] = '1st-arg-empty' + case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE) + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + case_data['extended_name'] = 'arg-empty' + case_data['params'] = '' + cases.append(AssertInvalid.get_arg_empty_test(**case_data)) + + return '\n'.join(cases) + def get_all_cases(self): case_data = {'lane_type': self.LANE_TYPE, 'normal_cases': self.get_normal_case(), @@ -448,4 +473,4 @@ def gen_test_cases(): if __name__ == '__main__': - gen_test_cases() \ No newline at end of file + gen_test_cases() diff --git a/test/core/simd/meta/test_assert.py b/test/core/simd/meta/test_assert.py index 8425b46ad..186577f9a 100644 --- a/test/core/simd/meta/test_assert.py +++ b/test/core/simd/meta/test_assert.py @@ -12,31 +12,30 @@ # Generate assert_return to test class AssertReturn: - instruction = '' - instruction_param = '' + op = '' + params = '' expected_result = '' - def __init__(self, instruction, instruction_param, expected_result): - super(AssertReturn, self).__init__() + def __init__(self, op, params, expected_result): # Convert to list if got str - if isinstance(instruction_param, str): - instruction_param = [instruction_param] + if isinstance(params, str): + params = [params] if isinstance(expected_result, str): expected_result = [expected_result] - self.instruction = instruction - self.instruction_param = instruction_param + self.op = op + self.params = params self.expected_result = expected_result def __str__(self): - assert_return = '(assert_return (invoke "{}"'.format(self.instruction) + assert_return = '(assert_return (invoke "{}"'.format(self.op) head_len = len(assert_return) # Add write space to make the test case easier to read params = [] - for param in self.instruction_param: + for param in self.params: white_space = ' ' if len(params) != 0: white_space = '\n ' + ' ' * head_len @@ -49,4 +48,33 @@ def __str__(self): white_space = '\n ' + ' ' * head_len results.append(white_space + result) - return '{assert_head}{params}){expected_result})'.format(assert_head=assert_return, params=''.join(params), expected_result=''.join(results)) \ No newline at end of file + return '{assert_head}{params}){expected_result})'.format(assert_head=assert_return, params=''.join(params), expected_result=''.join(results)) + + +# Generate assert_invalid to test +class AssertInvalid: + + @staticmethod + def get_arg_empty_test(op, extended_name, param_type, result_type, params): + + arg_empty_test = '(assert_invalid' \ + '\n (module' \ + '\n (func ${op}-{extended_name}{param_type}{result_type}' \ + '\n ({op}{params})' \ + '\n )' \ + '\n )' \ + '\n "type mismatch"' \ + '\n)' + + def str_with_space(input_str): + return (' ' if input_str else '') + input_str + + param_map = { + 'op': op, + 'extended_name': extended_name, + 'param_type': str_with_space(param_type), + 'result_type': str_with_space(result_type), + 'params': str_with_space(params), + } + + return arg_empty_test.format(**param_map) diff --git a/test/core/simd/simd_bit_shift.wast b/test/core/simd/simd_bit_shift.wast index a49b8032e..98e155651 100644 --- a/test/core/simd/simd_bit_shift.wast +++ b/test/core/simd/simd_bit_shift.wast @@ -1002,4 +1002,103 @@ (assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shr (v128.const i32x4 0 0 0 0)))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shl (v128.const i32x4 0 0 0 0)))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0)))") "unknown operator") -(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator") \ No newline at end of file +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.shl-1st-arg-empty (result v128) + (i8x16.shl (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.shl-last-arg-empty (result v128) + (i8x16.shl (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.shl-arg-empty (result v128) + (i8x16.shl) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.shr_u-1st-arg-empty (result v128) + (i16x8.shr_u (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.shr_u-last-arg-empty (result v128) + (i16x8.shr_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.shr_u-arg-empty (result v128) + (i16x8.shr_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.shr_s-1st-arg-empty (result v128) + (i32x4.shr_s (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.shr_s-last-arg-empty (result v128) + (i32x4.shr_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.shr_s-arg-empty (result v128) + (i32x4.shr_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.shl-1st-arg-empty (result v128) + (i64x2.shl (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.shr_u-last-arg-empty (result v128) + (i64x2.shr_u (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.shr_s-arg-empty (result v128) + (i64x2.shr_s) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_bitwise.wast b/test/core/simd/simd_bitwise.wast index 821f46aa8..f646bf61d 100644 --- a/test/core/simd/simd_bitwise.wast +++ b/test/core/simd/simd_bitwise.wast @@ -709,4 +709,104 @@ (assert_return (invoke "nested-v128.xor")) (assert_return (invoke "nested-v128.bitselect")) (assert_return (invoke "nested-v128.andnot")) -(assert_return (invoke "as-param")) \ No newline at end of file +(assert_return (invoke "as-param")) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $v128.not-arg-empty (result v128) + (v128.not) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.and-1st-arg-empty (result v128) + (v128.and (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.and-arg-empty (result v128) + (v128.and) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.or-1st-arg-empty (result v128) + (v128.or (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.or-arg-empty (result v128) + (v128.or) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.xor-1st-arg-empty (result v128) + (v128.xor (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.xor-arg-empty (result v128) + (v128.xor) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.andnot-1st-arg-empty (result v128) + (v128.andnot (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.andnot-arg-empty (result v128) + (v128.andnot) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.bitselect-1st-arg-empty (result v128) + (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.bitselect-two-args-empty (result v128) + (v128.bitselect (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.bitselect-arg-empty (result v128) + (v128.bitselect) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_boolean.wast b/test/core/simd/simd_boolean.wast index 7838520c5..27d3738bf 100644 --- a/test/core/simd/simd_boolean.wast +++ b/test/core/simd/simd_boolean.wast @@ -961,4 +961,55 @@ (assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator") -(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator") \ No newline at end of file +(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.any_true-arg-empty (result v128) + (i8x16.any_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.all_true-arg-empty (result v128) + (i8x16.all_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.any_true-arg-empty (result v128) + (i16x8.any_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.all_true-arg-empty (result v128) + (i16x8.all_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.any_true-arg-empty (result v128) + (i32x4.any_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.all_true-arg-empty (result v128) + (i32x4.all_true) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_const.wast b/test/core/simd/simd_const.wast index df5bf2f83..b0c142382 100644 --- a/test/core/simd/simd_const.wast +++ b/test/core/simd/simd_const.wast @@ -1657,4 +1657,4 @@ "\ff\ff\ff\ff\ff\ff\ef\7f" ;; data lane 1 (0x1.fffffffffffffp+1023) "\0b" ;; end ) -(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) \ No newline at end of file diff --git a/test/core/simd/simd_conversions.wast b/test/core/simd/simd_conversions.wast index b33f2ec6a..5a06db730 100644 --- a/test/core/simd/simd_conversions.wast +++ b/test/core/simd/simd_conversions.wast @@ -1487,4 +1487,199 @@ (v128.const i32x4 0 0 0xffff 0)) (assert_return (invoke "i32x4_high_widen_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000) (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)) - (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff)) \ No newline at end of file + (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff)) + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.trunc_sat_f32x4_s-arg-empty (result v128) + (i32x4.trunc_sat_f32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.trunc_sat_f32x4_u-arg-empty (result v128) + (i32x4.trunc_sat_f32x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.trunc_sat_f64x2_s-arg-empty (result v128) + (i64x2.trunc_sat_f64x2_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.trunc_sat_f64x2_u-arg-empty (result v128) + (i64x2.trunc_sat_f64x2_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.convert_i32x4_s-arg-empty (result v128) + (f32x4.convert_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.convert_i32x4_u-arg-empty (result v128) + (f32x4.convert_i32x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.convert_i64x2_s-arg-empty (result v128) + (f64x2.convert_i64x2_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.convert_i64x2_u-arg-empty (result v128) + (f64x2.convert_i64x2_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_s-1st-arg-empty (result v128) + (i8x16.narrow_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_s-arg-empty (result v128) + (i8x16.narrow_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_u-1st-arg-empty (result v128) + (i8x16.narrow_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_u-arg-empty (result v128) + (i8x16.narrow_i16x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_s-1st-arg-empty (result v128) + (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_s-arg-empty (result v128) + (i16x8.narrow_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_u-1st-arg-empty (result v128) + (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_u-arg-empty (result v128) + (i16x8.narrow_i32x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.widen_high_i8x16_s-arg-empty (result v128) + (i16x8.widen_high_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.widen_high_i8x16_u-arg-empty (result v128) + (i16x8.widen_high_i8x16_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.widen_low_i8x16_s-arg-empty (result v128) + (i16x8.widen_low_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.widen_low_i8x16_u-arg-empty (result v128) + (i16x8.widen_low_i8x16_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.widen_high_i16x8_s-arg-empty (result v128) + (i32x4.widen_high_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.widen_high_i16x8_u-arg-empty (result v128) + (i32x4.widen_high_i16x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.widen_low_i16x8_s-arg-empty (result v128) + (i32x4.widen_low_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.widen_low_i16x8_u-arg-empty (result v128) + (i32x4.widen_low_i16x8_u) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_f32x4.wast b/test/core/simd/simd_f32x4.wast index ce0745bc0..b91198012 100644 --- a/test/core/simd/simd_f32x4.wast +++ b/test/core/simd/simd_f32x4.wast @@ -2337,6 +2337,49 @@ (assert_invalid (module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.abs-arg-empty (result v128) + (f32x4.abs) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.min-1st-arg-empty (result v128) + (f32x4.min (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.min-arg-empty (result v128) + (f32x4.min) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.max-1st-arg-empty (result v128) + (f32x4.max (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.max-arg-empty (result v128) + (f32x4.max) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "max-min") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_f32x4_arith.wast b/test/core/simd/simd_f32x4_arith.wast index 69ed526e6..56f80f547 100644 --- a/test/core/simd/simd_f32x4_arith.wast +++ b/test/core/simd/simd_f32x4_arith.wast @@ -5299,6 +5299,89 @@ (assert_invalid (module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.neg-arg-empty (result v128) + (f32x4.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.sqrt-arg-empty (result v128) + (f32x4.sqrt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.add-1st-arg-empty (result v128) + (f32x4.add (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.add-arg-empty (result v128) + (f32x4.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.sub-1st-arg-empty (result v128) + (f32x4.sub (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.sub-arg-empty (result v128) + (f32x4.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.mul-1st-arg-empty (result v128) + (f32x4.mul (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.mul-arg-empty (result v128) + (f32x4.mul) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.div-1st-arg-empty (result v128) + (f32x4.div (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.div-arg-empty (result v128) + (f32x4.div) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "add-sub") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_f32x4_cmp.wast b/test/core/simd/simd_f32x4_cmp.wast index 3d3145f93..9e9a8735b 100644 --- a/test/core/simd/simd_f32x4_cmp.wast +++ b/test/core/simd/simd_f32x4_cmp.wast @@ -8066,3 +8066,102 @@ (assert_return (invoke "nested-gt")) (assert_return (invoke "nested-ge")) (assert_return (invoke "as-param")) + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.eq-1st-arg-empty (result v128) + (f32x4.eq (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.eq-arg-empty (result v128) + (f32x4.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ne-1st-arg-empty (result v128) + (f32x4.ne (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ne-arg-empty (result v128) + (f32x4.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.lt-1st-arg-empty (result v128) + (f32x4.lt (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.lt-arg-empty (result v128) + (f32x4.lt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.le-1st-arg-empty (result v128) + (f32x4.le (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.le-arg-empty (result v128) + (f32x4.le) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.gt-1st-arg-empty (result v128) + (f32x4.gt (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.gt-arg-empty (result v128) + (f32x4.gt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ge-1st-arg-empty (result v128) + (f32x4.ge (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ge-arg-empty (result v128) + (f32x4.ge) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/test/core/simd/simd_f64x2.wast b/test/core/simd/simd_f64x2.wast index a8c3850c4..a237a16eb 100644 --- a/test/core/simd/simd_f64x2.wast +++ b/test/core/simd/simd_f64x2.wast @@ -2388,6 +2388,49 @@ (assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.abs-arg-empty (result v128) + (f64x2.abs) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.min-1st-arg-empty (result v128) + (f64x2.min (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.min-arg-empty (result v128) + (f64x2.min) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.max-1st-arg-empty (result v128) + (f64x2.max (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.max-arg-empty (result v128) + (f64x2.max) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "max-min") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_f64x2_arith.wast b/test/core/simd/simd_f64x2_arith.wast index b91c071ad..9f570f7e6 100644 --- a/test/core/simd/simd_f64x2_arith.wast +++ b/test/core/simd/simd_f64x2_arith.wast @@ -5306,6 +5306,89 @@ (assert_invalid (module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.neg-arg-empty (result v128) + (f64x2.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.sqrt-arg-empty (result v128) + (f64x2.sqrt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.add-1st-arg-empty (result v128) + (f64x2.add (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.add-arg-empty (result v128) + (f64x2.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.sub-1st-arg-empty (result v128) + (f64x2.sub (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.sub-arg-empty (result v128) + (f64x2.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.mul-1st-arg-empty (result v128) + (f64x2.mul (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.mul-arg-empty (result v128) + (f64x2.mul) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.div-1st-arg-empty (result v128) + (f64x2.div (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.div-arg-empty (result v128) + (f64x2.div) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "add-sub") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_f64x2_cmp.wast b/test/core/simd/simd_f64x2_cmp.wast index ea9b6bb44..cab815ea5 100644 --- a/test/core/simd/simd_f64x2_cmp.wast +++ b/test/core/simd/simd_f64x2_cmp.wast @@ -7966,6 +7966,105 @@ (assert_invalid (module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.eq-1st-arg-empty (result v128) + (f64x2.eq (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.eq-arg-empty (result v128) + (f64x2.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ne-1st-arg-empty (result v128) + (f64x2.ne (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ne-arg-empty (result v128) + (f64x2.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.lt-1st-arg-empty (result v128) + (f64x2.lt (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.lt-arg-empty (result v128) + (f64x2.lt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.le-1st-arg-empty (result v128) + (f64x2.le (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.le-arg-empty (result v128) + (f64x2.le) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.gt-1st-arg-empty (result v128) + (f64x2.gt (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.gt-arg-empty (result v128) + (f64x2.gt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ge-1st-arg-empty (result v128) + (f64x2.ge (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ge-arg-empty (result v128) + (f64x2.ge) + ) + ) + "type mismatch" +) + ;; combination (module (memory 1) (func (export "f64x2.eq-in-block") diff --git a/test/core/simd/simd_i16x8_arith.wast b/test/core/simd/simd_i16x8_arith.wast index 7841a2817..3dc4d5ed7 100644 --- a/test/core/simd/simd_i16x8_arith.wast +++ b/test/core/simd/simd_i16x8_arith.wast @@ -530,6 +530,65 @@ (assert_invalid (module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.neg-arg-empty (result v128) + (i16x8.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add-1st-arg-empty (result v128) + (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add-arg-empty (result v128) + (i16x8.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub-1st-arg-empty (result v128) + (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub-arg-empty (result v128) + (i16x8.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.mul-1st-arg-empty (result v128) + (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.mul-arg-empty (result v128) + (i16x8.mul) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "add-sub") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_i16x8_arith2.wast b/test/core/simd/simd_i16x8_arith2.wast index c19685c9e..79fd67f89 100644 --- a/test/core/simd/simd_i16x8_arith2.wast +++ b/test/core/simd/simd_i16x8_arith2.wast @@ -254,7 +254,7 @@ ) (assert_invalid (module - (func $i16x8.min_s-all-args-empty (result v128) + (func $i16x8.min_s-arg-empty (result v128) (i16x8.min_s) ) ) @@ -270,7 +270,7 @@ ) (assert_invalid (module - (func $i16x8.min_u-all-args-empty (result v128) + (func $i16x8.min_u-arg-empty (result v128) (i16x8.min_u) ) ) @@ -286,7 +286,7 @@ ) (assert_invalid (module - (func $i16x8.max_s-all-args-empty (result v128) + (func $i16x8.max_s-arg-empty (result v128) (i16x8.max_s) ) ) @@ -302,7 +302,7 @@ ) (assert_invalid (module - (func $i16x8.max_u-all-args-empty (result v128) + (func $i16x8.max_u-arg-empty (result v128) (i16x8.max_u) ) ) diff --git a/test/core/simd/simd_i16x8_cmp.wast b/test/core/simd/simd_i16x8_cmp.wast index 9c3bbdc5a..24068ce32 100644 --- a/test/core/simd/simd_i16x8_cmp.wast +++ b/test/core/simd/simd_i16x8_cmp.wast @@ -1735,3 +1735,167 @@ (assert_return (invoke "nested-gt_u")) (assert_return (invoke "nested-ge_s")) (assert_return (invoke "as-param")) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.eq-1st-arg-empty (result v128) + (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.eq-arg-empty (result v128) + (i16x8.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ne-1st-arg-empty (result v128) + (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ne-arg-empty (result v128) + (i16x8.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_s-1st-arg-empty (result v128) + (i16x8.lt_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_s-arg-empty (result v128) + (i16x8.lt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_u-1st-arg-empty (result v128) + (i16x8.lt_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_u-arg-empty (result v128) + (i16x8.lt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_s-1st-arg-empty (result v128) + (i16x8.le_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_s-arg-empty (result v128) + (i16x8.le_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_u-1st-arg-empty (result v128) + (i16x8.le_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_u-arg-empty (result v128) + (i16x8.le_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_s-1st-arg-empty (result v128) + (i16x8.gt_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_s-arg-empty (result v128) + (i16x8.gt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_u-1st-arg-empty (result v128) + (i16x8.gt_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_u-arg-empty (result v128) + (i16x8.gt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_s-1st-arg-empty (result v128) + (i16x8.ge_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_s-arg-empty (result v128) + (i16x8.ge_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_u-1st-arg-empty (result v128) + (i16x8.ge_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_u-arg-empty (result v128) + (i16x8.ge_u) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/test/core/simd/simd_i16x8_sat_arith.wast b/test/core/simd/simd_i16x8_sat_arith.wast index 9348b99d1..44f859aa5 100644 --- a/test/core/simd/simd_i16x8_sat_arith.wast +++ b/test/core/simd/simd_i16x8_sat_arith.wast @@ -625,6 +625,73 @@ (assert_invalid (module (func (result v128) (i16x8.sub_saturate_s (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (i16x8.sub_saturate_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.add_saturate_s-1st-arg-empty (result v128) + (i16x8.add_saturate_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add_saturate_s-arg-empty (result v128) + (i16x8.add_saturate_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add_saturate_u-1st-arg-empty (result v128) + (i16x8.add_saturate_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add_saturate_u-arg-empty (result v128) + (i16x8.add_saturate_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_saturate_s-1st-arg-empty (result v128) + (i16x8.sub_saturate_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_saturate_s-arg-empty (result v128) + (i16x8.sub_saturate_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_saturate_u-1st-arg-empty (result v128) + (i16x8.sub_saturate_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_saturate_u-arg-empty (result v128) + (i16x8.sub_saturate_u) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_i32x4_arith.wast b/test/core/simd/simd_i32x4_arith.wast index faca8be4d..f0e09b8bf 100644 --- a/test/core/simd/simd_i32x4_arith.wast +++ b/test/core/simd/simd_i32x4_arith.wast @@ -530,6 +530,65 @@ (assert_invalid (module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.neg-arg-empty (result v128) + (i32x4.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.add-1st-arg-empty (result v128) + (i32x4.add (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.add-arg-empty (result v128) + (i32x4.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.sub-1st-arg-empty (result v128) + (i32x4.sub (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.sub-arg-empty (result v128) + (i32x4.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.mul-1st-arg-empty (result v128) + (i32x4.mul (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.mul-arg-empty (result v128) + (i32x4.mul) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "add-sub") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_i32x4_arith2.wast b/test/core/simd/simd_i32x4_arith2.wast index 16f2bfda4..809c1648b 100644 --- a/test/core/simd/simd_i32x4_arith2.wast +++ b/test/core/simd/simd_i32x4_arith2.wast @@ -264,7 +264,7 @@ ) (assert_invalid (module - (func $i32x4.min_s-all-args-empty (result v128) + (func $i32x4.min_s-arg-empty (result v128) (i32x4.min_s) ) ) @@ -280,7 +280,7 @@ ) (assert_invalid (module - (func $i32x4.min_u-all-args-empty (result v128) + (func $i32x4.min_u-arg-empty (result v128) (i32x4.min_u) ) ) @@ -296,7 +296,7 @@ ) (assert_invalid (module - (func $i32x4.max_s-all-args-empty (result v128) + (func $i32x4.max_s-arg-empty (result v128) (i32x4.max_s) ) ) @@ -312,7 +312,7 @@ ) (assert_invalid (module - (func $i32x4.max_u-all-args-empty (result v128) + (func $i32x4.max_u-arg-empty (result v128) (i32x4.max_u) ) ) diff --git a/test/core/simd/simd_i32x4_cmp.wast b/test/core/simd/simd_i32x4_cmp.wast index d541c18a4..fca45ab96 100644 --- a/test/core/simd/simd_i32x4_cmp.wast +++ b/test/core/simd/simd_i32x4_cmp.wast @@ -1743,6 +1743,168 @@ (assert_return (invoke "as-param")) +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.eq-1st-arg-empty (result v128) + (i32x4.eq (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.eq-arg-empty (result v128) + (i32x4.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ne-1st-arg-empty (result v128) + (i32x4.ne (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ne-arg-empty (result v128) + (i32x4.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_s-1st-arg-empty (result v128) + (i32x4.lt_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_s-arg-empty (result v128) + (i32x4.lt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_u-1st-arg-empty (result v128) + (i32x4.lt_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_u-arg-empty (result v128) + (i32x4.lt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_s-1st-arg-empty (result v128) + (i32x4.le_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_s-arg-empty (result v128) + (i32x4.le_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_u-1st-arg-empty (result v128) + (i32x4.le_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_u-arg-empty (result v128) + (i32x4.le_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_s-1st-arg-empty (result v128) + (i32x4.gt_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_s-arg-empty (result v128) + (i32x4.gt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_u-1st-arg-empty (result v128) + (i32x4.gt_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_u-arg-empty (result v128) + (i32x4.gt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_s-1st-arg-empty (result v128) + (i32x4.ge_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_s-arg-empty (result v128) + (i32x4.ge_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_u-1st-arg-empty (result v128) + (i32x4.ge_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_u-arg-empty (result v128) + (i32x4.ge_u) + ) + ) + "type mismatch" +) ;; Unknown operators (assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator") @@ -1755,3 +1917,4 @@ (assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator") + diff --git a/test/core/simd/simd_i64x2_arith.wast b/test/core/simd/simd_i64x2_arith.wast index 72e763477..00963a0d0 100644 --- a/test/core/simd/simd_i64x2_arith.wast +++ b/test/core/simd/simd_i64x2_arith.wast @@ -548,6 +548,65 @@ (assert_invalid (module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $i64x2.neg-arg-empty (result v128) + (i64x2.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.add-1st-arg-empty (result v128) + (i64x2.add (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.add-arg-empty (result v128) + (i64x2.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.sub-1st-arg-empty (result v128) + (i64x2.sub (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.sub-arg-empty (result v128) + (i64x2.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.mul-1st-arg-empty (result v128) + (i64x2.mul (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.mul-arg-empty (result v128) + (i64x2.mul) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "add-sub") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_i8x16_arith.wast b/test/core/simd/simd_i8x16_arith.wast index 1042233f1..1e56b4c00 100644 --- a/test/core/simd/simd_i8x16_arith.wast +++ b/test/core/simd/simd_i8x16_arith.wast @@ -355,6 +355,49 @@ (assert_invalid (module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.neg-arg-empty (result v128) + (i8x16.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add-1st-arg-empty (result v128) + (i8x16.add (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.add-arg-empty (result v128) + (i8x16.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub-1st-arg-empty (result v128) + (i8x16.sub (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.sub-arg-empty (result v128) + (i8x16.sub) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "add-sub") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_i8x16_arith2.wast b/test/core/simd/simd_i8x16_arith2.wast index 0573c1f20..ac26d347c 100644 --- a/test/core/simd/simd_i8x16_arith2.wast +++ b/test/core/simd/simd_i8x16_arith2.wast @@ -254,7 +254,7 @@ ) (assert_invalid (module - (func $i8x16.min_s-all-args-empty (result v128) + (func $i8x16.min_s-arg-empty (result v128) (i8x16.min_s) ) ) @@ -270,7 +270,7 @@ ) (assert_invalid (module - (func $i8x16.min_u-all-args-empty (result v128) + (func $i8x16.min_u-arg-empty (result v128) (i8x16.min_u) ) ) @@ -286,7 +286,7 @@ ) (assert_invalid (module - (func $i8x16.max_s-all-args-empty (result v128) + (func $i8x16.max_s-arg-empty (result v128) (i8x16.max_s) ) ) @@ -302,7 +302,7 @@ ) (assert_invalid (module - (func $i8x16.max_u-all-args-empty (result v128) + (func $i8x16.max_u-arg-empty (result v128) (i8x16.max_u) ) ) diff --git a/test/core/simd/simd_i8x16_cmp.wast b/test/core/simd/simd_i8x16_cmp.wast index 64cf871fa..8683accea 100644 --- a/test/core/simd/simd_i8x16_cmp.wast +++ b/test/core/simd/simd_i8x16_cmp.wast @@ -1682,3 +1682,166 @@ (assert_return (invoke "nested-ge_s")) (assert_return (invoke "as-param")) + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.eq-1st-arg-empty (result v128) + (i8x16.eq (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.eq-arg-empty (result v128) + (i8x16.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ne-1st-arg-empty (result v128) + (i8x16.ne (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.ne-arg-empty (result v128) + (i8x16.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.lt_s-1st-arg-empty (result v128) + (i8x16.lt_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.lt_s-arg-empty (result v128) + (i8x16.lt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.lt_u-1st-arg-empty (result v128) + (i8x16.lt_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.lt_u-arg-empty (result v128) + (i8x16.lt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.le_s-1st-arg-empty (result v128) + (i8x16.le_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.le_s-arg-empty (result v128) + (i8x16.le_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.le_u-1st-arg-empty (result v128) + (i8x16.le_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.le_u-arg-empty (result v128) + (i8x16.le_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.gt_s-1st-arg-empty (result v128) + (i8x16.gt_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.gt_s-arg-empty (result v128) + (i8x16.gt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.gt_u-1st-arg-empty (result v128) + (i8x16.gt_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.gt_u-arg-empty (result v128) + (i8x16.gt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ge_s-1st-arg-empty (result v128) + (i8x16.ge_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.ge_s-arg-empty (result v128) + (i8x16.ge_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ge_u-1st-arg-empty (result v128) + (i8x16.ge_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.ge_u-arg-empty (result v128) + (i8x16.ge_u) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/test/core/simd/simd_i8x16_sat_arith.wast b/test/core/simd/simd_i8x16_sat_arith.wast index 2ea780922..6a178e55c 100644 --- a/test/core/simd/simd_i8x16_sat_arith.wast +++ b/test/core/simd/simd_i8x16_sat_arith.wast @@ -601,6 +601,73 @@ (assert_invalid (module (func (result v128) (i8x16.sub_saturate_s (i32.const 0) (f32.const 0.0)))) "type mismatch") (assert_invalid (module (func (result v128) (i8x16.sub_saturate_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.add_saturate_s-1st-arg-empty (result v128) + (i8x16.add_saturate_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.add_saturate_s-arg-empty (result v128) + (i8x16.add_saturate_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add_saturate_u-1st-arg-empty (result v128) + (i8x16.add_saturate_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.add_saturate_u-arg-empty (result v128) + (i8x16.add_saturate_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub_saturate_s-1st-arg-empty (result v128) + (i8x16.sub_saturate_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.sub_saturate_s-arg-empty (result v128) + (i8x16.sub_saturate_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub_saturate_u-1st-arg-empty (result v128) + (i8x16.sub_saturate_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.sub_saturate_u-arg-empty (result v128) + (i8x16.sub_saturate_u) + ) + ) + "type mismatch" +) + ;; combination (module (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128) diff --git a/test/core/simd/simd_lane.wast b/test/core/simd/simd_lane.wast index 08d647440..96b781269 100644 --- a/test/core/simd/simd_lane.wast +++ b/test/core/simd/simd_lane.wast @@ -846,3 +846,150 @@ (assert_return (invoke "as-local_set-value-1" (v128.const i64x2 -1 -1)) (i64.const -1)) (assert_return (invoke "as-global_set-value-3" (v128.const f64x2 0 0)(f64.const 3.14)) (v128.const f64x2 3.14 0)) + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.extract_lane_s-1st-arg-empty (result i32) + (i8x16.extract_lane_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.extract_lane_s-2nd-arg-empty (result i32) + (i8x16.extract_lane_s 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.extract_lane_s-arg-empty (result i32) + (i8x16.extract_lane_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extract_lane_u-1st-arg-empty (result i32) + (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extract_lane_u-2nd-arg-empty (result i32) + (i16x8.extract_lane_u 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extract_lane_u-arg-empty (result i32) + (i16x8.extract_lane_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extract_lane-1st-arg-empty (result i32) + (i32x4.extract_lane (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extract_lane-2nd-arg-empty (result i32) + (i32x4.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extract_lane-arg-empty (result i32) + (i32x4.extract_lane) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extract_lane-1st-arg-empty (result i64) + (i64x2.extract_lane (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extract_lane-2nd-arg-empty (result i64) + (i64x2.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extract_lane-arg-empty (result i64) + (i64x2.extract_lane) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.extract_lane-1st-arg-empty (result f32) + (f32x4.extract_lane (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.extract_lane-2nd-arg-empty (result f32) + (f32x4.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.extract_lane-arg-empty (result f32) + (f32x4.extract_lane) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.extract_lane-1st-arg-empty (result f64) + (f64x2.extract_lane (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.extract_lane-2nd-arg-empty (result f64) + (f64x2.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.extract_lane-arg-empty (result f64) + (f64x2.extract_lane) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_load.wast b/test/core/simd/simd_load.wast index ad85a7c62..1cc2045f4 100644 --- a/test/core/simd/simd_load.wast +++ b/test/core/simd/simd_load.wast @@ -181,4 +181,32 @@ (assert_invalid (module (memory 1) (func (drop (v128.load (local.get 2))))) "unknown local 2" -) \ No newline at end of file +) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $v128.const-arg-empty (result v128) + (v128.const) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.const-1st-arg-empty (result v128) + (v128.const 0 0 0 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.const-2nd-arg-empty (result v128) + (v128.const i32x4) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_load_extend.wast b/test/core/simd/simd_load_extend.wast index 483fe9de7..d6a1ac122 100644 --- a/test/core/simd/simd_load_extend.wast +++ b/test/core/simd/simd_load_extend.wast @@ -220,7 +220,59 @@ (assert_invalid (module (memory 0) (func (result v128) (i64x2.load32x2_s (v128.const i32x4 0 0 0 0)))) "type mismatch") (assert_invalid (module (memory 0) (func (result v128) (i64x2.load32x2_u (v128.const i32x4 0 0 0 0)))) "type mismatch") -;; unknown operator +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $i16x8.load8x8_s-arg-empty (result v128) + (i16x8.load8x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $i16x8.load8x8_u-arg-empty (result v128) + (i16x8.load8x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $i32x4.load16x4_s-arg-empty (result v128) + (i32x4.load16x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $i32x4.load16x4_u-arg-empty (result v128) + (i32x4.load16x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $i64x2.load32x2_s-arg-empty (result v128) + (i64x2.load32x2_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $i64x2.load32x2_u-arg-empty (result v128) + (i64x2.load32x2_u) + ) + ) + "type mismatch" +) + +;; Unknown operator + (assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator") @@ -304,4 +356,4 @@ (assert_return (invoke "i32x4.load16x4_s-extract_lane_s-operand") (i32.const 14)) (assert_return (invoke "i32x4.load16x4_u-extract_lane_s-operand") (i32.const 15)) (assert_return (invoke "i64x2.load32x2_s-extract_lane_s-operand") (i32.const -128)) -(assert_return (invoke "i64x2.load32x2_u-extract_lane_s-operand") (i32.const -127)) \ No newline at end of file +(assert_return (invoke "i64x2.load32x2_u-extract_lane_s-operand") (i32.const -127)) diff --git a/test/core/simd/simd_load_splat.wast b/test/core/simd/simd_load_splat.wast index a9faf2161..a2d804273 100644 --- a/test/core/simd/simd_load_splat.wast +++ b/test/core/simd/simd_load_splat.wast @@ -217,4 +217,40 @@ (assert_malformed (module quote "(memory 1) (func (drop (i8x16.load_splat (i32.const 0))))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (drop (i16x8.load_splat (i32.const 0))))") "unknown operator") (assert_malformed (module quote "(memory 1) (func (drop (i32x4.load_splat (i32.const 0))))") "unknown operator") -(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator") \ No newline at end of file +(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator") + + +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $v8x16.load_splat-arg-empty (result v128) + (v8x16.load_splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v16x8.load_splat-arg-empty (result v128) + (v16x8.load_splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v32x4.load_splat-arg-empty (result v128) + (v32x4.load_splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v64x2.load_splat-arg-empty (result v128) + (v64x2.load_splat) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_splat.wast b/test/core/simd/simd_splat.wast index 721bbca06..94004b7b4 100644 --- a/test/core/simd/simd_splat.wast +++ b/test/core/simd/simd_splat.wast @@ -229,7 +229,7 @@ (i8x16.sub_saturate_u (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1)))) (func (export "as-i16x8_sub_saturate_u-operands") (param i32 i32) (result v128) (i16x8.sub_saturate_u (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1)))) - + ;; Bit shifts (func (export "as-i8x16_shr_s-operand") (param i32 i32) (result v128) (i8x16.shr_s (i8x16.splat (local.get 0)) (local.get 1))) @@ -375,4 +375,56 @@ (assert_return (invoke "as-br-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD)) (assert_return (invoke "as-return-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD)) (assert_return (invoke "as-local_set-value2" (i64.const 0x10000)) (v128.const i64x2 0x10000 0x10000)) -(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0)) \ No newline at end of file +(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0)) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.splat-arg-empty (result v128) + (i8x16.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.splat-arg-empty (result v128) + (i16x8.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.splat-arg-empty (result v128) + (i32x4.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.splat-arg-empty (result v128) + (f32x4.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.splat-arg-empty (result v128) + (i64x2.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.splat-arg-empty (result v128) + (f64x2.splat) + ) + ) + "type mismatch" +) diff --git a/test/core/simd/simd_store.wast b/test/core/simd/simd_store.wast index 74931e51c..50349c41b 100644 --- a/test/core/simd/simd_store.wast +++ b/test/core/simd/simd_store.wast @@ -135,4 +135,32 @@ (assert_invalid (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch" -) \ No newline at end of file +) + + +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $v128.store-1st-arg-empty + (v128.store (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.store-2nd-arg-empty + (v128.store (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.store-arg-empty + (v128.store) + ) + ) + "type mismatch" +)