Implement LLVM variables

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -54,6 +54,8 @@ class ICodeBuilder
         virtual void createExp() = 0;
         virtual void createExp10() = 0;
 
+        virtual void createVariableWrite(Variable *variable) = 0;
+
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -5,6 +5,10 @@
 #include <llvm/ExecutionEngine/Orc/LLJIT.h>
 #include <llvm/Passes/PassBuilder.h>
 
+#include <scratchcpp/stage.h>
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/variable.h>
+
 #include "llvmcodebuilder.h"
 #include "llvmexecutablecode.h"
 
@@ -28,6 +32,7 @@ LLVMCodeBuilder::LLVMCodeBuilder(Target *target, const std::string &id, bool war
     m_constValues.push_back({});
     m_regs.push_back({});
     initTypes();
+    createVariableMap();
 }
 
 std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
@@ -41,10 +46,12 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     }
 
     // Create function
-    // void *f(Target *)
+    // void *f(Target *, ValueData **)
     llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, pointerType, false);
+    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType }, false);
     llvm::Function *func = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "f", m_module.get());
+    llvm::Value *targetPtr = func->getArg(0);
+    llvm::Value *targetVariables = func->getArg(1);
 
     llvm::BasicBlock *entry = llvm::BasicBlock::Create(m_ctx, "entry", func);
     m_builder.SetInsertPoint(entry);
@@ -59,6 +66,20 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     std::vector<Loop> loops;
     m_heap.clear();
 
+    // Create variable pointers
+    for (auto &[var, varPtr] : m_variablePtrs) {
+        llvm::Value *ptr = getVariablePtr(targetVariables, var);
+
+        // Access variable directly (slow?)
+        // varPtr.ptr = ptr;
+
+        // All variables are currently copied to the stack and synced later (seems to be faster)
+        // NOTE: Strings are NOT copied, only the pointer and string size are copied
+        varPtr.ptr = m_builder.CreateAlloca(m_valueDataType);
+        varPtr.onStack = true;
+        createValueCopy(ptr, varPtr.ptr);
+    }
+
     // Execute recorded steps
     for (const Step &step : m_steps) {
         switch (step.type) {
@@ -67,9 +88,8 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 std::vector<llvm::Value *> args;
 
                 // Add target pointer arg
-                assert(func->arg_size() == 1);
                 types.push_back(llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0));
-                args.push_back(func->getArg(0));
+                args.push_back(targetPtr);
 
                 // Args
                 for (auto &arg : step.args) {
@@ -395,9 +415,27 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::WriteVariable: {
+                assert(step.args.size() == 1);
+                assert(m_variablePtrs.find(step.workVariable) != m_variablePtrs.cend());
+                const auto &arg = step.args[0];
+                VariablePtr &varPtr = m_variablePtrs[step.workVariable];
+                varPtr.changed = true;
+                createValueStore(arg.second, varPtr.ptr);
+                break;
+            }
+
+            case Step::Type::ReadVariable: {
+                assert(step.args.size() == 0);
+                const VariablePtr &varPtr = m_variablePtrs[step.workVariable];
+                step.functionReturnReg->value = varPtr.ptr;
+                break;
+            }
+
             case Step::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
+                    syncVariables(targetVariables);
                     m_builder.CreateStore(m_builder.getInt1(true), coro.didSuspend);
                     llvm::BasicBlock *resumeBranch = llvm::BasicBlock::Create(m_ctx, "", func);
                     llvm::Value *noneToken = llvm::ConstantTokenNone::get(m_ctx);
@@ -608,6 +646,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     }
 
     freeHeap();
+    syncVariables(targetVariables);
 
     // Add final suspend point
     if (!m_warp) {
@@ -707,6 +746,18 @@ void LLVMCodeBuilder::addConstValue(const Value &value)
 
 void LLVMCodeBuilder::addVariableValue(Variable *variable)
 {
+    // TODO: Implement type prediction
+    Step step(Step::Type::ReadVariable);
+    step.workVariable = variable;
+    m_variablePtrs[variable] = VariablePtr();
+
+    auto ret = std::make_shared<Register>(Compiler::StaticType::Unknown);
+    ret->isRawValue = false;
+    step.functionReturnReg = ret;
+    m_regs[m_currentFunction].push_back(ret);
+    m_tmpRegs.push_back(ret);
+
+    m_steps.push_back(step);
 }
 
 void LLVMCodeBuilder::addListContents(List *list)
@@ -843,6 +894,13 @@ void LLVMCodeBuilder::createExp10()
     createOp(Step::Type::Exp10, Compiler::StaticType::Number, Compiler::StaticType::Number, 1);
 }
 
+void LLVMCodeBuilder::createVariableWrite(Variable *variable)
+{
+    Step &step = createOp(Step::Type::WriteVariable, Compiler::StaticType::Void, Compiler::StaticType::Unknown, 1);
+    step.workVariable = variable;
+    m_variablePtrs[variable] = VariablePtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     Step step(Step::Type::BeginIf);
@@ -926,6 +984,36 @@ void LLVMCodeBuilder::initTypes()
     m_valueDataType->setBody({ unionType, valueType, sizeType });
 }
 
+void LLVMCodeBuilder::createVariableMap()
+{
+    if (!m_target)
+        return;
+
+    // Map variable pointers to variable data array indices
+    const auto &variables = m_target->variables();
+    ValueData **variableData = m_target->variableData();
+    const size_t len = variables.size();
+    m_targetVariableMap.clear();
+    m_targetVariableMap.reserve(len);
+
+    size_t i, j;
+
+    for (i = 0; i < len; i++) {
+        Variable *var = variables[i].get();
+
+        // Find the data for this variable
+        for (j = 0; j < len; j++) {
+            if (variableData[j] == &var->valuePtr()->data())
+                break;
+        }
+
+        if (j < len)
+            m_targetVariableMap[var] = j;
+        else
+            assert(false);
+    }
+}
+
 LLVMCodeBuilder::Coroutine LLVMCodeBuilder::initCoroutine(llvm::Function *func)
 {
     // Set presplitcoroutine attribute
@@ -1224,7 +1312,32 @@ llvm::Value *LLVMCodeBuilder::removeNaN(llvm::Value *num)
     return m_builder.CreateSelect(isNaN(num), llvm::ConstantFP::get(m_ctx, llvm::APFloat(0.0)), num);
 }
 
-void LLVMCodeBuilder::createOp(Step::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount)
+llvm::Value *LLVMCodeBuilder::getVariablePtr(llvm::Value *targetVariables, Variable *variable)
+{
+    if (!m_target->isStage() && variable->target() == m_target) {
+        // If this is a local sprite variable, use the variable array at runtime (for clones)
+        assert(m_targetVariableMap.find(variable) != m_targetVariableMap.cend());
+        const size_t index = m_targetVariableMap[variable];
+        llvm::Value *ptr = m_builder.CreateGEP(m_valueDataType->getPointerTo(), targetVariables, m_builder.getInt64(index));
+        return m_builder.CreateLoad(m_valueDataType->getPointerTo(), ptr);
+    }
+
+    // Otherwise create a raw pointer at compile time
+    llvm::Value *addr = m_builder.getInt64((uintptr_t)&variable->value().data());
+    return m_builder.CreateIntToPtr(addr, m_valueDataType->getPointerTo());
+}
+
+void LLVMCodeBuilder::syncVariables(llvm::Value *targetVariables)
+{
+    for (auto &[var, varPtr] : m_variablePtrs) {
+        if (varPtr.onStack && varPtr.changed)
+            createValueCopy(varPtr.ptr, getVariablePtr(targetVariables, var));
+
+        varPtr.changed = false;
+    }
+}
+
+LLVMCodeBuilder::Step &LLVMCodeBuilder::createOp(Step::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount)
 {
     Step step(type);
 
@@ -1236,13 +1349,71 @@ void LLVMCodeBuilder::createOp(Step::Type type, Compiler::StaticType retType, Co
 
     m_tmpRegs.erase(m_tmpRegs.end() - argCount, m_tmpRegs.end());
 
-    auto ret = std::make_shared<Register>(retType);
-    ret->isRawValue = true;
-    step.functionReturnReg = ret;
-    m_regs[m_currentFunction].push_back(ret);
-    m_tmpRegs.push_back(ret);
+    if (retType != Compiler::StaticType::Void) {
+        auto ret = std::make_shared<Register>(retType);
+        ret->isRawValue = true;
+        step.functionReturnReg = ret;
+        m_regs[m_currentFunction].push_back(ret);
+        m_tmpRegs.push_back(ret);
+    }
 
     m_steps.push_back(step);
+    return m_steps.back();
+}
+
+void LLVMCodeBuilder::createValueStore(std::shared_ptr<Register> reg, llvm::Value *targetPtr)
+{
+    // TODO: Implement type prediction
+    Compiler::StaticType type = reg->type;
+    llvm::Value *converted = nullptr;
+
+    // Optimize string constants that represent numbers
+    if (reg->isConstValue && reg->type == Compiler::StaticType::String && reg->constValue.isValidNumber())
+        type = Compiler::StaticType::Number;
+
+    switch (type) {
+        case Compiler::StaticType::Number:
+            converted = castValue(reg, type);
+            m_builder.CreateCall(resolve_value_assign_double(), { targetPtr, converted });
+            /*{
+                llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
+                m_builder.CreateStore(converted, ptr);
+            }*/
+            break;
+
+        case Compiler::StaticType::Bool:
+            converted = castValue(reg, type);
+            m_builder.CreateCall(resolve_value_assign_bool(), { targetPtr, converted });
+            break;
+
+        case Compiler::StaticType::String:
+            converted = castValue(reg, type);
+            m_builder.CreateCall(resolve_value_assign_cstring(), { targetPtr, converted });
+            break;
+
+        case Compiler::StaticType::Unknown:
+            m_builder.CreateCall(resolve_value_assign_copy(), { targetPtr, reg->value });
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
+void LLVMCodeBuilder::createValueCopy(llvm::Value *source, llvm::Value *target)
+{
+    // NOTE: This doesn't copy strings, but only the pointers
+    copyStructField(source, target, 0, m_valueDataType, m_builder.getInt64Ty()); // value
+    copyStructField(source, target, 1, m_valueDataType, m_builder.getInt32Ty()); // type
+    copyStructField(source, target, 2, m_valueDataType, m_builder.getInt64Ty()); // string size
+}
+
+void LLVMCodeBuilder::copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType)
+{
+    llvm::Value *sourceField = m_builder.CreateStructGEP(structType, source, index);
+    llvm::Value *targetField = m_builder.CreateStructGEP(structType, target, index);
+    m_builder.CreateStore(m_builder.CreateLoad(fieldType, sourceField), targetField);
 }
 
 llvm::Value *LLVMCodeBuilder::createValue(std::shared_ptr<Register> reg)
@@ -1505,6 +1676,11 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_value_assign_special()
     return resolveFunction("value_assign_special", llvm::FunctionType::get(m_builder.getVoidTy(), { m_valueDataType->getPointerTo(), m_builder.getInt32Ty() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_value_assign_copy()
+{
+    return resolveFunction("value_assign_copy", llvm::FunctionType::get(m_builder.getVoidTy(), { m_valueDataType->getPointerTo(), m_valueDataType->getPointerTo() }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_value_toDouble()
 {
     return resolveFunction("value_toDouble", llvm::FunctionType::get(m_builder.getDoubleTy(), m_valueDataType->getPointerTo(), false));

src/dev/engine/internal/llvmcodebuilder.h

@@ -56,6 +56,8 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createExp() override;
         void createExp10() override;
 
+        void createVariableWrite(Variable *variable) override;
+
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -114,6 +116,8 @@ class LLVMCodeBuilder : public ICodeBuilder
                     Log10,
                     Exp,
                     Exp10,
+                    WriteVariable,
+                    ReadVariable,
                     Yield,
                     BeginIf,
                     BeginElse,
@@ -135,6 +139,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                 std::vector<std::pair<Compiler::StaticType, std::shared_ptr<Register>>> args; // target type, register
                 Compiler::StaticType functionReturnType = Compiler::StaticType::Void;
                 std::shared_ptr<Register> functionReturnReg;
+                Variable *workVariable = nullptr; // for variable write
         };
 
         struct IfStatement
@@ -163,6 +168,14 @@ class LLVMCodeBuilder : public ICodeBuilder
                 llvm::Value *didSuspend = nullptr;
         };
 
+        struct VariablePtr
+        {
+                llvm::Value *ptr = nullptr;
+                Compiler::StaticType type = Compiler::StaticType::Unknown;
+                bool onStack = false;
+                bool changed = false;
+        };
+
         struct Procedure
         {
                 // TODO: Implement procedures
@@ -177,6 +190,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         };
 
         void initTypes();
+        void createVariableMap();
 
         Coroutine initCoroutine(llvm::Function *func);
         void verifyFunction(llvm::Function *func);
@@ -190,7 +204,14 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::Value *isNaN(llvm::Value *num);
         llvm::Value *removeNaN(llvm::Value *num);
 
-        void createOp(Step::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
+        llvm::Value *getVariablePtr(llvm::Value *targetVariables, Variable *variable);
+        void syncVariables(llvm::Value *targetVariables);
+
+        Step &createOp(Step::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
+
+        void createValueStore(std::shared_ptr<Register> reg, llvm::Value *targetPtr);
+        void createValueCopy(llvm::Value *source, llvm::Value *target);
+        void copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType);
         llvm::Value *createValue(std::shared_ptr<Register> reg);
         llvm::Value *createComparison(std::shared_ptr<Register> arg1, std::shared_ptr<Register> arg2, Comparison type);
 
@@ -202,6 +223,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_value_assign_bool();
         llvm::FunctionCallee resolve_value_assign_cstring();
         llvm::FunctionCallee resolve_value_assign_special();
+        llvm::FunctionCallee resolve_value_assign_copy();
         llvm::FunctionCallee resolve_value_toDouble();
         llvm::FunctionCallee resolve_value_toBool();
         llvm::FunctionCallee resolve_value_toCString();
@@ -215,6 +237,8 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
+        std::unordered_map<Variable *, size_t> m_targetVariableMap;
+        std::unordered_map<Variable *, VariablePtr> m_variablePtrs;
 
         std::string m_id;
         llvm::LLVMContext m_ctx;