+ virtual void assignPassManager(PMStack &PMS,
+ PassManagerType T = PMT_ModulePassManager);
+
+ /// Return what kind of Pass Manager can manage this pass.
+ virtual PassManagerType getPotentialPassManagerType() const {
+ return PMT_ModulePassManager;
+ }
+
+ explicit ModulePass(intptr_t pid) : Pass(pid) {}
+ explicit ModulePass(const void *pid) : Pass(pid) {}
+ // Force out-of-line virtual method.
+ virtual ~ModulePass();
+};
+
+
+//===----------------------------------------------------------------------===//
+/// ImmutablePass class - This class is used to provide information that does
+/// not need to be run. This is useful for things like target information and
+/// "basic" versions of AnalysisGroups.
+///
+class ImmutablePass : public ModulePass {
+public:
+ /// initializePass - This method may be overriden by immutable passes to allow
+ /// them to perform various initialization actions they require. This is
+ /// primarily because an ImmutablePass can "require" another ImmutablePass,
+ /// and if it does, the overloaded version of initializePass may get access to
+ /// these passes with getAnalysis<>.
+ ///
+ virtual void initializePass() {}
+
+ /// ImmutablePasses are never run.
+ ///
+ bool runOnModule(Module &) { return false; }
+
+ explicit ImmutablePass(intptr_t pid) : ModulePass(pid) {}
+ explicit ImmutablePass(const void *pid)
+ : ModulePass(pid) {}
+
+ // Force out-of-line virtual method.
+ virtual ~ImmutablePass();
+};
+
+//===----------------------------------------------------------------------===//
+/// FunctionPass class - This class is used to implement most global
+/// optimizations. Optimizations should subclass this class if they meet the
+/// following constraints:
+///
+/// 1. Optimizations are organized globally, i.e., a function at a time
+/// 2. Optimizing a function does not cause the addition or removal of any
+/// functions in the module
+///
+class FunctionPass : public Pass {
+public:
+ explicit FunctionPass(intptr_t pid) : Pass(pid) {}
+ explicit FunctionPass(const void *pid) : Pass(pid) {}
+
+ /// doInitialization - Virtual method overridden by subclasses to do
+ /// any necessary per-module initialization.
+ ///
+ virtual bool doInitialization(Module &) { return false; }
+
+ /// runOnFunction - Virtual method overriden by subclasses to do the
+ /// per-function processing of the pass.
+ ///