Skip to content

Commit

Permalink
64
Browse files Browse the repository at this point in the history
  • Loading branch information
@ashleynh
ashleynh committed Feb 26, 2025
1 parent 955af60 commit 820d207
Show file tree
Hide file tree
Showing 2 changed files with 283 additions and 0 deletions.
25 changes: 25 additions & 0 deletions src/interpreter/interpreter.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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));
Expand All @@ -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));
Expand Down
258 changes: 258 additions & 0 deletions test/gtest/interpreter.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -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);
Expand Down

0 comments on commit 820d207

Please # to comment.