LLVMCodeBuilder: Implement list append

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -58,6 +58,7 @@ class ICodeBuilder
 
         virtual void createListClear(List *list) = 0;
         virtual void createListRemove(List *list) = 0;
+        virtual void createListAppend(List *list) = 0;
 
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;

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

@@ -493,6 +493,17 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::AppendToList: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                Compiler::StaticType type = optimizeRegisterType(arg.second);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_append_empty(), listPtr.ptr);
+                createInitialValueStore(arg.second, itemPtr, type);
+                // TODO: Implement list type prediction
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -962,6 +973,13 @@ void LLVMCodeBuilder::createListRemove(List *list)
     m_listPtrs[list] = LLVMListPtr();
 }
 
+void LLVMCodeBuilder::createListAppend(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::AppendToList, Compiler::StaticType::Void, Compiler::StaticType::Unknown, 1);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1519,6 +1537,41 @@ void LLVMCodeBuilder::createValueStore(LLVMRegisterPtr reg, llvm::Value *targetP
     }
 }
 
+void LLVMCodeBuilder::createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType)
+{
+    llvm::Value *converted = nullptr;
+
+    if (sourceType != Compiler::StaticType::Unknown)
+        converted = castValue(reg, sourceType);
+
+    auto it = std::find_if(TYPE_MAP.begin(), TYPE_MAP.end(), [sourceType](const std::pair<ValueType, Compiler::StaticType> &pair) { return pair.second == sourceType; });
+    const ValueType mappedType = it == TYPE_MAP.cend() ? ValueType::Number : it->first; // unknown type can be ignored
+
+    llvm::Value *valuePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
+    llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 1);
+    m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(mappedType)), typePtr);
+
+    switch (sourceType) {
+        case Compiler::StaticType::Number:
+        case Compiler::StaticType::Bool:
+            // Write number/bool directly
+            m_builder.CreateStore(converted, valuePtr);
+            break;
+
+        case Compiler::StaticType::String:
+            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
@@ -1864,6 +1917,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_remove()
     return resolveFunction("list_remove", llvm::FunctionType::get(m_builder.getVoidTy(), { listPtr, m_builder.getInt64Ty() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_append_empty()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_append_empty", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);

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

@@ -64,6 +64,7 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void createListClear(List *list) override;
         void createListRemove(List *list) override;
+        void createListAppend(List *list) override;
 
         void beginIfStatement() override;
         void beginElseBranch() override;
@@ -111,6 +112,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
 
         void createValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType, Compiler::StaticType targetType);
+        void createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType);
         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(LLVMRegisterPtr reg);
@@ -137,6 +139,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_value_lower();
         llvm::FunctionCallee resolve_list_clear();
         llvm::FunctionCallee resolve_list_remove();
+        llvm::FunctionCallee resolve_list_append_empty();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;

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

@@ -44,6 +44,7 @@ struct LLVMInstruction
             ReadVariable,
             ClearList,
             RemoveListItem,
+            AppendToList,
             Yield,
             BeginIf,
             BeginElse,

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -2016,6 +2016,62 @@ TEST_F(LLVMCodeBuilderTest, RemoveFromList)
     ASSERT_EQ(localList->toString(), "Lorem ipsum dolor");
 }
 
+TEST_F(LLVMCodeBuilderTest, AppendToList)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+    strings[localList.get()] = localList->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(1);
+    m_builder->createListAppend(globalList.get());
+
+    m_builder->addConstValue("test");
+    m_builder->createListAppend(globalList.get());
+
+    m_builder->addConstValue(3);
+    m_builder->createListAppend(localList.get());
+
+    m_builder->createListClear(localList.get());
+
+    m_builder->addConstValue(true);
+    m_builder->createListAppend(localList.get());
+
+    m_builder->addConstValue(false);
+    m_builder->createListAppend(localList.get());
+
+    m_builder->addConstValue("hello world");
+    m_builder->createListAppend(localList.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_EQ(globalList->toString(), "1 2 3 1 test");
+    ASSERT_EQ(localList->toString(), "true false hello world");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {

test/mocks/codebuildermock.h

@@ -48,6 +48,7 @@ class CodeBuilderMock : public ICodeBuilder
 
         MOCK_METHOD(void, createListClear, (List *), (override));
         MOCK_METHOD(void, createListRemove, (List *), (override));
+        MOCK_METHOD(void, createListAppend, (List *), (override));
 
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));