Fixed minor bug in SafeToHoist and made some changes suggested by Chris.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7614 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp
index 4358c0461a8d04dcc0402ed3dfb1887e06dae97d..f2cf68b4e9c880778bed7c2237fd57d72227a775 100644 (file)
--- a/lib/Transforms/Scalar/LICM.cpp
+++ b/lib/Transforms/Scalar/LICM.cpp
@@ -67,7 +67,7 @@ namespace {
     BasicBlock *Preheader;   // The preheader block of the current loop...
     Loop *CurLoop;           // The current loop we are working on...
     AliasSetTracker *CurAST; // AliasSet information for the current loop...
-    DominatorTree *CurDT;    // Dominator Tree for the current Loop...
+    DominatorTree *DT;       // Dominator Tree for the current Loop...
 
     /// visitLoop - Hoist expressions out of the specified loop...    
     ///
@@ -173,6 +173,7 @@ bool LICM::runOnFunction(Function &) {
   // Get our Loop and Alias Analysis information...
   LI = &getAnalysis<LoopInfo>();
   AA = &getAnalysis<AliasAnalysis>();
+  DT = &getAnalysis<DominatorTree>();
 
   // Hoist expressions out of all of the top-level loops.
   const std::vector<Loop*> &TopLevelLoops = LI->getTopLevelLoops();
@@ -223,9 +224,7 @@ void LICM::visitLoop(Loop *L, AliasSetTracker &AST) {
   // that we are guaranteed to see definitions before we see uses.  This allows
   // us to perform the LICM transformation in one pass, without iteration.
   //
-  CurDT = &getAnalysis<DominatorTree>();
-  
-  HoistRegion(CurDT->getNode(L->getHeader()));
+  HoistRegion(DT->getNode(L->getHeader()));
 
   // Now that all loop invariants have been removed from the loop, promote any
   // memory references to scalars that we can...
@@ -290,36 +289,28 @@ bool LICM::SafeToHoist(Instruction &Inst) {
     BasicBlock *InstBB = Inst.getParent();
     
     //Get the Dominator Tree Node for the instruction's basic block/
-    DominatorTree::Node *InstDTNode = CurDT->getNode(InstBB);
+    DominatorTree::Node *InstDTNode = DT->getNode(InstBB);
 
     //Get the exit blocks for the current loop.
-    const std::vector<BasicBlock* > ExitBlocks = CurLoop->getExitBlocks();
+    const std::vector<BasicBlock* > &ExitBlocks = CurLoop->getExitBlocks();
 
     //For each exit block, get the DT node and walk up the DT until
     //the instruction's basic block is found or we exit the loop.
     for(unsigned i=0; i < ExitBlocks.size(); ++i) {
-      DominatorTree::Node *IDom = CurDT->getNode(ExitBlocks[i]);
+      DominatorTree::Node *IDom = DT->getNode(ExitBlocks[i]);
       
-      //Using boolean variable because exit nodes are not "contained"
-      //in the loop, so can not use that as the while test condition
-      //for first pass.
-      bool inLoop = true;
-
-      while(inLoop) {
+      while(IDom != InstDTNode) {
  
-        //compare Instruction DT node to Current DT Node
-        if(IDom == InstDTNode)
-          return true;
-
         //Get next Immediate Dominator.
         IDom = IDom->getIDom();
 
         //See if we exited the loop.
-        inLoop = CurLoop->contains(IDom->getNode());
+        if(!CurLoop->contains(IDom->getNode()))
+          return false;
       }
-      return false;
     }
   }
+  
   return true;
 }