LLVMCodeAnalyzer: Reset types after procedure calls

Author: adazem009

src/engine/internal/llvm/llvmcodeanalyzer.cpp

@@ -102,6 +102,29 @@ void LLVMCodeAnalyzer::analyzeScript(const LLVMInstructionList &script) const
             // Store the type in the return register
             // NOTE: Get list item returns empty string if index is out of range
             ins->functionReturnReg->setType(ins->targetType | Compiler::StaticType::String);
+        } else if (isProcedureCall(ins)) {
+            // Variables/lists may change in procedures
+            for (auto &[var, type] : currentBranch->variableTypes) {
+                if (type != Compiler::StaticType::Unknown) {
+                    type = Compiler::StaticType::Unknown;
+
+                    if (typeAssignedInstructions.find(ins) == typeAssignedInstructions.cend())
+                        currentBranch->typeChanges = true;
+                }
+            }
+
+            for (auto &[list, type] : currentBranch->listTypes) {
+                if (type != Compiler::StaticType::Unknown) {
+                    type = Compiler::StaticType::Unknown;
+
+                    if (typeAssignedInstructions.find(ins) == typeAssignedInstructions.cend()) {
+                        typeAssignedInstructions.insert(ins);
+                        currentBranch->typeChanges = true;
+                    }
+                }
+            }
+
+            typeAssignedInstructions.insert(ins);
         }
 
         ins = ins->next;
@@ -247,6 +270,11 @@ bool LLVMCodeAnalyzer::isListClear(const LLVMInstruction *ins) const
     return (ins->type == LLVMInstruction::Type::ClearList);
 }
 
+bool LLVMCodeAnalyzer::isProcedureCall(const LLVMInstruction *ins) const
+{
+    return (ins->type == LLVMInstruction::Type::CallProcedure);
+}
+
 Compiler::StaticType LLVMCodeAnalyzer::writeType(LLVMInstruction *ins) const
 {
     assert(ins);

src/engine/internal/llvm/llvmcodeanalyzer.h

@@ -47,6 +47,8 @@ class LLVMCodeAnalyzer
         bool isListWrite(const LLVMInstruction *ins) const;
         bool isListClear(const LLVMInstruction *ins) const;
 
+        bool isProcedureCall(const LLVMInstruction *ins) const;
+
         Compiler::StaticType writeType(LLVMInstruction *ins) const;
 };
 

test/llvm/code_analyzer/list_type_analysis.cpp

@@ -182,6 +182,39 @@ TEST(LLVMCodeAnalyzer_ListTypeAnalysis, ClearListOperation)
     ASSERT_EQ(appendList2->targetType, Compiler::StaticType::Void);
 }
 
+TEST(LLVMCodeAnalyzer_ListTypeAnalysis, ProcedureCall)
+{
+    LLVMCodeAnalyzer analyzer;
+    LLVMInstructionList list;
+    List targetList("", "");
+
+    auto clearList = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::ClearList, false);
+    clearList->targetList = &targetList;
+    list.addInstruction(clearList);
+
+    auto appendList1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::AppendToList, false);
+    LLVMConstantRegister value1(Compiler::StaticType::String, "hello");
+    appendList1->targetList = &targetList;
+    appendList1->args.push_back({ Compiler::StaticType::Unknown, &value1 });
+    list.addInstruction(appendList1);
+
+    auto procCall = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::CallProcedure, false);
+    list.addInstruction(procCall);
+
+    auto appendList2 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::AppendToList, false);
+    LLVMConstantRegister value2(Compiler::StaticType::Number, 5.2);
+    appendList2->targetList = &targetList;
+    appendList2->args.push_back({ Compiler::StaticType::Unknown, &value2 });
+    list.addInstruction(appendList2);
+
+    analyzer.analyzeScript(list);
+
+    ASSERT_EQ(appendList1->targetType, Compiler::StaticType::Void);
+
+    // Type unknown due to procedure call
+    ASSERT_EQ(appendList2->targetType, Compiler::StaticType::Unknown);
+}
+
 TEST(LLVMCodeAnalyzer_ListTypeAnalysis, MixedWriteOperationsSameType_AfterClear)
 {
     LLVMCodeAnalyzer analyzer;

test/llvm/code_analyzer/variable_type_analysis.cpp

@@ -191,6 +191,41 @@ TEST(LLVMCodeAnalyzer_VariableTypeAnalysis, RepeatUntilLoop)
     ASSERT_EQ(setVar1->targetType, Compiler::StaticType::Number | Compiler::StaticType::Bool);
 }
 
+TEST(LLVMCodeAnalyzer_VariableTypeAnalysis, ProcedureCallInLoop)
+{
+    LLVMCodeAnalyzer analyzer;
+    LLVMInstructionList list;
+    Variable var("", "");
+
+    auto setVar1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value1(Compiler::StaticType::Number, 1.25);
+    setVar1->targetVariable = &var;
+    setVar1->args.push_back({ Compiler::StaticType::Unknown, &value1 });
+    list.addInstruction(setVar1);
+
+    auto loopStart = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::BeginRepeatLoop, false);
+    list.addInstruction(loopStart);
+
+    auto setVar2 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value2(Compiler::StaticType::Number, 5);
+    setVar2->targetVariable = &var;
+    setVar2->args.push_back({ Compiler::StaticType::Unknown, &value2 });
+    list.addInstruction(setVar2);
+
+    auto procCall = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::CallProcedure, false);
+    list.addInstruction(procCall);
+
+    auto loopEnd = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::EndLoop, false);
+    list.addInstruction(loopEnd);
+
+    analyzer.analyzeScript(list);
+
+    ASSERT_EQ(setVar1->targetType, Compiler::StaticType::Unknown);
+
+    // Type unknown due to procedure call
+    ASSERT_EQ(setVar2->targetType, Compiler::StaticType::Unknown);
+}
+
 TEST(LLVMCodeAnalyzer_VariableTypeAnalysis, LoopMultipleWrites_UnknownType)
 {
     LLVMCodeAnalyzer analyzer;