Revert r108794, "Separate PassInfo into two classes: a constructor-free

superclass (StaticPassInfo) and a constructor-ful subclass (PassInfo).", it is
breaking teh everything.

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

diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h
index be73a106bb81a544e1fce953cabb5fd00d34bd1e..5a5893140e050d4016b34c842657f071a27a7feb 100644 (file)
--- a/include/llvm/Pass.h
+++ b/include/llvm/Pass.h
@@ -41,7 +41,6 @@ class BasicBlock;
 class Function;
 class Module;
 class AnalysisUsage;
-class StaticPassInfo;
 class PassInfo;
 class ImmutablePass;
 class PMStack;
@@ -51,7 +50,7 @@ class raw_ostream;
 class StringRef;
 
 // AnalysisID - Use the PassInfo to identify a pass...
-typedef const StaticPassInfo* AnalysisID;
+typedef const PassInfo* AnalysisID;
 
 /// Different types of internal pass managers. External pass managers
 /// (PassManager and FunctionPassManager) are not represented here.
@@ -105,7 +104,7 @@ public:
   /// getPassInfo - Return the PassInfo data structure that corresponds to this
   /// pass...  If the pass has not been registered, this will return null.
   ///
-  const StaticPassInfo *getPassInfo() const;
+  const PassInfo *getPassInfo() const;
 
   /// print - Print out the internal state of the pass.  This is called by
   /// Analyze to print out the contents of an analysis.  Otherwise it is not
@@ -160,7 +159,7 @@ public:
   /// an analysis interface through multiple inheritance.  If needed, it should
   /// override this to adjust the this pointer as needed for the specified pass
   /// info.
-  virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *);
+  virtual void *getAdjustedAnalysisPointer(const PassInfo *);
   virtual ImmutablePass *getAsImmutablePass();
   virtual PMDataManager *getAsPMDataManager();
   
@@ -172,17 +171,17 @@ public:
   virtual void dumpPassStructure(unsigned Offset = 0);
 
   template<typename AnalysisClass>
-  static const StaticPassInfo *getClassPassInfo() {
+  static const PassInfo *getClassPassInfo() {
     return lookupPassInfo(intptr_t(&AnalysisClass::ID));
   }
 
   // lookupPassInfo - Return the pass info object for the specified pass class,
   // or null if it is not known.
-  static const StaticPassInfo *lookupPassInfo(intptr_t TI);
+  static const PassInfo *lookupPassInfo(intptr_t TI);
 
   // lookupPassInfo - Return the pass info object for the pass with the given
   // argument string, or null if it is not known.
-  static const StaticPassInfo *lookupPassInfo(StringRef Arg);
+  static const PassInfo *lookupPassInfo(StringRef Arg);
 
   /// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
   /// get analysis information that might be around, for example to update it.
@@ -214,10 +213,10 @@ public:
   AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
 
   template<typename AnalysisType>
-  AnalysisType &getAnalysisID(const StaticPassInfo *PI) const;
+  AnalysisType &getAnalysisID(const PassInfo *PI) const;
 
   template<typename AnalysisType>
-  AnalysisType &getAnalysisID(const StaticPassInfo *PI, Function &F);
+  AnalysisType &getAnalysisID(const PassInfo *PI, Function &F);
 };
 
 

diff --git a/include/llvm/PassAnalysisSupport.h b/include/llvm/PassAnalysisSupport.h
index e24ccde6c71942302b778b14452591b4c029b82e..977d4f4e30d32894c5b8159f23f8259914cf566c 100644 (file)
--- a/include/llvm/PassAnalysisSupport.h
+++ b/include/llvm/PassAnalysisSupport.h
@@ -86,7 +86,7 @@ public:
   // linked in. Be careful about spelling!
   //
   AnalysisUsage &addPreserved(StringRef Arg) {
-    const StaticPassInfo *PI = Pass::lookupPassInfo(Arg);
+    const PassInfo *PI = Pass::lookupPassInfo(Arg);
     // If the pass exists, preserve it. Otherwise silently do nothing.
     if (PI) Preserved.push_back(PI);
     return *this;
@@ -130,7 +130,7 @@ public:
   inline PMDataManager &getPMDataManager() { return PM; }
 
   // Find pass that is implementing PI.
-  Pass *findImplPass(const StaticPassInfo *PI) {
+  Pass *findImplPass(const PassInfo *PI) {
     Pass *ResultPass = 0;
     for (unsigned i = 0; i < AnalysisImpls.size() ; ++i) {
       if (AnalysisImpls[i].first == PI) {
@@ -142,10 +142,10 @@ public:
   }
 
   // Find pass that is implementing PI. Initialize pass for Function F.
-  Pass *findImplPass(Pass *P, const StaticPassInfo *PI, Function &F);
+  Pass *findImplPass(Pass *P, const PassInfo *PI, Function &F);
 
-  void addAnalysisImplsPair(const StaticPassInfo *PI, Pass *P) {
-    std::pair<const StaticPassInfo*, Pass*> pir = std::make_pair(PI,P);
+  void addAnalysisImplsPair(const PassInfo *PI, Pass *P) {
+    std::pair<const PassInfo*, Pass*> pir = std::make_pair(PI,P);
     AnalysisImpls.push_back(pir);
   }
 
@@ -160,7 +160,7 @@ public:
 
   // AnalysisImpls - This keeps track of which passes implements the interfaces
   // that are required by the current pass (to implement getAnalysis()).
-  std::vector<std::pair<const StaticPassInfo*, Pass*> > AnalysisImpls;
+  std::vector<std::pair<const PassInfo*, Pass*> > AnalysisImpls;
 
 private:
   // PassManager that is used to resolve analysis info
@@ -179,7 +179,7 @@ template<typename AnalysisType>
 AnalysisType *Pass::getAnalysisIfAvailable() const {
   assert(Resolver && "Pass not resident in a PassManager object!");
 
-  const StaticPassInfo *PI = getClassPassInfo<AnalysisType>();
+  const PassInfo *PI = getClassPassInfo<AnalysisType>();
   if (PI == 0) return 0;
 
   Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
@@ -203,7 +203,7 @@ AnalysisType &Pass::getAnalysis() const {
 }
 
 template<typename AnalysisType>
-AnalysisType &Pass::getAnalysisID(const StaticPassInfo *PI) const {
+AnalysisType &Pass::getAnalysisID(const PassInfo *PI) const {
   assert(PI && "getAnalysis for unregistered pass!");
   assert(Resolver&&"Pass has not been inserted into a PassManager object!");
   // PI *must* appear in AnalysisImpls.  Because the number of passes used
@@ -233,7 +233,7 @@ AnalysisType &Pass::getAnalysis(Function &F) {
 }
 
 template<typename AnalysisType>
-AnalysisType &Pass::getAnalysisID(const StaticPassInfo *PI, Function &F) {
+AnalysisType &Pass::getAnalysisID(const PassInfo *PI, Function &F) {
   assert(PI && "getAnalysis for unregistered pass!");
   assert(Resolver && "Pass has not been inserted into a PassManager object!");
   // PI *must* appear in AnalysisImpls.  Because the number of passes used

diff --git a/include/llvm/PassManagers.h b/include/llvm/PassManagers.h
index c4593e625b0f4141d40075d9c7c86c25fd605f41..81b7e7af816e4a1f32f957e7905f421f4fb0377b 100644 (file)
--- a/include/llvm/PassManagers.h
+++ b/include/llvm/PassManagers.h
@@ -302,7 +302,7 @@ public:
   /// through getAnalysis interface.
   virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass);
 
-  virtual Pass *getOnTheFlyPass(Pass *P, const StaticPassInfo *PI, Function &F);
+  virtual Pass *getOnTheFlyPass(Pass *P, const PassInfo *PI, Function &F);
 
   /// Initialize available analysis information.
   void initializeAnalysisInfo() { 

diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h
index c396b87b6cb1faa7c74a601eef7b830a7134a66b..09abe93e916dd07b46c6501a479396ca595038de 100644 (file)
--- a/include/llvm/PassSupport.h
+++ b/include/llvm/PassSupport.h
@@ -22,7 +22,6 @@
 #define LLVM_PASS_SUPPORT_H
 
 #include "Pass.h"
-#include "llvm/Config/config.h"
 
 namespace llvm {
 
@@ -34,24 +33,45 @@ class TargetMachine;
 /// getPassInfo() method.  These objects are set up by the RegisterPass<>
 /// template, defined below.
 ///
-
-struct StaticPassInfo {
+class PassInfo {
+public:
   typedef Pass* (*NormalCtor_t)();
   struct InterfaceInfo {
-    const StaticPassInfo *interface;
+    const PassInfo *interface;
     const InterfaceInfo *next;
   };
 
-  const char *PassName;     // Nice name for Pass
-  const char *PassArgument; // Command Line argument to run this pass
-  intptr_t  PassID;      
-  bool IsCFGOnlyPass;            // Pass only looks at the CFG.
-  bool IsAnalysis;               // True if an analysis pass.
-  bool IsAnalysisGroup;          // True if an analysis group.
-  InterfaceInfo *ItfImpl;// Interfaces implemented by this pass
+private:
+  const char      *const PassName;     // Nice name for Pass
+  const char      *const PassArgument; // Command Line argument to run this pass
+  const intptr_t  PassID;      
+  const bool IsCFGOnlyPass;            // Pass only looks at the CFG.
+  const bool IsAnalysis;               // True if an analysis pass.
+  const bool IsAnalysisGroup;          // True if an analysis group.
+  const InterfaceInfo *ItfImpl;// Interfaces implemented by this pass
 
   NormalCtor_t NormalCtor;
-    
+
+public:
+  /// PassInfo ctor - Do not call this directly, this should only be invoked
+  /// through RegisterPass.
+  PassInfo(const char *name, const char *arg, intptr_t pi,
+           NormalCtor_t normal = 0,
+           bool isCFGOnly = false, bool is_analysis = false)
+    : PassName(name), PassArgument(arg), PassID(pi), 
+      IsCFGOnlyPass(isCFGOnly), 
+      IsAnalysis(is_analysis), IsAnalysisGroup(false), NormalCtor(normal) {
+    registerPass();
+  }
+  /// PassInfo ctor - Do not call this directly, this should only be invoked
+  /// through RegisterPass. This version is for use by analysis groups; it
+  /// does not auto-register the pass.
+  PassInfo(const char *name, intptr_t pi)
+    : PassName(name), PassArgument(""), PassID(pi), 
+      IsCFGOnlyPass(false), 
+      IsAnalysis(false), IsAnalysisGroup(true), NormalCtor(0) {
+  }
+
   /// getPassName - Return the friendly name for the pass, never returns null
   ///
   const char *getPassName() const { return PassName; }
@@ -70,7 +90,7 @@ struct StaticPassInfo {
   bool isPassID(void *IDPtr) const {
     return PassID == (intptr_t)IDPtr;
   }
-
+  
   /// isAnalysisGroup - Return true if this is an analysis group, not a normal
   /// pass.
   ///
@@ -80,7 +100,7 @@ struct StaticPassInfo {
   /// isCFGOnlyPass - return true if this pass only looks at the CFG for the
   /// function.
   bool isCFGOnlyPass() const { return IsCFGOnlyPass; }
-
+  
   /// getNormalCtor - Return a pointer to a function, that when called, creates
   /// an instance of the pass and returns it.  This pointer may be null if there
   /// is no default constructor for the pass.
@@ -92,11 +112,14 @@ struct StaticPassInfo {
     NormalCtor = Ctor;
   }
 
+  /// createPass() - Use this method to create an instance of this pass.
+  Pass *createPass() const;
+
   /// addInterfaceImplemented - This method is called when this pass is
   /// registered as a member of an analysis group with the RegisterAnalysisGroup
   /// template.
   ///
-  void addInterfaceImplemented(const StaticPassInfo *ItfPI) {
+  void addInterfaceImplemented(const PassInfo *ItfPI) {
     InterfaceInfo *NewInfo = new InterfaceInfo();
     NewInfo->interface = ItfPI;
     NewInfo->next = ItfImpl;
@@ -110,39 +133,6 @@ struct StaticPassInfo {
     return ItfImpl;
   }
 
-  /// createPass() - Use this method to create an instance of this pass.
-  Pass *createPass() const;
-};
-
-class PassInfo : public StaticPassInfo {
-public:
-  /// PassInfo ctor - Do not call this directly, this should only be invoked
-  /// through RegisterPass.
-  PassInfo(const char *name, const char *arg, intptr_t pi,
-           NormalCtor_t normal = 0,
-           bool isCFGOnly = false, bool is_analysis = false) {
-    this->PassName = name;
-    this->PassArgument = arg;
-    this->PassID = pi;
-    this->IsCFGOnlyPass = isCFGOnly;
-    this->IsAnalysis = is_analysis;
-    this->IsAnalysisGroup = false;
-    this->NormalCtor = normal;
-    registerPass();
-  }
-  /// PassInfo ctor - Do not call this directly, this should only be invoked
-  /// through RegisterPass. This version is for use by analysis groups; it
-  /// does not auto-register the pass.
-  PassInfo(const char *name, intptr_t pi) {
-    this->PassName = name;
-    this->PassArgument = "";
-    this->PassID = pi;
-    this->IsCFGOnlyPass = false;
-    this->IsAnalysis = false;
-    this->IsAnalysisGroup = true;
-    this->NormalCtor = 0;
-  }
-
 protected:
   void registerPass();
   void unregisterPass();
@@ -250,7 +240,7 @@ struct PassRegistrationListener {
   /// Callback functions - These functions are invoked whenever a pass is loaded
   /// or removed from the current executable.
   ///
-  virtual void passRegistered(const StaticPassInfo *) {}
+  virtual void passRegistered(const PassInfo *) {}
 
   /// enumeratePasses - Iterate over the registered passes, calling the
   /// passEnumerate callback on each PassInfo object.
@@ -260,7 +250,7 @@ struct PassRegistrationListener {
   /// passEnumerate - Callback function invoked when someone calls
   /// enumeratePasses on this PassRegistrationListener object.
   ///
-  virtual void passEnumerate(const StaticPassInfo *) {}
+  virtual void passEnumerate(const PassInfo *) {}
 };
 
 

diff --git a/include/llvm/Support/PassNameParser.h b/include/llvm/Support/PassNameParser.h
index c3564399e2b9188a24c6018182e675b2d4d9442d..cdca978cfef64cc642f0ca201824acfa5dc2d57a 100644 (file)
--- a/include/llvm/Support/PassNameParser.h
+++ b/include/llvm/Support/PassNameParser.h
@@ -55,11 +55,9 @@ public:
   // ignorablePassImpl - Can be overriden in subclasses to refine the list of
   // which passes we want to include.
   //
-  virtual bool ignorablePassImpl(const StaticPassInfo *P) const {
-    return false;
-  }
+  virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
 
-  inline bool ignorablePass(const StaticPassInfo *P) const {
+  inline bool ignorablePass(const PassInfo *P) const {
     // Ignore non-selectable and non-constructible passes!  Ignore
     // non-optimizations.
     return P->getPassArgument() == 0 || *P->getPassArgument() == 0 ||
@@ -68,7 +66,7 @@ public:
 
   // Implement the PassRegistrationListener callbacks used to populate our map
   //
-  virtual void passRegistered(const StaticPassInfo *P) {
+  virtual void passRegistered(const PassInfo *P) {
     if (ignorablePass(P) || !Opt) return;
     if (findOption(P->getPassArgument()) != getNumOptions()) {
       errs() << "Two passes with the same argument (-"
@@ -77,7 +75,7 @@ public:
     }
     addLiteralOption(P->getPassArgument(), P, P->getPassName());
   }
-  virtual void passEnumerate(const StaticPassInfo *P) { passRegistered(P); }
+  virtual void passEnumerate(const PassInfo *P) { passRegistered(P); }
 
   // ValLessThan - Provide a sorting comparator for Values elements...
   typedef std::pair<const char*,
@@ -107,7 +105,7 @@ private:
   Filter filter;
 
 public:
-  bool ignorablePassImpl(const StaticPassInfo *P) const { return !filter(*P); }
+  bool ignorablePassImpl(const PassInfo *P) const { return !filter(*P); }
 };
 
 ///===----------------------------------------------------------------------===//

diff --git a/lib/Analysis/AliasAnalysisCounter.cpp b/lib/Analysis/AliasAnalysisCounter.cpp
index 7d908604487bf252816ebb3a3eb413ad16c0ad70..1053955ea23397654a33b904b7a8742e1dc26087 100644 (file)
--- a/lib/Analysis/AliasAnalysisCounter.cpp
+++ b/lib/Analysis/AliasAnalysisCounter.cpp
@@ -87,7 +87,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it
     /// should override this to adjust the this pointer as needed for the
     /// specified pass info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&AliasAnalysis::ID))
         return (AliasAnalysis*)this;
       return this;

diff --git a/lib/Analysis/AliasDebugger.cpp b/lib/Analysis/AliasDebugger.cpp
index 578bc68bd3e2bf16bad0fc5180b2532f93cdca8e..bc2d9c55d18376812d3a8ced6143ea3edfc6ba38 100644 (file)
--- a/lib/Analysis/AliasDebugger.cpp
+++ b/lib/Analysis/AliasDebugger.cpp
@@ -83,7 +83,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it
     /// should override this to adjust the this pointer as needed for the
     /// specified pass info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&AliasAnalysis::ID))
         return (AliasAnalysis*)this;
       return this;

diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp
index 91a17e5106a2486cc5f7d3881510c40adb752beb..4f53a6d62559bea022d1ae547c1530481f759ec4 100644 (file)
--- a/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/lib/Analysis/BasicAliasAnalysis.cpp
@@ -172,7 +172,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it should
     /// override this to adjust the this pointer as needed for the specified pass
     /// info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&AliasAnalysis::ID))
         return (AliasAnalysis*)this;
       return this;
@@ -243,7 +243,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it should
     /// override this to adjust the this pointer as needed for the specified pass
     /// info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&AliasAnalysis::ID))
         return (AliasAnalysis*)this;
       return this;

diff --git a/lib/Analysis/IPA/CallGraph.cpp b/lib/Analysis/IPA/CallGraph.cpp
index fc0d33d5dc58d406df3fb90444f3cc7b26a99b51..65c7c6efd8027e74ee5931d13c72eebf1aceba86 100644 (file)
--- a/lib/Analysis/IPA/CallGraph.cpp
+++ b/lib/Analysis/IPA/CallGraph.cpp
@@ -86,7 +86,7 @@ public:
   /// an analysis interface through multiple inheritance.  If needed, it should
   /// override this to adjust the this pointer as needed for the specified pass
   /// info.
-  virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+  virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
     if (PI->isPassID(&CallGraph::ID))
       return (CallGraph*)this;
     return this;

diff --git a/lib/Analysis/IPA/GlobalsModRef.cpp b/lib/Analysis/IPA/GlobalsModRef.cpp
index 7e328ef85e197b97fb7cb48b9bca94685d13aa82..f13deea41d4ede8642dccdbd584bde689af98964 100644 (file)
--- a/lib/Analysis/IPA/GlobalsModRef.cpp
+++ b/lib/Analysis/IPA/GlobalsModRef.cpp
@@ -149,7 +149,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it
     /// should override this to adjust the this pointer as needed for the
     /// specified pass info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&AliasAnalysis::ID))
         return (AliasAnalysis*)this;
       return this;

diff --git a/lib/Analysis/ProfileEstimatorPass.cpp b/lib/Analysis/ProfileEstimatorPass.cpp
index a06d0fc8b3a327a106c96241dda460261b5a2339..da4ce47692624b0eea0d36e8514e6982407e2ca4 100644 (file)
--- a/lib/Analysis/ProfileEstimatorPass.cpp
+++ b/lib/Analysis/ProfileEstimatorPass.cpp
@@ -59,7 +59,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it
     /// should override this to adjust the this pointer as needed for the
     /// specified pass info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&ProfileInfo::ID))
         return (ProfileInfo*)this;
       return this;

diff --git a/lib/Analysis/ProfileInfoLoaderPass.cpp b/lib/Analysis/ProfileInfoLoaderPass.cpp
index 90f40406a6696f8d401131963d6d34e48ecbe668..8ea4ecf54f98f6a8510b55e670afcd50ad63aa4f 100644 (file)
--- a/lib/Analysis/ProfileInfoLoaderPass.cpp
+++ b/lib/Analysis/ProfileInfoLoaderPass.cpp
@@ -67,7 +67,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it
     /// should override this to adjust the this pointer as needed for the
     /// specified pass info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&ProfileInfo::ID))
         return (ProfileInfo*)this;
       return this;

diff --git a/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
index 11885b2b1a87f4d5c611e61f819d6f792a3b7533..58711b8be59e8bb38659753133faa70400771890 100644 (file)
--- a/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
+++ b/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
@@ -40,7 +40,7 @@ namespace {
     /// an analysis interface through multiple inheritance.  If needed, it
     /// should override this to adjust the this pointer as needed for the
     /// specified pass info.
-    virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
+    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
       if (PI->isPassID(&AliasAnalysis::ID))
         return (AliasAnalysis*)this;
       return this;

diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp
index f78e85596b227bd63eeb3c6fcd6236011bedab17..efd98af0f443ce4acfc56b53af0c5f3e0f4ff953 100644 (file)
--- a/lib/VMCore/Pass.cpp
+++ b/lib/VMCore/Pass.cpp
@@ -75,7 +75,7 @@ void Pass::dumpPassStructure(unsigned Offset) {
 /// Registration templates, but can be overloaded directly.
 ///
 const char *Pass::getPassName() const {
-  if (const StaticPassInfo *PI = getPassInfo())
+  if (const PassInfo *PI = getPassInfo())
     return PI->getPassName();
   return "Unnamed pass: implement Pass::getPassName()";
 }
@@ -101,7 +101,7 @@ void Pass::verifyAnalysis() const {
   // By default, don't do anything.
 }
 
-void *Pass::getAdjustedAnalysisPointer(const StaticPassInfo *) {
+void *Pass::getAdjustedAnalysisPointer(const PassInfo *) {
   return this;
 }
 
@@ -243,35 +243,35 @@ class PassRegistrar {
 
   /// PassInfoMap - Keep track of the passinfo object for each registered llvm
   /// pass.
-  typedef std::map<intptr_t, const StaticPassInfo*> MapType;
+  typedef std::map<intptr_t, const PassInfo*> MapType;
   MapType PassInfoMap;
 
-  typedef StringMap<const StaticPassInfo*> StringMapType;
+  typedef StringMap<const PassInfo*> StringMapType;
   StringMapType PassInfoStringMap;
   
   /// AnalysisGroupInfo - Keep track of information for each analysis group.
   struct AnalysisGroupInfo {
-    std::set<const StaticPassInfo *> Implementations;
+    std::set<const PassInfo *> Implementations;
   };
   
   /// AnalysisGroupInfoMap - Information for each analysis group.
-  std::map<const StaticPassInfo *, AnalysisGroupInfo> AnalysisGroupInfoMap;
+  std::map<const PassInfo *, AnalysisGroupInfo> AnalysisGroupInfoMap;
 
 public:
   
-  const StaticPassInfo *GetPassInfo(intptr_t TI) const {
+  const PassInfo *GetPassInfo(intptr_t TI) const {
     sys::SmartScopedLock<true> Guard(Lock);
     MapType::const_iterator I = PassInfoMap.find(TI);
     return I != PassInfoMap.end() ? I->second : 0;
   }
   
-  const StaticPassInfo *GetPassInfo(StringRef Arg) const {
+  const PassInfo *GetPassInfo(StringRef Arg) const {
     sys::SmartScopedLock<true> Guard(Lock);
     StringMapType::const_iterator I = PassInfoStringMap.find(Arg);
     return I != PassInfoStringMap.end() ? I->second : 0;
   }
   
-  void RegisterPass(const StaticPassInfo &PI) {
+  void RegisterPass(const PassInfo &PI) {
     sys::SmartScopedLock<true> Guard(Lock);
     bool Inserted =
       PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second;
@@ -279,7 +279,7 @@ public:
     PassInfoStringMap[PI.getPassArgument()] = &PI;
   }
   
-  void UnregisterPass(const StaticPassInfo &PI) {
+  void UnregisterPass(const PassInfo &PI) {
     sys::SmartScopedLock<true> Guard(Lock);
     MapType::iterator I = PassInfoMap.find(PI.getTypeInfo());
     assert(I != PassInfoMap.end() && "Pass registered but not in map!");
@@ -298,8 +298,8 @@ public:
   
   
   /// Analysis Group Mechanisms.
-  void RegisterAnalysisGroup(StaticPassInfo *InterfaceInfo,
-                             const StaticPassInfo *ImplementationInfo,
+  void RegisterAnalysisGroup(PassInfo *InterfaceInfo,
+                             const PassInfo *ImplementationInfo,
                              bool isDefault) {
     sys::SmartScopedLock<true> Guard(Lock);
     AnalysisGroupInfo &AGI = AnalysisGroupInfoMap[InterfaceInfo];
@@ -363,15 +363,15 @@ ManagedCleanup<&cleanupPassRegistrar> registrarCleanup ATTRIBUTE_USED;
 
 // getPassInfo - Return the PassInfo data structure that corresponds to this
 // pass...
-const StaticPassInfo *Pass::getPassInfo() const {
+const PassInfo *Pass::getPassInfo() const {
   return lookupPassInfo(PassID);
 }
 
-const StaticPassInfo *Pass::lookupPassInfo(intptr_t TI) {
+const PassInfo *Pass::lookupPassInfo(intptr_t TI) {
   return getPassRegistrar()->GetPassInfo(TI);
 }
 
-const StaticPassInfo *Pass::lookupPassInfo(StringRef Arg) {
+const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
   return getPassRegistrar()->GetPassInfo(Arg);
 }
 
@@ -390,7 +390,7 @@ void PassInfo::unregisterPass() {
   getPassRegistrar()->UnregisterPass(*this);
 }
 
-Pass *StaticPassInfo::createPass() const {
+Pass *PassInfo::createPass() const {
   assert((!isAnalysisGroup() || NormalCtor) &&
          "No default implementation found for analysis group!");
   assert(NormalCtor &&
@@ -408,8 +408,8 @@ RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID,
                                intptr_t PassID, bool isDefault)
   : PassInfo(Name, InterfaceID) {
 
-  StaticPassInfo *InterfaceInfo =
-    const_cast<StaticPassInfo*>(Pass::lookupPassInfo(InterfaceID));
+  PassInfo *InterfaceInfo =
+    const_cast<PassInfo*>(Pass::lookupPassInfo(InterfaceID));
   if (InterfaceInfo == 0) {
     // First reference to Interface, register it now.
     registerPass();
@@ -419,13 +419,13 @@ RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID,
          "Trying to join an analysis group that is a normal pass!");
 
   if (PassID) {
-    const StaticPassInfo *ImplementationInfo = Pass::lookupPassInfo(PassID);
+    const PassInfo *ImplementationInfo = Pass::lookupPassInfo(PassID);
     assert(ImplementationInfo &&
            "Must register pass before adding to AnalysisGroup!");
 
     // Make sure we keep track of the fact that the implementation implements
     // the interface.
-    StaticPassInfo *IIPI = const_cast<StaticPassInfo*>(ImplementationInfo);
+    PassInfo *IIPI = const_cast<PassInfo*>(ImplementationInfo);
     IIPI->addInterfaceImplemented(InterfaceInfo);
     
     getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault);
@@ -479,7 +479,7 @@ namespace {
     VectorType &CFGOnlyList;
     GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
     
-    void passEnumerate(const StaticPassInfo *P) {
+    void passEnumerate(const PassInfo *P) {
       if (P->isCFGOnlyPass())
         CFGOnlyList.push_back(P);
     }

diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index 9e0be3b9689b9384adb13330a6ae72809750796c..4cf5501379c95894497c8e922fb2da2740dc0bd4 100644 (file)
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -332,8 +332,7 @@ public:
   /// Return function pass corresponding to PassInfo PI, that is 
   /// required by module pass MP. Instantiate analysis pass, by using
   /// its runOnFunction() for function F.
-  virtual Pass* getOnTheFlyPass(Pass *MP, const StaticPassInfo *PI,
-                                Function &F);
+  virtual Pass* getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F);
 
   virtual const char *getPassName() const {
     return "Module Pass Manager";
@@ -633,7 +632,7 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) {
 
   for (SmallVector<ImmutablePass *, 8>::iterator I = ImmutablePasses.begin(),
          E = ImmutablePasses.end(); P == NULL && I != E; ++I) {
-    const StaticPassInfo *PI = (*I)->getPassInfo();
+    const PassInfo *PI = (*I)->getPassInfo();
     if (PI == AID)
       P = *I;
 
@@ -729,7 +728,7 @@ PMTopLevelManager::~PMTopLevelManager() {
 
 /// Augement AvailableAnalysis by adding analysis made available by pass P.
 void PMDataManager::recordAvailableAnalysis(Pass *P) {
-  const StaticPassInfo *PI = P->getPassInfo();
+  const PassInfo *PI = P->getPassInfo();
   if (PI == 0) return;
   
   AvailableAnalysis[PI] = P;
@@ -868,7 +867,7 @@ void PMDataManager::freePass(Pass *P, StringRef Msg,
     P->releaseMemory();
   }
 
-  if (const StaticPassInfo *PI = P->getPassInfo()) {
+  if (const PassInfo *PI = P->getPassInfo()) {
     // Remove the pass itself (if it is not already removed).
     AvailableAnalysis.erase(PI);
 
@@ -1052,7 +1051,7 @@ void PMDataManager::dumpPassArguments() const {
     if (PMDataManager *PMD = (*I)->getAsPMDataManager())
       PMD->dumpPassArguments();
     else
-      if (const StaticPassInfo *PI = (*I)->getPassInfo())
+      if (const PassInfo *PI = (*I)->getPassInfo())
         if (!PI->isAnalysisGroup())
           dbgs() << " -" << PI->getPassArgument();
   }
@@ -1155,8 +1154,7 @@ void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
   llvm_unreachable("Unable to schedule pass");
 }
 
-Pass *PMDataManager::getOnTheFlyPass(Pass *P, const StaticPassInfo *PI,
-                                     Function &F) {
+Pass *PMDataManager::getOnTheFlyPass(Pass *P, const PassInfo *PI, Function &F) {
   assert(0 && "Unable to find on the fly pass");
   return NULL;
 }
@@ -1175,7 +1173,7 @@ Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID, bool dir) const {
   return PM.findAnalysisPass(ID, dir);
 }
 
-Pass *AnalysisResolver::findImplPass(Pass *P, const StaticPassInfo *AnalysisPI, 
+Pass *AnalysisResolver::findImplPass(Pass *P, const PassInfo *AnalysisPI, 
                                      Function &F) {
   return PM.getOnTheFlyPass(P, AnalysisPI, F);
 }
@@ -1570,8 +1568,7 @@ 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 StaticPassInfo *PI,
-                                     Function &F){
+Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F){
   FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
   assert(FPP && "Unable to find on the fly pass");
   

diff --git a/tools/bugpoint/BugDriver.cpp b/tools/bugpoint/BugDriver.cpp
index 49b664010905a719e9638365597b2db8dc569c78..45a0d4dd17a31e0ae77c1f360a3318e453b7be46 100644 (file)
--- a/tools/bugpoint/BugDriver.cpp
+++ b/tools/bugpoint/BugDriver.cpp
@@ -56,8 +56,7 @@ void BugDriver::setNewProgram(Module *M) {
 /// getPassesString - Turn a list of passes into a string which indicates the
 /// command line options that must be passed to add the passes.
 ///
-std::string
-llvm::getPassesString(const std::vector<const StaticPassInfo*> &Passes) {
+std::string llvm::getPassesString(const std::vector<const PassInfo*> &Passes) {
   std::string Result;
   for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
     if (i) Result += " ";

diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 36c90b0541d6b1d327dd7c2297e66bd98efc534c..4f6bae5d5abb4f847219d2af267a98a0d8e0efd2 100644 (file)
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -23,7 +23,7 @@
 namespace llvm {
 
 class Value;
-class StaticPassInfo;
+class PassInfo;
 class Module;
 class GlobalVariable;
 class Function;
@@ -47,7 +47,7 @@ class BugDriver {
   const char *ToolName;            // argv[0] of bugpoint
   std::string ReferenceOutputFile; // Name of `good' output file
   Module *Program;             // The raw program, linked together
-  std::vector<const StaticPassInfo*> PassesToRun;
+  std::vector<const PassInfo*> PassesToRun;
   AbstractInterpreter *Interpreter;   // How to run the program
   AbstractInterpreter *SafeInterpreter;  // To generate reference output, etc.
   GCC *gcc;
@@ -77,10 +77,10 @@ public:
   bool addSources(const std::vector<std::string> &FileNames);
   template<class It>
   void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
-  void setPassesToRun(const std::vector<const StaticPassInfo*> &PTR) {
+  void setPassesToRun(const std::vector<const PassInfo*> &PTR) {
     PassesToRun = PTR;
   }
-  const std::vector<const StaticPassInfo*> &getPassesToRun() const {
+  const std::vector<const PassInfo*> &getPassesToRun() const {
     return PassesToRun;
   }
 
@@ -112,7 +112,7 @@ public:
   /// ReferenceOutput contains the filename of the file containing the output we
   /// are to match.
   ///
-  bool debugPassMiscompilation(const StaticPassInfo *ThePass,
+  bool debugPassMiscompilation(const PassInfo *ThePass,
                                const std::string &ReferenceOutput);
 
   /// compileSharedObject - This method creates a SharedObject from a given
@@ -243,8 +243,7 @@ public:
   /// failure.  If AutoDebugCrashes is set to true, then bugpoint will
   /// automatically attempt to track down a crashing pass if one exists, and
   /// this method will never return null.
-  Module *runPassesOn(Module *M,
-                      const std::vector<const StaticPassInfo*> &Passes,
+  Module *runPassesOn(Module *M, const std::vector<const PassInfo*> &Passes,
                       bool AutoDebugCrashes = false, unsigned NumExtraArgs = 0,
                       const char * const *ExtraArgs = NULL);
 
@@ -257,7 +256,7 @@ public:
   /// or failed, unless Quiet is set.  ExtraArgs specifies additional arguments
   /// to pass to the child bugpoint instance.
   ///
-  bool runPasses(const std::vector<const StaticPassInfo*> &PassesToRun,
+  bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
                  std::string &OutputFilename, bool DeleteOutput = false,
                  bool Quiet = false, unsigned NumExtraArgs = 0,
                  const char * const *ExtraArgs = NULL) const;
@@ -269,7 +268,7 @@ public:
   /// If the passes did not compile correctly, output the command required to 
   /// recreate the failure. This returns true if a compiler error is found.
   ///
-  bool runManyPasses(const std::vector<const StaticPassInfo*> &AllPasses,
+  bool runManyPasses(const std::vector<const PassInfo*> &AllPasses,
                      std::string &ErrMsg);
 
   /// writeProgramToFile - This writes the current "Program" to the named
@@ -282,14 +281,14 @@ private:
   /// false indicating whether or not the optimizer crashed on the specified
   /// input (true = crashed).
   ///
-  bool runPasses(const std::vector<const StaticPassInfo*> &PassesToRun,
+  bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
                  bool DeleteOutput = true) const {
     std::string Filename;
     return runPasses(PassesToRun, Filename, DeleteOutput);
   }
 
   /// runAsChild - The actual "runPasses" guts that runs in a child process.
-  int runPassesAsChild(const std::vector<const StaticPassInfo*> &PassesToRun);
+  int runPassesAsChild(const std::vector<const PassInfo*> &PassesToRun);
 
   /// initializeExecutionEnvironment - This method is used to set up the
   /// environment for executing LLVM programs.
@@ -307,7 +306,7 @@ Module *ParseInputFile(const std::string &InputFilename,
 /// getPassesString - Turn a list of passes into a string which indicates the
 /// command line options that must be passed to add the passes.
 ///
-std::string getPassesString(const std::vector<const StaticPassInfo*> &Passes);
+std::string getPassesString(const std::vector<const PassInfo*> &Passes);
 
 /// PrintFunctionList - prints out list of problematic functions
 ///

diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp
index b0ee672e63db87d55e0a70c7236bb043b1e39d7e..2d0631cdad901473521a88d958339ab043cfcbca 100644 (file)
--- a/tools/bugpoint/CrashDebugger.cpp
+++ b/tools/bugpoint/CrashDebugger.cpp
@@ -43,7 +43,7 @@ namespace {
 }
 
 namespace llvm {
-  class ReducePassList : public ListReducer<const StaticPassInfo*> {
+  class ReducePassList : public ListReducer<const PassInfo*> {
     BugDriver &BD;
   public:
     ReducePassList(BugDriver &bd) : BD(bd) {}
@@ -52,15 +52,15 @@ namespace llvm {
     // running the "Kept" passes fail when run on the output of the "removed"
     // passes.  If we return true, we update the current module of bugpoint.
     //
-    virtual TestResult doTest(std::vector<const StaticPassInfo*> &Removed,
-                              std::vector<const StaticPassInfo*> &Kept,
+    virtual TestResult doTest(std::vector<const PassInfo*> &Removed,
+                              std::vector<const PassInfo*> &Kept,
                               std::string &Error);
   };
 }
 
 ReducePassList::TestResult
-ReducePassList::doTest(std::vector<const StaticPassInfo*> &Prefix,
-                       std::vector<const StaticPassInfo*> &Suffix,
+ReducePassList::doTest(std::vector<const PassInfo*> &Prefix,
+                       std::vector<const PassInfo*> &Suffix,
                        std::string &Error) {
   sys::Path PrefixOutput;
   Module *OrigProgram = 0;

diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp
index 55c1780ff929dba4bc4cf2331a8e55339d3ef3bd..d5611b58ae20c77ee9b99832ef960d7e2d4cddb9 100644 (file)
--- a/tools/bugpoint/ExtractFunction.cpp
+++ b/tools/bugpoint/ExtractFunction.cpp
@@ -99,8 +99,8 @@ Module *BugDriver::deleteInstructionFromProgram(const Instruction *I,
   return Result;
 }
 
-static const StaticPassInfo *getPI(Pass *P) {
-  const StaticPassInfo *PI = P->getPassInfo();
+static const PassInfo *getPI(Pass *P) {
+  const PassInfo *PI = P->getPassInfo();
   delete P;
   return PI;
 }
@@ -114,7 +114,7 @@ Module *BugDriver::performFinalCleanups(Module *M, bool MayModifySemantics) {
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
     I->setLinkage(GlobalValue::ExternalLinkage);
 
-  std::vector<const StaticPassInfo*> CleanupPasses;
+  std::vector<const PassInfo*> CleanupPasses;
   CleanupPasses.push_back(getPI(createGlobalDCEPass()));
 
   if (MayModifySemantics)
@@ -138,7 +138,7 @@ Module *BugDriver::performFinalCleanups(Module *M, bool MayModifySemantics) {
 /// function.  This returns null if there are no extractable loops in the
 /// program or if the loop extractor crashes.
 Module *BugDriver::ExtractLoop(Module *M) {
-  std::vector<const StaticPassInfo*> LoopExtractPasses;
+  std::vector<const PassInfo*> LoopExtractPasses;
   LoopExtractPasses.push_back(getPI(createSingleLoopExtractorPass()));
 
   Module *NewM = runPassesOn(M, LoopExtractPasses);
@@ -359,7 +359,7 @@ Module *BugDriver::ExtractMappedBlocksFromModule(const
   std::string uniqueFN = "--extract-blocks-file=" + uniqueFilename.str();
   const char *ExtraArg = uniqueFN.c_str();
 
-  std::vector<const StaticPassInfo*> PI;
+  std::vector<const PassInfo*> PI;
   std::vector<BasicBlock *> EmptyBBs; // This parameter is ignored.
   PI.push_back(getPI(createBlockExtractorPass(EmptyBBs)));
   Module *Ret = runPassesOn(M, PI, false, 1, &ExtraArg);

diff --git a/tools/bugpoint/FindBugs.cpp b/tools/bugpoint/FindBugs.cpp
index 5c1bedebf19edef27def4b86787a85d8dcf16190..224c71747a6f5c8c4acaee0a42fcd987d3da8c5b 100644 (file)
--- a/tools/bugpoint/FindBugs.cpp
+++ b/tools/bugpoint/FindBugs.cpp
@@ -29,8 +29,7 @@ using namespace llvm;
 /// If the passes did not compile correctly, output the command required to 
 /// recreate the failure. This returns true if a compiler error is found.
 ///
-bool
-BugDriver::runManyPasses(const std::vector<const StaticPassInfo*> &AllPasses,
+bool BugDriver::runManyPasses(const std::vector<const PassInfo*> &AllPasses,
                               std::string &ErrMsg) {
   setPassesToRun(AllPasses);
   outs() << "Starting bug finding procedure...\n\n";

diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp
index e40e5efc1eacf1a059406833eb9428436c10e145..47ac3c5c4d3a71dcce68d77fab3497492b43d23a 100644 (file)
--- a/tools/bugpoint/Miscompilation.cpp
+++ b/tools/bugpoint/Miscompilation.cpp
@@ -43,13 +43,13 @@ namespace {
         cl::desc("Don't extract blocks when searching for miscompilations"),
         cl::init(false));
 
-  class ReduceMiscompilingPasses : public ListReducer<const StaticPassInfo*> {
+  class ReduceMiscompilingPasses : public ListReducer<const PassInfo*> {
     BugDriver &BD;
   public:
     ReduceMiscompilingPasses(BugDriver &bd) : BD(bd) {}
 
-    virtual TestResult doTest(std::vector<const StaticPassInfo*> &Prefix,
-                              std::vector<const StaticPassInfo*> &Suffix,
+    virtual TestResult doTest(std::vector<const PassInfo*> &Prefix,
+                              std::vector<const PassInfo*> &Suffix,
                               std::string &Error);
   };
 }
@@ -58,8 +58,8 @@ namespace {
 /// group, see if they still break the program.
 ///
 ReduceMiscompilingPasses::TestResult
-ReduceMiscompilingPasses::doTest(std::vector<const StaticPassInfo*> &Prefix,
-                                 std::vector<const StaticPassInfo*> &Suffix,
+ReduceMiscompilingPasses::doTest(std::vector<const PassInfo*> &Prefix,
+                                 std::vector<const PassInfo*> &Suffix,
                                  std::string &Error) {
   // First, run the program with just the Suffix passes.  If it is still broken
   // with JUST the kept passes, discard the prefix passes.

diff --git a/tools/bugpoint/OptimizerDriver.cpp b/tools/bugpoint/OptimizerDriver.cpp
index 462718b7bf9eb702ee6f3d69542fd25b5f001ade..3a6149b24a529f8657852b5c895a447c15f9c389 100644 (file)
--- a/tools/bugpoint/OptimizerDriver.cpp
+++ b/tools/bugpoint/OptimizerDriver.cpp
@@ -83,7 +83,7 @@ void BugDriver::EmitProgressBitcode(const std::string &ID, bool NoFlyer) {
   outs() << getPassesString(PassesToRun) << "\n";
 }
 
-int BugDriver::runPassesAsChild(const std::vector<const StaticPassInfo*> &Passes) {
+int BugDriver::runPassesAsChild(const std::vector<const PassInfo*> &Passes) {
   std::string ErrInfo;
   raw_fd_ostream OutFile(ChildOutput.c_str(), ErrInfo,
                          raw_fd_ostream::F_Binary);
@@ -124,7 +124,7 @@ cl::opt<bool> SilencePasses("silence-passes", cl::desc("Suppress output of runni
 /// outs() a single line message indicating whether compilation was successful
 /// or failed.
 ///
-bool BugDriver::runPasses(const std::vector<const StaticPassInfo*> &Passes,
+bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
                           std::string &OutputFilename, bool DeleteOutput,
                           bool Quiet, unsigned NumExtraArgs,
                           const char * const *ExtraArgs) const {
@@ -178,7 +178,7 @@ bool BugDriver::runPasses(const std::vector<const StaticPassInfo*> &Passes,
     pass_args.push_back( std::string("-load"));
     pass_args.push_back( PluginLoader::getPlugin(i));
   }
-  for (std::vector<const StaticPassInfo*>::const_iterator I = Passes.begin(),
+  for (std::vector<const PassInfo*>::const_iterator I = Passes.begin(),
        E = Passes.end(); I != E; ++I )
     pass_args.push_back( std::string("-") + (*I)->getPassArgument() );
   for (std::vector<std::string>::const_iterator I = pass_args.begin(),
@@ -235,7 +235,7 @@ bool BugDriver::runPasses(const std::vector<const StaticPassInfo*> &Passes,
 /// module, returning the transformed module on success, or a null pointer on
 /// failure.
 Module *BugDriver::runPassesOn(Module *M,
-                               const std::vector<const StaticPassInfo*> &Passes,
+                               const std::vector<const PassInfo*> &Passes,
                                bool AutoDebugCrashes, unsigned NumExtraArgs,
                                const char * const *ExtraArgs) {
   Module *OldProgram = swapProgramIn(M);

diff --git a/tools/bugpoint/bugpoint.cpp b/tools/bugpoint/bugpoint.cpp
index d4951adc6ebd60a7034277a9749c208d1a4271a0..ba5234bdc89d52f7659eddef22ce4db3d696ed8c 100644 (file)
--- a/tools/bugpoint/bugpoint.cpp
+++ b/tools/bugpoint/bugpoint.cpp
@@ -61,7 +61,7 @@ UseValgrind("enable-valgrind",
 // The AnalysesList is automatically populated with registered Passes by the
 // PassNameParser.
 //
-static cl::list<const StaticPassInfo*, bool, PassNameParser>
+static cl::list<const PassInfo*, bool, PassNameParser>
 PassList(cl::desc("Passes available:"), cl::ZeroOrMore);
 
 static cl::opt<bool>
@@ -90,7 +90,7 @@ namespace {
     AddToDriver(BugDriver &_D) : D(_D) {}
     
     virtual void add(Pass *P) {
-      const StaticPassInfo *PI = P->getPassInfo();
+      const PassInfo *PI = P->getPassInfo();
       D.addPasses(&PI, &PI + 1);
     }
   };