Implement floating-point rounding in interpreter (#344)

Implement f32x4 and f64x2 ceil, floor, trunc, nearest. They have the
same behavior as the f32 and f64 instructions.

Also implemented to encoding and decoding.

These new instructions were added to simd_f32x4.wast test case, and the
test generation script is updated with these new instructions.

Author: ngzhian

interpreter/binary/decode.ml

@@ -377,6 +377,14 @@ let simd_prefix s =
   | 0xcel -> i64x2_add
   | 0xd1l -> i64x2_sub
   | 0xd5l -> i64x2_mul
+  | 0xd8l -> f32x4_ceil
+  | 0xd9l -> f32x4_floor
+  | 0xdal -> f32x4_trunc
+  | 0xdbl -> f32x4_nearest
+  | 0xdcl -> f64x2_ceil
+  | 0xddl -> f64x2_floor
+  | 0xdel -> f64x2_trunc
+  | 0xdfl -> f64x2_nearest
   | 0xe0l -> f32x4_abs
   | 0xe1l -> f32x4_neg
   | 0xe3l -> f32x4_sqrt

interpreter/binary/encode.ml

@@ -339,6 +339,14 @@ let encode m =
       | Unary (V128 V128Op.(I32x4 WidenLowU)) -> simd_op 0xa9l
       | Unary (V128 V128Op.(I32x4 WidenHighU)) -> simd_op 0xaal
       | Unary (V128 V128Op.(I64x2 Neg)) -> simd_op 0xc1l
+      | Unary (V128 V128Op.(F32x4 Ceil)) -> simd_op 0xd8l
+      | Unary (V128 V128Op.(F32x4 Floor)) -> simd_op 0xd9l
+      | Unary (V128 V128Op.(F32x4 Trunc)) -> simd_op 0xdal
+      | Unary (V128 V128Op.(F32x4 Nearest)) -> simd_op 0xdbl
+      | Unary (V128 V128Op.(F64x2 Ceil)) -> simd_op 0xdcl
+      | Unary (V128 V128Op.(F64x2 Floor)) -> simd_op 0xddl
+      | Unary (V128 V128Op.(F64x2 Trunc)) -> simd_op 0xdel
+      | Unary (V128 V128Op.(F64x2 Nearest)) -> simd_op 0xdfl
       | Unary (V128 V128Op.(F32x4 Abs)) -> simd_op 0xe0l
       | Unary (V128 V128Op.(F32x4 Neg)) -> simd_op 0xe1l
       | Unary (V128 V128Op.(F32x4 Sqrt)) -> simd_op 0xe3l

interpreter/exec/eval_numeric.ml

@@ -148,11 +148,19 @@ struct
       | F32x4 Abs -> to_value (SXX.F32x4.abs (of_value 1 v))
       | F32x4 Neg -> to_value (SXX.F32x4.neg (of_value 1 v))
       | F32x4 Sqrt -> to_value (SXX.F32x4.sqrt (of_value 1 v))
+      | F32x4 Ceil -> to_value (SXX.F32x4.ceil (of_value 1 v))
+      | F32x4 Floor -> to_value (SXX.F32x4.floor (of_value 1 v))
+      | F32x4 Trunc -> to_value (SXX.F32x4.trunc (of_value 1 v))
+      | F32x4 Nearest -> to_value (SXX.F32x4.nearest (of_value 1 v))
       | F32x4 ConvertI32x4S -> to_value (SXX.F32x4_convert.convert_i32x4_s (of_value 1 v))
       | F32x4 ConvertI32x4U -> to_value (SXX.F32x4_convert.convert_i32x4_u (of_value 1 v))
       | F64x2 Abs -> to_value (SXX.F64x2.abs (of_value 1 v))
       | F64x2 Neg -> to_value (SXX.F64x2.neg (of_value 1 v))
       | F64x2 Sqrt -> to_value (SXX.F64x2.sqrt (of_value 1 v))
+      | F64x2 Ceil -> to_value (SXX.F64x2.ceil (of_value 1 v))
+      | F64x2 Floor -> to_value (SXX.F64x2.floor (of_value 1 v))
+      | F64x2 Trunc -> to_value (SXX.F64x2.trunc (of_value 1 v))
+      | F64x2 Nearest -> to_value (SXX.F64x2.nearest (of_value 1 v))
       | V128 Not -> to_value (SXX.V128.lognot (of_value 1 v))
       | _ -> failwith "TODO v128 unimplemented unop"
 

interpreter/exec/simd.ml

@@ -109,6 +109,10 @@ sig
   val abs : t -> t
   val neg : t -> t
   val sqrt : t -> t
+  val ceil : t -> t
+  val floor : t -> t
+  val trunc : t -> t
+  val nearest : t -> t
   val add : t -> t -> t
   val sub : t -> t -> t
   val mul : t -> t -> t
@@ -254,6 +258,10 @@ struct
     let abs = unop Float.abs
     let neg = unop Float.neg
     let sqrt = unop Float.sqrt
+    let ceil = unop Float.ceil
+    let floor = unop Float.floor
+    let trunc = unop Float.trunc
+    let nearest = unop Float.nearest
     let add = binop Float.add
     let sub = binop Float.sub
     let mul = binop Float.mul

interpreter/syntax/ast.ml

@@ -54,7 +54,9 @@ struct
               | Eq | Ne | LtS | LtU | LeS | LeU | GtS | GtU | GeS | GeU
               | Swizzle | Shuffle of int list | NarrowS | NarrowU
               | AddSatS | AddSatU | SubSatS | SubSatU
-  type funop = Abs | Neg | Sqrt | ConvertI32x4S | ConvertI32x4U
+  type funop = Abs | Neg | Sqrt
+             | Ceil | Floor | Trunc | Nearest
+             | ConvertI32x4S | ConvertI32x4U
   type fbinop = Add | Sub | Mul | Div | Min | Max
               | Eq | Ne | Lt | Le | Gt | Ge
   type vunop = Not

interpreter/syntax/operators.ml

@@ -385,6 +385,10 @@ let f32x4_ge = Binary (V128 V128Op.(F32x4 Ge))
 let f32x4_abs = Unary (V128 (V128Op.F32x4 V128Op.Abs))
 let f32x4_neg = Unary (V128 (V128Op.F32x4 V128Op.Neg))
 let f32x4_sqrt = Unary (V128 (V128Op.F32x4 V128Op.Sqrt))
+let f32x4_ceil = Unary (V128 (V128Op.(F32x4 Ceil)))
+let f32x4_floor = Unary (V128 (V128Op.(F32x4 Floor)))
+let f32x4_trunc = Unary (V128 (V128Op.(F32x4 Trunc)))
+let f32x4_nearest = Unary (V128 (V128Op.(F32x4 Nearest)))
 let f32x4_add = Binary (V128 (V128Op.F32x4 V128Op.Add))
 let f32x4_sub = Binary (V128 (V128Op.F32x4 V128Op.Sub))
 let f32x4_mul = Binary (V128 (V128Op.F32x4 V128Op.Mul))
@@ -405,6 +409,10 @@ let f64x2_gt = Binary (V128 V128Op.(F64x2 Gt))
 let f64x2_ge = Binary (V128 V128Op.(F64x2 Ge))
 let f64x2_neg = Unary (V128 (V128Op.F64x2 V128Op.Neg))
 let f64x2_sqrt = Unary (V128 (V128Op.F64x2 V128Op.Sqrt))
+let f64x2_ceil = Unary (V128 (V128Op.(F64x2 Ceil)))
+let f64x2_floor = Unary (V128 (V128Op.(F64x2 Floor)))
+let f64x2_trunc = Unary (V128 (V128Op.(F64x2 Trunc)))
+let f64x2_nearest = Unary (V128 (V128Op.(F64x2 Nearest)))
 let f64x2_add = Binary (V128 (V128Op.F64x2 V128Op.Add))
 let f64x2_sub = Binary (V128 (V128Op.F64x2 V128Op.Sub))
 let f64x2_mul = Binary (V128 (V128Op.F64x2 V128Op.Mul))

interpreter/text/arrange.ml

@@ -219,6 +219,14 @@ struct
     | I32x4 TruncSatF32x4S -> "i32x4.trunc_sat_f32x4_s"
     | I32x4 TruncSatF32x4U -> "i32x4.trunc_sat_f32x4_u"
     | I64x2 Neg -> "i64x2.neg"
+    | F32x4 Ceil -> "f32x4.ceil"
+    | F32x4 Floor -> "f32x4.floor"
+    | F32x4 Trunc -> "f32x4.trunc"
+    | F32x4 Nearest -> "f32x4.nearest"
+    | F64x2 Ceil -> "f64x2.ceil"
+    | F64x2 Floor -> "f64x2.floor"
+    | F64x2 Trunc -> "f64x2.trunc"
+    | F64x2 Nearest -> "f64x2.nearest"
     | F32x4 Abs -> "f32x4.abs"
     | F32x4 Neg -> "f32x4.neg"
     | F32x4 Sqrt -> "f32x4.sqrt"

interpreter/text/lexer.mll

@@ -490,6 +490,10 @@ rule token = parse
   | (simd_shape as s)".neg"
     { UNARY (simdop s i8x16_neg i16x8_neg i32x4_neg i64x2_neg f32x4_neg f64x2_neg) }
   | (simd_float_shape as s)".sqrt" { UNARY (simd_float_op s f32x4_sqrt f64x2_sqrt) }
+  | (simd_float_shape as s)".ceil" { UNARY (simd_float_op s f32x4_ceil f64x2_ceil) }
+  | (simd_float_shape as s)".floor" { UNARY (simd_float_op s f32x4_floor f64x2_floor) }
+  | (simd_float_shape as s)".trunc" { UNARY (simd_float_op s f32x4_trunc f64x2_trunc) }
+  | (simd_float_shape as s)".nearest" { UNARY (simd_float_op s f32x4_nearest f64x2_nearest) }
   | (simd_shape as s)".add"
     { BINARY (simdop s i8x16_add i16x8_add i32x4_add i64x2_add f32x4_add f64x2_add) }
   | (simd_shape as s)".sub"

test/core/simd/meta/README.md

@@ -22,6 +22,8 @@ Currently it only support following simd test files generation.
 - 'simd_i16x8_sat_arith.wast'
 - 'simd_f32x4.wast'
 - 'simd_f64x2.wast'
+- 'simd_f32x4_rounding'
+- 'simd_f64x2_rounding'
 
 
 Usage:

test/core/simd/meta/gen_tests.py

@@ -26,6 +26,8 @@
     'simd_f32x4',
     'simd_f64x2',
     'simd_int_arith2',
+    'simd_f32x4_rounding',
+    'simd_f64x2_rounding',
 )
 
 
@@ -61,4 +63,4 @@ def main():
 
 if __name__ == '__main__':
     main()
-    print('Done.')
+    print('Done.')

test/core/simd/meta/simd_f32x4_rounding.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [ceil, floor, trunc, nearest] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointRoundingOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4RoundingCase(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ('ceil', 'floor', 'trunc', 'nearest')
+    BINARY_OPS = ()
+    floatOp = FloatingPointRoundingOp()
+
+    def get_combine_cases(self):
+        return ''
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        unary_test_data = []
+
+        for op in self.UNARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand in self.FLOAT_NUMBERS:
+                result = self.floatOp.unary_op(op, operand)
+                if 'nan' in result:
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+                else:
+                    unary_test_data.append([op_name, operand, result])
+
+            for operand in self.LITERAL_NUMBERS:
+                result = self.floatOp.unary_op(op, operand, hex_form=False)
+                unary_test_data.append([op_name, operand, result])
+
+            for operand in self.NAN_NUMBERS:
+                if 'nan:' in operand:
+                    unary_test_data.append([op_name, operand, 'nan:arithmetic'])
+                else:
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+            for op in self.UNARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=self.v128_const('i32x4', '0')))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_rounding.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace(
+                    self.LANE_TYPE + ' arithmetic',
+                    self.LANE_TYPE + ' [ceil, floor, trunc, nearest]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_case = Simdf32x4RoundingCase()
+    simd_f32x4_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()

test/core/simd/meta/simd_f64x2_rounding.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [ceil, floor, trunc, nearest] cases.
+"""
+
+from simd_f32x4_rounding import Simdf32x4RoundingCase
+from simd_f64x2 import Simdf64x2Case
+from simd_f64x2_arith import Simdf64x2ArithmeticCase
+from simd_float_op import FloatingPointRoundingOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf64x2RoundingCase(Simdf32x4RoundingCase):
+
+    LANE_TYPE = 'f64x2'
+    FLOAT_NUMBERS = Simdf64x2ArithmeticCase.FLOAT_NUMBERS
+    LITERAL_NUMBERS = Simdf64x2ArithmeticCase.LITERAL_NUMBERS
+    NAN_NUMBERS = Simdf64x2ArithmeticCase.NAN_NUMBERS
+
+
+def gen_test_cases():
+    simd_f64x2_case = Simdf64x2RoundingCase()
+    simd_f64x2_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()

test/core/simd/meta/simd_float_op.py

@@ -252,4 +252,53 @@ def binary_op(self, op: str, p1: str, p2: str) -> str:
         elif op == 'ge':
             return '-1' if f1 >= f2 else '0'
         else:
-            raise Exception('Unknown binary operation')
+            raise Exception('Unknown binary operation')
+
+
+class FloatingPointRoundingOp(FloatingPointOp):
+    def unary_op(self, op: str, p1: str, hex_form=True) -> str:
+        """Unnary operation on p1 with the operation specified by op
+
+        :param op: ceil, floor, trunc, nearest
+        :param p1: float number in hex
+        :return:
+        """
+        if '0x' in p1:
+            f1 = float.fromhex(p1)
+        else:
+            f1 = float(p1)
+
+        if 'nan' in p1:
+            return 'nan'
+
+        if 'inf' in p1:
+            return p1
+
+        # The rounding ops don't treat -0.0 correctly, e.g.:
+        # math.ceil(-0.4) returns +0.0, so copy the sign.
+        elif op == 'ceil':
+            r = math.copysign(math.ceil(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'floor':
+            r = math.copysign(math.floor(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'trunc':
+            r = math.copysign(math.trunc(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'nearest':
+            r = math.copysign(round(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        else:
+            raise Exception('Unknown binary operation')