LLVMCodeBuilder: Implement mod operator

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -37,6 +37,8 @@ class ICodeBuilder
         virtual void createOr() = 0;
         virtual void createNot() = 0;
 
+        virtual void createMod() = 0;
+
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -180,6 +180,20 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::Mod: {
+                assert(step.args.size() == 2);
+                const auto &arg1 = step.args[0];
+                const auto &arg2 = step.args[1];
+                // rem(a, b) / b < 0.0 ? rem(a, b) + b : rem(a, b)
+                llvm::Constant *zero = llvm::ConstantFP::get(m_ctx, llvm::APFloat(0.0));
+                llvm::Value *num1 = removeNaN(castValue(arg1.second, arg1.first));
+                llvm::Value *num2 = removeNaN(castValue(arg2.second, arg2.first));
+                llvm::Value *value = m_builder.CreateFRem(num1, num2);                                // rem(a, b)
+                llvm::Value *cond = m_builder.CreateFCmpOLT(m_builder.CreateFDiv(value, num2), zero); // rem(a, b) / b < 0.0                                                            // rem(a, b)
+                step.functionReturnReg->value = m_builder.CreateSelect(cond, m_builder.CreateFAdd(value, num2), value);
+                break;
+            }
+
             case Step::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -548,6 +562,11 @@ void LLVMCodeBuilder::createNot()
     createOp(Step::Type::Not, Compiler::StaticType::Bool, Compiler::StaticType::Bool, 1);
 }
 
+void LLVMCodeBuilder::createMod()
+{
+    createOp(Step::Type::Mod, Compiler::StaticType::Number, Compiler::StaticType::Number, 2);
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     Step step(Step::Type::BeginIf);

src/dev/engine/internal/llvmcodebuilder.h

@@ -39,6 +39,8 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createOr() override;
         void createNot() override;
 
+        void createMod() override;
+
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -81,6 +83,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                     And,
                     Or,
                     Not,
+                    Mod,
                     Yield,
                     BeginIf,
                     BeginElse,

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -1024,6 +1024,67 @@ TEST_F(LLVMCodeBuilderTest, Not)
     addOpTest("nan");
 }
 
+TEST_F(LLVMCodeBuilderTest, Mod)
+{
+    std::string expected;
+
+    auto addOpTest = [this, &expected](Value v1, Value v2) {
+        createBuilder(true);
+
+        m_builder->addConstValue(v1);
+        m_builder->addConstValue(v2);
+        m_builder->createMod();
+        m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+        m_builder->addConstValue(v1);
+        m_builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number });
+        m_builder->addConstValue(v2);
+        m_builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number });
+        m_builder->createMod();
+        m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+        std::string str = (v1 % v2).toString() + '\n';
+        std::string expected = str + str;
+
+        auto code = m_builder->finalize();
+        auto ctx = code->createExecutionContext(&m_target);
+
+        testing::internal::CaptureStdout();
+        code->run(ctx.get());
+        const std::string quotes1 = v1.isString() ? "\"" : "";
+        const std::string quotes2 = v2.isString() ? "\"" : "";
+        ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << quotes1 << v1.toString() << quotes1 << " " << quotes2 << v2.toString() << quotes2;
+    };
+
+    addOpTest(4, 3);
+    addOpTest(3, 3);
+    addOpTest(2, 3);
+    addOpTest(1, 3);
+    addOpTest(0, 3);
+    addOpTest(-1, 3);
+    addOpTest(-2, 3);
+    addOpTest(-3, 3);
+    addOpTest(-4, 3);
+    addOpTest(4.75, 2);
+    addOpTest(-4.75, 2);
+    addOpTest(-4.75, -2);
+    addOpTest(4.75, -2);
+    addOpTest(5, 0);
+    addOpTest(-5, 0);
+    addOpTest(-2.5, "Infinity");
+    addOpTest(-1.2, "-Infinity");
+    addOpTest(2.5, "Infinity");
+    addOpTest(1.2, "-Infinity");
+    addOpTest("Infinity", 2);
+    addOpTest("-Infinity", 2);
+    addOpTest("Infinity", -2);
+    addOpTest("-Infinity", -2);
+    addOpTest(3, "NaN");
+    addOpTest(-3, "NaN");
+    addOpTest("NaN", 5);
+    addOpTest("NaN", -5);
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {

test/mocks/codebuildermock.h

@@ -27,6 +27,8 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createOr, (), (override));
         MOCK_METHOD(void, createNot, (), (override));
 
+        MOCK_METHOD(void, createMod, (), (override));
+
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));
         MOCK_METHOD(void, endIf, (), (override));