X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=f2c9ea3b997e56acd49a6aa8a67e6f6737de3c44;hb=d9221d75f02a81eec9c22473b4f2a809d83bf60a;hp=f2bfaefe0f78f69775f967146417687140feb759;hpb=1465d61bdd36cfd6021036a527895f0dd358e97d;p=oota-llvm.git

diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index f2bfaefe0f7..f2c9ea3b997 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -17,13 +17,15 @@
 #include "llvm/Support/Timer.h"
 #include "llvm/Module.h"
 #include "llvm/ModuleProvider.h"
-#include "llvm/Support/Streams.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/System/Mutex.h"
+#include "llvm/System/Threading.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm-c/Core.h"
 #include <algorithm>
 #include <cstdio>
-#include <vector>
 #include <map>
 using namespace llvm;
 
@@ -43,7 +45,12 @@ enum PassDebugLevel {
   None, Arguments, Structure, Executions, Details
 };
 
+// Always verify dominfo if expensive checking is enabled.
+#ifdef XDEBUG
+bool VerifyDomInfo = true;
+#else
 bool VerifyDomInfo = false;
+#endif
 static cl::opt<bool,true>
 VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo),
                cl::desc("Verify dominator info (time consuming)"));
@@ -60,6 +67,46 @@ PassDebugging("debug-pass", cl::Hidden,
                              clEnumValEnd));
 } // End of llvm namespace
 
+/// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
+/// or higher is specified.
+bool PMDataManager::isPassDebuggingExecutionsOrMore() const {
+  return PassDebugging >= Executions;
+}
+
+
+
+
+void PassManagerPrettyStackEntry::print(raw_ostream &OS) const {
+  if (V == 0 && M == 0)
+    OS << "Releasing pass '";
+  else
+    OS << "Running pass '";
+  
+  OS << P->getPassName() << "'";
+  
+  if (M) {
+    OS << " on module '" << M->getModuleIdentifier() << "'.\n";
+    return;
+  }
+  if (V == 0) {
+    OS << '\n';
+    return;
+  }
+
+  OS << " on ";
+  if (isa<Function>(V))
+    OS << "function";
+  else if (isa<BasicBlock>(V))
+    OS << "basic block";
+  else
+    OS << "value";
+
+  OS << " '";
+  WriteAsOperand(OS, V, /*PrintTy=*/false, M);
+  OS << "'\n";
+}
+
+
 namespace {
 
 //===----------------------------------------------------------------------===//
@@ -96,7 +143,7 @@ public:
 
   // Print passes managed by this manager
   void dumpPassStructure(unsigned Offset) {
-    llvm::cerr << std::string(Offset*2, ' ') << "BasicBlockPass Manager\n";
+    llvm::errs() << std::string(Offset*2, ' ') << "BasicBlockPass Manager\n";
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       BasicBlockPass *BP = getContainedPass(Index);
       BP->dumpPassStructure(Offset + 1);
@@ -105,7 +152,7 @@ public:
   }
 
   BasicBlockPass *getContainedPass(unsigned N) {
-    assert ( N < PassVector.size() && "Pass number out of range!");
+    assert(N < PassVector.size() && "Pass number out of range!");
     BasicBlockPass *BP = static_cast<BasicBlockPass *>(PassVector[N]);
     return BP;
   }
@@ -127,11 +174,13 @@ namespace llvm {
 class FunctionPassManagerImpl : public Pass,
                                 public PMDataManager,
                                 public PMTopLevelManager {
+private:
+  bool wasRun;
 public:
   static char ID;
   explicit FunctionPassManagerImpl(int Depth) : 
     Pass(&ID), PMDataManager(Depth), 
-    PMTopLevelManager(TLM_Function) { }
+    PMTopLevelManager(TLM_Function), wasRun(false) { }
 
   /// add - Add a pass to the queue of passes to run.  This passes ownership of
   /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
@@ -141,6 +190,10 @@ public:
     schedulePass(P);
   }
  
+  // Prepare for running an on the fly pass, freeing memory if needed
+  // from a previous run.
+  void releaseMemoryOnTheFly();
+
   /// run - Execute all of the passes scheduled for execution.  Keep track of
   /// whether any of the passes modifies the module, and if so, return true.
   bool run(Function &F);
@@ -176,7 +229,7 @@ public:
   }
 
   FPPassManager *getContainedManager(unsigned N) {
-    assert ( N < PassManagers.size() && "Pass number out of range!");
+    assert(N < PassManagers.size() && "Pass number out of range!");
     FPPassManager *FP = static_cast<FPPassManager *>(PassManagers[N]);
     return FP;
   }
@@ -190,7 +243,6 @@ char FunctionPassManagerImpl::ID = 0;
 /// It batches all Module passes and function pass managers together and
 /// sequences them to process one module.
 class MPPassManager : public Pass, public PMDataManager {
- 
 public:
   static char ID;
   explicit MPPassManager(int Depth) :
@@ -231,20 +283,21 @@ public:
 
   // Print passes managed by this manager
   void dumpPassStructure(unsigned Offset) {
-    llvm::cerr << std::string(Offset*2, ' ') << "ModulePass Manager\n";
+    llvm::errs() << std::string(Offset*2, ' ') << "ModulePass Manager\n";
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       ModulePass *MP = getContainedPass(Index);
       MP->dumpPassStructure(Offset + 1);
-      if (FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP])
-        FPP->dumpPassStructure(Offset + 2);
+      std::map<Pass *, FunctionPassManagerImpl *>::const_iterator I =
+        OnTheFlyManagers.find(MP);
+      if (I != OnTheFlyManagers.end())
+        I->second->dumpPassStructure(Offset + 2);
       dumpLastUses(MP, Offset+1);
     }
   }
 
   ModulePass *getContainedPass(unsigned N) {
-    assert ( N < PassVector.size() && "Pass number out of range!");
-    ModulePass *MP = static_cast<ModulePass *>(PassVector[N]);
-    return MP;
+    assert(N < PassVector.size() && "Pass number out of range!");
+    return static_cast<ModulePass *>(PassVector[N]);
   }
 
   virtual PassManagerType getPassManagerType() const { 
@@ -290,7 +343,6 @@ public:
   }
 
   inline void addTopLevelPass(Pass *P) {
-
     if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) {
       
       // P is a immutable pass and it will be managed by this
@@ -303,15 +355,13 @@ public:
     } else {
       P->assignPassManager(activeStack);
     }
-
   }
 
   MPPassManager *getContainedManager(unsigned N) {
-    assert ( N < PassManagers.size() && "Pass number out of range!");
+    assert(N < PassManagers.size() && "Pass number out of range!");
     MPPassManager *MP = static_cast<MPPassManager *>(PassManagers[N]);
     return MP;
   }
-
 };
 
 char PassManagerImpl::ID = 0;
@@ -320,10 +370,12 @@ char PassManagerImpl::ID = 0;
 namespace {
 
 //===----------------------------------------------------------------------===//
-// TimingInfo Class - This class is used to calculate information about the
-// amount of time each pass takes to execute.  This only happens when
-// -time-passes is enabled on the command line.
-//
+/// TimingInfo Class - This class is used to calculate information about the
+/// amount of time each pass takes to execute.  This only happens when
+/// -time-passes is enabled on the command line.
+///
+
+static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
 
 class VISIBILITY_HIDDEN TimingInfo {
   std::map<Pass*, Timer> TimingData;
@@ -346,22 +398,23 @@ public:
   static void createTheTimeInfo();
 
   void passStarted(Pass *P) {
-
     if (dynamic_cast<PMDataManager *>(P)) 
       return;
 
+    sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
     std::map<Pass*, Timer>::iterator I = TimingData.find(P);
     if (I == TimingData.end())
       I=TimingData.insert(std::make_pair(P, Timer(P->getPassName(), TG))).first;
     I->second.startTimer();
   }
+  
   void passEnded(Pass *P) {
-
     if (dynamic_cast<PMDataManager *>(P)) 
       return;
 
+    sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
     std::map<Pass*, Timer>::iterator I = TimingData.find(P);
-    assert (I != TimingData.end() && "passStarted/passEnded not nested right!");
+    assert(I != TimingData.end() && "passStarted/passEnded not nested right!");
     I->second.stopTimer();
   }
 };
@@ -374,15 +427,13 @@ static TimingInfo *TheTimeInfo;
 // PMTopLevelManager implementation
 
 /// Initialize top level manager. Create first pass manager.
-PMTopLevelManager::PMTopLevelManager (enum TopLevelManagerType t) {
-
+PMTopLevelManager::PMTopLevelManager(enum TopLevelManagerType t) {
   if (t == TLM_Pass) {
     MPPassManager *MPP = new MPPassManager(1);
     MPP->setTopLevelManager(this);
     addPassManager(MPP);
     activeStack.push(MPP);
-  } 
-  else if (t == TLM_Function) {
+  } else if (t == TLM_Function) {
     FPPassManager *FPP = new FPPassManager(1);
     FPP->setTopLevelManager(this);
     addPassManager(FPP);
@@ -393,7 +444,6 @@ PMTopLevelManager::PMTopLevelManager (enum TopLevelManagerType t) {
 /// Set pass P as the last user of the given analysis passes.
 void PMTopLevelManager::setLastUser(SmallVector<Pass *, 12> &AnalysisPasses, 
                                     Pass *P) {
-
   for (SmallVector<Pass *, 12>::iterator I = AnalysisPasses.begin(),
          E = AnalysisPasses.end(); I != E; ++I) {
     Pass *AP = *I;
@@ -514,7 +564,8 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) {
   }
 
   // Check other pass managers
-  for (SmallVector<PMDataManager *, 8>::iterator I = IndirectPassManagers.begin(),
+  for (SmallVector<PMDataManager *, 8>::iterator
+         I = IndirectPassManagers.begin(),
          E = IndirectPassManagers.end(); P == NULL && I != E; ++I)
     P = (*I)->findAnalysisPass(AID, false);
 
@@ -561,29 +612,24 @@ void PMTopLevelManager::dumpArguments() const {
   if (PassDebugging < Arguments)
     return;
 
-  cerr << "Pass Arguments: ";
+  errs() << "Pass Arguments: ";
   for (SmallVector<PMDataManager *, 8>::const_iterator I = PassManagers.begin(),
-         E = PassManagers.end(); I != E; ++I) {
-    PMDataManager *PMD = *I;
-    PMD->dumpPassArguments();
-  }
-  cerr << "\n";
+         E = PassManagers.end(); I != E; ++I)
+    (*I)->dumpPassArguments();
+  errs() << "\n";
 }
 
 void PMTopLevelManager::initializeAllAnalysisInfo() {
-  
   for (SmallVector<PMDataManager *, 8>::iterator I = PassManagers.begin(),
-         E = PassManagers.end(); I != E; ++I) {
-    PMDataManager *PMD = *I;
-    PMD->initializeAnalysisInfo();
-  }
+         E = PassManagers.end(); I != E; ++I)
+    (*I)->initializeAnalysisInfo();
   
   // Initailize other pass managers
   for (SmallVector<PMDataManager *, 8>::iterator I = IndirectPassManagers.begin(),
          E = IndirectPassManagers.end(); I != E; ++I)
     (*I)->initializeAnalysisInfo();
 
-  for(DenseMap<Pass *, Pass *>::iterator DMI = LastUser.begin(),
+  for (DenseMap<Pass *, Pass *>::iterator DMI = LastUser.begin(),
         DME = LastUser.end(); DMI != DME; ++DMI) {
     DenseMap<Pass *, SmallPtrSet<Pass *, 8> >::iterator InvDMI = 
       InversedLastUser.find(DMI->second);
@@ -608,11 +654,8 @@ PMTopLevelManager::~PMTopLevelManager() {
     delete *I;
 
   for (DenseMap<Pass *, AnalysisUsage *>::iterator DMI = AnUsageMap.begin(),
-         DME = AnUsageMap.end(); DMI != DME; ++DMI) {
-    AnalysisUsage *AU = DMI->second;
-    delete AU;
-  }
-    
+         DME = AnUsageMap.end(); DMI != DME; ++DMI)
+    delete DMI->second;
 }
 
 //===----------------------------------------------------------------------===//
@@ -620,24 +663,22 @@ PMTopLevelManager::~PMTopLevelManager() {
 
 /// Augement AvailableAnalysis by adding analysis made available by pass P.
 void PMDataManager::recordAvailableAnalysis(Pass *P) {
-                                                
-  if (const PassInfo *PI = P->getPassInfo()) {
-    AvailableAnalysis[PI] = P;
+  const PassInfo *PI = P->getPassInfo();
+  if (PI == 0) return;
+  
+  AvailableAnalysis[PI] = P;
 
-    //This pass is the current implementation of all of the interfaces it
-    //implements as well.
-    const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented();
-    for (unsigned i = 0, e = II.size(); i != e; ++i)
-      AvailableAnalysis[II[i]] = P;
-  }
+  //This pass is the current implementation of all of the interfaces it
+  //implements as well.
+  const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented();
+  for (unsigned i = 0, e = II.size(); i != e; ++i)
+    AvailableAnalysis[II[i]] = P;
 }
 
 // Return true if P preserves high level analysis used by other
 // passes managed by this manager
 bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) {
-
   AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
-  
   if (AnUsage->getPreservesAll())
     return true;
   
@@ -675,7 +716,6 @@ void PMDataManager::verifyPreservedAnalysis(Pass *P) {
 
 /// verifyDomInfo - Verify dominator information if it is available.
 void PMDataManager::verifyDomInfo(Pass &P, Function &F) {
-  
   if (!VerifyDomInfo || !P.getResolver())
     return;
 
@@ -686,13 +726,13 @@ void PMDataManager::verifyDomInfo(Pass &P, Function &F) {
   DominatorTree OtherDT;
   OtherDT.getBase().recalculate(F);
   if (DT->compare(OtherDT)) {
-    cerr << "Dominator Information for " << F.getNameStart() << "\n";
-    cerr << "Pass '" << P.getPassName() << "'\n";
-    cerr << "----- Valid -----\n";
+    errs() << "Dominator Information for " << F.getName() << "\n";
+    errs() << "Pass '" << P.getPassName() << "'\n";
+    errs() << "----- Valid -----\n";
     OtherDT.dump();
-    cerr << "----- Invalid -----\n";
+    errs() << "----- Invalid -----\n";
     DT->dump();
-    assert (0 && "Invalid dominator info");
+    llvm_unreachable("Invalid dominator info");
   }
 
   DominanceFrontier *DF = P.getAnalysisIfAvailable<DominanceFrontier>();
@@ -703,13 +743,13 @@ void PMDataManager::verifyDomInfo(Pass &P, Function &F) {
   std::vector<BasicBlock*> DTRoots = DT->getRoots();
   OtherDF.calculate(*DT, DT->getNode(DTRoots[0]));
   if (DF->compare(OtherDF)) {
-    cerr << "Dominator Information for " << F.getNameStart() << "\n";
-    cerr << "Pass '" << P.getPassName() << "'\n";
-    cerr << "----- Valid -----\n";
+    errs() << "Dominator Information for " << F.getName() << "\n";
+    errs() << "Pass '" << P.getPassName() << "'\n";
+    errs() << "----- Valid -----\n";
     OtherDF.dump();
-    cerr << "----- Invalid -----\n";
+    errs() << "----- Invalid -----\n";
     DF->dump();
-    assert (0 && "Invalid dominator info");
+    llvm_unreachable("Invalid dominator info");
   }
 }
 
@@ -729,8 +769,8 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) {
       // Remove this analysis
       if (PassDebugging >= Details) {
         Pass *S = Info->second;
-        cerr << " -- '" <<  P->getPassName() << "' is not preserving '";
-        cerr << S->getPassName() << "'\n";
+        errs() << " -- '" <<  P->getPassName() << "' is not preserving '";
+        errs() << S->getPassName() << "'\n";
       }
       AvailableAnalysis.erase(Info);
     }
@@ -757,7 +797,7 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) {
 }
 
 /// Remove analysis passes that are not used any longer
-void PMDataManager::removeDeadPasses(Pass *P, const char *Msg,
+void PMDataManager::removeDeadPasses(Pass *P, const StringRef &Msg,
                                      enum PassDebuggingString DBG_STR) {
 
   SmallVector<Pass *, 12> DeadPasses;
@@ -769,9 +809,9 @@ void PMDataManager::removeDeadPasses(Pass *P, const char *Msg,
   TPM->collectLastUses(DeadPasses, P);
 
   if (PassDebugging >= Details && !DeadPasses.empty()) {
-    cerr << " -*- '" <<  P->getPassName();
-    cerr << "' is the last user of following pass instances.";
-    cerr << " Free these instances\n";
+    errs() << " -*- '" <<  P->getPassName();
+    errs() << "' is the last user of following pass instances.";
+    errs() << " Free these instances\n";
   }
 
   for (SmallVector<Pass *, 12>::iterator I = DeadPasses.begin(),
@@ -779,9 +819,14 @@ void PMDataManager::removeDeadPasses(Pass *P, const char *Msg,
 
     dumpPassInfo(*I, FREEING_MSG, DBG_STR, Msg);
 
-    if (TheTimeInfo) TheTimeInfo->passStarted(*I);
-    (*I)->releaseMemory();
-    if (TheTimeInfo) TheTimeInfo->passEnded(*I);
+    {
+      // If the pass crashes releasing memory, remember this.
+      PassManagerPrettyStackEntry X(*I);
+      
+      if (TheTimeInfo) TheTimeInfo->passStarted(*I);
+      (*I)->releaseMemory();
+      if (TheTimeInfo) TheTimeInfo->passEnded(*I);
+    }
     if (const PassInfo *PI = (*I)->getPassInfo()) {
       std::map<AnalysisID, Pass*>::iterator Pos =
         AvailableAnalysis.find(PI);
@@ -804,9 +849,7 @@ void PMDataManager::removeDeadPasses(Pass *P, const char *Msg,
 
 /// Add pass P into the PassVector. Update 
 /// AvailableAnalysis appropriately if ProcessAnalysis is true.
-void PMDataManager::add(Pass *P, 
-                        bool ProcessAnalysis) {
-
+void PMDataManager::add(Pass *P, bool ProcessAnalysis) {
   // This manager is going to manage pass P. Set up analysis resolver
   // to connect them.
   AnalysisResolver *AR = new AnalysisResolver(*this);
@@ -816,64 +859,67 @@ void PMDataManager::add(Pass *P,
   // then the F's manager, not F, records itself as a last user of M.
   SmallVector<Pass *, 12> TransferLastUses;
 
-  if (ProcessAnalysis) {
-
-    // At the moment, this pass is the last user of all required passes.
-    SmallVector<Pass *, 12> LastUses;
-    SmallVector<Pass *, 8> RequiredPasses;
-    SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable;
-
-    unsigned PDepth = this->getDepth();
-
-    collectRequiredAnalysis(RequiredPasses, 
-                            ReqAnalysisNotAvailable, P);
-    for (SmallVector<Pass *, 8>::iterator I = RequiredPasses.begin(),
-           E = RequiredPasses.end(); I != E; ++I) {
-      Pass *PRequired = *I;
-      unsigned RDepth = 0;
-
-      assert (PRequired->getResolver() && "Analysis Resolver is not set");
-      PMDataManager &DM = PRequired->getResolver()->getPMDataManager();
-      RDepth = DM.getDepth();
-
-      if (PDepth == RDepth)
-        LastUses.push_back(PRequired);
-      else if (PDepth >  RDepth) {
-        // Let the parent claim responsibility of last use
-        TransferLastUses.push_back(PRequired);
-        // Keep track of higher level analysis used by this manager.
-        HigherLevelAnalysis.push_back(PRequired);
-      } else 
-        assert (0 && "Unable to accomodate Required Pass");
-    }
+  if (!ProcessAnalysis) {
+    // Add pass
+    PassVector.push_back(P);
+    return;
+  }
 
-    // Set P as P's last user until someone starts using P.
-    // However, if P is a Pass Manager then it does not need
-    // to record its last user.
-    if (!dynamic_cast<PMDataManager *>(P))
-      LastUses.push_back(P);
-    TPM->setLastUser(LastUses, P);
-
-    if (!TransferLastUses.empty()) {
-      Pass *My_PM = dynamic_cast<Pass *>(this);
-      TPM->setLastUser(TransferLastUses, My_PM);
-      TransferLastUses.clear();
-    }
+  // At the moment, this pass is the last user of all required passes.
+  SmallVector<Pass *, 12> LastUses;
+  SmallVector<Pass *, 8> RequiredPasses;
+  SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable;
 
-    // Now, take care of required analysises that are not available.
-    for (SmallVector<AnalysisID, 8>::iterator 
-           I = ReqAnalysisNotAvailable.begin(), 
-           E = ReqAnalysisNotAvailable.end() ;I != E; ++I) {
-      Pass *AnalysisPass = (*I)->createPass();
-      this->addLowerLevelRequiredPass(P, AnalysisPass);
-    }
+  unsigned PDepth = this->getDepth();
+
+  collectRequiredAnalysis(RequiredPasses, 
+                          ReqAnalysisNotAvailable, P);
+  for (SmallVector<Pass *, 8>::iterator I = RequiredPasses.begin(),
+         E = RequiredPasses.end(); I != E; ++I) {
+    Pass *PRequired = *I;
+    unsigned RDepth = 0;
+
+    assert(PRequired->getResolver() && "Analysis Resolver is not set");
+    PMDataManager &DM = PRequired->getResolver()->getPMDataManager();
+    RDepth = DM.getDepth();
+
+    if (PDepth == RDepth)
+      LastUses.push_back(PRequired);
+    else if (PDepth > RDepth) {
+      // Let the parent claim responsibility of last use
+      TransferLastUses.push_back(PRequired);
+      // Keep track of higher level analysis used by this manager.
+      HigherLevelAnalysis.push_back(PRequired);
+    } else 
+      llvm_unreachable("Unable to accomodate Required Pass");
+  }
+
+  // Set P as P's last user until someone starts using P.
+  // However, if P is a Pass Manager then it does not need
+  // to record its last user.
+  if (!dynamic_cast<PMDataManager *>(P))
+    LastUses.push_back(P);
+  TPM->setLastUser(LastUses, P);
+
+  if (!TransferLastUses.empty()) {
+    Pass *My_PM = dynamic_cast<Pass *>(this);
+    TPM->setLastUser(TransferLastUses, My_PM);
+    TransferLastUses.clear();
+  }
 
-    // Take a note of analysis required and made available by this pass.
-    // Remove the analysis not preserved by this pass
-    removeNotPreservedAnalysis(P);
-    recordAvailableAnalysis(P);
+  // Now, take care of required analysises that are not available.
+  for (SmallVector<AnalysisID, 8>::iterator 
+         I = ReqAnalysisNotAvailable.begin(), 
+         E = ReqAnalysisNotAvailable.end() ;I != E; ++I) {
+    Pass *AnalysisPass = (*I)->createPass();
+    this->addLowerLevelRequiredPass(P, AnalysisPass);
   }
 
+  // Take a note of analysis required and made available by this pass.
+  // Remove the analysis not preserved by this pass
+  removeNotPreservedAnalysis(P);
+  recordAvailableAnalysis(P);
+
   // Add pass
   PassVector.push_back(P);
 }
@@ -888,23 +934,20 @@ void PMDataManager::collectRequiredAnalysis(SmallVector<Pass *, 8>&RP,
   AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
   const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet();
   for (AnalysisUsage::VectorType::const_iterator 
-         I = RequiredSet.begin(), E = RequiredSet.end();
-       I != E; ++I) {
-    AnalysisID AID = *I;
+         I = RequiredSet.begin(), E = RequiredSet.end(); I != E; ++I) {
     if (Pass *AnalysisPass = findAnalysisPass(*I, true))
       RP.push_back(AnalysisPass);   
     else
-      RP_NotAvail.push_back(AID);
+      RP_NotAvail.push_back(*I);
   }
 
   const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet();
   for (AnalysisUsage::VectorType::const_iterator I = IDs.begin(),
          E = IDs.end(); I != E; ++I) {
-    AnalysisID AID = *I;
     if (Pass *AnalysisPass = findAnalysisPass(*I, true))
       RP.push_back(AnalysisPass);   
     else
-      RP_NotAvail.push_back(AID);
+      RP_NotAvail.push_back(*I);
   }
 }
 
@@ -925,7 +968,7 @@ void PMDataManager::initializeAnalysisImpl(Pass *P) {
       // If that is not the case then it will raise an assert when it is used.
       continue;
     AnalysisResolver *AR = P->getResolver();
-    assert (AR && "Analysis Resolver is not set");
+    assert(AR && "Analysis Resolver is not set");
     AR->addAnalysisImplsPair(*I, Impl);
   }
 }
@@ -960,65 +1003,64 @@ void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{
   
   for (SmallVector<Pass *, 12>::iterator I = LUses.begin(),
          E = LUses.end(); I != E; ++I) {
-    llvm::cerr << "--" << std::string(Offset*2, ' ');
+    llvm::errs() << "--" << std::string(Offset*2, ' ');
     (*I)->dumpPassStructure(0);
   }
 }
 
 void PMDataManager::dumpPassArguments() const {
-  for(SmallVector<Pass *, 8>::const_iterator I = PassVector.begin(),
+  for (SmallVector<Pass *, 8>::const_iterator I = PassVector.begin(),
         E = PassVector.end(); I != E; ++I) {
     if (PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I))
       PMD->dumpPassArguments();
     else
       if (const PassInfo *PI = (*I)->getPassInfo())
         if (!PI->isAnalysisGroup())
-          cerr << " -" << PI->getPassArgument();
+          errs() << " -" << PI->getPassArgument();
   }
 }
 
 void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1,
                                  enum PassDebuggingString S2,
-                                 const char *Msg) {
+                                 const StringRef &Msg) {
   if (PassDebugging < Executions)
     return;
-  cerr << (void*)this << std::string(getDepth()*2+1, ' ');
+  errs() << (void*)this << std::string(getDepth()*2+1, ' ');
   switch (S1) {
   case EXECUTION_MSG:
-    cerr << "Executing Pass '" << P->getPassName();
+    errs() << "Executing Pass '" << P->getPassName();
     break;
   case MODIFICATION_MSG:
-    cerr << "Made Modification '" << P->getPassName();
+    errs() << "Made Modification '" << P->getPassName();
     break;
   case FREEING_MSG:
-    cerr << " Freeing Pass '" << P->getPassName();
+    errs() << " Freeing Pass '" << P->getPassName();
     break;
   default:
     break;
   }
   switch (S2) {
   case ON_BASICBLOCK_MSG:
-    cerr << "' on BasicBlock '" << Msg << "'...\n";
+    errs() << "' on BasicBlock '" << Msg << "'...\n";
     break;
   case ON_FUNCTION_MSG:
-    cerr << "' on Function '" << Msg << "'...\n";
+    errs() << "' on Function '" << Msg << "'...\n";
     break;
   case ON_MODULE_MSG:
-    cerr << "' on Module '"  << Msg << "'...\n";
+    errs() << "' on Module '"  << Msg << "'...\n";
     break;
   case ON_LOOP_MSG:
-    cerr << "' on Loop " << Msg << "'...\n";
+    errs() << "' on Loop '" << Msg << "'...\n";
     break;
   case ON_CG_MSG:
-    cerr << "' on Call Graph " << Msg << "'...\n";
+    errs() << "' on Call Graph Nodes '" << Msg << "'...\n";
     break;
   default:
     break;
   }
 }
 
-void PMDataManager::dumpRequiredSet(const Pass *P)
-  const {
+void PMDataManager::dumpRequiredSet(const Pass *P) const {
   if (PassDebugging < Details)
     return;
     
@@ -1027,8 +1069,7 @@ void PMDataManager::dumpRequiredSet(const Pass *P)
   dumpAnalysisUsage("Required", P, analysisUsage.getRequiredSet());
 }
 
-void PMDataManager::dumpPreservedSet(const Pass *P)
-  const {
+void PMDataManager::dumpPreservedSet(const Pass *P) const {
   if (PassDebugging < Details)
     return;
     
@@ -1037,18 +1078,17 @@ void PMDataManager::dumpPreservedSet(const Pass *P)
   dumpAnalysisUsage("Preserved", P, analysisUsage.getPreservedSet());
 }
 
-void PMDataManager::dumpAnalysisUsage(const char *Msg, const Pass *P,
-                                        const AnalysisUsage::VectorType &Set)
-  const {
+void PMDataManager::dumpAnalysisUsage(const StringRef &Msg, const Pass *P,
+                                   const AnalysisUsage::VectorType &Set) const {
   assert(PassDebugging >= Details);
   if (Set.empty())
     return;
-  cerr << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:";
-    for (unsigned i = 0; i != Set.size(); ++i) {
-      if (i) cerr << ",";
-      cerr << " " << Set[i]->getPassName();
-    }
-    cerr << "\n";
+  errs() << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:";
+  for (unsigned i = 0; i != Set.size(); ++i) {
+    if (i) errs() << ',';
+    errs() << ' ' << Set[i]->getPassName();
+  }
+  errs() << '\n';
 }
 
 /// Add RequiredPass into list of lower level passes required by pass P.
@@ -1071,19 +1111,17 @@ void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
   // checks whether any lower level manager will be able to provide this 
   // analysis info on demand or not.
 #ifndef NDEBUG
-  cerr << "Unable to schedule '" << RequiredPass->getPassName();
-  cerr << "' required by '" << P->getPassName() << "'\n";
+  errs() << "Unable to schedule '" << RequiredPass->getPassName();
+  errs() << "' required by '" << P->getPassName() << "'\n";
 #endif
-  assert (0 && "Unable to schedule pass");
+  llvm_unreachable("Unable to schedule pass");
 }
 
 // Destructor
 PMDataManager::~PMDataManager() {
-  
   for (SmallVector<Pass *, 8>::iterator I = PassVector.begin(),
          E = PassVector.end(); I != E; ++I)
     delete *I;
-  
 }
 
 //===----------------------------------------------------------------------===//
@@ -1104,9 +1142,7 @@ Pass *AnalysisResolver::findImplPass(Pass *P, const PassInfo *AnalysisPI,
 /// Execute all of the passes scheduled for execution by invoking 
 /// runOnBasicBlock method.  Keep track of whether any of the passes modifies 
 /// the function, and if so, return true.
-bool
-BBPassManager::runOnFunction(Function &F) {
-
+bool BBPassManager::runOnFunction(Function &F) {
   if (F.isDeclaration())
     return false;
 
@@ -1116,53 +1152,54 @@ BBPassManager::runOnFunction(Function &F) {
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       BasicBlockPass *BP = getContainedPass(Index);
 
-      dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getNameStart());
+      dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getName());
       dumpRequiredSet(BP);
 
       initializeAnalysisImpl(BP);
 
-      if (TheTimeInfo) TheTimeInfo->passStarted(BP);
-      Changed |= BP->runOnBasicBlock(*I);
-      if (TheTimeInfo) TheTimeInfo->passEnded(BP);
+      {
+        // If the pass crashes, remember this.
+        PassManagerPrettyStackEntry X(BP, *I);
+      
+        if (TheTimeInfo) TheTimeInfo->passStarted(BP);
+        Changed |= BP->runOnBasicBlock(*I);
+        if (TheTimeInfo) TheTimeInfo->passEnded(BP);
+      }
 
       if (Changed) 
         dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG,
-                     I->getNameStart());
+                     I->getName());
       dumpPreservedSet(BP);
 
       verifyPreservedAnalysis(BP);
       removeNotPreservedAnalysis(BP);
       recordAvailableAnalysis(BP);
-      removeDeadPasses(BP, I->getNameStart(), ON_BASICBLOCK_MSG);
+      removeDeadPasses(BP, I->getName(), ON_BASICBLOCK_MSG);
     }
 
   return Changed |= doFinalization(F);
 }
 
 // Implement doInitialization and doFinalization
-inline bool BBPassManager::doInitialization(Module &M) {
+bool BBPassManager::doInitialization(Module &M) {
   bool Changed = false;
 
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-    BasicBlockPass *BP = getContainedPass(Index);
-    Changed |= BP->doInitialization(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
+    Changed |= getContainedPass(Index)->doInitialization(M);
 
   return Changed;
 }
 
-inline bool BBPassManager::doFinalization(Module &M) {
+bool BBPassManager::doFinalization(Module &M) {
   bool Changed = false;
 
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-    BasicBlockPass *BP = getContainedPass(Index);
-    Changed |= BP->doFinalization(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
+    Changed |= getContainedPass(Index)->doFinalization(M);
 
   return Changed;
 }
 
-inline bool BBPassManager::doInitialization(Function &F) {
+bool BBPassManager::doInitialization(Function &F) {
   bool Changed = false;
 
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
@@ -1173,7 +1210,7 @@ inline bool BBPassManager::doInitialization(Function &F) {
   return Changed;
 }
 
-inline bool BBPassManager::doFinalization(Function &F) {
+bool BBPassManager::doFinalization(Function &F) {
   bool Changed = false;
 
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
@@ -1220,8 +1257,7 @@ void FunctionPassManager::add(Pass *P) {
 bool FunctionPassManager::run(Function &F) {
   std::string errstr;
   if (MP->materializeFunction(&F, &errstr)) {
-    cerr << "Error reading bitcode file: " << errstr << "\n";
-    abort();
+    llvm_report_error("Error reading bitcode file: " + errstr);
   }
   return FPM->run(F);
 }
@@ -1242,44 +1278,63 @@ bool FunctionPassManager::doFinalization() {
 //===----------------------------------------------------------------------===//
 // FunctionPassManagerImpl implementation
 //
-inline bool FunctionPassManagerImpl::doInitialization(Module &M) {
+bool FunctionPassManagerImpl::doInitialization(Module &M) {
   bool Changed = false;
 
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {  
-    FPPassManager *FP = getContainedManager(Index);
-    Changed |= FP->doInitialization(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    Changed |= getContainedManager(Index)->doInitialization(M);
 
   return Changed;
 }
 
-inline bool FunctionPassManagerImpl::doFinalization(Module &M) {
+bool FunctionPassManagerImpl::doFinalization(Module &M) {
   bool Changed = false;
 
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {  
-    FPPassManager *FP = getContainedManager(Index);
-    Changed |= FP->doFinalization(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    Changed |= getContainedManager(Index)->doFinalization(M);
 
   return Changed;
 }
 
+/// cleanup - After running all passes, clean up pass manager cache.
+void FPPassManager::cleanup() {
+ for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
+    FunctionPass *FP = getContainedPass(Index);
+    AnalysisResolver *AR = FP->getResolver();
+    assert(AR && "Analysis Resolver is not set");
+    AR->clearAnalysisImpls();
+ }
+}
+
+void FunctionPassManagerImpl::releaseMemoryOnTheFly() {
+  if (!wasRun)
+    return;
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
+    FPPassManager *FPPM = getContainedManager(Index);
+    for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) {
+      FPPM->getContainedPass(Index)->releaseMemory();
+    }
+  }
+  wasRun = false;
+}
+
 // Execute all the passes managed by this top level manager.
 // Return true if any function is modified by a pass.
 bool FunctionPassManagerImpl::run(Function &F) {
-
   bool Changed = false;
-
   TimingInfo::createTheTimeInfo();
 
   dumpArguments();
   dumpPasses();
 
   initializeAllAnalysisInfo();
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {  
-    FPPassManager *FP = getContainedManager(Index);
-    Changed |= FP->runOnFunction(F);
-  }
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    Changed |= getContainedManager(Index)->runOnFunction(F);
+
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    getContainedManager(Index)->cleanup();
+
+  wasRun = true;
   return Changed;
 }
 
@@ -1289,7 +1344,7 @@ bool FunctionPassManagerImpl::run(Function &F) {
 char FPPassManager::ID = 0;
 /// Print passes managed by this manager
 void FPPassManager::dumpPassStructure(unsigned Offset) {
-  llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n";
+  llvm::errs() << std::string(Offset*2, ' ') << "FunctionPass Manager\n";
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     FunctionPass *FP = getContainedPass(Index);
     FP->dumpPassStructure(Offset + 1);
@@ -1302,35 +1357,38 @@ void FPPassManager::dumpPassStructure(unsigned Offset) {
 /// runOnFunction method.  Keep track of whether any of the passes modifies 
 /// the function, and if so, return true.
 bool FPPassManager::runOnFunction(Function &F) {
+  if (F.isDeclaration())
+    return false;
 
   bool Changed = false;
 
-  if (F.isDeclaration())
-    return false;
-  
   // Collect inherited analysis from Module level pass manager.
   populateInheritedAnalysis(TPM->activeStack);
 
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     FunctionPass *FP = getContainedPass(Index);
 
-    dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getNameStart());
+    dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName());
     dumpRequiredSet(FP);
 
     initializeAnalysisImpl(FP);
 
-    if (TheTimeInfo) TheTimeInfo->passStarted(FP);
-    Changed |= FP->runOnFunction(F);
-    if (TheTimeInfo) TheTimeInfo->passEnded(FP);
+    {
+      PassManagerPrettyStackEntry X(FP, F);
+
+      if (TheTimeInfo) TheTimeInfo->passStarted(FP);
+      Changed |= FP->runOnFunction(F);
+      if (TheTimeInfo) TheTimeInfo->passEnded(FP);
+    }
 
     if (Changed) 
-      dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getNameStart());
+      dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName());
     dumpPreservedSet(FP);
 
     verifyPreservedAnalysis(FP);
     removeNotPreservedAnalysis(FP);
     recordAvailableAnalysis(FP);
-    removeDeadPasses(FP, F.getNameStart(), ON_FUNCTION_MSG);
+    removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG);
 
     // If dominator information is available then verify the info if requested.
     verifyDomInfo(*FP, F);
@@ -1339,33 +1397,28 @@ bool FPPassManager::runOnFunction(Function &F) {
 }
 
 bool FPPassManager::runOnModule(Module &M) {
-
   bool Changed = doInitialization(M);
 
-  for(Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
-    this->runOnFunction(*I);
+  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
+    runOnFunction(*I);
 
   return Changed |= doFinalization(M);
 }
 
-inline bool FPPassManager::doInitialization(Module &M) {
+bool FPPassManager::doInitialization(Module &M) {
   bool Changed = false;
 
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {  
-    FunctionPass *FP = getContainedPass(Index);
-    Changed |= FP->doInitialization(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
+    Changed |= getContainedPass(Index)->doInitialization(M);
 
   return Changed;
 }
 
-inline bool FPPassManager::doFinalization(Module &M) {
+bool FPPassManager::doFinalization(Module &M) {
   bool Changed = false;
 
-  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {  
-    FunctionPass *FP = getContainedPass(Index);
-    Changed |= FP->doFinalization(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
+    Changed |= getContainedPass(Index)->doFinalization(M);
 
   return Changed;
 }
@@ -1380,6 +1433,14 @@ bool
 MPPassManager::runOnModule(Module &M) {
   bool Changed = false;
 
+  // Initialize on-the-fly passes
+  for (std::map<Pass *, FunctionPassManagerImpl *>::iterator
+       I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end();
+       I != E; ++I) {
+    FunctionPassManagerImpl *FPP = I->second;
+    Changed |= FPP->doInitialization(M);
+  }
+
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     ModulePass *MP = getContainedPass(Index);
 
@@ -1389,9 +1450,12 @@ MPPassManager::runOnModule(Module &M) {
 
     initializeAnalysisImpl(MP);
 
-    if (TheTimeInfo) TheTimeInfo->passStarted(MP);
-    Changed |= MP->runOnModule(M);
-    if (TheTimeInfo) TheTimeInfo->passEnded(MP);
+    {
+      PassManagerPrettyStackEntry X(MP, M);
+      if (TheTimeInfo) TheTimeInfo->passStarted(MP);
+      Changed |= MP->runOnModule(M);
+      if (TheTimeInfo) TheTimeInfo->passEnded(MP);
+    }
 
     if (Changed) 
       dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG,
@@ -1403,6 +1467,17 @@ MPPassManager::runOnModule(Module &M) {
     recordAvailableAnalysis(MP);
     removeDeadPasses(MP, M.getModuleIdentifier().c_str(), ON_MODULE_MSG);
   }
+
+  // Finalize on-the-fly passes
+  for (std::map<Pass *, FunctionPassManagerImpl *>::iterator
+       I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end();
+       I != E; ++I) {
+    FunctionPassManagerImpl *FPP = I->second;
+    // We don't know when is the last time an on-the-fly pass is run,
+    // so we need to releaseMemory / finalize here
+    FPP->releaseMemoryOnTheFly();
+    Changed |= FPP->doFinalization(M);
+  }
   return Changed;
 }
 
@@ -1410,12 +1485,11 @@ MPPassManager::runOnModule(Module &M) {
 /// RequiredPass is run on the fly by Pass Manager when P requests it
 /// through getAnalysis interface.
 void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
-
-  assert (P->getPotentialPassManagerType() == PMT_ModulePassManager
-          && "Unable to handle Pass that requires lower level Analysis pass");
-  assert ((P->getPotentialPassManagerType() < 
-           RequiredPass->getPotentialPassManagerType())
-          && "Unable to handle Pass that requires lower level Analysis pass");
+  assert(P->getPotentialPassManagerType() == PMT_ModulePassManager &&
+         "Unable to handle Pass that requires lower level Analysis pass");
+  assert((P->getPotentialPassManagerType() < 
+          RequiredPass->getPotentialPassManagerType()) &&
+         "Unable to handle Pass that requires lower level Analysis pass");
 
   FunctionPassManagerImpl *FPP = OnTheFlyManagers[P];
   if (!FPP) {
@@ -1436,14 +1510,13 @@ void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
 /// Return function pass corresponding to PassInfo PI, that is 
 /// required by module pass MP. Instantiate analysis pass, by using
 /// its runOnFunction() for function F.
-Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, 
-                                     Function &F) {
-   AnalysisID AID = PI;
+Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F){
   FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
-  assert (FPP && "Unable to find on the fly pass");
+  assert(FPP && "Unable to find on the fly pass");
   
+  FPP->releaseMemoryOnTheFly();
   FPP->run(F);
-  return (dynamic_cast<PMTopLevelManager *>(FPP))->findAnalysisPass(AID);
+  return (dynamic_cast<PMTopLevelManager *>(FPP))->findAnalysisPass(PI);
 }
 
 
@@ -1453,19 +1526,15 @@ Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI,
 /// run - Execute all of the passes scheduled for execution.  Keep track of
 /// whether any of the passes modifies the module, and if so, return true.
 bool PassManagerImpl::run(Module &M) {
-
   bool Changed = false;
-
   TimingInfo::createTheTimeInfo();
 
   dumpArguments();
   dumpPasses();
 
   initializeAllAnalysisInfo();
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {  
-    MPPassManager *MP = getContainedManager(Index);
-    Changed |= MP->runOnModule(M);
-  }
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    Changed |= getContainedManager(Index)->runOnModule(M);
   return Changed;
 }
 
@@ -1487,15 +1556,13 @@ PassManager::~PassManager() {
 /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
 /// will be destroyed as well, so there is no need to delete the pass.  This
 /// implies that all passes MUST be allocated with 'new'.
-void 
-PassManager::add(Pass *P) {
+void PassManager::add(Pass *P) {
   PM->add(P);
 }
 
 /// run - Execute all of the passes scheduled for execution.  Keep track of
 /// whether any of the passes modifies the module, and if so, return true.
-bool
-PassManager::run(Module &M) {
+bool PassManager::run(Module &M) {
   return PM->run(M);
 }
 
@@ -1523,13 +1590,13 @@ void TimingInfo::createTheTimeInfo() {
 }
 
 /// If TimingInfo is enabled then start pass timer.
-void StartPassTimer(Pass *P) {
+void llvm::StartPassTimer(Pass *P) {
   if (TheTimeInfo) 
     TheTimeInfo->passStarted(P);
 }
 
 /// If TimingInfo is enabled then stop pass timer.
-void StopPassTimer(Pass *P) {
+void llvm::StopPassTimer(Pass *P) {
   if (TheTimeInfo) 
     TheTimeInfo->passEnded(P);
 }
@@ -1549,18 +1616,12 @@ void PMStack::pop() {
 
 // Push PM on the stack and set its top level manager.
 void PMStack::push(PMDataManager *PM) {
+  assert(PM && "Unable to push. Pass Manager expected");
 
-  PMDataManager *Top = NULL;
-  assert (PM && "Unable to push. Pass Manager expected");
-
-  if (this->empty()) {
-    Top = PM;
-  } 
-  else {
-    Top = this->top();
-    PMTopLevelManager *TPM = Top->getTopLevelManager();
+  if (!this->empty()) {
+    PMTopLevelManager *TPM = this->top()->getTopLevelManager();
 
-    assert (TPM && "Unable to find top level manager");
+    assert(TPM && "Unable to find top level manager");
     TPM->addIndirectPassManager(PM);
     PM->setTopLevelManager(TPM);
   }
@@ -1570,11 +1631,10 @@ void PMStack::push(PMDataManager *PM) {
 
 // Dump content of the pass manager stack.
 void PMStack::dump() {
-  for(std::deque<PMDataManager *>::iterator I = S.begin(),
-        E = S.end(); I != E; ++I) {
-    Pass *P = dynamic_cast<Pass *>(*I);
-    printf("%s ", P->getPassName());
-  }
+  for (std::deque<PMDataManager *>::iterator I = S.begin(),
+         E = S.end(); I != E; ++I)
+    printf("%s ", dynamic_cast<Pass *>(*I)->getPassName());
+
   if (!S.empty())
     printf("\n");
 }
@@ -1583,7 +1643,6 @@ void PMStack::dump() {
 /// add self into that manager. 
 void ModulePass::assignPassManager(PMStack &PMS, 
                                    PassManagerType PreferredType) {
-
   // Find Module Pass Manager
   while(!PMS.empty()) {
     PassManagerType TopPMType = PMS.top()->getPassManagerType();
@@ -1641,7 +1700,6 @@ void FunctionPass::assignPassManager(PMStack &PMS,
 /// in the PM Stack and add self into that manager. 
 void BasicBlockPass::assignPassManager(PMStack &PMS,
                                        PassManagerType PreferredType) {
-
   BBPassManager *BBP = NULL;
 
   // Basic Pass Manager is a leaf pass manager. It does not handle