LLVMCodeBuilder: Implement add operator

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -24,6 +24,7 @@ class ICodeBuilder
         virtual void addVariableValue(Variable *variable) = 0;
         virtual void addListContents(List *list) = 0;
 
+        virtual void createAdd() = 0;
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -88,6 +88,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::Add: {
+                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.CreateFAdd(num1, num2);
+                break;
+            }
+
             case Step::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -412,6 +422,11 @@ void LLVMCodeBuilder::addListContents(List *list)
 {
 }
 
+void LLVMCodeBuilder::createAdd()
+{
+    createOp(Step::Type::Add, 2);
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     Step step(Step::Type::BeginIf);
@@ -785,6 +800,34 @@ llvm::Type *LLVMCodeBuilder::getType(Compiler::StaticType type)
     }
 }
 
+llvm::Value *LLVMCodeBuilder::removeNaN(llvm::Value *num)
+{
+    // Replace NaN with zero
+    llvm::Value *isNaN = m_builder.CreateFCmpUNO(num, num);
+    return m_builder.CreateSelect(isNaN, llvm::ConstantFP::get(m_ctx, llvm::APFloat(0.0)), num);
+}
+
+void LLVMCodeBuilder::createOp(Step::Type type, size_t argCount)
+{
+    Step step(type);
+
+    assert(m_tmpRegs.size() >= argCount);
+    size_t j = 0;
+
+    for (size_t i = m_tmpRegs.size() - argCount; i < m_tmpRegs.size(); i++)
+        step.args.push_back({ Compiler::StaticType::Number, m_tmpRegs[i] });
+
+    m_tmpRegs.erase(m_tmpRegs.end() - argCount, m_tmpRegs.end());
+
+    auto ret = std::make_shared<Register>(Compiler::StaticType::Number);
+    ret->isRawValue = true;
+    step.functionReturnReg = ret;
+    m_regs[m_currentFunction].push_back(ret);
+    m_tmpRegs.push_back(ret);
+
+    m_steps.push_back(step);
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolveFunction(const std::string name, llvm::FunctionType *type)
 {
     return m_module->getOrInsertFunction(name, type);

src/dev/engine/internal/llvmcodebuilder.h

@@ -26,6 +26,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void addVariableValue(Variable *variable) override;
         void addListContents(List *list) override;
 
+        void createAdd() override;
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -58,6 +59,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                 enum class Type
                 {
                     FunctionCall,
+                    Add,
                     Yield,
                     BeginIf,
                     BeginElse,
@@ -124,6 +126,9 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::Value *castRawValue(std::shared_ptr<Register> reg, Compiler::StaticType targetType);
         llvm::Value *castConstValue(const Value &value, Compiler::StaticType targetType);
         llvm::Type *getType(Compiler::StaticType type);
+        llvm::Value *removeNaN(llvm::Value *num);
+
+        void createOp(Step::Type type, size_t argCount);
 
         llvm::FunctionCallee resolveFunction(const std::string name, llvm::FunctionType *type);
         llvm::FunctionCallee resolve_value_init();

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -200,6 +200,50 @@ TEST_F(LLVMCodeBuilderTest, RawValueCasting)
     ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
 }
 
+TEST_F(LLVMCodeBuilderTest, Add)
+{
+    std::string expected;
+
+    auto addOpTest = [this, &expected](Value v1, Value v2, double expectedResult) {
+        m_builder->addConstValue(v1);
+        m_builder->addConstValue(v2);
+        m_builder->createAdd();
+        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->createAdd();
+        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, 25, 75);
+    addOpTest(-500, 25, -475);
+    addOpTest(-500, -25, -525);
+    addOpTest("2.54", "6.28", 8.82);
+    addOpTest(2.54, "-6.28", -3.74);
+    addOpTest(true, true, 2);
+    addOpTest("Infinity", "Infinity", 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", "-Infinity", -std::numeric_limits<double>::infinity());
+    addOpTest(1, "NaN", 1);
+
+    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

@@ -14,6 +14,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, addVariableValue, (Variable *), (override));
         MOCK_METHOD(void, addListContents, (List *), (override));
 
+        MOCK_METHOD(void, createAdd, (), (override));
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));
         MOCK_METHOD(void, endIf, (), (override));