More cleanups and simplifications, no functionality change.

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

1 files changed, 23 insertions, 47 deletions

diff --git a/lib/Transforms/Scalar/LoopRotation.cpp b/lib/Transforms/Scalar/LoopRotation.cpp
index 857d326..1118ed5 100644
--- a/lib/Transforms/Scalar/LoopRotation.cpp
+++ b/lib/Transforms/Scalar/LoopRotation.cpp
@@ -128,7 +128,6 @@ bool LoopRotate::runOnLoop(Loop *Lp, LPPassManager &LPM) {
 
 /// Rotate loop LP. Return true if the loop is rotated.
 bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
-
   L = Lp;
 
   OrigHeader =  L->getHeader();
@@ -170,8 +169,8 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
   // Now, this loop is suitable for rotation.
 
   // Find new Loop header. NewHeader is a Header's one and only successor
-  // that is inside loop.  Header's other successor is out side the
-  // loop. Otherwise loop is not suitable for rotation.
+  // that is inside loop.  Header's other successor is outside the
+  // loop.  Otherwise loop is not suitable for rotation.
   Exit = BI->getSuccessor(0);
   NewHeader = BI->getSuccessor(1);
   if (L->contains(Exit))
@@ -197,31 +196,29 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
   // receive a clone of original header terminator as a new terminator.
   OrigPreHeader->getInstList().pop_back();
   BasicBlock::iterator I = OrigHeader->begin(), E = OrigHeader->end();
-  PHINode *PN = NULL;
+  PHINode *PN = 0;
   for (; (PN = dyn_cast<PHINode>(I)); ++I) {
-    Instruction *In = I;
-
     // PHI nodes are not copied into original pre-header. Instead their values
     // are directly propagated.
-    Value * NPV = PN->getIncomingValueForBlock(OrigPreHeader);
+    Value *NPV = PN->getIncomingValueForBlock(OrigPreHeader);
 
     // Create new PHI node with two incoming values for NewHeader.
     // One incoming value is from OrigLatch (through OrigHeader) and 
     // second incoming value is from original pre-header.
-    PHINode *NH = PHINode::Create(In->getType(), In->getName(),
+    PHINode *NH = PHINode::Create(PN->getType(), PN->getName(),
                                   NewHeader->begin());
     NH->addIncoming(PN->getIncomingValueForBlock(OrigLatch), OrigHeader);
     NH->addIncoming(NPV, OrigPreHeader);
     
     // "In" can be replaced by NH at various places.
-    LoopHeaderInfo.push_back(RenameData(In, NPV, NH));
+    LoopHeaderInfo.push_back(RenameData(PN, NPV, NH));
   }
 
   // Now, handle non-phi instructions.
   for (; I != E; ++I) {
     Instruction *In = I;
-
     assert(!isa<PHINode>(In) && "PHINode is not expected here");
+    
     // This is not a PHI instruction. Insert its clone into original pre-header.
     // If this instruction is using a value from same basic block then
     // update it to use value from cloned instruction.
@@ -230,21 +227,12 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
     OrigPreHeader->getInstList().push_back(C);
 
     for (unsigned opi = 0, e = In->getNumOperands(); opi != e; ++opi) {
-      if (Instruction *OpPhi = dyn_cast<PHINode>(In->getOperand(opi))) {
-        if (const RenameData *D = findReplacementData(OpPhi)) {
-          // This is using values from original header PHI node.
-          // Here, directly used incoming value from original pre-header.
-          C->setOperand(opi, D->PreHeader);
-        }
-      }
-      else if (Instruction *OpInsn = 
-               dyn_cast<Instruction>(In->getOperand(opi))) {
-        if (const RenameData *D = findReplacementData(OpInsn))
-          C->setOperand(opi, D->PreHeader);
-      }
+      Instruction *OpInsn = dyn_cast<Instruction>(In->getOperand(opi));
+      if (!OpInsn) continue;  // Ignore non-instruction values.
+      if (const RenameData *D = findReplacementData(OpInsn))
+        C->setOperand(opi, D->PreHeader);
     }
 
-
     // If this instruction is used outside this basic block then
     // create new PHINode for this instruction.
     Instruction *NewHeaderReplacement = NULL;
@@ -276,7 +264,7 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
   // 2) Inside loop but not in original header
   //
   //    Replace this use to reflect definition from new header.
-  for(unsigned LHI = 0, LHI_E = LoopHeaderInfo.size(); LHI != LHI_E; ++LHI) {
+  for (unsigned LHI = 0, LHI_E = LoopHeaderInfo.size(); LHI != LHI_E; ++LHI) {
     const RenameData &ILoopHeaderInfo = LoopHeaderInfo[LHI];
 
     if (!ILoopHeaderInfo.Header)
@@ -289,10 +277,8 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
     // not invalidated.
     SmallVector<Instruction *, 16> AllUses;
     for (Value::use_iterator UI = OldPhi->use_begin(), UE = OldPhi->use_end();
-         UI != UE; ++UI) {
-      Instruction *U = cast<Instruction>(UI);
-      AllUses.push_back(U);
-    }
+         UI != UE; ++UI)
+      AllUses.push_back(cast<Instruction>(UI));
 
     for (SmallVector<Instruction *, 16>::iterator UI = AllUses.begin(), 
            UE = AllUses.end(); UI != UE; ++UI) {
@@ -351,14 +337,9 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
   // Removing incoming branch from loop preheader to original header.
   // Now original header is inside the loop.
   for (BasicBlock::iterator I = OrigHeader->begin(), E = OrigHeader->end();
-       I != E; ++I) {
-    Instruction *In = I;
-    PHINode *PN = dyn_cast<PHINode>(In);
-    if (!PN)
-      break;
-
-    PN->removeIncomingValue(OrigPreHeader);
-  }
+       I != E; ++I)
+    if (PHINode *PN = dyn_cast<PHINode>(I))
+      PN->removeIncomingValue(OrigPreHeader);
 
   // Make NewHeader as the new header for the loop.
   L->moveToHeader(NewHeader);
@@ -411,14 +392,11 @@ void LoopRotate::initialize() {
 /// Return true if this instruction is used by any instructions in the loop that
 /// aren't in original header.
 bool LoopRotate::usedOutsideOriginalHeader(Instruction *In) {
-
   for (Value::use_iterator UI = In->use_begin(), UE = In->use_end();
        UI != UE; ++UI) {
-    Instruction *U = cast<Instruction>(UI);
-    if (U->getParent() != OrigHeader) {
-      if (L->contains(U->getParent()))
-        return true;
-    }
+    BasicBlock *UserBB = cast<Instruction>(UI)->getParent();
+    if (UserBB != OrigHeader && L->contains(UserBB))
+      return true;
   }
 
   return false;
@@ -429,7 +407,7 @@ bool LoopRotate::usedOutsideOriginalHeader(Instruction *In) {
 const RenameData *LoopRotate::findReplacementData(Instruction *In) {
 
   // Since LoopHeaderInfo is small, linear walk is OK.
-  for(unsigned LHI = 0, LHI_E = LoopHeaderInfo.size(); LHI != LHI_E; ++LHI) {
+  for (unsigned LHI = 0, LHI_E = LoopHeaderInfo.size(); LHI != LHI_E; ++LHI) {
     const RenameData &ILoopHeaderInfo = LoopHeaderInfo[LHI];
     if (ILoopHeaderInfo.Original == In)
       return &ILoopHeaderInfo;
@@ -464,8 +442,7 @@ void LoopRotate::preserveCanonicalLoopForm(LPPassManager &LPM) {
   
   for (BasicBlock::iterator I = NewHeader->begin(), E = NewHeader->end();
        I != E; ++I) {
-    Instruction *In = I;
-    PHINode *PN = dyn_cast<PHINode>(In);
+    PHINode *PN = dyn_cast<PHINode>(I);
     if (!PN)
       break;
 
@@ -492,8 +469,7 @@ void LoopRotate::preserveCanonicalLoopForm(LPPassManager &LPM) {
     DT->changeImmediateDominator(OrigHeader, OrigLatch);
   }
 
-  if(DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>()) {
-
+  if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>()) {
     // New Preheader's dominance frontier is Exit block.
     DominanceFrontier::DomSetType NewPHSet;
     NewPHSet.insert(Exit);