LLVMCodeBuilder: Always store return type in the value argument

Author: adazem009

src/engine/internal/llvm/llvmcodeanalyzer.cpp

@@ -300,12 +300,7 @@ Compiler::StaticType LLVMCodeAnalyzer::writeType(LLVMInstruction *ins) const
     auto &arg = ins->args.back(); // value is always the last argument in variable/list write instructions
     const LLVMRegister *argReg = arg.second;
 
-    if (argReg->instruction) {
-        if (isVariableRead(argReg->instruction.get()) || isListRead(argReg->instruction.get())) {
-            // Store the variable/list type in the value argument
-            arg.first = argReg->instruction->functionReturnReg->type();
-        }
-    }
-
-    return m_utils.optimizeRegisterType(argReg);
+    Compiler::StaticType ret = m_utils.optimizeRegisterType(argReg);
+    arg.first = ret; // store the return type in the value argument
+    return ret;
 }

test/llvm/code_analyzer/variable_type_analysis.cpp

@@ -70,6 +70,23 @@ TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, FirstVariableWrite)
     ASSERT_EQ(setVar->targetType, Compiler::StaticType::Unknown);
 }
 
+TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, FirstVariableWrite_ArgType)
+{
+    LLVMInstructionList list;
+    Variable var("", "");
+
+    auto setVar = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value(Compiler::StaticType::String, "test");
+    setVar->targetVariable = &var;
+    setVar->args.push_back({ Compiler::StaticType::Unknown, &value });
+    list.addInstruction(setVar);
+
+    m_analyzer->analyzeScript(list);
+
+    // The argument should use the constant type
+    ASSERT_EQ(setVar->args.back().first, Compiler::StaticType::String);
+}
+
 TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, SecondVariableWrite)
 {
     LLVMInstructionList list;
@@ -95,6 +112,62 @@ TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, SecondVariableWrite)
     ASSERT_EQ(setVar2->targetType, Compiler::StaticType::Number);
 }
 
+TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, InstructionReturnTypePropagation)
+{
+    LLVMInstructionList list;
+    Variable var("", "");
+
+    auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::Add, true);
+    list.addInstruction(ins);
+
+    LLVMRegister ret(Compiler::StaticType::Number);
+    ret.isRawValue = false;
+    ret.instruction = ins;
+    ins->functionReturnReg = &ret;
+
+    auto setVar1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    setVar1->targetVariable = &var;
+    setVar1->args.push_back({ Compiler::StaticType::Unknown, &ret });
+    list.addInstruction(setVar1);
+
+    auto setVar2 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value2(Compiler::StaticType::String, "hello");
+    setVar2->targetVariable = &var;
+    setVar2->args.push_back({ Compiler::StaticType::Unknown, &value2 });
+    list.addInstruction(setVar2);
+
+    m_analyzer->analyzeScript(list);
+
+    // First write has no previous type
+    ASSERT_EQ(setVar1->targetType, Compiler::StaticType::Unknown);
+    // Second write has Number type from the instruction
+    ASSERT_EQ(setVar2->targetType, Compiler::StaticType::Number);
+}
+
+TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, InstructionReturnTypePropagation_ArgType)
+{
+    LLVMInstructionList list;
+    Variable var("", "");
+
+    auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::Add, true);
+    list.addInstruction(ins);
+
+    LLVMRegister ret(Compiler::StaticType::Number);
+    ret.isRawValue = false;
+    ret.instruction = ins;
+    ins->functionReturnReg = &ret;
+
+    auto setVar1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    setVar1->targetVariable = &var;
+    setVar1->args.push_back({ Compiler::StaticType::Unknown, &ret });
+    list.addInstruction(setVar1);
+
+    m_analyzer->analyzeScript(list);
+
+    // Second write has Number type from the instruction stored in the value argument
+    ASSERT_EQ(setVar1->args.back().first, Compiler::StaticType::Number);
+}
+
 TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, MultipleWritesSameType)
 {
     LLVMInstructionList list;
@@ -221,6 +294,22 @@ TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, StringOptimization_UnsafeSoundCons
     ASSERT_EQ(setVar2->targetType, Compiler::StaticType::String);
 }
 
+TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, ArgTypeStringOptimization)
+{
+    LLVMInstructionList list;
+    Variable var("", "");
+
+    auto setVar1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value1(Compiler::StaticType::String, m_safeNumConstant);
+    setVar1->targetVariable = &var;
+    setVar1->args.push_back({ Compiler::StaticType::Unknown, &value1 });
+    list.addInstruction(setVar1);
+
+    m_analyzer->analyzeScript(list);
+
+    ASSERT_EQ(setVar1->args.back().first, Compiler::StaticType::Number);
+}
+
 TEST_F(LLVMCodeAnalyzer_VariableTypeAnalysis, LoopSingleWrite)
 {
     LLVMInstructionList list;