Add loop info verification mechanism.

[oota-llvm.git] / include / llvm / Analysis / LoopPass.h

diff --git a/include/llvm/Analysis/LoopPass.h b/include/llvm/Analysis/LoopPass.h
index 2fd14f2dad4a1ecf26bb34256c4e7e73c6257af3..7a820ccc5dac0015d3a9e650ffd1e9f614f79f47 100644 (file)
--- a/include/llvm/Analysis/LoopPass.h
+++ b/include/llvm/Analysis/LoopPass.h
@@ -25,41 +25,59 @@ namespace llvm {
 class LPPassManager;
 class Loop;
 class Function;
-class LoopQueue;
 
 class LoopPass : public Pass {
 
  public:
+ LoopPass(intptr_t pid) : Pass(pid) {}
+
   // runOnLoop - THis method should be implemented by the subclass to perform
   // whatever action is necessary for the specfied Loop. 
-  virtual bool runOnLoop (Loop &L, LPPassManager &LPM) = 0;
+  virtual bool runOnLoop (Loop *L, LPPassManager &LPM) = 0;
   virtual bool runOnFunctionBody (Function &F, LPPassManager &LPM) { 
     return false; 
   }
 
+  // Initialization and finalization hooks.
+  virtual bool doInitialization(Loop *L, LPPassManager &LPM) { 
+    return false; 
+  }
+
+  // Finalization hook does not supply Loop because at this time
+  // loop nest is completely different.
+  virtual bool doFinalization() { return false; }
+
+  // Check if this pass is suitable for the current LPPassManager, if
+  // available. This pass P is not suitable for a LPPassManager if P
+  // is not preserving higher level analysis info used by other
+  // LPPassManager passes. In such case, pop LPPassManager from the
+  // stack. This will force assignPassManager() to create new
+  // LPPassManger as expected.
+  void preparePassManager(PMStack &PMS);
+
   /// Assign pass manager to manager this pass
   virtual void assignPassManager(PMStack &PMS,
-                                PassManagerType PMT = PMT_LoopPassManager);
+                                 PassManagerType PMT = PMT_LoopPassManager);
 
+  ///  Return what kind of Pass Manager can manage this pass.
+  virtual PassManagerType getPotentialPassManagerType() const {
+    return PMT_LoopPassManager;
+  }
 };
 
 class LPPassManager : public FunctionPass, public PMDataManager {
 
 public:
+  static char ID;
   LPPassManager(int Depth);
-  ~LPPassManager();
 
   /// 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 runOnFunction(Function &F);
 
   /// Pass Manager itself does not invalidate any analysis info.
-  void getAnalysisUsage(AnalysisUsage &Info) const {
-    // LPPassManager needs LoopInfo. In the long term LoopInfo class will 
-    // be consumed by LPPassManager.
-    Info.addRequired<LoopInfo>();
-    Info.setPreservesAll();
-  }
+  // LPPassManager needs LoopInfo. 
+  void getAnalysisUsage(AnalysisUsage &Info) const; 
   
   virtual const char *getPassName() const {
     return "Loop Pass Manager";
@@ -81,23 +99,32 @@ public:
     return FP;
   }
 
-  virtual PassManagerType getPassManagerType() { 
+  virtual PassManagerType getPassManagerType() const { 
     return PMT_LoopPassManager; 
   }
 
 public:
-  // Delete loop from the loop queue. This is used by Loop pass to inform
-  // Loop Pass Manager that it should skip rest of the passes for this loop.
+  // Delete loop from the loop queue and loop nest (LoopInfo).
   void deleteLoopFromQueue(Loop *L);
+  
+  // Inset loop into the loop nest(LoopInfo) and loop queue(LQ).
+  void insertLoop(Loop *L, Loop *ParentLoop);
 
   // Reoptimize this loop. LPPassManager will re-insert this loop into the
   // queue. This allows LoopPass to change loop nest for the loop. This
   // utility may send LPPassManager into infinite loops so use caution.
   void redoLoop(Loop *L);
+
+private:
+  /// verifyLoopInfo - Verify loop nest.
+  void verifyLoopInfo();
+
 private:
-  LoopQueue *LQ;
+  std::deque<Loop *> LQ;
   bool skipThisLoop;
   bool redoThisLoop;
+  LoopInfo *LI;
+  Loop *CurrentLoop;
 };
 
 } // End llvm namespace