LLVMCodeBuilder: Implement divide operator

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -27,6 +27,8 @@ class ICodeBuilder
         virtual void createAdd() = 0;
         virtual void createSub() = 0;
         virtual void createMul() = 0;
+        virtual void createDiv() = 0;
+
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -118,6 +118,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::Div: {
+                assert(step.args.size() == 2);
+                const auto &arg1 = step.args[0];
+                const auto &arg2 = step.args[1];
+                llvm::Value *num1 = removeNaN(castValue(arg1.second, arg1.first));
+                llvm::Value *num2 = removeNaN(castValue(arg2.second, arg2.first));
+                step.functionReturnReg->value = m_builder.CreateFDiv(num1, num2);
+                break;
+            }
+
             case Step::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -457,6 +467,11 @@ void LLVMCodeBuilder::createMul()
     createOp(Step::Type::Mul, 2);
 }
 
+void LLVMCodeBuilder::createDiv()
+{
+    createOp(Step::Type::Div, 2);
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     Step step(Step::Type::BeginIf);

src/dev/engine/internal/llvmcodebuilder.h

@@ -29,6 +29,8 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createAdd() override;
         void createSub() override;
         void createMul() override;
+        void createDiv() override;
+
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -64,6 +66,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                     Add,
                     Sub,
                     Mul,
+                    Div,
                     Yield,
                     BeginIf,
                     BeginElse,

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -340,6 +340,65 @@ TEST_F(LLVMCodeBuilderTest, Multiply)
     ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
 }
 
+TEST_F(LLVMCodeBuilderTest, Divide)
+{
+    std::string expected;
+
+    auto addOpTest = [this, &expected](Value v1, Value v2, double expectedResult) {
+        m_builder->addConstValue(v1);
+        m_builder->addConstValue(v2);
+        m_builder->createDiv();
+        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->createDiv();
+        m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+        std::string str = Value(expectedResult).toString() + '\n';
+        expected += str;
+        expected += str;
+    };
+
+    createBuilder(true);
+
+    addOpTest(50, 2, 25);
+    addOpTest(-500, 25, -20);
+    addOpTest("-500", -25, 20);
+    addOpTest("3.5", "2.5", 1.4);
+    addOpTest(true, true, 1);
+    addOpTest("Infinity", "Infinity", std::numeric_limits<double>::quiet_NaN());
+    addOpTest("Infinity", 0, std::numeric_limits<double>::infinity());
+    addOpTest("Infinity", 2, std::numeric_limits<double>::infinity());
+    addOpTest("Infinity", -2, -std::numeric_limits<double>::infinity());
+    addOpTest("Infinity", "-Infinity", std::numeric_limits<double>::quiet_NaN());
+    addOpTest("-Infinity", "Infinity", std::numeric_limits<double>::quiet_NaN());
+    addOpTest("-Infinity", 0, -std::numeric_limits<double>::infinity());
+    addOpTest("-Infinity", 2, -std::numeric_limits<double>::infinity());
+    addOpTest("-Infinity", -2, std::numeric_limits<double>::infinity());
+    addOpTest("-Infinity", "-Infinity", std::numeric_limits<double>::quiet_NaN());
+    addOpTest(0, "Infinity", 0);
+    addOpTest(2, "Infinity", 0);
+    addOpTest(-2, "Infinity", 0);
+    addOpTest(0, "-Infinity", 0);
+    addOpTest(2, "-Infinity", 0);
+    addOpTest(-2, "-Infinity", 0);
+    addOpTest(1, "NaN", std::numeric_limits<double>::infinity());
+    addOpTest("NaN", 1, 0);
+    addOpTest(5, 0, std::numeric_limits<double>::infinity());
+    addOpTest(-5, 0, -std::numeric_limits<double>::infinity());
+    addOpTest(0, 0, std::numeric_limits<double>::quiet_NaN());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&m_target);
+
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {

test/mocks/codebuildermock.h

@@ -17,6 +17,8 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createAdd, (), (override));
         MOCK_METHOD(void, createSub, (), (override));
         MOCK_METHOD(void, createMul, (), (override));
+        MOCK_METHOD(void, createDiv, (), (override));
+
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));
         MOCK_METHOD(void, endIf, (), (override));