LLVM optimizations

.github/workflows/utests-minimal.yml

@@ -19,7 +19,7 @@ jobs:
         submodules: true
 
     - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DLIBSCRATCHCPP_BUILD_UNIT_TESTS=ON -DLIBSCRATCHCPP_ENABLE_SANITIZER=ON -DLIBSCRATCHCPP_AUDIO_SUPPORT=OFF -DLIBSCRATCHCPP_NETWORK_SUPPORT=OFF
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DLIBSCRATCHCPP_BUILD_UNIT_TESTS=ON -DLIBSCRATCHCPP_ENABLE_SANITIZER=ON -DLIBSCRATCHCPP_AUDIO_SUPPORT=OFF -DLIBSCRATCHCPP_NETWORK_SUPPORT=OFF -DLIBSCRATCHCPP_ENABLE_CODE_ANALYZER=OFF -DLIBSCRATCHCPP_LLVM_INTEGER_SUPPORT=OFF
 
     - name: Build
       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j$(nproc --all)

CMakeLists.txt

@@ -10,6 +10,7 @@ option(LIBSCRATCHCPP_BUILD_UNIT_TESTS "Build unit tests" ON)
 option(LIBSCRATCHCPP_NETWORK_SUPPORT "Support for downloading projects" ON)
 option(LIBSCRATCHCPP_PRINT_LLVM_IR "Print LLVM IR of compiled Scratch scripts (for debugging)" OFF)
 option(LIBSCRATCHCPP_ENABLE_CODE_ANALYZER "Analyze Scratch scripts to enable various optimizations" ON)
+option(LIBSCRATCHCPP_LLVM_INTEGER_SUPPORT "Use integers when possible to enable various optimizations" ON)
 option(LIBSCRATCHCPP_ENABLE_SANITIZER "Enable sanitizer to detect memory issues" OFF)
 
 if (LIBSCRATCHCPP_ENABLE_SANITIZER)
@@ -126,6 +127,10 @@ if(LIBSCRATCHCPP_ENABLE_CODE_ANALYZER)
     target_compile_definitions(scratchcpp PRIVATE ENABLE_CODE_ANALYZER)
 endif()
 
+if(LIBSCRATCHCPP_LLVM_INTEGER_SUPPORT)
+    target_compile_definitions(scratchcpp PRIVATE LLVM_INTEGER_SUPPORT)
+endif()
+
 # Macros
 target_compile_definitions(scratchcpp PRIVATE LIBSCRATCHCPP_LIBRARY)
 target_compile_definitions(scratchcpp PRIVATE LIBSCRATCHCPP_VERSION="${PROJECT_VERSION}")

include/scratchcpp/compiler.h

@@ -148,6 +148,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         void createYield();
         void createStop();
+        void createStopWithoutSync();
 
         void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args);
 

include/scratchcpp/valuedata.h

@@ -5,6 +5,7 @@
 #include <string>
 
 #include "global.h"
+#include "enum_bitmask.h"
 
 namespace libscratchcpp
 {
@@ -13,12 +14,15 @@ struct StringPtr;
 
 enum class LIBSCRATCHCPP_EXPORT ValueType
 {
-    Number = 0,
-    Bool = 1,
-    String = 2,
-    Pointer = 3
+    Void = 0,
+    Number = 1 << 0,
+    Bool = 1 << 1,
+    String = 1 << 2,
+    Pointer = 1 << 3
 };
 
+constexpr bool enable_enum_bitmask(ValueType);
+
 extern "C"
 {
     /*! \brief The ValueData struct holds the data of Value. It's used in compiled Scratch code for better performance. */

src/blocks/controlblocks.cpp

@@ -178,7 +178,10 @@ CompilerValue *ControlBlocks::compileCreateCloneOf(Compiler *compiler)
 
 CompilerValue *ControlBlocks::compileDeleteThisClone(Compiler *compiler)
 {
-    compiler->addTargetFunctionCall("control_delete_this_clone");
+    CompilerValue *deleted = compiler->addTargetFunctionCall("control_delete_this_clone", Compiler::StaticType::Bool);
+    compiler->beginIfStatement(deleted);
+    compiler->createStopWithoutSync(); // sync happens before the function call
+    compiler->endIf();
     return nullptr;
 }
 
@@ -234,10 +237,17 @@ extern "C" void control_create_clone(ExecutionContext *ctx, const StringPtr *spr
     }
 }
 
-extern "C" void control_delete_this_clone(Target *target)
+extern "C" bool control_delete_this_clone(Target *target)
 {
     if (!target->isStage()) {
-        target->engine()->stopTarget(target, nullptr);
-        static_cast<Sprite *>(target)->deleteClone();
+        Sprite *sprite = static_cast<Sprite *>(target);
+
+        if (sprite->isClone()) {
+            target->engine()->stopTarget(target, nullptr);
+            sprite->deleteClone();
+            return true;
+        }
     }
+
+    return false;
 }

src/engine/compiler.cpp

@@ -136,7 +136,7 @@ void Compiler::preoptimize()
 
 /*!
  * Adds a call to the given function.\n
- * For example: extern "C" bool some_block(double arg1, const char *arg2)
+ * For example: extern "C" bool some_block(double arg1, const StringPtr *arg2)
  */
 CompilerValue *Compiler::addFunctionCall(const std::string &functionName, StaticType returnType, const ArgTypes &argTypes, const Args &args)
 {
@@ -146,7 +146,7 @@ CompilerValue *Compiler::addFunctionCall(const std::string &functionName, Static
 
 /*!
  * Adds a call to the given function with a target parameter.\n
- * For example: extern "C" bool some_block(Target *target, double arg1, const char *arg2)
+ * For example: extern "C" bool some_block(Target *target, double arg1, const StringPtr *arg2)
  */
 CompilerValue *Compiler::addTargetFunctionCall(const std::string &functionName, StaticType returnType, const ArgTypes &argTypes, const Args &args)
 {
@@ -156,7 +156,7 @@ CompilerValue *Compiler::addTargetFunctionCall(const std::string &functionName,
 
 /*!
  * Adds a call to the given function with an execution context parameter.\n
- * For example: extern "C" bool some_block(ExecutionContext *ctx, double arg1, const char *arg2)
+ * For example: extern "C" bool some_block(ExecutionContext *ctx, double arg1, const StringPtr *arg2)
  */
 CompilerValue *Compiler::addFunctionCallWithCtx(const std::string &functionName, StaticType returnType, const ArgTypes &argTypes, const Args &args)
 {
@@ -705,6 +705,16 @@ void Compiler::createStop()
     impl->builder->createStop();
 }
 
+/*!
+ * Creates a stop script without synchronization instruction.\n
+ * Use this if synchronization is not possible at the stop point.
+ * \note Only use this when everything is synchronized, e. g. after a function call.
+ */
+void Compiler::createStopWithoutSync()
+{
+    impl->builder->createStopWithoutSync();
+}
+
 /*! Creates a call to the procedure with the given prototype. */
 void Compiler::createProcedureCall(BlockPrototype *prototype, const libscratchcpp::Compiler::Args &args)
 {

src/engine/internal/icodebuilder.h

@@ -99,6 +99,7 @@ class ICodeBuilder
         virtual void yield() = 0;
 
         virtual void createStop() = 0;
+        virtual void createStopWithoutSync() = 0;
 
         virtual void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args) = 0;
 };

src/engine/internal/llvm/CMakeLists.txt

@@ -15,6 +15,7 @@ target_sources(scratchcpp
     llvmloop.h
     llvmcoroutine.cpp
     llvmcoroutine.h
+    llvmlocalvariableinfo.h
     llvmvariableptr.h
     llvmlistptr.h
     llvmtypes.cpp

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

@@ -60,6 +60,10 @@ ProcessResult Control::process(LLVMInstruction *ins)
             ret.next = buildStop(ins);
             break;
 
+        case LLVMInstruction::Type::StopWithoutSync:
+            ret.next = buildStopWithoutSync(ins);
+            break;
+
         default:
             ret.match = false;
             break;
@@ -88,6 +92,8 @@ LLVMInstruction *Control::buildSelect(LLVMInstruction *ins)
     }
 
     ins->functionReturnReg->value = m_builder.CreateSelect(cond, trueValue, falseValue);
+    ins->functionReturnReg->isInt = m_builder.CreateSelect(cond, arg2.second->isInt, arg3.second->isInt);
+    ins->functionReturnReg->intValue = m_builder.CreateSelect(cond, arg2.second->intValue, arg3.second->intValue);
     return ins->next;
 }
 
@@ -241,6 +247,8 @@ LLVMInstruction *Control::buildLoopIndex(LLVMInstruction *ins)
     LLVMLoop &loop = m_utils.loops().back();
     llvm::Value *index = m_builder.CreateLoad(m_builder.getInt64Ty(), loop.index);
     ins->functionReturnReg->value = m_builder.CreateUIToFP(index, m_builder.getDoubleTy());
+    ins->functionReturnReg->intValue = index;
+    ins->functionReturnReg->isInt = m_builder.getInt1(true);
 
     return ins->next;
 }
@@ -336,6 +344,12 @@ LLVMInstruction *Control::buildEndLoop(LLVMInstruction *ins)
 }
 
 LLVMInstruction *Control::buildStop(LLVMInstruction *ins)
+{
+    m_utils.syncVariables();
+    return buildStopWithoutSync(ins);
+}
+
+LLVMInstruction *Control::buildStopWithoutSync(LLVMInstruction *ins)
 {
     m_utils.freeScopeHeap();
     m_builder.CreateBr(m_utils.endBranch());

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

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

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

@@ -30,7 +30,7 @@ LLVMInstruction *Functions::buildFunctionCall(LLVMInstruction *ins)
     std::vector<llvm::Value *> args;
 
     // Variables must be synchronized because the function can read them
-    m_utils.syncVariables(m_utils.targetVariables());
+    m_utils.syncVariables();
 
     // Add execution context arg
     if (ins->functionCtxArg) {

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

@@ -10,11 +10,14 @@
 #include "variables.h"
 #include "lists.h"
 #include "procedures.h"
+#include "../llvminstruction.h"
+#include "../llvmbuildutils.h"
 
 using namespace libscratchcpp;
 using namespace libscratchcpp::llvmins;
 
-InstructionBuilder::InstructionBuilder(LLVMBuildUtils &utils)
+InstructionBuilder::InstructionBuilder(LLVMBuildUtils &utils) :
+    m_utils(utils)
 {
     // Create groups
     m_groups.push_back(std::make_shared<Functions>(utils));
@@ -34,8 +37,14 @@ LLVMInstruction *InstructionBuilder::process(LLVMInstruction *ins)
     for (const auto &group : m_groups) {
         ProcessResult result = group->process(ins);
 
-        if (result.match)
+        if (result.match) {
+#ifndef LLVM_INTEGER_SUPPORT
+            if (ins->functionReturnReg)
+                ins->functionReturnReg->isInt = m_utils.builder().getInt1(false);
+#endif
+
             return result.next;
+        }
     }
 
     assert(false); // instruction not found

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

@@ -15,6 +15,7 @@ class InstructionBuilder
         LLVMInstruction *process(LLVMInstruction *ins);
 
     private:
+        LLVMBuildUtils &m_utils;
         std::vector<std::shared_ptr<InstructionGroup>> m_groups;
 };