Reset variable lifetime to be valid if not dead in DeadStorePhase

Author: ThomsonTan

lib/Backend/BackwardPass.cpp

@@ -34,12 +34,21 @@ BackwardPass::BackwardPass(Func * func, GlobOpt * globOpt, Js::Phase tag)
 #endif
 }
 
-bool
-BackwardPass::DoSetDead() const
+void
+BackwardPass::DoSetDead(IR::Opnd * opnd, bool isDead) const
 {
     // Note: Dead bit on the Opnd records flow-based liveness.
     // This is distinct from isLastUse, which records lexical last-ness.
-    return this->tag == Js::BackwardPhase && !this->IsPrePass();
+    if (isDead && this->tag == Js::BackwardPhase && !this->IsPrePass())
+    {
+        opnd->SetIsDead();
+    }
+    else if (this->tag == Js::DeadStorePhase)
+    {
+        // Set or reset in DeadStorePhase.
+        // CSE could make previous dead operand not the last use, so reset it.
+        opnd->SetIsDead(isDead);
+    }
 }
 
 bool
@@ -4554,10 +4563,7 @@ BackwardPass::ProcessUse(IR::Opnd * opnd)
                 this->CollectCloneStrCandidate(opnd);
             }
 
-            if (!this->ProcessSymUse(sym, true, regOpnd->GetIsJITOptimizedReg()) && this->DoSetDead())
-            {
-                regOpnd->SetIsDead();
-            }
+            this->DoSetDead(regOpnd, !this->ProcessSymUse(sym, true, regOpnd->GetIsJITOptimizedReg()));
 
             if (IsCollectionPass())
             {
@@ -4602,10 +4608,8 @@ BackwardPass::ProcessUse(IR::Opnd * opnd)
         {
             IR::SymOpnd *symOpnd = opnd->AsSymOpnd();
             Sym * sym = symOpnd->m_sym;
-            if (!this->ProcessSymUse(sym, false, opnd->GetIsJITOptimizedReg()) && this->DoSetDead())
-            {
-                symOpnd->SetIsDead();
-            }
+
+            this->DoSetDead(symOpnd, !this->ProcessSymUse(sym, false, opnd->GetIsJITOptimizedReg()));
 
             if (IsCollectionPass())
             {
@@ -4641,18 +4645,12 @@ BackwardPass::ProcessUse(IR::Opnd * opnd)
             IR::IndirOpnd * indirOpnd = opnd->AsIndirOpnd();
             IR::RegOpnd * baseOpnd = indirOpnd->GetBaseOpnd();
 
-            if (!this->ProcessSymUse(baseOpnd->m_sym, false, baseOpnd->GetIsJITOptimizedReg()) && this->DoSetDead())
-            {
-                baseOpnd->SetIsDead();
-            }
+            this->DoSetDead(baseOpnd, !this->ProcessSymUse(baseOpnd->m_sym, false, baseOpnd->GetIsJITOptimizedReg()));
 
             IR::RegOpnd * indexOpnd = indirOpnd->GetIndexOpnd();
             if (indexOpnd)
             {
-                if (!this->ProcessSymUse(indexOpnd->m_sym, false, indexOpnd->GetIsJITOptimizedReg()) && this->DoSetDead())
-                {
-                    indexOpnd->SetIsDead();
-                }
+                this->DoSetDead(indexOpnd, !this->ProcessSymUse(indexOpnd->m_sym, false, indexOpnd->GetIsJITOptimizedReg()));
             }
 
             if(IsCollectionPass())
@@ -5996,10 +5994,8 @@ BackwardPass::ProcessDef(IR::Opnd * opnd)
             }
         }
 
-        if (!block->upwardExposedFields->TestAndClear(propertySym->m_id) && this->DoSetDead())
-        {
-            opnd->SetIsDead();
-        }
+        this->DoSetDead(opnd, !block->upwardExposedFields->TestAndClear(propertySym->m_id));
+
         ProcessStackSymUse(propertySym->m_stackSym, isJITOptimizedReg);
         if (tag == Js::BackwardPhase)
         {

lib/Backend/BackwardPass.h

@@ -96,7 +96,7 @@ class BackwardPass
     bool ProcessBailOnNoProfile(IR::Instr *instr, BasicBlock *block);
 
     bool DoByteCodeUpwardExposedUsed() const;
-    bool DoSetDead() const;
+    void DoSetDead(IR::Opnd * opnd, bool isDead) const;
     bool DoFieldHoistCandidates() const;
     bool DoFieldHoistCandidates(Loop * loop) const;
     bool DoMarkTempObjects() const;

lib/Backend/PreLowerPeeps.cpp

@@ -6,7 +6,7 @@
 
 IR::Instr *Lowerer::PreLowerPeepInstr(IR::Instr *instr, IR::Instr **pInstrPrev)
 {
-    if (!PHASE_ON(Js::PreLowererPeepsPhase, this->m_func))
+    if (!PHASE_OFF(Js::PreLowererPeepsPhase, this->m_func))
     {
         return instr;
     }