Refactor LLVMCodeBuilder

include/scratchcpp/list.h

@@ -41,7 +41,13 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         void setMonitor(Monitor *monitor);
 
         /*! Returns a pointer to the raw list data. */
-        inline ValueData *data() const { return m_dataPtr->data(); }
+        inline ValueData *data() const { return m_rawDataPtr; }
+
+        /*!
+         * Returns a pointer to pointer to the raw list data.
+         * \note This is used internally by compiled code for various optimizations.
+         */
+        inline ValueData *const *dataPtr() const { return &m_rawDataPtr; }
 
         /*!
          * Returns a pointer to the list size.
@@ -247,6 +253,8 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
                 value_free(&m_dataPtr->back());
                 m_dataPtr->erase(m_dataPtr->end());
             }
+
+            m_rawDataPtr = m_dataPtr->data();
         }
 
         inline size_t getAllocSize(size_t x)
@@ -264,6 +272,7 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
 
         spimpl::unique_impl_ptr<ListPrivate> impl;
         veque::veque<ValueData> *m_dataPtr = nullptr; // NOTE: accessing through pointer is faster! (from benchmarks)
+        ValueData *m_rawDataPtr = nullptr;
         size_t m_size = 0;
 };
 

src/engine/compiler.cpp

@@ -83,7 +83,7 @@ std::shared_ptr<ExecutableCode> Compiler::compile(Block *startBlock, CodeType co
         }
 
         impl->block = nullptr;
-        return impl->builder->finalize();
+        return impl->builder->build();
     }
 
     while (impl->block) {
@@ -122,7 +122,7 @@ std::shared_ptr<ExecutableCode> Compiler::compile(Block *startBlock, CodeType co
             impl->substackEnd();
     }
 
-    return impl->builder->finalize();
+    return impl->builder->build();
 }
 
 /*!

src/engine/internal/engine.cpp

@@ -528,8 +528,8 @@ void Engine::step()
     m_frameActivity = !m_threads.empty();
 
     // Resolve stopped broadcast scripts
-    std::vector<Broadcast *> resolved;
-    std::vector<Thread *> resolvedThreads;
+    std::unordered_map<Broadcast *, Thread *> stoppedBroadcasts; // sender thread
+    std::unordered_map<Thread *, bool> runningStatus;            // sender thread
 
     for (const auto &[broadcast, senderThread] : m_broadcastSenders) {
         std::unordered_map<Broadcast *, std::vector<Script *>> *broadcastMap = nullptr;
@@ -544,44 +544,41 @@ void Engine::step()
             broadcastMap = &m_broadcastMap;
         }
 
-        bool found = false;
+        bool isRunning = false;
 
         if (broadcastMap->find(broadcast) != broadcastMap->cend()) {
             const auto &scripts = (*broadcastMap)[broadcast];
 
             for (auto script : scripts) {
                 if (std::find_if(m_threads.begin(), m_threads.end(), [script](std::shared_ptr<Thread> thread) { return thread->script() == script; }) != m_threads.end()) {
-                    found = true;
+                    isRunning = true;
                     break;
                 }
             }
         }
 
-        if (found) {
-            // If a broadcast with the same name but different case
-            // was considered stopped before, restore the promise.
-            if (std::find(resolvedThreads.begin(), resolvedThreads.end(), senderThread) != resolvedThreads.end()) {
-                senderThread->promise();
-                resolvedThreads.erase(std::remove(resolvedThreads.begin(), resolvedThreads.end(), senderThread), resolvedThreads.end());
-            }
-        } else {
-            Thread *th = senderThread;
+        if (runningStatus.find(senderThread) == runningStatus.cend() || isRunning)
+            runningStatus[senderThread] = isRunning;
 
-            if (std::find_if(m_threads.begin(), m_threads.end(), [th](std::shared_ptr<Thread> thread) { return thread.get() == th; }) != m_threads.end()) {
-                auto promise = th->promise();
+        if (!isRunning)
+            stoppedBroadcasts[broadcast] = senderThread;
+    }
 
-                if (promise)
-                    promise->resolve();
-            }
+    for (const auto &[broadcast, senderThread] : stoppedBroadcasts) {
+        m_broadcastSenders.erase(broadcast);
 
-            resolved.push_back(broadcast);
-            resolvedThreads.push_back(th);
+        // Resolve broadcast promise
+        Thread *th = senderThread;
+
+        if (std::find_if(m_threads.begin(), m_threads.end(), [th](std::shared_ptr<Thread> thread) { return thread.get() == th; }) != m_threads.end()) {
+            auto promise = th->promise().get();
+
+            // Resolve only if all broadcasts of the same name but different case are stopped
+            if (promise && !runningStatus[senderThread])
+                promise->resolve();
         }
     }
 
-    for (Broadcast *broadcast : resolved)
-        m_broadcastSenders.erase(broadcast);
-
     m_redrawRequested = false;
 
     // Step threads

src/engine/internal/icodebuilder.h

@@ -18,7 +18,7 @@ class ICodeBuilder
     public:
         virtual ~ICodeBuilder() { }
 
-        virtual std::shared_ptr<ExecutableCode> finalize() = 0;
+        virtual std::shared_ptr<ExecutableCode> build() = 0;
 
         virtual CompilerValue *addFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) = 0;
         virtual CompilerValue *addTargetFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) = 0;

src/engine/internal/llvm/CMakeLists.txt

@@ -1,25 +1,32 @@
 target_sources(scratchcpp
   PRIVATE
+    llvmbuildutils.cpp
+    llvmbuildutils.h
     llvmcodebuilder.cpp
     llvmcodebuilder.h
     llvmregister.h
     llvmconstantregister.h
     llvminstruction.h
+    llvminstructionlist.cpp
+    llvminstructionlist.h
     llvmifstatement.h
     llvmloop.h
     llvmcoroutine.cpp
     llvmcoroutine.h
     llvmvariableptr.h
     llvmlistptr.h
-    llvmprocedure.h
     llvmtypes.cpp
     llvmtypes.h
     llvmfunctions.cpp
-    llvmloopscope.h
+    llvmfunctions.h
+    llvmtypeanalyzer.cpp
+    llvmtypeanalyzer.h
     llvmcompilercontext.cpp
     llvmcompilercontext.h
     llvmexecutablecode.cpp
     llvmexecutablecode.h
     llvmexecutioncontext.cpp
     llvmexecutioncontext.h
 )
+
+add_subdirectory(instructions)

src/engine/internal/llvm/instructions/CMakeLists.txt

@@ -0,0 +1,30 @@
+target_sources(scratchcpp
+  PRIVATE
+    instructionbuilder.cpp
+    instructionbuilder.h
+    instructiongroup.cpp
+    instructiongroup.h
+    processresult.h
+)
+
+target_sources(scratchcpp
+  PRIVATE
+    functions.cpp
+    functions.h
+    math.cpp
+    math.h
+    comparison.cpp
+    comparison.h
+    string.cpp
+    string.h
+    logic.cpp
+    logic.h
+    control.cpp
+    control.h
+    variables.cpp
+    variables.h
+    lists.cpp
+    lists.h
+    procedures.cpp
+    procedures.h
+)

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

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "comparison.h"
+#include "../llvminstruction.h"
+#include "../llvmbuildutils.h"
+
+using namespace libscratchcpp;
+using namespace libscratchcpp::llvmins;
+
+ProcessResult Comparison::process(LLVMInstruction *ins)
+{
+    ProcessResult ret(true, ins);
+
+    switch (ins->type) {
+        case LLVMInstruction::Type::CmpEQ:
+            ret.next = buildCmpEQ(ins);
+            break;
+
+        case LLVMInstruction::Type::CmpGT:
+            ret.next = buildCmpGT(ins);
+            break;
+
+        case LLVMInstruction::Type::CmpLT:
+            ret.next = buildCmpLT(ins);
+            break;
+
+        case LLVMInstruction::Type::StrCmpEQCS:
+            ret.next = buildStrCmpEQCS(ins);
+            break;
+
+        case LLVMInstruction::Type::StrCmpEQCI:
+            ret.next = buildStrCmpEQCI(ins);
+            break;
+
+        default:
+            ret.match = false;
+            break;
+    }
+
+    return ret;
+}
+
+LLVMInstruction *Comparison::buildCmpEQ(LLVMInstruction *ins)
+{
+    assert(ins->args.size() == 2);
+    const auto &arg1 = ins->args[0].second;
+    const auto &arg2 = ins->args[1].second;
+    ins->functionReturnReg->value = m_utils.createComparison(arg1, arg2, LLVMBuildUtils::Comparison::EQ);
+
+    return ins->next;
+}
+
+LLVMInstruction *Comparison::buildCmpGT(LLVMInstruction *ins)
+{
+    assert(ins->args.size() == 2);
+    const auto &arg1 = ins->args[0].second;
+    const auto &arg2 = ins->args[1].second;
+    ins->functionReturnReg->value = m_utils.createComparison(arg1, arg2, LLVMBuildUtils::Comparison::GT);
+
+    return ins->next;
+}
+
+LLVMInstruction *Comparison::buildCmpLT(LLVMInstruction *ins)
+{
+    assert(ins->args.size() == 2);
+    const auto &arg1 = ins->args[0].second;
+    const auto &arg2 = ins->args[1].second;
+    ins->functionReturnReg->value = m_utils.createComparison(arg1, arg2, LLVMBuildUtils::Comparison::LT);
+
+    return ins->next;
+}
+
+LLVMInstruction *Comparison::buildStrCmpEQCS(LLVMInstruction *ins)
+{
+    assert(ins->args.size() == 2);
+    const auto &arg1 = ins->args[0].second;
+    const auto &arg2 = ins->args[1].second;
+    ins->functionReturnReg->value = m_utils.createStringComparison(arg1, arg2, true);
+
+    return ins->next;
+}
+
+LLVMInstruction *Comparison::buildStrCmpEQCI(LLVMInstruction *ins)
+{
+    assert(ins->args.size() == 2);
+    const auto &arg1 = ins->args[0].second;
+    const auto &arg2 = ins->args[1].second;
+    ins->functionReturnReg->value = m_utils.createStringComparison(arg1, arg2, false);
+
+    return ins->next;
+}

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

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "instructiongroup.h"
+
+namespace libscratchcpp::llvmins
+{
+
+class Comparison : public InstructionGroup
+{
+    public:
+        using InstructionGroup::InstructionGroup;
+
+        ProcessResult process(LLVMInstruction *ins) override;
+
+    private:
+        LLVMInstruction *buildCmpEQ(LLVMInstruction *ins);
+        LLVMInstruction *buildCmpGT(LLVMInstruction *ins);
+        LLVMInstruction *buildCmpLT(LLVMInstruction *ins);
+        LLVMInstruction *buildStrCmpEQCS(LLVMInstruction *ins);
+        LLVMInstruction *buildStrCmpEQCI(LLVMInstruction *ins);
+};
+
+} // namespace libscratchcpp::llvmins