MEGAPATCH checkin.

For details, See: docs/2002-06-25-MegaPatchInfo.txt


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

1 files changed, 38 insertions, 55 deletions

diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp
index 12430e1270..7d36e379bc 100644
--- a/lib/Transforms/IPO/InlineSimple.cpp
+++ b/lib/Transforms/IPO/InlineSimple.cpp
@@ -20,18 +20,16 @@
 
 #include "llvm/Transforms/FunctionInlining.h"
 #include "llvm/Module.h"
-#include "llvm/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iPHINode.h"
 #include "llvm/iOther.h"
 #include "llvm/Type.h"
-#include "llvm/Argument.h"
 #include "Support/StatisticReporter.h"
-
-static Statistic<> NumInlined("inline\t\t- Number of functions inlined");
 #include <algorithm>
 #include <iostream>
+
+static Statistic<> NumInlined("inline\t\t- Number of functions inlined");
 using std::cerr;
 
 // RemapInstruction - Convert the instruction operands from referencing the 
@@ -65,17 +63,16 @@ static inline void RemapInstruction(Instruction *I,
 // exists in the instruction stream.  Similiarly this will inline a recursive
 // function by one level.
 //
-bool InlineFunction(BasicBlock::iterator CIIt) {
-  assert(isa<CallInst>(*CIIt) && "InlineFunction only works on CallInst nodes");
-  assert((*CIIt)->getParent() && "Instruction not embedded in basic block!");
-  assert((*CIIt)->getParent()->getParent() && "Instruction not in function!");
+bool InlineFunction(CallInst *CI) {
+  assert(isa<CallInst>(CI) && "InlineFunction only works on CallInst nodes");
+  assert(CI->getParent() && "Instruction not embedded in basic block!");
+  assert(CI->getParent()->getParent() && "Instruction not in function!");
 
-  CallInst *CI = cast<CallInst>(*CIIt);
-  const Function *CalledMeth = CI->getCalledFunction();
-  if (CalledMeth == 0 ||   // Can't inline external function or indirect call!
-      CalledMeth->isExternal()) return false;
+  const Function *CalledFunc = CI->getCalledFunction();
+  if (CalledFunc == 0 ||   // Can't inline external function or indirect call!
+      CalledFunc->isExternal()) return false;
 
-  //cerr << "Inlining " << CalledMeth->getName() << " into " 
+  //cerr << "Inlining " << CalledFunc->getName() << " into " 
   //     << CurrentMeth->getName() << "\n";
 
   BasicBlock *OrigBB = CI->getParent();
@@ -84,7 +81,7 @@ bool InlineFunction(BasicBlock::iterator CIIt) {
   // immediately before the call.  The original basic block now ends with an
   // unconditional branch to NewBB, and NewBB starts with the call instruction.
   //
-  BasicBlock *NewBB = OrigBB->splitBasicBlock(CIIt);
+  BasicBlock *NewBB = OrigBB->splitBasicBlock(CI);
   NewBB->setName("InlinedFunctionReturnNode");
 
   // Remove (unlink) the CallInst from the start of the new basic block.  
@@ -95,8 +92,8 @@ bool InlineFunction(BasicBlock::iterator CIIt) {
   // function.
   //
   PHINode *PHI = 0;
-  if (CalledMeth->getReturnType() != Type::VoidTy) {
-    PHI = new PHINode(CalledMeth->getReturnType(), CI->getName());
+  if (CalledFunc->getReturnType() != Type::VoidTy) {
+    PHI = new PHINode(CalledFunc->getReturnType(), CI->getName());
 
     // The PHI node should go at the front of the new basic block to merge all 
     // possible incoming values.
@@ -118,19 +115,17 @@ bool InlineFunction(BasicBlock::iterator CIIt) {
   // Add the function arguments to the mapping: (start counting at 1 to skip the
   // function reference itself)
   //
-  Function::ArgumentListType::const_iterator PTI = 
-    CalledMeth->getArgumentList().begin();
+  Function::const_aiterator PTI = CalledFunc->abegin();
   for (unsigned a = 1, E = CI->getNumOperands(); a != E; ++a, ++PTI)
-    ValueMap[*PTI] = CI->getOperand(a);
+    ValueMap[PTI] = CI->getOperand(a);
   
   ValueMap[NewBB] = NewBB;  // Returns get converted to reference NewBB
 
   // Loop over all of the basic blocks in the function, inlining them as 
   // appropriate.  Keep track of the first basic block of the function...
   //
-  for (Function::const_iterator BI = CalledMeth->begin(); 
-       BI != CalledMeth->end(); ++BI) {
-    const BasicBlock *BB = *BI;
+  for (Function::const_iterator BB = CalledFunc->begin(); 
+       BB != CalledFunc->end(); ++BB) {
     assert(BB->getTerminator() && "BasicBlock doesn't have terminator!?!?");
     
     // Create a new basic block to copy instructions into!
@@ -148,23 +143,24 @@ bool InlineFunction(BasicBlock::iterator CIIt) {
     // Loop over all instructions copying them over...
     Instruction *NewInst;
     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.
-      if ((*II)->hasName())
-        NewInst->setName((*II)->getName()+".i");  // .i = inlined once
+	 II != --BB->end(); ++II) {
+      IBB->getInstList().push_back((NewInst = II->clone()));
+      ValueMap[II] = NewInst;                  // Add instruction map to value.
+      if (II->hasName())
+        NewInst->setName(II->getName()+".i");  // .i = inlined once
     }
 
     // Copy over the terminator now...
     switch (TI->getOpcode()) {
     case Instruction::Ret: {
-      const ReturnInst *RI = cast<const ReturnInst>(TI);
+      const ReturnInst *RI = cast<ReturnInst>(TI);
 
       if (PHI) {   // The PHI node should include this value!
 	assert(RI->getReturnValue() && "Ret should have value!");
 	assert(RI->getReturnValue()->getType() == PHI->getType() && 
 	       "Ret value not consistent in function!");
-	PHI->addIncoming((Value*)RI->getReturnValue(), cast<BasicBlock>(BB));
+	PHI->addIncoming((Value*)RI->getReturnValue(),
+                         (BasicBlock*)cast<BasicBlock>(&*BB));
       }
 
       // Add a branch to the code that was after the original Call.
@@ -185,15 +181,14 @@ bool InlineFunction(BasicBlock::iterator CIIt) {
   // Loop over all of the instructions in the function, fixing up operand 
   // references as we go.  This uses ValueMap to do all the hard work.
   //
-  for (Function::const_iterator BI = CalledMeth->begin(); 
-       BI != CalledMeth->end(); ++BI) {
-    const BasicBlock *BB = *BI;
+  for (Function::const_iterator BB = CalledFunc->begin(); 
+       BB != CalledFunc->end(); ++BB) {
     BasicBlock *NBB = (BasicBlock*)ValueMap[BB];
 
     // Loop over all instructions, fixing each one as we find it...
     //
-    for (BasicBlock::iterator II = NBB->begin(); II != NBB->end(); II++)
-      RemapInstruction(*II, ValueMap);
+    for (BasicBlock::iterator II = NBB->begin(); II != NBB->end(); ++II)
+      RemapInstruction(II, ValueMap);
   }
 
   if (PHI) RemapInstruction(PHI, ValueMap);  // Fix the PHI node also...
@@ -204,24 +199,13 @@ bool InlineFunction(BasicBlock::iterator CIIt) {
   TerminatorInst *Br = OrigBB->getTerminator();
   assert(Br && Br->getOpcode() == Instruction::Br && 
 	 "splitBasicBlock broken!");
-  Br->setOperand(0, ValueMap[CalledMeth->front()]);
+  Br->setOperand(0, ValueMap[&CalledFunc->front()]);
 
   // Since we are now done with the CallInst, we can finally delete it.
   delete CI;
   return true;
 }
 
-bool InlineFunction(CallInst *CI) {
-  assert(CI->getParent() && "CallInst not embeded in BasicBlock!");
-  BasicBlock *PBB = CI->getParent();
-
-  BasicBlock::iterator CallIt = find(PBB->begin(), PBB->end(), CI);
-
-  assert(CallIt != PBB->end() && 
-	 "CallInst has parent that doesn't contain CallInst?!?");
-  return InlineFunction(CallIt);
-}
-
 static inline bool ShouldInlineFunction(const CallInst *CI, const Function *F) {
   assert(CI->getParent() && CI->getParent()->getParent() && 
 	 "Call not embedded into a function!");
@@ -242,11 +226,12 @@ static inline bool ShouldInlineFunction(const CallInst *CI, const Function *F) {
 
 static inline bool DoFunctionInlining(BasicBlock *BB) {
   for (BasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) {
-    if (CallInst *CI = dyn_cast<CallInst>(*I)) {
+    if (CallInst *CI = dyn_cast<CallInst>(&*I)) {
       // Check to see if we should inline this function
       Function *F = CI->getCalledFunction();
-      if (F && ShouldInlineFunction(CI, F))
-	return InlineFunction(I);
+      if (F && ShouldInlineFunction(CI, F)) {
+	return InlineFunction(CI);
+      }
     }
   }
   return false;
@@ -255,16 +240,14 @@ static inline bool DoFunctionInlining(BasicBlock *BB) {
 // doFunctionInlining - Use a heuristic based approach to inline functions that
 // seem to look good.
 //
-static bool doFunctionInlining(Function *F) {
+static bool doFunctionInlining(Function &F) {
   bool Changed = false;
 
   // Loop through now and inline instructions a basic block at a time...
-  for (Function::iterator I = F->begin(); I != F->end(); )
-    if (DoFunctionInlining(*I)) {
+  for (Function::iterator I = F.begin(); I != F.end(); )
+    if (DoFunctionInlining(I)) {
       ++NumInlined;
       Changed = true;
-      // Iterator is now invalidated by new basic blocks inserted
-      I = F->begin();
     } else {
       ++I;
     }
@@ -275,7 +258,7 @@ static bool doFunctionInlining(Function *F) {
 namespace {
   struct FunctionInlining : public FunctionPass {
     const char *getPassName() const { return "Function Inlining"; }
-    virtual bool runOnFunction(Function *F) {
+    virtual bool runOnFunction(Function &F) {
       return doFunctionInlining(F);
     }
   };