Add invalidate target LLVM instruction

Author: adazem009

src/engine/internal/icodebuilder.h

@@ -102,6 +102,8 @@ class ICodeBuilder
         virtual void createThreadStop() = 0;
         virtual void createStopWithoutSync() = 0;
 
+        virtual void invalidateTarget() = 0;
+
         virtual void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args) = 0;
 };
 

src/engine/internal/llvm/instructions/control.cpp

@@ -68,6 +68,10 @@ ProcessResult Control::process(LLVMInstruction *ins)
             ret.next = buildStopWithoutSync(ins);
             break;
 
+        case LLVMInstruction::Type::InvalidateTarget:
+            ret.next = buildInvalidateTarget(ins);
+            break;
+
         default:
             ret.match = false;
             break;
@@ -363,3 +367,9 @@ LLVMInstruction *Control::buildStopWithoutSync(LLVMInstruction *ins)
 
     return ins->next;
 }
+
+LLVMInstruction *Control::buildInvalidateTarget(LLVMInstruction *ins)
+{
+    m_utils.invalidateTarget();
+    return ins->next;
+}

src/engine/internal/llvm/instructions/control.h

@@ -29,6 +29,7 @@ class Control : public InstructionGroup
         LLVMInstruction *buildStop(LLVMInstruction *ins);
         LLVMInstruction *buildThreadStop(LLVMInstruction *ins);
         LLVMInstruction *buildStopWithoutSync(LLVMInstruction *ins);
+        LLVMInstruction *buildInvalidateTarget(LLVMInstruction *ins);
 };
 
 } // namespace libscratchcpp::llvmins

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -161,6 +161,10 @@ void LLVMBuildUtils::init(llvm::Function *function, BlockPrototype *procedurePro
     reloadVariables();
     reloadLists();
 
+    // Mark the target as valid
+    m_targetValidFlag = m_builder.CreateAlloca(m_builder.getInt1Ty());
+    m_builder.CreateStore(m_builder.getInt1(true), m_targetValidFlag);
+
     // Create end branches
     m_endBranch = llvm::BasicBlock::Create(m_llvmCtx, "end", m_function);
     m_endThreadBranch = llvm::BasicBlock::Create(m_llvmCtx, "endThread", m_function);
@@ -438,6 +442,12 @@ LLVMListPtr &LLVMBuildUtils::listPtr(List *list)
 
 void LLVMBuildUtils::syncVariables()
 {
+    llvm::BasicBlock *syncBlock = llvm::BasicBlock::Create(m_llvmCtx, "syncVariables", m_function);
+    llvm::BasicBlock *syncNextBlock = llvm::BasicBlock::Create(m_llvmCtx, "syncVariables.next", m_function);
+    m_builder.CreateCondBr(m_builder.CreateLoad(m_builder.getInt1Ty(), m_targetValidFlag), syncBlock, syncNextBlock);
+
+    m_builder.SetInsertPoint(syncBlock);
+
     // Copy stack variables to the actual variables
     for (auto &[var, varPtr] : m_variablePtrs) {
         llvm::BasicBlock *copyBlock = llvm::BasicBlock::Create(m_llvmCtx, "syncVar", m_function);
@@ -451,6 +461,9 @@ void LLVMBuildUtils::syncVariables()
 
         m_builder.SetInsertPoint(nextBlock);
     }
+
+    m_builder.CreateBr(syncNextBlock);
+    m_builder.SetInsertPoint(syncNextBlock);
 }
 
 void LLVMBuildUtils::reloadVariables()
@@ -481,6 +494,11 @@ void LLVMBuildUtils::reloadLists()
     }
 }
 
+void LLVMBuildUtils::invalidateTarget()
+{
+    m_builder.CreateStore(m_builder.getInt1(false), m_targetValidFlag);
+}
+
 std::vector<LLVMIfStatement> &LLVMBuildUtils::ifStatements()
 {
     return m_ifStatements;

src/engine/internal/llvm/llvmbuildutils.h

@@ -82,6 +82,7 @@ class LIBSCRATCHCPP_TEST_EXPORT LLVMBuildUtils
         void syncVariables();
         void reloadVariables();
         void reloadLists();
+        void invalidateTarget();
 
         std::vector<LLVMIfStatement> &ifStatements();
         std::vector<LLVMLoop> &loops();
@@ -186,6 +187,7 @@ class LIBSCRATCHCPP_TEST_EXPORT LLVMBuildUtils
         llvm::Value *m_targetVariables = nullptr;
         llvm::Value *m_targetLists = nullptr;
         llvm::Value *m_warpArg = nullptr;
+        llvm::Value *m_targetValidFlag = nullptr;
 
         std::unique_ptr<LLVMCoroutine> m_coroutine;
 

src/engine/internal/llvm/llvmcodebuilder.cpp

@@ -579,6 +579,12 @@ void LLVMCodeBuilder::createStopWithoutSync()
     m_instructions.addInstruction(ins);
 }
 
+void LLVMCodeBuilder::invalidateTarget()
+{
+    auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::InvalidateTarget, m_loopCondition);
+    m_instructions.addInstruction(ins);
+}
+
 void LLVMCodeBuilder::createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args)
 {
     assert(prototype);

src/engine/internal/llvm/llvmcodebuilder.h

@@ -116,6 +116,8 @@ class LIBSCRATCHCPP_TEST_EXPORT LLVMCodeBuilder : public ICodeBuilder
         void createThreadStop() override;
         void createStopWithoutSync() override;
 
+        void invalidateTarget() override;
+
         void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args) override;
 
     private:

src/engine/internal/llvm/llvminstruction.h

@@ -79,6 +79,7 @@ struct LLVMInstruction
             Stop,
             ThreadStop,
             StopWithoutSync,
+            InvalidateTarget,
             CallProcedure,
             ProcedureArg
         };

test/mocks/codebuildermock.h

@@ -91,5 +91,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createThreadStop, (), (override));
         MOCK_METHOD(void, createStopWithoutSync, (), (override));
 
+        MOCK_METHOD(void, invalidateTarget, (), (override));
+
         MOCK_METHOD(void, createProcedureCall, (BlockPrototype *, const Compiler::Args &), (override));
 };