From 820d207d0cb685a6b7d53bbc53150d4c99d7bc20 Mon Sep 17 00:00:00 2001
From: Ashley Nelson <nashley@google.com>
Date: Wed, 26 Feb 2025 01:54:10 +0000
Subject: [PATCH] 64

---
 src/interpreter/interpreter.cpp |  25 ++++
 test/gtest/interpreter.cpp      | 258 ++++++++++++++++++++++++++++++++
 2 files changed, 283 insertions(+)

diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
index b07cc328cea..69c670c56a4 100644
--- a/src/interpreter/interpreter.cpp
+++ b/src/interpreter/interpreter.cpp
@@ -119,16 +119,19 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
     // TODO: add support for all operations.
     switch (curr->op) {
       case AddInt32:
+      case AddInt64:
       case AddFloat32:
       case AddFloat64:
         push(lhs.add(rhs));
         return {};
       case SubInt32:
+      case SubInt64:
       case SubFloat32:
       case SubFloat64:
         push(lhs.sub(rhs));
         return {};
       case MulInt32:
+      case MulInt64:
       case MulFloat32:
       case MulFloat64:
         push(lhs.mul(rhs));
@@ -137,6 +140,28 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
       case DivFloat64:
         push(lhs.div(rhs));
         return {};
+      case EqInt32:
+      case EqInt64:
+      case EqFloat32:
+      case EqFloat64:
+        push(lhs.eq(rhs));
+        return {};
+      case LtSInt32:
+      case LtSInt64:
+        push(lhs.ltS(rhs));
+        return {};
+      case LtUInt32:
+      case LtUInt64:
+        push(lhs.ltU(rhs));
+        return {};
+      case GtSInt32:
+      case GtSInt64:
+        push(lhs.gtS(rhs));
+        return {};
+      case GtUInt32:
+      case GtUInt64:
+        push(lhs.gtU(rhs));
+        return {};
       case MinFloat32:
       case MinFloat64:
         push(lhs.min(rhs));
diff --git a/test/gtest/interpreter.cpp b/test/gtest/interpreter.cpp
index fce15a31e5a..1a155dca38b 100644
--- a/test/gtest/interpreter.cpp
+++ b/test/gtest/interpreter.cpp
@@ -77,6 +77,230 @@ TEST(InterpreterTest, MulI32) {
   EXPECT_EQ(results, expected);
 }
 
+TEST(InterpreterTest, EqI32) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint32_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint32_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(EqInt32).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, LtUI32) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint32_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint32_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(LtUInt32).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(1))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, GtUI32) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint32_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint32_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(GtUInt32).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+// sInt32
+TEST(InterpreterTest, LtSI32) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(int32_t(-1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(int32_t(-2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(LtSInt32).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(int32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, GtSI32) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(int32_t(-3))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(int32_t(-4))).getErr());
+  ASSERT_FALSE(builder.makeBinary(GtSInt32).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(int32_t(1))};
+
+  EXPECT_EQ(results, expected);
+}
+
+// uInt64
+TEST(InterpreterTest, AddI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(AddInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint64_t(3))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, SubI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(SubInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint64_t(-1))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, MulI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(MulInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint64_t(2))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, EqI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(EqInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, LtUI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(LtSInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(1))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, GtUI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(uint64_t(2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(GtSInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+// sInt64
+TEST(InterpreterTest, LtSI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(int64_t(-1))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(int64_t(-2))).getErr());
+  ASSERT_FALSE(builder.makeBinary(LtSInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(int32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
+TEST(InterpreterTest, GtSI64) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(int64_t(-3))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(int64_t(-4))).getErr());
+  ASSERT_FALSE(builder.makeBinary(GtSInt64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(int32_t(1))};
+
+  EXPECT_EQ(results, expected);
+}
+
 // Float32
 TEST(InterpreterTest, AddF32) {
   Module wasm;
@@ -146,6 +370,23 @@ TEST(InterpreterTest, DivF32) {
   EXPECT_EQ(results, expected);
 }
 
+TEST(InterpreterTest, EqF32) {
+  Module wasm;
+  IRBuilder builder(wasm);
+
+  ASSERT_FALSE(builder.makeConst(Literal(float(1.0))).getErr());
+  ASSERT_FALSE(builder.makeConst(Literal(float(2.0))).getErr());
+  ASSERT_FALSE(builder.makeBinary(EqFloat32).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
 TEST(InterpreterTest, SqrtF32) {
   Module wasm;
   IRBuilder builder(wasm);
@@ -295,6 +536,23 @@ TEST(InterpreterTest, DivF64) {
   EXPECT_EQ(results, expected);
 }
 
+TEST(InterpreterTest, EqF64) {
+  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(EqFloat64).getErr());
+
+  auto expr = builder.build();
+  ASSERT_FALSE(expr.getErr());
+
+  auto results = Interpreter{}.run(*expr);
+  std::vector<Literal> expected{Literal(uint32_t(0))};
+
+  EXPECT_EQ(results, expected);
+}
+
 TEST(InterpreterTest, SqrtF64) {
   Module wasm;
   IRBuilder builder(wasm);