Reapply r108794, a fix for the failing test from last time.

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

5 files changed, 76 insertions, 63 deletions

diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h
index 5a5893140e..be73a106bb 100644
--- a/include/llvm/Pass.h
+++ b/include/llvm/Pass.h
@@ -41,6 +41,7 @@ class BasicBlock;
 class Function;
 class Module;
 class AnalysisUsage;
+class StaticPassInfo;
 class PassInfo;
 class ImmutablePass;
 class PMStack;
@@ -50,7 +51,7 @@ class raw_ostream;
 class StringRef;
 
 // AnalysisID - Use the PassInfo to identify a pass...
-typedef const PassInfo* AnalysisID;
+typedef const StaticPassInfo* AnalysisID;
 
 /// Different types of internal pass managers. External pass managers
 /// (PassManager and FunctionPassManager) are not represented here.
@@ -104,7 +105,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 PassInfo *getPassInfo() const;
+  const StaticPassInfo *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
@@ -159,7 +160,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 PassInfo *);
+  virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *);
   virtual ImmutablePass *getAsImmutablePass();
   virtual PMDataManager *getAsPMDataManager();
   
@@ -171,17 +172,17 @@ public:
   virtual void dumpPassStructure(unsigned Offset = 0);
 
   template<typename AnalysisClass>
-  static const PassInfo *getClassPassInfo() {
+  static const StaticPassInfo *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 PassInfo *lookupPassInfo(intptr_t TI);
+  static const StaticPassInfo *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 PassInfo *lookupPassInfo(StringRef Arg);
+  static const StaticPassInfo *lookupPassInfo(StringRef Arg);
 
   /// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
   /// get analysis information that might be around, for example to update it.
@@ -213,10 +214,10 @@ public:
   AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
 
   template<typename AnalysisType>
-  AnalysisType &getAnalysisID(const PassInfo *PI) const;
+  AnalysisType &getAnalysisID(const StaticPassInfo *PI) const;
 
   template<typename AnalysisType>
-  AnalysisType &getAnalysisID(const PassInfo *PI, Function &F);
+  AnalysisType &getAnalysisID(const StaticPassInfo *PI, Function &F);
 };
 
 
diff --git a/include/llvm/PassAnalysisSupport.h b/include/llvm/PassAnalysisSupport.h
index 977d4f4e30..e24ccde6c7 100644
--- 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 PassInfo *PI = Pass::lookupPassInfo(Arg);
+    const StaticPassInfo *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 PassInfo *PI) {
+  Pass *findImplPass(const StaticPassInfo *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 PassInfo *PI, Function &F);
+  Pass *findImplPass(Pass *P, const StaticPassInfo *PI, Function &F);
 
-  void addAnalysisImplsPair(const PassInfo *PI, Pass *P) {
-    std::pair<const PassInfo*, Pass*> pir = std::make_pair(PI,P);
+  void addAnalysisImplsPair(const StaticPassInfo *PI, Pass *P) {
+    std::pair<const StaticPassInfo*, 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 PassInfo*, Pass*> > AnalysisImpls;
+  std::vector<std::pair<const StaticPassInfo*, 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 PassInfo *PI = getClassPassInfo<AnalysisType>();
+  const StaticPassInfo *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 PassInfo *PI) const {
+AnalysisType &Pass::getAnalysisID(const StaticPassInfo *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 PassInfo *PI, Function &F) {
+AnalysisType &Pass::getAnalysisID(const StaticPassInfo *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 81b7e7af81..c4593e625b 100644
--- 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 PassInfo *PI, Function &F);
+  virtual Pass *getOnTheFlyPass(Pass *P, const StaticPassInfo *PI, Function &F);
 
   /// Initialize available analysis information.
   void initializeAnalysisInfo() { 
diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h
index 09abe93e91..c396b87b6c 100644
--- a/include/llvm/PassSupport.h
+++ b/include/llvm/PassSupport.h
@@ -22,6 +22,7 @@
 #define LLVM_PASS_SUPPORT_H
 
 #include "Pass.h"
+#include "llvm/Config/config.h"
 
 namespace llvm {
 
@@ -33,45 +34,24 @@ class TargetMachine;
 /// getPassInfo() method.  These objects are set up by the RegisterPass<>
 /// template, defined below.
 ///
-class PassInfo {
-public:
+
+struct StaticPassInfo {
   typedef Pass* (*NormalCtor_t)();
   struct InterfaceInfo {
-    const PassInfo *interface;
+    const StaticPassInfo *interface;
     const InterfaceInfo *next;
   };
 
-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
+  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
 
   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; }
@@ -90,7 +70,7 @@ public:
   bool isPassID(void *IDPtr) const {
     return PassID == (intptr_t)IDPtr;
   }
-  
+
   /// isAnalysisGroup - Return true if this is an analysis group, not a normal
   /// pass.
   ///
@@ -100,7 +80,7 @@ public:
   /// 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.
@@ -112,14 +92,11 @@ public:
     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 PassInfo *ItfPI) {
+  void addInterfaceImplemented(const StaticPassInfo *ItfPI) {
     InterfaceInfo *NewInfo = new InterfaceInfo();
     NewInfo->interface = ItfPI;
     NewInfo->next = ItfImpl;
@@ -133,6 +110,39 @@ public:
     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();
@@ -240,7 +250,7 @@ struct PassRegistrationListener {
   /// Callback functions - These functions are invoked whenever a pass is loaded
   /// or removed from the current executable.
   ///
-  virtual void passRegistered(const PassInfo *) {}
+  virtual void passRegistered(const StaticPassInfo *) {}
 
   /// enumeratePasses - Iterate over the registered passes, calling the
   /// passEnumerate callback on each PassInfo object.
@@ -250,7 +260,7 @@ struct PassRegistrationListener {
   /// passEnumerate - Callback function invoked when someone calls
   /// enumeratePasses on this PassRegistrationListener object.
   ///
-  virtual void passEnumerate(const PassInfo *) {}
+  virtual void passEnumerate(const StaticPassInfo *) {}
 };
 
 
diff --git a/include/llvm/Support/PassNameParser.h b/include/llvm/Support/PassNameParser.h
index cdca978cfe..c3564399e2 100644
--- a/include/llvm/Support/PassNameParser.h
+++ b/include/llvm/Support/PassNameParser.h
@@ -55,9 +55,11 @@ public:
   // ignorablePassImpl - Can be overriden in subclasses to refine the list of
   // which passes we want to include.
   //
-  virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
+  virtual bool ignorablePassImpl(const StaticPassInfo *P) const {
+    return false;
+  }
 
-  inline bool ignorablePass(const PassInfo *P) const {
+  inline bool ignorablePass(const StaticPassInfo *P) const {
     // Ignore non-selectable and non-constructible passes!  Ignore
     // non-optimizations.
     return P->getPassArgument() == 0 || *P->getPassArgument() == 0 ||
@@ -66,7 +68,7 @@ public:
 
   // Implement the PassRegistrationListener callbacks used to populate our map
   //
-  virtual void passRegistered(const PassInfo *P) {
+  virtual void passRegistered(const StaticPassInfo *P) {
     if (ignorablePass(P) || !Opt) return;
     if (findOption(P->getPassArgument()) != getNumOptions()) {
       errs() << "Two passes with the same argument (-"
@@ -75,7 +77,7 @@ public:
     }
     addLiteralOption(P->getPassArgument(), P, P->getPassName());
   }
-  virtual void passEnumerate(const PassInfo *P) { passRegistered(P); }
+  virtual void passEnumerate(const StaticPassInfo *P) { passRegistered(P); }
 
   // ValLessThan - Provide a sorting comparator for Values elements...
   typedef std::pair<const char*,
@@ -105,7 +107,7 @@ private:
   Filter filter;
 
 public:
-  bool ignorablePassImpl(const PassInfo *P) const { return !filter(*P); }
+  bool ignorablePassImpl(const StaticPassInfo *P) const { return !filter(*P); }
 };
 
 ///===----------------------------------------------------------------------===//