LLVMCodeBuilder: Initial list limplementation

Author: adazem009

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

@@ -9,6 +9,7 @@ target_sources(scratchcpp
     llvmcoroutine.cpp
     llvmcoroutine.h
     llvmvariableptr.h
+    llvmlistptr.h
     llvmprocedure.h
     llvmtypes.cpp
     llvmtypes.h

src/dev/engine/internal/llvm/llvmcodebuilder.cpp

@@ -8,6 +8,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 
 #include "llvmcodebuilder.h"
 #include "llvmexecutablecode.h"
@@ -56,12 +57,13 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     m_builder.setFastMathFlags(fmf);
 
     // Create function
-    // void *f(Target *, ValueData **)
+    // void *f(Target *, ValueData **, List **)
     llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType }, false);
+    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { 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::Value *targetLists = func->getArg(2);
 
     llvm::BasicBlock *entry = llvm::BasicBlock::Create(m_ctx, "entry", func);
     m_builder.SetInsertPoint(entry);
@@ -92,6 +94,10 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     m_scopeVariables.clear();
     m_scopeVariables.push_back({});
 
+    // Create list pointers
+    for (auto &[list, listPtr] : m_listPtrs)
+        listPtr.ptr = getListPtr(targetLists, list);
+
     // Execute recorded steps
     for (const LLVMInstruction &step : m_instructions) {
         switch (step.type) {
@@ -1315,6 +1321,22 @@ llvm::Value *LLVMCodeBuilder::getVariablePtr(llvm::Value *targetVariables, Varia
     return m_builder.CreateIntToPtr(addr, m_valueDataType->getPointerTo());
 }
 
+llvm::Value *LLVMCodeBuilder::getListPtr(llvm::Value *targetLists, List *list)
+{
+    if (!m_target->isStage() && list->target() == m_target) {
+        // If this is a local sprite list, use the list array at runtime (for clones)
+        assert(m_targetListMap.find(list) != m_targetListMap.cend());
+        const size_t index = m_targetListMap[list];
+        auto pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+        llvm::Value *ptr = m_builder.CreateGEP(pointerType, targetLists, m_builder.getInt64(index));
+        return m_builder.CreateLoad(pointerType, ptr);
+    }
+
+    // Otherwise create a raw pointer at compile time
+    llvm::Value *addr = m_builder.getInt64((uintptr_t)list);
+    return m_builder.CreateIntToPtr(addr, m_valueDataType->getPointerTo());
+}
+
 void LLVMCodeBuilder::syncVariables(llvm::Value *targetVariables)
 {
     // Copy stack variables to the actual variables

src/dev/engine/internal/llvm/llvmcodebuilder.h

@@ -11,6 +11,7 @@
 #include "llvminstruction.h"
 #include "llvmcoroutine.h"
 #include "llvmvariableptr.h"
+#include "llvmlistptr.h"
 
 namespace libscratchcpp
 {
@@ -99,6 +100,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::Value *removeNaN(llvm::Value *num);
 
         llvm::Value *getVariablePtr(llvm::Value *targetVariables, Variable *variable);
+        llvm::Value *getListPtr(llvm::Value *targetLists, List *list);
         void syncVariables(llvm::Value *targetVariables);
         void reloadVariables(llvm::Value *targetVariables);
 
@@ -132,10 +134,14 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
+
         std::unordered_map<Variable *, size_t> m_targetVariableMap;
         std::unordered_map<Variable *, LLVMVariablePtr> m_variablePtrs;
         std::vector<std::unordered_map<LLVMVariablePtr *, Compiler::StaticType>> m_scopeVariables;
 
+        std::unordered_map<List *, size_t> m_targetListMap;
+        std::unordered_map<List *, LLVMListPtr> m_listPtrs;
+
         std::string m_id;
         llvm::LLVMContext m_ctx;
         std::unique_ptr<llvm::Module> m_module;

src/dev/engine/internal/llvm/llvmexecutablecode.cpp

@@ -55,7 +55,7 @@ void LLVMExecutableCode::run(ExecutionContext *context)
         ctx->setFinished(done);
     } else {
         Target *target = ctx->target();
-        void *handle = m_mainFunction(target, target->variableData());
+        void *handle = m_mainFunction(target, target->variableData(), target->listData());
 
         if (!handle)
             ctx->setFinished(true);

src/dev/engine/internal/llvm/llvmexecutablecode.h

@@ -11,6 +11,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class List;
 class LLVMExecutionContext;
 
 class LLVMExecutableCode : public ExecutableCode
@@ -32,7 +33,7 @@ class LLVMExecutableCode : public ExecutableCode
     private:
         uint64_t lookupFunction(const std::string &name);
 
-        using MainFunctionType = void *(*)(Target *, ValueData **);
+        using MainFunctionType = void *(*)(Target *, ValueData **, List **);
         using ResumeFunctionType = bool (*)(void *);
 
         static LLVMExecutionContext *getContext(ExecutionContext *context);

src/dev/engine/internal/llvm/llvminstruction.h

@@ -63,6 +63,7 @@ struct LLVMInstruction
         std::vector<std::pair<Compiler::StaticType, LLVMRegisterPtr>> args; // target type, register
         LLVMRegisterPtr functionReturnReg;
         Variable *workVariable = nullptr; // for variables
+        List *workList = nullptr;         // for lists
 };
 
 } // namespace libscratchcpp

src/dev/engine/internal/llvm/llvmlistptr.h

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/dev/compiler.h>
+
+namespace llvm
+{
+
+class Value;
+
+}
+
+namespace libscratchcpp
+{
+
+struct LLVMListPtr
+{
+        llvm::Value *ptr = nullptr;
+        Compiler::StaticType type = Compiler::StaticType::Unknown;
+};
+
+} // namespace libscratchcpp

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -20,7 +20,7 @@ class LLVMCodeBuilderTest : public testing::Test
     public:
         void SetUp() override
         {
-            test_function(nullptr, nullptr); // force dependency
+            test_function(nullptr, nullptr, nullptr, nullptr); // force dependency
         }
 
         void createBuilder(Target *target, bool warp) { m_builder = std::make_unique<LLVMCodeBuilder>(target, "test", warp); }

test/dev/llvm/llvmexecutablecode_test.cpp

@@ -1,5 +1,7 @@
 #include <scratchcpp/target.h>
 #include <scratchcpp/value_functions.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 #include <dev/engine/internal/llvm/llvmexecutablecode.h>
 #include <dev/engine/internal/llvm/llvmexecutioncontext.h>
 #include <llvm/Support/TargetSelect.h>
@@ -18,7 +20,7 @@ class LLVMExecutableCodeTest : public testing::Test
         {
             m_module = std::make_unique<llvm::Module>("test", m_ctx);
             m_builder = std::make_unique<llvm::IRBuilder<>>(m_ctx);
-            test_function(nullptr, nullptr); // force dependency
+            test_function(nullptr, nullptr, nullptr, nullptr); // force dependency
 
             llvm::InitializeNativeTarget();
             llvm::InitializeNativeTargetAsmPrinter();
@@ -29,7 +31,7 @@ class LLVMExecutableCodeTest : public testing::Test
 
         llvm::Function *beginMainFunction()
         {
-            // void *f(Target *, ValueData **, ValueData **)
+            // void *f(Target *, ValueData **, List **)
             llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
             llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType, pointerType }, false);
             llvm::Function *func = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "f", m_module.get());
@@ -55,12 +57,12 @@ class LLVMExecutableCodeTest : public testing::Test
         void addTestFunction(llvm::Function *mainFunc)
         {
             auto ptrType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-            auto func = m_module->getOrInsertFunction("test_function", llvm::FunctionType::get(m_builder->getVoidTy(), { ptrType, ptrType }, false));
+            auto func = m_module->getOrInsertFunction("test_function", llvm::FunctionType::get(m_builder->getVoidTy(), { ptrType, ptrType, ptrType, ptrType }, false));
 
             llvm::Constant *mockInt = llvm::ConstantInt::get(llvm::Type::getInt64Ty(m_ctx), (uintptr_t)&m_mock, false);
             llvm::Constant *mockPtr = llvm::ConstantExpr::getIntToPtr(mockInt, ptrType);
 
-            m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0) });
+            m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0), mainFunc->getArg(1), mainFunc->getArg(2) });
         }
 
         void addTestPrintFunction(llvm::Value *arg1, llvm::Value *arg2)
@@ -94,6 +96,9 @@ TEST_F(LLVMExecutableCodeTest, CreateExecutionContext)
 
 TEST_F(LLVMExecutableCodeTest, MainFunction)
 {
+    m_target.addVariable(std::make_shared<Variable>("", ""));
+    m_target.addList(std::make_shared<List>("", ""));
+
     auto f = beginMainFunction();
     addTestFunction(f);
     endFunction(nullPointer());
@@ -105,7 +110,7 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
     auto ctx = code.createExecutionContext(&m_target);
     ASSERT_FALSE(code.isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f(&m_target));
+    EXPECT_CALL(m_mock, f(&m_target, m_target.variableData(), m_target.listData()));
     code.run(ctx.get());
     ASSERT_TRUE(code.isFinished(ctx.get()));
 
@@ -124,11 +129,13 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
 
     // Test with another context
     Target anotherTarget;
+    anotherTarget.addVariable(std::make_shared<Variable>("", ""));
+    anotherTarget.addList(std::make_shared<List>("", ""));
     auto anotherCtx = code.createExecutionContext(&anotherTarget);
     ASSERT_FALSE(code.isFinished(anotherCtx.get()));
     ASSERT_TRUE(code.isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f(&anotherTarget));
+    EXPECT_CALL(m_mock, f(&anotherTarget, anotherTarget.variableData(), anotherTarget.listData()));
     code.run(anotherCtx.get());
     ASSERT_TRUE(code.isFinished(anotherCtx.get()));
     ASSERT_TRUE(code.isFinished(ctx.get()));

test/dev/llvm/testfunctions.cpp

@@ -11,10 +11,10 @@ static int counter = 0;
 
 extern "C"
 {
-    void test_function(TestMock *mock, Target *target)
+    void test_function(TestMock *mock, Target *target, ValueData **varData, List **listData)
     {
         if (mock)
-            mock->f(target);
+            mock->f(target, varData, listData);
     }
 
     void test_print_function(ValueData *arg1, ValueData *arg2)