llvm/include/llvm/Analysis/LoopPass.h

   1 //===- LoopPass.h - LoopPass class ----------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines LoopPass class. All loop optimization
  10 // and transformation passes are derived from LoopPass.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_ANALYSIS_LOOPPASS_H
  15 #define LLVM_ANALYSIS_LOOPPASS_H
  16
  17 #include "llvm/IR/LegacyPassManagers.h"
  18 #include "llvm/Pass.h"
  19 #include <deque>
  20
  21 namespace llvm {
  22
  23 class Loop;
  24 class LoopInfo;
  25 class LPPassManager;
  26 class Function;
  27
  28 class LoopPass : public Pass {
  29 public:
  30   explicit LoopPass(char &pid) : Pass(PT_Loop, pid) {}
  31
  32   /// getPrinterPass - Get a pass to print the function corresponding
  33   /// to a Loop.
  34   Pass *createPrinterPass(raw_ostream &O,
  35                           const std::string &Banner) const override;
  36
  37   // runOnLoop - This method should be implemented by the subclass to perform
  38   // whatever action is necessary for the specified Loop.
  39   virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
  40
  41   using llvm::Pass::doInitialization;
  42   using llvm::Pass::doFinalization;
  43
  44   // Initialization and finalization hooks.
  45   virtual bool doInitialization(Loop *L, LPPassManager &LPM) {
  46     return false;
  47   }
  48
  49   // Finalization hook does not supply Loop because at this time
  50   // loop nest is completely different.
  51   virtual bool doFinalization() { return false; }
  52
  53   // Check if this pass is suitable for the current LPPassManager, if
  54   // available. This pass P is not suitable for a LPPassManager if P
  55   // is not preserving higher level analysis info used by other
  56   // LPPassManager passes. In such case, pop LPPassManager from the
  57   // stack. This will force assignPassManager() to create new
  58   // LPPassManger as expected.
  59   void preparePassManager(PMStack &PMS) override;
  60
  61   /// Assign pass manager to manage this pass
  62   void assignPassManager(PMStack &PMS, PassManagerType PMT) override;
  63
  64   ///  Return what kind of Pass Manager can manage this pass.
  65   PassManagerType getPotentialPassManagerType() const override {
  66     return PMT_LoopPassManager;
  67   }
  68
  69 protected:
  70   /// Optional passes call this function to check whether the pass should be
  71   /// skipped. This is the case when Attribute::OptimizeNone is set or when
  72   /// optimization bisect is over the limit.
  73   bool skipLoop(const Loop *L) const;
  74 };
  75
  76 class LPPassManager : public FunctionPass, public PMDataManager {
  77 public:
  78   static char ID;
  79   explicit LPPassManager();
  80
  81   /// run - Execute all of the passes scheduled for execution.  Keep track of
  82   /// whether any of the passes modifies the module, and if so, return true.
  83   bool runOnFunction(Function &F) override;
  84
  85   /// Pass Manager itself does not invalidate any analysis info.
  86   // LPPassManager needs LoopInfo.
  87   void getAnalysisUsage(AnalysisUsage &Info) const override;
  88
  89   StringRef getPassName() const override { return "Loop Pass Manager"; }
  90
  91   PMDataManager *getAsPMDataManager() override { return this; }
  92   Pass *getAsPass() override { return this; }
  93
  94   /// Print passes managed by this manager
  95   void dumpPassStructure(unsigned Offset) override;
  96
  97   LoopPass *getContainedPass(unsigned N) {
  98     assert(N < PassVector.size() && "Pass number out of range!");
  99     LoopPass *LP = static_cast<LoopPass *>(PassVector[N]);
 100     return LP;
 101   }
 102
 103   PassManagerType getPassManagerType() const override {
 104     return PMT_LoopPassManager;
 105   }
 106
 107 public:
 108   // Add a new loop into the loop queue.
 109   void addLoop(Loop &L);
 110
 111   // Mark \p L as deleted.
 112   void markLoopAsDeleted(Loop &L);
 113
 114 private:
 115   std::deque<Loop *> LQ;
 116   LoopInfo *LI;
 117   Loop *CurrentLoop;
 118   bool CurrentLoopDeleted;
 119 };
 120
 121 // This pass is required by the LCSSA transformation. It is used inside
 122 // LPPassManager to check if current pass preserves LCSSA form, and if it does
 123 // pass manager calls lcssa verification for the current loop.
 124 struct LCSSAVerificationPass : public FunctionPass {
 125   static char ID;
 126   LCSSAVerificationPass();
 127
 128   bool runOnFunction(Function &F) override { return false; }
 129
 130   void getAnalysisUsage(AnalysisUsage &AU) const override {
 131     AU.setPreservesAll();
 132   }
 133 };
 134
 135 } // End llvm namespace
 136
 137 #endif