Store list types locally in warp scripts

Author: adazem009

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

@@ -4,6 +4,7 @@
 #include "../llvminstruction.h"
 #include "../llvmbuildutils.h"
 #include "../llvmconstantregister.h"
+#include "../llvmcompilercontext.h"
 
 using namespace libscratchcpp;
 using namespace libscratchcpp::llvmins;
@@ -72,6 +73,11 @@ LLVMInstruction *Lists::buildClearList(LLVMInstruction *ins)
             // Update size
             m_builder.CreateStore(m_builder.getInt64(0), listPtr.size);
         }
+
+        if (listPtr.type) {
+            // Update type
+            m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Void)), listPtr.type);
+        }
     }
 
     return ins->next;
@@ -161,6 +167,7 @@ LLVMInstruction *Lists::buildAppendToList(LLVMInstruction *ins)
         m_builder.CreateStore(size, listPtr.size);
     }
 
+    createListTypeUpdate(listPtr, arg.second);
     return ins->next;
 }
 
@@ -198,6 +205,7 @@ LLVMInstruction *Lists::buildInsertToList(LLVMInstruction *ins)
         m_builder.CreateStore(size, listPtr.size);
     }
 
+    createListTypeUpdate(listPtr, valueArg.second);
     m_builder.CreateBr(nextBlock);
 
     m_builder.SetInsertPoint(nextBlock);
@@ -236,6 +244,7 @@ LLVMInstruction *Lists::buildListReplace(LLVMInstruction *ins)
     index = m_builder.CreateFPToUI(index, m_builder.getInt64Ty());
     llvm::Value *itemPtr = m_utils.getListItem(listPtr, index);
     m_utils.createValueStore(valueArg.second, itemPtr, listType, type);
+    createListTypeUpdate(listPtr, valueArg.second);
     m_builder.CreateBr(nextBlock);
 
     m_builder.SetInsertPoint(nextBlock);
@@ -276,7 +285,29 @@ LLVMInstruction *Lists::buildGetListItem(LLVMInstruction *ins)
     llvm::Value *null = m_utils.createValue(static_cast<LLVMRegister *>(&nullReg));
 
     index = m_builder.CreateFPToUI(index, m_builder.getInt64Ty());
-    ins->functionReturnReg->value = m_builder.CreateSelect(inRange, m_utils.getListItem(listPtr, index), null);
+    llvm::Value *itemPtr = m_builder.CreateSelect(inRange, m_utils.getListItem(listPtr, index), null);
+
+    ins->functionReturnReg->value = itemPtr;
+
+    if (listPtr.type) {
+        // Load the runtime list type information
+        llvm::Value *listTypeFlags = m_builder.CreateLoad(m_builder.getInt32Ty(), listPtr.type);
+
+        // The result is an empty string if index is out of range
+        llvm::Value *withString = m_builder.CreateOr(listTypeFlags, m_builder.getInt32(static_cast<uint32_t>(ValueType::String)));
+        listTypeFlags = m_builder.CreateSelect(inRange, listTypeFlags, withString);
+
+        // Load the actual item type from ValueData
+        llvm::Value *itemTypePtr = m_builder.CreateStructGEP(m_utils.compilerCtx()->valueDataType(), itemPtr, 1);
+        llvm::Value *actualItemType = m_builder.CreateLoad(m_builder.getInt32Ty(), itemTypePtr);
+
+        // Create assumption that the actual type is contained in the list type flags
+        llvm::Value *typeIsValid = m_builder.CreateICmpEQ(m_builder.CreateAnd(listTypeFlags, actualItemType), actualItemType);
+
+        // Tell LLVM to assume this is true
+        llvm::Function *assumeIntrinsic = llvm::Intrinsic::getDeclaration(m_utils.module(), llvm::Intrinsic::assume);
+        m_builder.CreateCall(assumeIntrinsic, typeIsValid);
+    }
 
     return ins->next;
 }
@@ -316,3 +347,21 @@ LLVMInstruction *Lists::buildListContainsItem(LLVMInstruction *ins)
 
     return ins->next;
 }
+
+void Lists::createListTypeUpdate(const LLVMListPtr &listPtr, const LLVMRegister *newValue)
+{
+    if (listPtr.type) {
+        // Update type
+        llvm::Value *currentType = m_builder.CreateLoad(m_builder.getInt32Ty(), listPtr.type);
+        llvm::Value *newTypeFlag;
+
+        if (newValue->isRawValue)
+            newTypeFlag = m_builder.getInt32(static_cast<uint32_t>(m_utils.mapType(newValue->type())));
+        else {
+            llvm::Value *typeField = m_builder.CreateStructGEP(m_utils.compilerCtx()->valueDataType(), newValue->value, 1);
+            newTypeFlag = m_builder.CreateLoad(m_builder.getInt32Ty(), typeField);
+        }
+
+        m_builder.CreateStore(m_builder.CreateOr(currentType, newTypeFlag), listPtr.type);
+    }
+}

src/engine/internal/llvm/instructions/lists.h

@@ -4,7 +4,13 @@
 
 #include "instructiongroup.h"
 
-namespace libscratchcpp::llvmins
+namespace libscratchcpp
+{
+
+class LLVMListPtr;
+class LLVMRegister;
+
+namespace llvmins
 {
 
 class Lists : public InstructionGroup
@@ -25,6 +31,10 @@ class Lists : public InstructionGroup
         LLVMInstruction *buildGetListSize(LLVMInstruction *ins);
         LLVMInstruction *buildGetListItemIndex(LLVMInstruction *ins);
         LLVMInstruction *buildListContainsItem(LLVMInstruction *ins);
+
+        void createListTypeUpdate(const LLVMListPtr &listPtr, const LLVMRegister *newValue);
 };
 
-} // namespace libscratchcpp::llvmins
+} // namespace llvmins
+
+} // namespace libscratchcpp

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -21,6 +21,13 @@ static std::unordered_map<ValueType, Compiler::StaticType> TYPE_MAP = {
     { ValueType::Pointer, Compiler::StaticType::Pointer }
 };
 
+static std::unordered_map<Compiler::StaticType, ValueType> REVERSE_TYPE_MAP = {
+    { Compiler::StaticType::Number, ValueType::Number },
+    { Compiler::StaticType::Bool, ValueType::Bool },
+    { Compiler::StaticType::String, ValueType::String },
+    { Compiler::StaticType::Pointer, ValueType::Pointer }
+};
+
 LLVMBuildUtils::LLVMBuildUtils(LLVMCompilerContext *ctx, llvm::IRBuilder<> &builder, Compiler::CodeType codeType) :
     m_ctx(ctx),
     m_llvmCtx(*ctx->llvmCtx()),
@@ -87,6 +94,10 @@ void LLVMBuildUtils::init(llvm::Function *function, BlockPrototype *procedurePro
 
             llvm::Value *size = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.sizePtr);
             m_builder.CreateStore(size, listPtr.size);
+
+            // Store list type locally to leave static type analysis to LLVM
+            listPtr.type = m_builder.CreateAlloca(m_builder.getInt32Ty(), nullptr, list->name() + ".type");
+            m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Number | ValueType::Bool | ValueType::String)), listPtr.type);
         }
     }
 
@@ -393,6 +404,12 @@ Compiler::StaticType LLVMBuildUtils::mapType(ValueType type)
     return TYPE_MAP[type];
 }
 
+ValueType LLVMBuildUtils::mapType(Compiler::StaticType type)
+{
+    assert(REVERSE_TYPE_MAP.find(type) != REVERSE_TYPE_MAP.cend());
+    return REVERSE_TYPE_MAP[type];
+}
+
 bool LLVMBuildUtils::isSingleType(Compiler::StaticType type)
 {
     // Check if the type is a power of 2 (only one bit set)

src/engine/internal/llvm/llvmbuildutils.h

@@ -76,6 +76,7 @@ class LLVMBuildUtils
 
         static Compiler::StaticType optimizeRegisterType(const LLVMRegister *reg);
         static Compiler::StaticType mapType(ValueType type);
+        static ValueType mapType(Compiler::StaticType type);
         static bool isSingleType(Compiler::StaticType type);
 
         llvm::Value *addAlloca(llvm::Type *type);

src/engine/internal/llvm/llvmlistptr.h

@@ -23,6 +23,7 @@ struct LLVMListPtr
         llvm::Value *sizePtr = nullptr;
         llvm::Value *allocatedSizePtr = nullptr;
         llvm::Value *size = nullptr;
+        llvm::Value *type = nullptr;
 };
 
 } // namespace libscratchcpp