LLVMCodeBuilder: Implement repeat until loop

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -31,6 +31,7 @@ class ICodeBuilder
 
         virtual void beginRepeatLoop() = 0;
         virtual void beginWhileLoop() = 0;
+        virtual void beginRepeatUntilLoop() = 0;
         virtual void beginLoopCondition() = 0;
         virtual void endLoop() = 0;
 

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -204,6 +204,24 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::BeginRepeatUntilLoop: {
+                assert(!loops.empty());
+                Loop &loop = loops.back();
+
+                // Create branches
+                llvm::BasicBlock *body = llvm::BasicBlock::Create(m_ctx, "", currentFunc);
+                loop.afterLoop = llvm::BasicBlock::Create(m_ctx, "", currentFunc);
+
+                // Convert last reg to bool and add condition
+                assert(step.args.size() == 1);
+                llvm::Value *condition = m_builder.CreateCall(resolve_value_toBool(), step.args[0]->value);
+                m_builder.CreateCondBr(condition, loop.afterLoop, body);
+
+                // Switch to body branch
+                m_builder.SetInsertPoint(body);
+                break;
+            }
+
             case Step::Type::BeginLoopCondition: {
                 Loop loop;
                 loop.isRepeatLoop = false;
@@ -338,6 +356,15 @@ void LLVMCodeBuilder::beginWhileLoop()
     m_steps.push_back(step);
 }
 
+void LLVMCodeBuilder::beginRepeatUntilLoop()
+{
+    Step step(Step::Type::BeginRepeatUntilLoop);
+    assert(!m_tmpRegs.empty());
+    step.args.push_back(m_tmpRegs.back());
+    m_tmpRegs.pop_back();
+    m_steps.push_back(step);
+}
+
 void LLVMCodeBuilder::beginLoopCondition()
 {
     m_steps.push_back(Step(Step::Type::BeginLoopCondition));

src/dev/engine/internal/llvmcodebuilder.h

@@ -33,6 +33,7 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void beginRepeatLoop() override;
         void beginWhileLoop() override;
+        void beginRepeatUntilLoop() override;
         void beginLoopCondition() override;
         void endLoop() override;
 
@@ -57,6 +58,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                     EndIf,
                     BeginRepeatLoop,
                     BeginWhileLoop,
+                    BeginRepeatUntilLoop,
                     BeginLoopCondition,
                     EndLoop
                 };

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -437,3 +437,83 @@ TEST_F(LLVMCodeBuilderTest, WhileLoop)
     code->run(ctx.get());
     ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
 }
+
+TEST_F(LLVMCodeBuilderTest, RepeatUntilLoop)
+{
+    // Const condition
+    m_builder->beginLoopCondition();
+    m_builder->addConstValue("true");
+    m_builder->beginRepeatUntilLoop();
+    m_builder->addFunctionCall("test_unreachable", 0, false);
+    m_builder->endLoop();
+
+    m_builder->beginLoopCondition();
+    m_builder->addConstValue(true);
+    m_builder->beginRepeatUntilLoop();
+    m_builder->addFunctionCall("test_unreachable", 0, false);
+    m_builder->endLoop();
+
+    // Condition returned by function
+    m_builder->addFunctionCall("test_reset_counter", 0, false);
+    m_builder->beginLoopCondition();
+    m_builder->addFunctionCall("test_get_counter", 0, true);
+    m_builder->addConstValue(2);
+    m_builder->addFunctionCall("test_lower_than", 2, true);
+    m_builder->addFunctionCall("test_not", 1, true);
+    m_builder->beginRepeatUntilLoop();
+    m_builder->addConstValue(0);
+    m_builder->addFunctionCall("test_function_1_arg", 1, false);
+    m_builder->addFunctionCall("test_increment_counter", 0, false);
+    m_builder->endLoop();
+
+    // Nested
+    m_builder->addFunctionCall("test_reset_counter", 0, false);
+    m_builder->beginLoopCondition();
+    m_builder->addFunctionCall("test_get_counter", 0, true);
+    m_builder->addConstValue(3);
+    m_builder->addFunctionCall("test_lower_than", 2, true);
+    m_builder->addFunctionCall("test_not", 1, true);
+    m_builder->beginRepeatUntilLoop();
+    {
+        m_builder->beginLoopCondition();
+        m_builder->addFunctionCall("test_get_counter", 0, true);
+        m_builder->addConstValue(3);
+        m_builder->addFunctionCall("test_lower_than", 2, true);
+        m_builder->addFunctionCall("test_not", 1, true);
+        m_builder->beginRepeatUntilLoop();
+        {
+            m_builder->addConstValue(1);
+            m_builder->addFunctionCall("test_function_1_arg", 1, false);
+            m_builder->addFunctionCall("test_increment_counter", 0, false);
+        }
+        m_builder->endLoop();
+
+        m_builder->addConstValue(2);
+        m_builder->addFunctionCall("test_function_1_arg", 1, false);
+
+        m_builder->beginLoopCondition();
+        m_builder->addConstValue(true);
+        m_builder->beginRepeatUntilLoop();
+        {
+            m_builder->addFunctionCall("test_unreachable", 0, false);
+        }
+        m_builder->endLoop();
+    }
+    m_builder->endLoop();
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&m_target);
+
+    static const std::string expected =
+        "1_arg 0\n"
+        "1_arg 0\n"
+        "1_arg 1\n"
+        "1_arg 1\n"
+        "1_arg 1\n"
+        "1_arg 2\n";
+
+    EXPECT_CALL(m_target, isStage).WillRepeatedly(Return(false));
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+}

test/dev/llvm/testfunctions.cpp

@@ -97,6 +97,11 @@ extern "C"
         value_assign_copy(ret, v);
     }
 
+    void test_not(Target *target, ValueData *ret, ValueData *arg)
+    {
+        value_assign_bool(ret, !value_toBool(arg));
+    }
+
     void test_reset_counter(Target *target)
     {
         counter = 0;

test/dev/llvm/testfunctions.h

@@ -21,6 +21,7 @@ extern "C"
 
     void test_equals(Target *target, ValueData *ret, ValueData *a, ValueData *b);
     void test_lower_than(Target *target, ValueData *ret, ValueData *a, ValueData *b);
+    void test_not(Target *target, ValueData *ret, ValueData *arg);
     void test_const(Target *target, ValueData *ret, ValueData *v);
 
     void test_unreachable(Target *target);

test/mocks/codebuildermock.h

@@ -20,6 +20,7 @@ class CodeBuilderMock : public ICodeBuilder
 
         MOCK_METHOD(void, beginRepeatLoop, (), (override));
         MOCK_METHOD(void, beginWhileLoop, (), (override));
+        MOCK_METHOD(void, beginRepeatUntilLoop, (), (override));
         MOCK_METHOD(void, beginLoopCondition, (), (override));
         MOCK_METHOD(void, endLoop, (), (override));