[Interpreter] Float64 (#7327)

Building on top of #7227 , the following are implemented and tested:

- f64.add
- f64.sub
- f64.mul
- f64.div
- f64.sqrt
- f64.ceil
- f64.floor
- f64.trunc
- f64.nearbyint

Author: ashleynh

src/interpreter/interpreter.cpp

@@ -90,18 +90,23 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
     auto value = pop();
     switch (curr->op) {
       case SqrtFloat32:
+      case SqrtFloat64:
         push(value.sqrt());
         return {};
       case CeilFloat32:
+      case CeilFloat64:
         push(value.ceil());
         return {};
       case FloorFloat32:
+      case FloorFloat64:
         push(value.floor());
         return {};
       case TruncFloat32:
+      case TruncFloat64:
         push(value.trunc());
         return {};
       case NearestFloat32:
+      case NearestFloat64:
         push(value.nearbyint());
         return {};
       default:
@@ -115,23 +120,29 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
     switch (curr->op) {
       case AddInt32:
       case AddFloat32:
+      case AddFloat64:
         push(lhs.add(rhs));
         return {};
       case SubInt32:
       case SubFloat32:
+      case SubFloat64:
         push(lhs.sub(rhs));
         return {};
       case MulInt32:
       case MulFloat32:
+      case MulFloat64:
         push(lhs.mul(rhs));
         return {};
       case DivFloat32:
+      case DivFloat64:
         push(lhs.div(rhs));
         return {};
       case MinFloat32:
+      case MinFloat64:
         push(lhs.min(rhs));
         return {};
       case MaxFloat32:
+      case MaxFloat64:
         push(lhs.max(rhs));
         return {};
       default:

test/gtest/interpreter.cpp

@@ -25,6 +25,7 @@
 
 using namespace wasm;
 
+// uInt32
 TEST(InterpreterTest, AddI32) {
   Module wasm;
   IRBuilder builder(wasm);
@@ -76,6 +77,7 @@ TEST(InterpreterTest, MulI32) {
   EXPECT_EQ(results, expected);
 }
 
+// Float32
 TEST(InterpreterTest, AddF32) {
   Module wasm;
   IRBuilder builder(wasm);
@@ -223,3 +225,152 @@ TEST(InterpreterTest, NearF32) {
 
   EXPECT_EQ(results, expected);
 }
+
+// Float 64
+TEST(InterpreterTest, AddF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(0.0))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(double(1.0))).getErr());
+  ASSERT_FALSE(builder.makeBinary(AddFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(1.0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, SubF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(1.0))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(double(2.0))).getErr());
+  ASSERT_FALSE(builder.makeBinary(SubFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(-1.0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, MulF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(1.5))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(double(2.0))).getErr());
+  ASSERT_FALSE(builder.makeBinary(MulFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(3.0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, DivF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(5.0))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(double(2.0))).getErr());
+  ASSERT_FALSE(builder.makeBinary(DivFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(2.5))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, SqrtF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(5.0))).getErr());
+  ASSERT_FALSE(builder.makeUnary(SqrtFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(2.23606797749979))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, CeilF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(1.5))).getErr());
+  ASSERT_FALSE(builder.makeUnary(CeilFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(2.0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, FloorF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(1.5))).getErr());
+  ASSERT_FALSE(builder.makeUnary(FloorFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(1.0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, TruncF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(2.017281))).getErr());
+  ASSERT_FALSE(builder.makeUnary(TruncFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(2.0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, NearF64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(double(2.5))).getErr());
+  ASSERT_FALSE(builder.makeUnary(NearestFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(double(2.0))};
+
+  EXPECT_EQ(results, expected);
+}