[test] Add spec tests for integer min/max ops

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`.

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',
 )
 
 

test/core/simd/meta/simd.py

@@ -6,33 +6,34 @@
 """
 
 
-class SIMD(object):
+class SIMD:
 
     # Constant template
     CONST = '({value_type}.const {value})'
 
     # 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)
+        return SIMD.V128_CONST.format(lane_type=lane_type, value=data_elem)

test/core/simd/meta/simd_integer_op.py

@@ -0,0 +1,66 @@
+#!/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: 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:
+        """
+        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']:
+            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:
+                return p1 if i1 >= i2 else p2
+
+        else:
+            raise Exception('Unknown binary operation')
+
+    @staticmethod
+    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 signed:
+            if value > lane.max:
+                return value - lane.mod
+            if value < lane.min:
+                return value + lane.mod
+
+        return value

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)