Store variables on the stack in warp scripts

Author: adazem009

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

@@ -111,30 +111,8 @@ LLVMInstruction *Variables::buildWriteVariable(LLVMInstruction *ins)
     const auto &arg = ins->args[0];
     Compiler::StaticType argType = m_utils.optimizeRegisterType(arg.second);
     LLVMVariablePtr &varPtr = m_utils.variablePtr(ins->targetVariable);
-    varPtr.changed = true; // TODO: Handle loops and if statements
-
-    // Initialize stack variable on first assignment
-    // TODO: Use stack in the top level (outside loops and if statements)
-    /*if (!varPtr.onStack) {
-        varPtr.onStack = true;
-        varPtr.type = type; // don't care about unknown type on first assignment
-
-                      ValueType mappedType;
-
-                        if (type == Compiler::StaticType::String || type == Compiler::StaticType::Unknown) {
-                            // Value functions are used for these types, so don't break them
-                            mappedType = ValueType::Number;
-                        } else {
-                            auto it = std::find_if(TYPE_MAP.begin(), TYPE_MAP.end(), [type](const std::pair<ValueType, Compiler::StaticType> &pair) { return pair.second == type; });
-                            assert(it != TYPE_MAP.cend());
-                            mappedType = it->first;
-                        }
-
-                        llvm::Value *typeField = m_builder.CreateStructGEP(m_valueDataType, varPtr.stackPtr, 1);
-                        m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(mappedType)), typeField);
-                    }*/
-
-    m_utils.createValueStore(arg.second, varPtr.stackPtr, ins->targetType, argType);
+
+    m_utils.createValueStore(arg.second, varPtr.onStack ? varPtr.stackPtr : varPtr.heapPtr, ins->targetType, argType);
     return ins->next;
 }
 
@@ -143,6 +121,6 @@ LLVMInstruction *Variables::buildReadVariable(LLVMInstruction *ins)
     assert(ins->args.size() == 0);
     LLVMVariablePtr &varPtr = m_utils.variablePtr(ins->targetVariable);
 
-    ins->functionReturnReg->value = varPtr.onStack && !(ins->loopCondition && !m_utils.warp()) ? varPtr.stackPtr : varPtr.heapPtr;
+    ins->functionReturnReg->value = varPtr.onStack ? varPtr.stackPtr : varPtr.heapPtr;
     return ins->next;
 }

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -63,26 +63,12 @@ void LLVMBuildUtils::init(llvm::Function *function, BlockPrototype *procedurePro
         // Direct access
         varPtr.heapPtr = ptr;
 
-        // All variables are currently created on the stack and synced later (seems to be faster)
+        // In warp scripts, all variables are created on the stack and synced later (seems to be faster)
         // NOTE: Strings are NOT copied, only the pointer is copied
-        // TODO: Restore this feature
-        // varPtr.stackPtr = m_builder.CreateAlloca(m_valueDataType);
-        varPtr.stackPtr = varPtr.heapPtr;
-        varPtr.onStack = false;
-
-        // If there are no write operations outside loops, initialize the stack variable now
-        /*Variable *variable = var;
-        // TODO: Loop scope was used here, replace it with some "inside loop" flag if needed
-        auto it = std::find_if(m_variableInstructions.begin(), m_variableInstructions.end(), [variable](const LLVMInstruction *ins) {
-            return ins->type == LLVMInstruction::Type::WriteVariable && ins->targetVariable == variable && !ins->loopScope;
-        });
-
-        if (it == m_variableInstructions.end()) {
-            createValueCopy(ptr, varPtr.stackPtr);
-            varPtr.onStack = true;
-        } else
-            varPtr.onStack = false; // use heap before the first assignment
-        */
+        varPtr.onStack = m_warp;
+
+        if (varPtr.onStack)
+            varPtr.stackPtr = m_builder.CreateAlloca(m_valueDataType);
     }
 
     // Create list pointers
@@ -104,6 +90,9 @@ void LLVMBuildUtils::init(llvm::Function *function, BlockPrototype *procedurePro
         }
     }
 
+    reloadVariables(m_targetVariables);
+    reloadLists();
+
     // Create end branch
     m_endBranch = llvm::BasicBlock::Create(m_llvmCtx, "end", m_function);
 }
@@ -313,19 +302,21 @@ void LLVMBuildUtils::syncVariables(llvm::Value *targetVariables)
 {
     // Copy stack variables to the actual variables
     for (auto &[var, varPtr] : m_variablePtrs) {
-        if (varPtr.onStack && varPtr.changed)
+        if (varPtr.onStack)
             createValueCopy(varPtr.stackPtr, getVariablePtr(targetVariables, var));
-
-        varPtr.changed = false;
     }
 }
 
 void LLVMBuildUtils::reloadVariables(llvm::Value *targetVariables)
 {
-    // Reset variables to use heap
-    for (auto &[var, varPtr] : m_variablePtrs) {
-        varPtr.onStack = false;
-        varPtr.changed = false;
+    // Load variables to stack
+    if (m_warp) {
+        for (auto &[var, varPtr] : m_variablePtrs) {
+            if (varPtr.onStack) {
+                llvm::Value *ptr = getVariablePtr(m_targetVariables, var);
+                createValueCopy(ptr, varPtr.stackPtr);
+            }
+        }
     }
 }
 

src/engine/internal/llvm/llvmvariableptr.h

@@ -21,7 +21,6 @@ struct LLVMVariablePtr
         llvm::Value *stackPtr = nullptr;
         llvm::Value *heapPtr = nullptr;
         bool onStack = false;
-        bool changed = false;
 };
 
 } // namespace libscratchcpp