From 5036695c32835ad0fb280b9d20f9214f5270dfb0 Mon Sep 17 00:00:00 2001
From: Dan Gohman <gohman@apple.com>
Date: Sun, 3 May 2009 05:46:20 +0000
Subject: Revert r70645 for now; it's causing a variety of regressions.

llvm-svn: 70661
---
 llvm/lib/Analysis/ScalarEvolution.cpp | 58 ++++++++++++++++++++---------------
 1 file changed, 33 insertions(+), 25 deletions(-)

(limited to 'llvm/lib/Analysis/ScalarEvolution.cpp')

diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 48a2f52612a..a6d39541aae 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -1466,6 +1466,34 @@ SCEVHandle ScalarEvolution::getUnknown(Value *V) {
 //            Basic SCEV Analysis and PHI Idiom Recognition Code
 //
 
+/// deleteValueFromRecords - This method should be called by the
+/// client before it removes an instruction from the program, to make sure
+/// that no dangling references are left around.
+void ScalarEvolution::deleteValueFromRecords(Value *V) {
+  SmallVector<Value *, 16> Worklist;
+
+  if (Scalars.erase(V)) {
+    if (PHINode *PN = dyn_cast<PHINode>(V))
+      ConstantEvolutionLoopExitValue.erase(PN);
+    Worklist.push_back(V);
+  }
+
+  while (!Worklist.empty()) {
+    Value *VV = Worklist.back();
+    Worklist.pop_back();
+
+    for (Instruction::use_iterator UI = VV->use_begin(), UE = VV->use_end();
+         UI != UE; ++UI) {
+      Instruction *Inst = cast<Instruction>(*UI);
+      if (Scalars.erase(Inst)) {
+        if (PHINode *PN = dyn_cast<PHINode>(VV))
+          ConstantEvolutionLoopExitValue.erase(PN);
+        Worklist.push_back(Inst);
+      }
+    }
+  }
+}
+
 /// isSCEVable - Test if values of the given type are analyzable within
 /// the SCEV framework. This primarily includes integer types, and it
 /// can optionally include pointer types if the ScalarEvolution class
@@ -1527,10 +1555,10 @@ bool ScalarEvolution::hasSCEV(Value *V) const {
 SCEVHandle ScalarEvolution::getSCEV(Value *V) {
   assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
 
-  std::map<SCEVCallbackVH, SCEVHandle>::iterator I = Scalars.find(V);
+  std::map<Value*, SCEVHandle>::iterator I = Scalars.find(V);
   if (I != Scalars.end()) return I->second;
   SCEVHandle S = createSCEV(V);
-  Scalars.insert(std::make_pair(SCEVCallbackVH(V, this), S));
+  Scalars.insert(std::make_pair(V, S));
   return S;
 }
 
@@ -1619,8 +1647,7 @@ ScalarEvolution::getTruncateOrSignExtend(const SCEVHandle &V,
 void ScalarEvolution::
 ReplaceSymbolicValueWithConcrete(Instruction *I, const SCEVHandle &SymName,
                                  const SCEVHandle &NewVal) {
-  std::map<SCEVCallbackVH, SCEVHandle>::iterator SI =
-    Scalars.find(SCEVCallbackVH(I, this));
+  std::map<Value*, SCEVHandle>::iterator SI = Scalars.find(I);
   if (SI == Scalars.end()) return;
 
   SCEVHandle NV =
@@ -1652,7 +1679,7 @@ SCEVHandle ScalarEvolution::createNodeForPHI(PHINode *PN) {
         SCEVHandle SymbolicName = getUnknown(PN);
         assert(Scalars.find(PN) == Scalars.end() &&
                "PHI node already processed?");
-        Scalars.insert(std::make_pair(SCEVCallbackVH(PN, this), SymbolicName));
+        Scalars.insert(std::make_pair(PN, SymbolicName));
 
         // Using this symbolic name for the PHI, analyze the value coming around
         // the back-edge.
@@ -2104,7 +2131,7 @@ void ScalarEvolution::forgetLoopBackedgeTakenCount(const Loop *L) {
 void ScalarEvolution::forgetLoopPHIs(const Loop *L) {
   for (BasicBlock::iterator I = L->getHeader()->begin();
        PHINode *PN = dyn_cast<PHINode>(I); ++I)
-    Scalars.erase(PN);
+    deleteValueFromRecords(PN);
 }
 
 /// ComputeBackedgeTakenCount - Compute the number of times the backedge
@@ -3316,25 +3343,6 @@ SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
 
 
 
-//===----------------------------------------------------------------------===//
-//                   SCEVCallbackVH Class Implementation
-//===----------------------------------------------------------------------===//
-
-void SCEVCallbackVH::deleted() {
-  assert(SE && "SCEVCallbackVH called with a non-null ScalarEvolution!");
-  SE->Scalars.erase(getValPtr());
-  // this now dangles!
-}
-
-void SCEVCallbackVH::allUsesReplacedWith(Value *V) {
-  assert(SE && "SCEVCallbackVH called with a non-null ScalarEvolution!");
-  SE->Scalars.erase(getValPtr());
-  // this now dangles!
-}
-
-SCEVCallbackVH::SCEVCallbackVH(Value *V, ScalarEvolution *se)
-  : CallbackVH(V), SE(se) {}
-
 //===----------------------------------------------------------------------===//
 //                   ScalarEvolution Class Implementation
 //===----------------------------------------------------------------------===//
-- 
cgit v1.2.3