LLVMCodeBuilder: Implement round operator

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -38,6 +38,7 @@ class ICodeBuilder
         virtual void createNot() = 0;
 
         virtual void createMod() = 0;
+        virtual void createRound() = 0;
 
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -194,6 +194,23 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::Round: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                // x >= 0.0 ? round(x) : (x >= -0.5 ? -0.0 : floor(x + 0.5))
+                llvm::Constant *zero = llvm::ConstantFP::get(m_ctx, llvm::APFloat(0.0));
+                llvm::Constant *negativeZero = llvm::ConstantFP::get(m_ctx, llvm::APFloat(-0.0));
+                llvm::Function *roundFunc = llvm::Intrinsic::getDeclaration(m_module.get(), llvm::Intrinsic::round, m_builder.getDoubleTy());
+                llvm::Function *floorFunc = llvm::Intrinsic::getDeclaration(m_module.get(), llvm::Intrinsic::floor, m_builder.getDoubleTy());
+                llvm::Value *num = removeNaN(castValue(arg.second, arg.first));
+                llvm::Value *notNegative = m_builder.CreateFCmpOGE(num, zero);                                                                             // num >= 0.0
+                llvm::Value *roundNum = m_builder.CreateCall(roundFunc, num);                                                                              // round(num)
+                llvm::Value *negativeCond = m_builder.CreateFCmpOGE(num, llvm::ConstantFP::get(m_ctx, llvm::APFloat(-0.5)));                               // num >= -0.5
+                llvm::Value *negativeRound = m_builder.CreateCall(floorFunc, m_builder.CreateFAdd(num, llvm::ConstantFP::get(m_ctx, llvm::APFloat(0.5)))); // floor(x + 0.5)
+                step.functionReturnReg->value = m_builder.CreateSelect(notNegative, roundNum, m_builder.CreateSelect(negativeCond, negativeZero, negativeRound));
+                break;
+            }
+
             case Step::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -567,6 +584,11 @@ void LLVMCodeBuilder::createMod()
     createOp(Step::Type::Mod, Compiler::StaticType::Number, Compiler::StaticType::Number, 2);
 }
 
+void LLVMCodeBuilder::createRound()
+{
+    createOp(Step::Type::Round, Compiler::StaticType::Number, Compiler::StaticType::Number, 1);
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     Step step(Step::Type::BeginIf);

src/dev/engine/internal/llvmcodebuilder.h

@@ -40,6 +40,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createNot() override;
 
         void createMod() override;
+        void createRound() override;
 
         void beginIfStatement() override;
         void beginElseBranch() override;
@@ -84,6 +85,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                     Or,
                     Not,
                     Mod,
+                    Round,
                     Yield,
                     BeginIf,
                     BeginElse,

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -1085,6 +1085,54 @@ TEST_F(LLVMCodeBuilderTest, Mod)
     addOpTest("NaN", -5);
 }
 
+TEST_F(LLVMCodeBuilderTest, Round)
+{
+    std::string expected;
+
+    auto addOpTest = [this, &expected](Value v1, double expectedResult) {
+        createBuilder(true);
+
+        m_builder->addConstValue(v1);
+        m_builder->createRound();
+        m_builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number });
+
+        m_builder->addConstValue(v1);
+        m_builder->addFunctionCall("test_const_number", Compiler::StaticType::Number, { Compiler::StaticType::Number });
+        m_builder->createRound();
+        m_builder->addFunctionCall("test_print_number", Compiler::StaticType::Void, { Compiler::StaticType::Number });
+
+        std::stringstream stream;
+        stream << expectedResult;
+        std::string str = stream.str() + '\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() ? "\"" : "";
+        ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << quotes1 << v1.toString() << quotes1;
+    };
+
+    static const double inf = std::numeric_limits<double>::infinity();
+    static const double nan = std::numeric_limits<double>::quiet_NaN();
+
+    addOpTest(4.0, 4.0);
+    addOpTest(3.2, 3.0);
+    addOpTest(3.5, 4.0);
+    addOpTest(3.6, 4.0);
+    addOpTest(-2.4, -2.0);
+    addOpTest(-2.5, -2.0);
+    addOpTest(-2.6, -3.0);
+    addOpTest(-0.4, -0.0);
+    addOpTest(-0.5, -0.0);
+    addOpTest(-0.51, -1.0);
+    addOpTest(inf, inf);
+    addOpTest(-inf, -inf);
+    addOpTest(nan, 0);
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {

test/mocks/codebuildermock.h

@@ -28,6 +28,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createNot, (), (override));
 
         MOCK_METHOD(void, createMod, (), (override));
+        MOCK_METHOD(void, createRound, (), (override));
 
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));