Revert "[indvars] Missing variables at Og (#88270)" (#93016)

This reverts commit 89e1f77.

#88270 (comment)
#88270 (comment)

Main concerns from @nikic are the interaction between the
'IndVars' and 'LoopDeletion' passes, increasing build times
and adding extra complexity.

llvm/include/llvm/Analysis/LoopInfo.h

@@ -17,9 +17,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/GenericLoopInfo.h"
 #include <algorithm>
@@ -394,36 +392,13 @@ class LLVM_EXTERNAL_VISIBILITY Loop : public LoopBase<BasicBlock, Loop> {
     return "<unnamed loop>";
   }
 
-  /// Preserve the induction variable exit value and its debug users by the
-  /// 'indvars' pass if the loop can deleted. Those debug users will be used
-  /// by the 'loop-delete' pass.
-  void preserveDebugInductionVariableInfo(
-      Value *FinalValue,
-      const SmallVectorImpl<DbgVariableIntrinsic *> &DbgUsers) {
-    IndVarFinalValue = FinalValue;
-    for (auto &DebugUser : DbgUsers)
-      IndVarDebugUsers.push_back(DebugUser);
-  }
-
-  Value *getDebugInductionVariableFinalValue() { return IndVarFinalValue; }
-  SmallVector<WeakVH> &getDebugInductionVariableDebugUsers() {
-    return IndVarDebugUsers;
-  }
-
 private:
   Loop() = default;
 
   friend class LoopInfoBase<BasicBlock, Loop>;
   friend class LoopBase<BasicBlock, Loop>;
   explicit Loop(BasicBlock *BB) : LoopBase<BasicBlock, Loop>(BB) {}
   ~Loop() = default;
-
-  // Induction variable exit value and its debug users, preserved by the
-  // 'indvars' pass, when it detects that the loop can be deleted and the
-  // there are no PHIs to be rewritten.
-  // For now, we only preserve single induction variables.
-  Value *IndVarFinalValue = nullptr;
-  SmallVector<WeakVH> IndVarDebugUsers;
 };
 
 // Implementation in Support/GenericLoopInfoImpl.h

llvm/include/llvm/Transforms/Utils/LoopUtils.h

@@ -468,12 +468,6 @@ int rewriteLoopExitValues(Loop *L, LoopInfo *LI, TargetLibraryInfo *TLI,
                           ReplaceExitVal ReplaceExitValue,
                           SmallVector<WeakTrackingVH, 16> &DeadInsts);
 
-/// Assign exit values to variables that use this loop variable during the loop.
-void addDebugValuesToIncomingValue(BasicBlock *Successor, Value *IndVar,
-                                   PHINode *PN);
-void addDebugValuesToLoopVariable(BasicBlock *Successor, Value *ExitValue,
-                                  PHINode *PN);
-
 /// Set weights for \p UnrolledLoop and \p RemainderLoop based on weights for
 /// \p OrigLoop and the following distribution of \p OrigLoop iteration among \p
 /// UnrolledLoop and \p RemainderLoop. \p UnrolledLoop receives weights that

llvm/lib/Transforms/Utils/LoopUtils.cpp

@@ -31,7 +31,6 @@
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/DIBuilder.h"
-#include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
@@ -609,17 +608,6 @@ void llvm::deleteDeadLoop(Loop *L, DominatorTree *DT, ScalarEvolution *SE,
   llvm::SmallVector<DbgVariableRecord *, 4> DeadDbgVariableRecords;
 
   if (ExitBlock) {
-    if (ExitBlock->phis().empty()) {
-      // As the loop is deleted, replace the debug users with the preserved
-      // induction variable final value recorded by the 'indvar' pass.
-      Value *FinalValue = L->getDebugInductionVariableFinalValue();
-      SmallVector<WeakVH> &DbgUsers = L->getDebugInductionVariableDebugUsers();
-      for (WeakVH &DebugUser : DbgUsers)
-        if (DebugUser)
-          cast<DbgVariableIntrinsic>(DebugUser)->replaceVariableLocationOp(
-              0u, FinalValue);
-    }
-
     // Given LCSSA form is satisfied, we should not have users of instructions
     // within the dead loop outside of the loop. However, LCSSA doesn't take
     // unreachable uses into account. We handle them here.
@@ -1413,36 +1401,6 @@ static bool checkIsIndPhi(PHINode *Phi, Loop *L, ScalarEvolution *SE,
   return InductionDescriptor::isInductionPHI(Phi, L, SE, ID);
 }
 
-void llvm::addDebugValuesToIncomingValue(BasicBlock *Successor, Value *IndVar,
-                                         PHINode *PN) {
-  SmallVector<DbgVariableIntrinsic *> DbgUsers;
-  findDbgUsers(DbgUsers, IndVar);
-  for (auto *DebugUser : DbgUsers) {
-    // Skip debug-users with variadic variable locations; they will not,
-    // get updated, which is fine as that is the existing behaviour.
-    if (DebugUser->hasArgList())
-      continue;
-    auto *Cloned = cast<DbgVariableIntrinsic>(DebugUser->clone());
-    Cloned->replaceVariableLocationOp(0u, PN);
-    Cloned->insertBefore(*Successor, Successor->getFirstNonPHIIt());
-  }
-}
-
-void llvm::addDebugValuesToLoopVariable(BasicBlock *Successor, Value *ExitValue,
-                                        PHINode *PN) {
-  SmallVector<DbgVariableIntrinsic *> DbgUsers;
-  findDbgUsers(DbgUsers, PN);
-  for (auto *DebugUser : DbgUsers) {
-    // Skip debug-users with variadic variable locations; they will not,
-    // get updated, which is fine as that is the existing behaviour.
-    if (DebugUser->hasArgList())
-      continue;
-    auto *Cloned = cast<DbgVariableIntrinsic>(DebugUser->clone());
-    Cloned->replaceVariableLocationOp(0u, ExitValue);
-    Cloned->insertBefore(*Successor, Successor->getFirstNonPHIIt());
-  }
-}
-
 int llvm::rewriteLoopExitValues(Loop *L, LoopInfo *LI, TargetLibraryInfo *TLI,
                                 ScalarEvolution *SE,
                                 const TargetTransformInfo *TTI,
@@ -1584,10 +1542,6 @@ int llvm::rewriteLoopExitValues(Loop *L, LoopInfo *LI, TargetLibraryInfo *TLI,
           (isa<PHINode>(Inst) || isa<LandingPadInst>(Inst)) ?
           &*Inst->getParent()->getFirstInsertionPt() : Inst;
         RewritePhiSet.emplace_back(PN, i, ExitValue, InsertPt, HighCost);
-
-        // Add debug values for the candidate PHINode incoming value.
-        if (BasicBlock *Successor = ExitBB->getSingleSuccessor())
-          addDebugValuesToIncomingValue(Successor, PN->getIncomingValue(i), PN);
       }
     }
   }
@@ -1646,30 +1600,11 @@ int llvm::rewriteLoopExitValues(Loop *L, LoopInfo *LI, TargetLibraryInfo *TLI,
     // Replace PN with ExitVal if that is legal and does not break LCSSA.
     if (PN->getNumIncomingValues() == 1 &&
         LI->replacementPreservesLCSSAForm(PN, ExitVal)) {
-      addDebugValuesToLoopVariable(PN->getParent(), ExitVal, PN);
       PN->replaceAllUsesWith(ExitVal);
       PN->eraseFromParent();
     }
   }
 
-  // If the loop can be deleted and there are no PHIs to be rewritten (there
-  // are no loop live-out values), record debug variables corresponding to the
-  // induction variable with their constant exit-values. Those values will be
-  // inserted by the 'deletion loop' logic.
-  if (LoopCanBeDel && RewritePhiSet.empty()) {
-    if (auto *IndVar = L->getInductionVariable(*SE)) {
-      const SCEV *PNSCEV = SE->getSCEVAtScope(IndVar, L->getParentLoop());
-      if (auto *Const = dyn_cast<SCEVConstant>(PNSCEV)) {
-        Value *FinalIVValue = Const->getValue();
-        if (L->getUniqueExitBlock()) {
-          SmallVector<DbgVariableIntrinsic *> DbgUsers;
-          findDbgUsers(DbgUsers, IndVar);
-          L->preserveDebugInductionVariableInfo(FinalIVValue, DbgUsers);
-        }
-      }
-    }
-  }
-
   // The insertion point instruction may have been deleted; clear it out
   // so that the rewriter doesn't trip over it later.
   Rewriter.clearInsertPoint();