Implement v128.const parsing for f64x2 with nans (#219)

And enough operations to pass the simd_f64x2.wast test.

Author: ngzhian

interpreter/exec/eval_numeric.ml

@@ -128,11 +128,14 @@ struct
   let unop op =
     fun v -> match op with
       | F32x4Abs -> to_value (SXX.f32x4_abs (of_value 1 v))
+      | F64x2Abs -> to_value (SXX.f64x2_abs (of_value 1 v))
 
   let binop op =
     let f = match op with
       | F32x4Min -> SXX.f32x4_min
       | F32x4Max -> SXX.f32x4_max
+      | F64x2Min -> SXX.f64x2_min
+      | F64x2Max -> SXX.f64x2_max
     in fun v1 v2 -> to_value (f (of_value 1 v1) (of_value 2 v2))
 
   (* FIXME *)

interpreter/exec/simd.ml

@@ -12,6 +12,7 @@ let lanes shape =
   | F64x2 -> 2
 
 let f32x4_indices = [0; 4; 8; 12]
+let f64x2_indices = [0; 8]
 
 module type RepType =
 sig
@@ -27,6 +28,9 @@ sig
 
   val to_f32x4 : t -> F32.t list
   val of_f32x4 : F32.t list -> t
+
+  val to_f64x2 : t -> F64.t list
+  val of_f64x2 : F64.t list -> t
 end
 
 module type S =
@@ -45,6 +49,11 @@ sig
   val f32x4_max : t -> t -> t
   val f32x4_abs : t -> t
   val f32x4_extract_lane : int -> t -> F32.t
+
+  val f64x2_min : t -> t -> t
+  val f64x2_max : t -> t -> t
+  val f64x2_abs : t -> t
+  val f64x2_extract_lane : int -> t -> F64.t
 end
 
 module Make (Rep : RepType) : S with type bits = Rep.t =
@@ -73,4 +82,16 @@ struct
   let f32x4_min = f32x4_binop F32.min
   let f32x4_max = f32x4_binop F32.max
   let f32x4_abs x = f32x4_unop F32.abs x
+
+  let to_f64x2 = Rep.to_f64x2
+  let of_f64x2 = Rep.of_f64x2
+  let f64x2_unop f x =
+    of_f64x2 (List.map f (to_f64x2 x))
+  let f64x2_binop f x y =
+    of_f64x2 (List.map2 f (to_f64x2 x) (to_f64x2 y))
+
+  let f64x2_extract_lane i x = List.nth (to_f64x2 x) i
+  let f64x2_min = f64x2_binop F64.min
+  let f64x2_max = f64x2_binop F64.max
+  let f64x2_abs x = f64x2_unop F64.abs x
 end

interpreter/exec/v128.ml

@@ -11,10 +11,18 @@ include Simd.Make
       List.map (fun i -> F32.of_bits (Bytes.get_int32_le (Bytes.of_string s) i)) Simd.f32x4_indices
 
     let of_f32x4 fs =
-      let b = create bytewidth in
+      let b = Bytes.create bytewidth in
       List.iter2 (fun i f -> Bytes.set_int32_le b i (F32.to_bits f)) Simd.f32x4_indices fs;
       Bytes.to_string b
 
+    let to_f64x2 s =
+      List.map (fun i -> F64.of_bits (Bytes.get_int64_le (Bytes.of_string s) i)) Simd.f64x2_indices
+
+    let of_f64x2 fs =
+      let b = Bytes.create bytewidth in
+      List.iter2 (fun i f -> Bytes.set_int64_le b i (F64.to_bits f)) Simd.f64x2_indices fs;
+      Bytes.to_string b
+
     let of_strings shape ss =
       if List.length ss <> Simd.lanes shape then raise (Invalid_argument "wrong length");
       let range_check i32 min max at =

interpreter/script/run.ml

@@ -383,6 +383,12 @@ let assert_result at got expect =
                       List.exists2 (fun v r ->
                           assert_num_pat at v r
                       ) [l0; l1; l2; l3]  vs
+            | F64x2, V128 v ->
+                    let l0 = F64 (V128.f64x2_extract_lane 0 v) in
+                    let l1 = F64 (V128.f64x2_extract_lane 1 v) in
+                      List.exists2 (fun v r ->
+                          assert_num_pat at v r
+                      ) [l0; l1]  vs
             | _ -> failwith "impossible"
         end
     ) got expect

interpreter/syntax/ast.ml

@@ -47,8 +47,8 @@ end
 (* FIXME *)
 module SimdOp =
 struct
-  type unop = F32x4Abs
-  type binop = F32x4Min | F32x4Max
+  type unop = F32x4Abs | F64x2Abs
+  type binop = F32x4Min | F32x4Max | F64x2Min | F64x2Max
   type testop = TodoTestOp
   type relop = TodoRelOp
   type cvtop = TodoCvtOp

interpreter/syntax/operators.ml

@@ -210,3 +210,7 @@ let f32x4_extract_lane imm = ExtractLane (V128Op.F32x4ExtractLane imm)
 let f32x4_min = Binary (V128 V128Op.F32x4Min)
 let f32x4_max = Binary (V128 V128Op.F32x4Max)
 let f32x4_abs = Unary (V128 V128Op.F32x4Abs)
+
+let f64x2_min = Binary (V128 V128Op.F64x2Min)
+let f64x2_max = Binary (V128 V128Op.F64x2Max)
+let f64x2_abs = Unary (V128 V128Op.F64x2Abs)

interpreter/text/lexer.mll

@@ -382,13 +382,13 @@ rule token = parse
 
   | (simd_shape as s)".min"
     { if s <> "f32x4" && s <> "f64x2" then error lexbuf "unknown operator";
-      BINARY (simdop s unreachable unreachable unreachable unreachable f32x4_min unreachable) }
+      BINARY (simdop s unreachable unreachable unreachable unreachable f32x4_min f64x2_min) }
   | (simd_shape as s)".max"
     { if s <> "f32x4" && s <> "f64x2" then error lexbuf "unknown operator";
-      BINARY (simdop s unreachable unreachable unreachable unreachable f32x4_max unreachable) }
+      BINARY (simdop s unreachable unreachable unreachable unreachable f32x4_max f64x2_max) }
   | (simd_shape as s)".abs"
     { if s = "i64x2" then error lexbuf "unknown operator";
-      UNARY (simdop s unreachable unreachable unreachable unreachable f32x4_abs unreachable) }
+      UNARY (simdop s unreachable unreachable unreachable unreachable f32x4_abs f64x2_abs) }
   | (simd_shape as s) { SIMD_SHAPE (simd_shape s) }
 
   | name as s { VAR s }

interpreter/text/parser.mly

@@ -880,8 +880,13 @@ result :
   | const { NumResult (LitPat $1 @@ at ()) @@ at () }
   | LPAR CONST NAN RPAR { NumResult (NanPat (nanop $2 ($3 @@ ati 3)) @@ ati 3) @@ at () }
   | LPAR V128_CONST SIMD_SHAPE numpat numpat numpat numpat RPAR {
+      if ($3 <> Simd.F32x4) then error (ati 3) "invalid SIMD shape";
       SimdResult ($3, [$4 $3; $5 $3; $6 $3; $7 $3]) @@ at ()
   }
+  | LPAR V128_CONST SIMD_SHAPE numpat numpat RPAR {
+      if ($3 <> Simd.F64x2) then error (ati 3) "invalid SIMD shape";
+      SimdResult ($3, [$4 $3; $5 $3]) @@ at ()
+  }
 
 result_list :
   | /* empty */ { [] }