LLVMTypeAnalyzer: Drop variableTypeChangesInBranch()

variableTypeAfterBranch() is the preferred method now

Author: adazem009

src/engine/internal/llvm/llvmtypeanalyzer.cpp

@@ -63,37 +63,6 @@ Compiler::StaticType LLVMTypeAnalyzer::variableType(LLVMVariablePtr *varPtr, LLV
     return previousType;
 }
 
-bool LLVMTypeAnalyzer::variableTypeChangesInBranch(LLVMVariablePtr *varPtr, LLVMInstruction *start, Compiler::StaticType previousType) const
-{
-    if (!varPtr || !start)
-        return false;
-
-    assert(isLoopStart(start) || isIfStart(start) || isElse(start));
-
-    // Find loop/if statement end or else branch
-    LLVMInstruction *ins = start->next;
-    int level = 0;
-
-    while (ins && !((isLoopEnd(ins) || isIfEnd(ins) || isElse(ins)) && level == 0)) {
-        if (isLoopStart(ins) || isIfStart(ins))
-            level++;
-        else if (isLoopEnd(ins) || isIfEnd(ins)) {
-            assert(level > 0);
-            level--;
-        }
-
-        ins = ins->next;
-    }
-
-    if (!ins) {
-        assert(false);
-        return true;
-    }
-
-    // Process the branch from end
-    return variableTypeChangesInBranchFromEnd(varPtr, ins, previousType);
-}
-
 Compiler::StaticType LLVMTypeAnalyzer::variableTypeAfterBranch(LLVMVariablePtr *varPtr, LLVMInstruction *start, Compiler::StaticType previousType) const
 {
     if (!varPtr || !start)
@@ -129,66 +98,45 @@ Compiler::StaticType LLVMTypeAnalyzer::variableTypeAfterBranchFromEnd(LLVMVariab
 {
     // Find the last write instruction
     LLVMInstruction *ins = end->previous;
+    bool typeMightReset = false;
 
     while (ins && !isLoopStart(ins) && !isIfStart(ins)) {
         if (isLoopEnd(ins) || isIfEnd(ins) || isElse(ins)) {
             // Process the nested loop or if statement
             Compiler::StaticType ret = variableTypeAfterBranchFromEnd(varPtr, ins, previousType);
 
-            if (!typesMatch(ret, previousType))
-                return ret;
+            if (typesMatch(ret, previousType))
+                typeMightReset = true;
+            else
+                return Compiler::StaticType::Unknown;
 
             ins = skipBranch(ins);
 
             if (isElse(ins)) {
                 // Process if branch (the else branch is already processed)
                 ret = variableTypeAfterBranchFromEnd(varPtr, ins, previousType);
 
-                if (!typesMatch(ret, previousType))
-                    return ret;
+                if (typesMatch(ret, previousType))
+                    typeMightReset = true;
+                else
+                    return Compiler::StaticType::Unknown;
 
                 ins = skipBranch(ins);
             }
         } else if (ins->type == LLVMInstruction::Type::WriteVariable && ins->workVariable == varPtr->var) {
             // Variable write instruction
-            return writeValueType(ins);
-        }
-
-        ins = ins->previous;
-    }
-
-    return previousType;
-}
-
-bool LLVMTypeAnalyzer::variableTypeChangesInBranchFromEnd(LLVMVariablePtr *varPtr, LLVMInstruction *end, Compiler::StaticType previousType) const
-{
-    // Find the last write instruction
-    LLVMInstruction *ins = end->previous;
-
-    while (ins && !isLoopStart(ins) && !isIfStart(ins)) {
-        if (isLoopEnd(ins) || isIfEnd(ins) || isElse(ins)) {
-            // Process the nested loop or if statement
-            if (variableTypeChangesInBranchFromEnd(varPtr, ins, previousType))
-                return true;
+            Compiler::StaticType writeType = writeValueType(ins);
 
-            ins = skipBranch(ins);
-
-            if (isElse(ins)) {
-                // Process if branch (the else branch is already processed)
-                if (variableTypeChangesInBranchFromEnd(varPtr, ins, previousType))
-                    return true;
-
-                ins = skipBranch(ins);
-            }
-        } else if (ins->type == LLVMInstruction::Type::WriteVariable && ins->workVariable == varPtr->var) {
-            // Variable write instruction
-            return !writeTypesMatch(ins, previousType);
+            if (typesMatch(writeType, previousType))
+                return writeType;
+            else
+                return typeMightReset ? Compiler::StaticType::Unknown : writeType;
         }
 
         ins = ins->previous;
     }
 
-    return false;
+    return previousType;
 }
 
 LLVMInstruction *LLVMTypeAnalyzer::skipBranch(LLVMInstruction *pos) const

src/engine/internal/llvm/llvmtypeanalyzer.h

@@ -13,12 +13,10 @@ class LLVMTypeAnalyzer
 {
     public:
         Compiler::StaticType variableType(LLVMVariablePtr *varPtr, LLVMInstruction *pos, Compiler::StaticType previousType) const;
-        bool variableTypeChangesInBranch(LLVMVariablePtr *varPtr, LLVMInstruction *start, Compiler::StaticType previousType) const;
+        Compiler::StaticType variableTypeAfterBranch(LLVMVariablePtr *varPtr, LLVMInstruction *start, Compiler::StaticType previousType) const;
 
     private:
-        Compiler::StaticType variableTypeAfterBranch(LLVMVariablePtr *varPtr, LLVMInstruction *start, Compiler::StaticType previousType) const;
         Compiler::StaticType variableTypeAfterBranchFromEnd(LLVMVariablePtr *varPtr, LLVMInstruction *end, Compiler::StaticType previousType) const;
-        bool variableTypeChangesInBranchFromEnd(LLVMVariablePtr *varPtr, LLVMInstruction *end, Compiler::StaticType previousType) const;
         LLVMInstruction *skipBranch(LLVMInstruction *pos) const;
         bool isLoopStart(LLVMInstruction *ins) const;
         bool isLoopEnd(LLVMInstruction *ins) const;

test/llvm/CMakeLists.txt

@@ -20,7 +20,7 @@ add_executable(
   llvmexecutablecode_test.cpp
   llvmcodebuilder_test.cpp
   llvminstructionlist_test.cpp
-  type_analyzer/variabletypechangesinbranch_test.cpp
+  type_analyzer/variabletypeafterbranch_test.cpp
   type_analyzer/variabletype_test.cpp
 )
 

test/llvm/type_analyzer/variabletype_test.cpp

@@ -1763,7 +1763,7 @@ TEST(LLVMTypeAnalyzer_VariableType, SameTypeIfElseInLoopWithTypeChange)
     list.addInstruction(funcCall);
 
     // The type always changes to string
-    ASSERT_EQ(analyzer.variableType(&varPtr, funcCall.get(), Compiler::StaticType::Number), Compiler::StaticType::String);
+    ASSERT_EQ(analyzer.variableType(&varPtr, funcCall.get(), Compiler::StaticType::Number), Compiler::StaticType::Unknown);
 }
 
 // TODO: Handle cross-variable dependencies