Miscellaneous cleanups:

  * Convert post to pre-increment for for loops
  * Use generic programming more
  * Use new Value::cast* instructions
  * Use new Module, Method, & BasicBlock forwarding methods
  * Use new facilities in STLExtras.h
  * Use new Instruction::isPHINode() method


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

3 files changed, 71 insertions, 63 deletions

diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp
index 0a191a5..e5bc171 100644
--- a/lib/Transforms/IPO/InlineSimple.cpp
+++ b/lib/Transforms/IPO/InlineSimple.cpp
@@ -36,9 +36,9 @@
 static inline void RemapInstruction(Instruction *I, 
 				    map<const Value *, Value*> &ValueMap) {
 
-  for (unsigned op = 0; const Value *Op = I->getOperand(op); op++) {
+  for (unsigned op = 0; const Value *Op = I->getOperand(op); ++op) {
     Value *V = ValueMap[Op];
-    if (!V && Op->getValueType() == Value::MethodVal) 
+    if (!V && Op->isMethod()) 
       continue;  // Methods don't get relocated
 
     if (!V) {
@@ -60,7 +60,7 @@ static inline void RemapInstruction(Instruction *I,
 // exists in the instruction stream.  Similiarly this will inline a recursive
 // method by one level.
 //
-bool InlineMethod(BasicBlock::InstListType::iterator CIIt) {
+bool InlineMethod(BasicBlock::iterator CIIt) {
   assert((*CIIt)->getInstType() == Instruction::Call && 
 	 "InlineMethod only works on CallInst nodes!");
   assert((*CIIt)->getParent() && "Instruction not embedded in basic block!");
@@ -124,9 +124,8 @@ bool InlineMethod(BasicBlock::InstListType::iterator CIIt) {
   // Loop over all of the basic blocks in the method, inlining them as 
   // appropriate.  Keep track of the first basic block of the method...
   //
-  for (Method::BasicBlocksType::const_iterator BI = 
-	 CalledMeth->getBasicBlocks().begin(); 
-       BI != CalledMeth->getBasicBlocks().end(); BI++) {
+  for (Method::const_iterator BI = CalledMeth->begin(); 
+       BI != CalledMeth->end(); ++BI) {
     const BasicBlock *BB = *BI;
     assert(BB->getTerminator() && "BasicBlock doesn't have terminator!?!?");
     
@@ -143,8 +142,8 @@ bool InlineMethod(BasicBlock::InstListType::iterator CIIt) {
    
     // Loop over all instructions copying them over...
     Instruction *NewInst;
-    for (BasicBlock::InstListType::const_iterator II = BB->getInstList().begin();
-	 II != (BB->getInstList().end()-1); II++) {
+    for (BasicBlock::const_iterator II = BB->begin();
+	 II != (BB->end()-1); ++II) {
       IBB->getInstList().push_back((NewInst = (*II)->clone()));
       ValueMap[*II] = NewInst;                  // Add instruction map to value.
     }
@@ -193,16 +192,14 @@ bool InlineMethod(BasicBlock::InstListType::iterator CIIt) {
   // Loop over all of the instructions in the method, fixing up operand 
   // references as we go.  This uses ValueMap to do all the hard work.
   //
-  for (Method::BasicBlocksType::const_iterator BI = 
-	 CalledMeth->getBasicBlocks().begin(); 
-       BI != CalledMeth->getBasicBlocks().end(); BI++) {
+  for (Method::const_iterator BI = CalledMeth->begin(); 
+       BI != CalledMeth->end(); ++BI) {
     const BasicBlock *BB = *BI;
     BasicBlock *NBB = (BasicBlock*)ValueMap[BB];
 
     // Loop over all instructions, fixing each one as we find it...
     //
-    for (BasicBlock::InstListType::iterator II = NBB->getInstList().begin();
-	 II != NBB->getInstList().end(); II++)
+    for (BasicBlock::iterator II = NBB->begin(); II != NBB->end(); II++)
       RemapInstruction(*II, ValueMap);
   }
 
@@ -214,7 +211,7 @@ bool InlineMethod(BasicBlock::InstListType::iterator CIIt) {
   TerminatorInst *Br = OrigBB->getTerminator();
   assert(Br && Br->getInstType() == Instruction::Br && 
 	 "splitBasicBlock broken!");
-  Br->setOperand(0, ValueMap[CalledMeth->getBasicBlocks().front()]);
+  Br->setOperand(0, ValueMap[CalledMeth->front()]);
 
   // Since we are now done with the CallInst, we can finally delete it.
   delete CI;
@@ -225,10 +222,9 @@ bool InlineMethod(CallInst *CI) {
   assert(CI->getParent() && "CallInst not embeded in BasicBlock!");
   BasicBlock *PBB = CI->getParent();
 
-  BasicBlock::InstListType::iterator CallIt = find(PBB->getInstList().begin(),
-						   PBB->getInstList().end(),
-						   CI);
-  assert(CallIt != PBB->getInstList().end() && 
+  BasicBlock::iterator CallIt = find(PBB->begin(), PBB->end(), CI);
+
+  assert(CallIt != PBB->end() && 
 	 "CallInst has parent that doesn't contain CallInst?!?");
   return InlineMethod(CallIt);
 }
@@ -241,10 +237,10 @@ static inline bool ShouldInlineMethod(const CallInst *CI, const Method *M) {
   if (CI->getParent()->getParent() == M) return false;
 
   // Don't inline something too big.  This is a really crappy heuristic
-  if (M->getBasicBlocks().size() > 3) return false;
+  if (M->size() > 3) return false;
 
   // Don't inline into something too big. This is a **really** crappy heuristic
-  if (CI->getParent()->getParent()->getBasicBlocks().size() > 10) return false;
+  if (CI->getParent()->getParent()->size() > 10) return false;
 
   // Go ahead and try just about anything else.
   return true;
@@ -252,8 +248,7 @@ static inline bool ShouldInlineMethod(const CallInst *CI, const Method *M) {
 
 
 static inline bool DoMethodInlining(BasicBlock *BB) {
-  for (BasicBlock::InstListType::iterator I = BB->getInstList().begin();
-       I != BB->getInstList().end(); I++) {
+  for (BasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) {
     if ((*I)->getInstType() == Instruction::Call) {
       // Check to see if we should inline this method
       CallInst *CI = (CallInst*)*I;
@@ -266,15 +261,14 @@ static inline bool DoMethodInlining(BasicBlock *BB) {
 }
 
 bool DoMethodInlining(Method *M) {
-  Method::BasicBlocksType &BBs = M->getBasicBlocks();
   bool Changed = false;
 
   // Loop through now and inline instructions a basic block at a time...
-  for (Method::BasicBlocksType::iterator I = BBs.begin(); I != BBs.end(); )
+  for (Method::iterator I = M->begin(); I != M->end(); )
     if (DoMethodInlining(*I)) {
       Changed = true;
       // Iterator is now invalidated by new basic blocks inserted
-      I = BBs.begin();
+      I = M->begin();
     } else {
       ++I;
     }
diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp
index 14ee8d5..5bc3c5b 100644
--- a/lib/Transforms/Scalar/DCE.cpp
+++ b/lib/Transforms/Scalar/DCE.cpp
@@ -61,7 +61,7 @@ static bool RemoveUnusedDefs(ValueHolder<ValueSubclass, ItemParentType> &Vals,
       delete Vals.remove(DI);
       Changed = true;
     } else {
-      DI++;
+      ++DI;
     }
   }
   return Changed;
@@ -79,8 +79,8 @@ static bool RemoveSingularPHIs(BasicBlock *BB) {
   if (PI == pred_end(BB) || ++PI != pred_end(BB)) 
     return false;   // More than one predecessor...
 
-  Instruction *I = BB->getInstList().front();
-  if (I->getInstType() != Instruction::PHINode) return false;  // No PHI nodes
+  Instruction *I = BB->front();
+  if (!I->isPHINode()) return false;  // No PHI nodes
 
   //cerr << "Killing PHIs from " << BB;
   //cerr << "Pred #0 = " << *pred_begin(BB);
@@ -93,10 +93,10 @@ static bool RemoveSingularPHIs(BasicBlock *BB) {
     Value *V = PN->getOperand(0);
 
     PN->replaceAllUsesWith(V);      // Replace PHI node with its single value.
-    delete BB->getInstList().remove(BB->getInstList().begin());
+    delete BB->getInstList().remove(BB->begin());
 
-    I = BB->getInstList().front();
-  } while (I->getInstType() == Instruction::PHINode);
+    I = BB->front();
+  } while (I->isPHINode());
 	
   return true;  // Yes, we nuked at least one phi node
 }
@@ -154,8 +154,8 @@ static void RemovePredecessorFromBlock(BasicBlock *BB, BasicBlock *Pred) {
   
   // Okay, now we know that we need to remove predecessor #pred_idx from all
   // PHI nodes.  Iterate over each PHI node fixing them up
-  BasicBlock::InstListType::iterator II(BB->getInstList().begin());
-  for (; (*II)->getInstType() == Instruction::PHINode; ++II) {
+  BasicBlock::iterator II(BB->begin());
+  for (; (*II)->isPHINode(); ++II) {
     PHINode *PN = (PHINode*)*II;
     PN->removeIncomingValue(BB);
 
@@ -177,25 +177,36 @@ static void RemovePredecessorFromBlock(BasicBlock *BB, BasicBlock *Pred) {
 // Assumption: BB is the single predecessor of Succ.
 //
 static void PropogatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
-  assert(BB && Succ && *pred_begin(Succ) == BB && "BB is only pred of Succ" &&
-	 ++pred_begin(Succ) == pred_end(Succ));
+  assert(Succ->front()->isPHINode() && "Only works on PHId BBs!");
 
   // If there is more than one predecessor, and there are PHI nodes in
   // the successor, then we need to add incoming edges for the PHI nodes
-  pred_iterator PI(pred_begin(BB));
-  for (; PI != pred_end(BB); ++PI) {
-    // TODO:
-  }
+  //
+  const vector<BasicBlock*> BBPreds(pred_begin(BB), pred_end(BB));
+
+  BasicBlock::iterator I = Succ->begin();
+  do {                     // Loop over all of the PHI nodes in the successor BB
+    PHINode *PN = (PHINode*)*I;
+    Value *OldVal = PN->removeIncomingValue(BB);
+    assert(OldVal && "No entry in PHI for Pred BB!");
+
+    for (vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(), 
+	   End = BBPreds.end(); PredI != End; ++PredI) {
+      // Add an incoming value for each of the new incoming values...
+      PN->addIncoming(OldVal, *PredI);
+    }
+
+    ++I;
+  } while ((*I)->isPHINode());
 }
 
 static bool DoDCEPass(Method *M) {
-  Method::BasicBlocksType &BBs = M->getBasicBlocks();
-  Method::BasicBlocksType::iterator BBIt, BBEnd = BBs.end();
-  if (BBs.begin() == BBEnd) return false;  // Nothing to do
+  Method::iterator BBIt, BBEnd = M->end();
+  if (M->begin() == BBEnd) return false;  // Nothing to do
   bool Changed = false;
 
   // Loop through now and remove instructions that have no uses...
-  for (BBIt = BBs.begin(); BBIt != BBEnd; BBIt++) {
+  for (BBIt = M->begin(); BBIt != BBEnd; ++BBIt) {
     Changed |= RemoveUnusedDefs((*BBIt)->getInstList(), BasicBlockDCE());
     Changed |= RemoveSingularPHIs(*BBIt);
   }
@@ -203,11 +214,11 @@ static bool DoDCEPass(Method *M) {
   // Loop over all of the basic blocks (except the first one) and remove them
   // if they are unneeded...
   //
-  for (BBIt = BBs.begin(), ++BBIt; BBIt != BBs.end(); ++BBIt) {
+  for (BBIt = M->begin(), ++BBIt; BBIt != M->end(); ++BBIt) {
     BasicBlock *BB = *BBIt;
     assert(BB->getTerminator() && "Degenerate basic block encountered!");
 
-#if 0
+#if 0  // This is know to basically work?
     // Remove basic blocks that have no predecessors... which are unreachable.
     if (pred_begin(BB) == pred_end(BB) &&
 	!BB->hasConstantPoolReferences() && 0) {
@@ -215,43 +226,46 @@ static bool DoDCEPass(Method *M) {
 
       // Loop through all of our successors and make sure they know that one
       // of their predecessors is going away.
-      for (succ_iterator SI = succ_begin(BB), EI = succ_end(BB); SI != EI; ++SI)
-	RemovePredecessorFromBlock(*SI, BB);
+      for_each(succ_begin(BB), succ_end(BB),
+	       bind_2nd(RemovePredecessorFromBlock, BB));
 
-      while (!BB->getInstList().empty()) {
-	Instruction *I = BB->getInstList().front();
+      while (!BB->empty()) {
+	Instruction *I = BB->front();
 	// If this instruction is used, replace uses with an arbitrary
 	// constant value.  Because control flow can't get here, we don't care
 	// what we replace the value with.
 	if (!I->use_empty()) ReplaceUsesWithConstant(I);
 
 	// Remove the instruction from the basic block
-	delete BB->getInstList().remove(BB->getInstList().begin());
+	delete BB->getInstList().remove(BB->begin());
       }
-      delete BBs.remove(BBIt);
+      delete M->getBasicBlocks().remove(BBIt);
       --BBIt;  // remove puts use on the next block, we want the previous one
       Changed = true;
       continue;
     } 
+#endif
 
+#if 0  // This has problems
     // Check to see if this block has no instructions and only a single 
     // successor.  If so, replace block references with successor.
     succ_iterator SI(succ_begin(BB));
     if (SI != succ_end(BB) && ++SI == succ_end(BB)) {  // One succ?
-      Instruction *I = BB->getInstList().front();
+      Instruction *I = BB->front();
       if (I->isTerminator()) {   // Terminator is the only instruction!
+	BasicBlock *Succ = *succ_begin(BB); // There is exactly one successor
+	cerr << "Killing Trivial BB: \n" << BB;
 
-	if (Succ->getInstList().front()->getInstType() == Instruction::PHINode){
-	  // Add entries to the PHI nodes so that the PHI nodes have the right
-	  // number of entries...
+	if (Succ->front()->isPHINode()) {
+	  // If our successor has PHI nodes, then we need to update them to
+	  // include entries for BB's predecessors, not for BB itself.
+	  //
 	  PropogatePredecessorsForPHIs(BB, Succ);
 	}
 
-	BasicBlock *Succ = *succ_begin(BB); // There is exactly one successor
 	BB->replaceAllUsesWith(Succ);
-	cerr << "Killing Trivial BB: \n" << BB;
 
-	BB = BBs.remove(BBIt);
+	BB = M->getBasicBlocks().remove(BBIt);
 	--BBIt; // remove puts use on the next block, we want the previous one
 	
 	if (BB->hasName() && !Succ->hasName())  // Transfer name if we can
@@ -280,21 +294,21 @@ static bool DoDCEPass(Method *M) {
 	//cerr << "Merging: " << BB << "into: " << Pred;
 
 	// Delete the unconditianal branch from the predecessor...
-	BasicBlock::InstListType::iterator DI = Pred->getInstList().end();
+	BasicBlock::iterator DI = Pred->end();
 	assert(Pred->getTerminator() && 
 	       "Degenerate basic block encountered!");  // Empty bb???      
 	delete Pred->getInstList().remove(--DI);        // Destroy uncond branch
 	
 	// Move all definitions in the succecessor to the predecessor...
-	while (!BB->getInstList().empty()) {
-	  DI = BB->getInstList().begin();
+	while (!BB->empty()) {
+	  DI = BB->begin();
 	  Instruction *Def = BB->getInstList().remove(DI); // Remove from front
 	  Pred->getInstList().push_back(Def);              // Add to end...
 	}
 
 	// Remove basic block from the method... and advance iterator to the
 	// next valid block...
-	BB = BBs.remove(BBIt);
+	BB = M->getBasicBlocks().remove(BBIt);
 	--BBIt;  // remove puts us on the NEXT bb.  We want the prev BB
 	Changed = true;
 
diff --git a/lib/Transforms/Scalar/SymbolStripping.cpp b/lib/Transforms/Scalar/SymbolStripping.cpp
index af5f18f..33b6005 100644
--- a/lib/Transforms/Scalar/SymbolStripping.cpp
+++ b/lib/Transforms/Scalar/SymbolStripping.cpp
@@ -23,7 +23,7 @@ static bool StripSymbolTable(SymbolTable *SymTab) {
   if (SymTab == 0) return false;    // No symbol table?  No problem.
   bool RemovedSymbol = false;
 
-  for (SymbolTable::iterator I = SymTab->begin(); I != SymTab->end(); I++) {
+  for (SymbolTable::iterator I = SymTab->begin(); I != SymTab->end(); ++I) {
     map<const string, Value *> &Plane = I->second;
     
     map<const string, Value *>::iterator B;