Make iostream #inclusion explicit

[oota-llvm.git] / lib / VMCore / Pass.cpp

diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp
index 87748d83b4753ddd0ce2842c1408c7ffdf7e4516..94b1d4795e4d2be4d4fcc2af5908813d085e3de8 100644 (file)
--- a/lib/VMCore/Pass.cpp
+++ b/lib/VMCore/Pass.cpp
@@ -1,10 +1,10 @@
 //===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LLVM Pass infrastructure.  It is primarily
@@ -45,6 +45,8 @@ void RegisterPassBase::setOnlyUsesCFG() {
 //   AnalysisResolver Class Implementation
 //
 
+AnalysisResolver::~AnalysisResolver() {
+}
 void AnalysisResolver::setAnalysisResolver(Pass *P, AnalysisResolver *AR) {
   assert(P->Resolver == 0 && "Pass already in a PassManager!");
   P->Resolver = AR;
@@ -76,7 +78,7 @@ void AnalysisUsage::setPreservesCFG() {
 // PassManager implementation - The PassManager class is a simple Pimpl class
 // that wraps the PassManagerT template.
 //
-PassManager::PassManager() : PM(new PassManagerT<Module>()) {}
+PassManager::PassManager() : PM(new ModulePassManager()) {}
 PassManager::~PassManager() { delete PM; }
 void PassManager::add(Pass *P) {
   ModulePass *MP = dynamic_cast<ModulePass*>(P);
@@ -90,12 +92,12 @@ bool PassManager::run(Module &M) { return PM->runOnModule(M); }
 // is a simple Pimpl class that wraps the PassManagerT template. It
 // is like PassManager, but only deals in FunctionPasses.
 //
-FunctionPassManager::FunctionPassManager(ModuleProvider *P) : 
-  PM(new PassManagerT<Function>()), MP(P) {}
+FunctionPassManager::FunctionPassManager(ModuleProvider *P) :
+  PM(new FunctionPassManagerT()), MP(P) {}
 FunctionPassManager::~FunctionPassManager() { delete PM; }
 void FunctionPassManager::add(FunctionPass *P) { PM->add(P); }
 void FunctionPassManager::add(ImmutablePass *IP) { PM->add(IP); }
-bool FunctionPassManager::run(Function &F) { 
+bool FunctionPassManager::run(Function &F) {
   try {
     MP->materializeFunction(&F);
   } catch (std::string& errstr) {
@@ -149,7 +151,7 @@ void PMDebug::PrintArgumentInformation(const Pass *P) {
 void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
                                    Pass *P, Module *M) {
   if (PassDebugging >= Executions) {
-    std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" 
+    std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '"
               << P->getPassName();
     if (M) std::cerr << "' on Module '" << M->getModuleIdentifier() << "'\n";
     std::cerr << "'...\n";
@@ -159,7 +161,7 @@ void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
 void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
                                    Pass *P, Function *F) {
   if (PassDebugging >= Executions) {
-    std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" 
+    std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '"
               << P->getPassName();
     if (F) std::cerr << "' on Function '" << F->getName();
     std::cerr << "'...\n";
@@ -169,7 +171,7 @@ void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
 void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
                                    Pass *P, BasicBlock *BB) {
   if (PassDebugging >= Executions) {
-    std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" 
+    std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '"
               << P->getPassName();
     if (BB) std::cerr << "' on BasicBlock '" << BB->getName();
     std::cerr << "'...\n";
@@ -192,7 +194,7 @@ void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg,
 // Pass Implementation
 //
 
-void ModulePass::addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU) {
+void ModulePass::addToPassManager(ModulePassManager *PM, AnalysisUsage &AU) {
   PM->addPass(this, AU);
 }
 
@@ -217,7 +219,7 @@ const char *Pass::getPassName() const {
 // to print out the contents of an analysis.  Otherwise it is not necessary to
 // implement this method.
 //
-void Pass::print(std::ostream &O) const {
+void Pass::print(std::ostream &O,const Module*) const {
   O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
 }
 
@@ -229,7 +231,7 @@ void Pass::dump() const {
 //===----------------------------------------------------------------------===//
 // ImmutablePass Implementation
 //
-void ImmutablePass::addToPassManager(PassManagerT<Module> *PM,
+void ImmutablePass::addToPassManager(ModulePassManager *PM, 
                                      AnalysisUsage &AU) {
   PM->addPass(this, AU);
 }
@@ -244,11 +246,11 @@ void ImmutablePass::addToPassManager(PassManagerT<Module> *PM,
 //
 bool FunctionPass::runOnModule(Module &M) {
   bool Changed = doInitialization(M);
-  
+
   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
     if (!I->isExternal())      // Passes are not run on external functions!
     Changed |= runOnFunction(*I);
-  
+
   return Changed | doFinalization(M);
 }
 
@@ -262,12 +264,12 @@ bool FunctionPass::run(Function &F) {
   return Changed | doFinalization(*F.getParent());
 }
 
-void FunctionPass::addToPassManager(PassManagerT<Module> *PM,
+void FunctionPass::addToPassManager(ModulePassManager *PM,
                                     AnalysisUsage &AU) {
   PM->addPass(this, AU);
 }
 
-void FunctionPass::addToPassManager(PassManagerT<Function> *PM,
+void FunctionPass::addToPassManager(FunctionPassManagerT *PM,
                                     AnalysisUsage &AU) {
   PM->addPass(this, AU);
 }
@@ -300,12 +302,12 @@ bool BasicBlockPass::runPass(BasicBlock &BB) {
   return Changed;
 }
 
-void BasicBlockPass::addToPassManager(PassManagerT<Function> *PM,
+void BasicBlockPass::addToPassManager(FunctionPassManagerT *PM,
                                       AnalysisUsage &AU) {
   PM->addPass(this, AU);
 }
 
-void BasicBlockPass::addToPassManager(PassManagerT<BasicBlock> *PM,
+void BasicBlockPass::addToPassManager(BasicBlockPassManager *PM,
                                       AnalysisUsage &AU) {
   PM->addPass(this, AU);
 }
@@ -441,7 +443,7 @@ RegisterAGBase::~RegisterAGBase() {
 
     if (AGI.DefaultImpl == ImplementationInfo)
       AGI.DefaultImpl = 0;
-    
+
     AGI.Implementations.erase(ImplementationInfo);
 
     // Last member of this analysis group? Unregister PassInfo, delete map entry
@@ -494,3 +496,4 @@ void PassRegistrationListener::enumeratePasses() {
            E = PassInfoMap->end(); I != E; ++I)
       passEnumerate(I->second);
 }
+