Add integer support for local variables

Author: adazem009

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/variables.cpp

@@ -44,6 +44,12 @@ ProcessResult Variables::process(LLVMInstruction *ins)
 LLVMInstruction *Variables::buildCreateLocalVariable(LLVMInstruction *ins)
 {
     assert(ins->args.empty());
+    LLVMLocalVariableInfo *info = ins->localVarInfo;
+
+    info->isInt = m_utils.addAlloca(m_builder.getInt1Ty());
+    info->intValue = m_utils.addAlloca(m_builder.getInt64Ty());
+    m_builder.CreateStore(m_builder.getInt1(false), info->isInt);
+    m_builder.CreateStore(llvm::ConstantInt::get(m_builder.getInt64Ty(), 0, true), info->isInt);
 
     LLVMConstantRegister null(ins->functionReturnReg->type(), Value());
     ins->functionReturnReg->value = m_utils.createValue(&null);
@@ -55,22 +61,22 @@ LLVMInstruction *Variables::buildWriteLocalVariable(LLVMInstruction *ins)
     assert(ins->args.size() == 2);
     const auto &arg1 = ins->args[0];
     const auto &arg2 = ins->args[1];
+    LLVMLocalVariableInfo *info = ins->localVarInfo;
     llvm::Value *typeVar = m_utils.addAlloca(m_builder.getInt32Ty());
     m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(m_utils.mapType(arg2.first))), typeVar);
 
-    // TODO: Add integer support for local variables
-    llvm::Value *isIntVar = m_utils.addAlloca(m_builder.getInt1Ty());
-    llvm::Value *intVar = m_utils.addAlloca(m_builder.getInt64Ty());
-
-    m_utils.createValueStore(arg1.second->value, typeVar, isIntVar, intVar, arg2.second, arg2.first, arg2.first);
+    m_utils.createValueStore(arg1.second->value, typeVar, info->isInt, info->intValue, arg2.second, arg2.first, arg2.first);
     return ins->next;
 }
 
 LLVMInstruction *Variables::buildReadLocalVariable(LLVMInstruction *ins)
 {
     assert(ins->args.size() == 1);
     const auto &arg = ins->args[0];
+    LLVMLocalVariableInfo *info = ins->localVarInfo;
     ins->functionReturnReg->value = m_utils.castValue(arg.second, ins->functionReturnReg->type());
+    ins->functionReturnReg->isInt = m_builder.CreateLoad(m_builder.getInt1Ty(), info->isInt);
+    ins->functionReturnReg->intValue = m_builder.CreateLoad(m_builder.getInt64Ty(), info->intValue);
     return ins->next;
 }
 

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -298,6 +298,12 @@ LLVMCoroutine *LLVMBuildUtils::coroutine() const
     return m_coroutine.get();
 }
 
+void LLVMBuildUtils::createLocalVariableInfo(CompilerLocalVariable *variable)
+{
+    if (m_localVariables.find(variable) == m_localVariables.cend())
+        m_localVariables[variable] = LLVMLocalVariableInfo();
+}
+
 void LLVMBuildUtils::createVariablePtr(Variable *variable)
 {
     if (m_variablePtrs.find(variable) == m_variablePtrs.cend())
@@ -310,6 +316,12 @@ void LLVMBuildUtils::createListPtr(List *list)
         m_listPtrs[list] = LLVMListPtr();
 }
 
+LLVMLocalVariableInfo &LLVMBuildUtils::localVariableInfo(CompilerLocalVariable *variable)
+{
+    assert(m_localVariables.find(variable) != m_localVariables.cend());
+    return m_localVariables[variable];
+}
+
 LLVMVariablePtr &LLVMBuildUtils::variablePtr(Variable *variable)
 {
     assert(m_variablePtrs.find(variable) != m_variablePtrs.cend());

src/engine/internal/llvm/llvmbuildutils.h

@@ -5,6 +5,7 @@
 #include <scratchcpp/valuedata.h>
 
 #include "llvmfunctions.h"
+#include "llvmlocalvariableinfo.h"
 #include "llvmvariableptr.h"
 #include "llvmlistptr.h"
 #include "llvmcoroutine.h"
@@ -61,9 +62,11 @@ class LLVMBuildUtils
 
         LLVMCoroutine *coroutine() const;
 
+        void createLocalVariableInfo(CompilerLocalVariable *variable);
         void createVariablePtr(Variable *variable);
         void createListPtr(List *list);
 
+        LLVMLocalVariableInfo &localVariableInfo(CompilerLocalVariable *variable);
         LLVMVariablePtr &variablePtr(Variable *variable);
         LLVMListPtr &listPtr(List *list);
 
@@ -154,6 +157,8 @@ class LLVMBuildUtils
 
         std::unique_ptr<LLVMCoroutine> m_coroutine;
 
+        std::unordered_map<CompilerLocalVariable *, LLVMLocalVariableInfo> m_localVariables;
+
         std::unordered_map<Variable *, size_t> m_targetVariableMap;
         std::unordered_map<Variable *, LLVMVariablePtr> m_variablePtrs;
 

src/engine/internal/llvm/llvmcodebuilder.cpp

@@ -159,6 +159,7 @@ CompilerValue *LLVMCodeBuilder::addLoopIndex()
 CompilerValue *LLVMCodeBuilder::addLocalVariableValue(CompilerLocalVariable *variable)
 {
     auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::ReadLocalVariable, m_loopCondition);
+    ins->localVarInfo = &m_utils.localVariableInfo(variable);
 
     ins->args.push_back({ variable->type(), dynamic_cast<LLVMRegister *>(variable->ptr()) });
 
@@ -425,12 +426,15 @@ CompilerLocalVariable *LLVMCodeBuilder::createLocalVariable(Compiler::StaticType
     CompilerValue *ptr = createOp(LLVMInstruction::Type::CreateLocalVariable, type);
     auto var = std::make_shared<CompilerLocalVariable>(ptr);
     m_localVars.push_back(var);
+    m_utils.createLocalVariableInfo(var.get());
+    m_instructions.last()->localVarInfo = &m_utils.localVariableInfo(var.get());
     return var.get();
 }
 
 void LLVMCodeBuilder::createLocalVariableWrite(CompilerLocalVariable *variable, CompilerValue *value)
 {
     createOp(LLVMInstruction::Type::WriteLocalVariable, Compiler::StaticType::Void, variable->type(), { variable->ptr(), value });
+    m_instructions.last()->localVarInfo = &m_utils.localVariableInfo(variable);
 }
 
 void LLVMCodeBuilder::createVariableWrite(Variable *variable, CompilerValue *value)

src/engine/internal/llvm/llvminstruction.h

@@ -9,6 +9,7 @@
 namespace libscratchcpp
 {
 
+class LLVMLocalVariableInfo;
 class BlockPrototype;
 
 struct LLVMInstruction
@@ -93,6 +94,7 @@ struct LLVMInstruction
         LLVMRegister *functionReturnReg = nullptr;
         bool functionTargetArg = false;                                  // whether to add target ptr to function parameters
         bool functionCtxArg = false;                                     // whether to add execution context ptr to function parameters
+        LLVMLocalVariableInfo *localVarInfo = nullptr;                   // for local variables
         Variable *targetVariable = nullptr;                              // for variables
         List *targetList = nullptr;                                      // for lists
         Compiler::StaticType targetType = Compiler::StaticType::Unknown; // variable or list type (before read/write operation)

src/engine/internal/llvm/llvmlocalvariableinfo.h

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace llvm
+{
+
+class Value;
+
+}
+
+namespace libscratchcpp
+{
+
+struct LLVMLocalVariableInfo
+{
+        llvm::Value *isInt = nullptr;
+        llvm::Value *intValue = nullptr;
+};
+
+} // namespace libscratchcpp