/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Analysis/LoopPass.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- LoopPass.h - LoopPass class ----------------------------------------===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This file defines LoopPass class. All loop optimization |
11 | | // and transformation passes are derived from LoopPass. |
12 | | // |
13 | | //===----------------------------------------------------------------------===// |
14 | | |
15 | | #ifndef LLVM_ANALYSIS_LOOPPASS_H |
16 | | #define LLVM_ANALYSIS_LOOPPASS_H |
17 | | |
18 | | #include "llvm/Analysis/LoopInfo.h" |
19 | | #include "llvm/IR/LegacyPassManagers.h" |
20 | | #include "llvm/Pass.h" |
21 | | #include <deque> |
22 | | |
23 | | namespace llvm { |
24 | | |
25 | | class LPPassManager; |
26 | | class Function; |
27 | | class PMStack; |
28 | | |
29 | | class LoopPass : public Pass { |
30 | | public: |
31 | 274k | explicit LoopPass(char &pid) : Pass(PT_Loop, pid) {} |
32 | | |
33 | | /// getPrinterPass - Get a pass to print the function corresponding |
34 | | /// to a Loop. |
35 | | Pass *createPrinterPass(raw_ostream &O, |
36 | | const std::string &Banner) const override; |
37 | | |
38 | | // runOnLoop - This method should be implemented by the subclass to perform |
39 | | // whatever action is necessary for the specified Loop. |
40 | | virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0; |
41 | | |
42 | | using llvm::Pass::doInitialization; |
43 | | using llvm::Pass::doFinalization; |
44 | | |
45 | | // Initialization and finalization hooks. |
46 | 4.81M | virtual bool doInitialization(Loop *L, LPPassManager &LPM) { |
47 | 4.81M | return false; |
48 | 4.81M | } |
49 | | |
50 | | // Finalization hook does not supply Loop because at this time |
51 | | // loop nest is completely different. |
52 | 1.21M | virtual bool doFinalization() { return false; } |
53 | | |
54 | | // Check if this pass is suitable for the current LPPassManager, if |
55 | | // available. This pass P is not suitable for a LPPassManager if P |
56 | | // is not preserving higher level analysis info used by other |
57 | | // LPPassManager passes. In such case, pop LPPassManager from the |
58 | | // stack. This will force assignPassManager() to create new |
59 | | // LPPassManger as expected. |
60 | | void preparePassManager(PMStack &PMS) override; |
61 | | |
62 | | /// Assign pass manager to manage this pass |
63 | | void assignPassManager(PMStack &PMS, PassManagerType PMT) override; |
64 | | |
65 | | /// Return what kind of Pass Manager can manage this pass. |
66 | 1.31M | PassManagerType getPotentialPassManagerType() const override { |
67 | 1.31M | return PMT_LoopPassManager; |
68 | 1.31M | } |
69 | | |
70 | | //===--------------------------------------------------------------------===// |
71 | | /// SimpleAnalysis - Provides simple interface to update analysis info |
72 | | /// maintained by various passes. Note, if required this interface can |
73 | | /// be extracted into a separate abstract class but it would require |
74 | | /// additional use of multiple inheritance in Pass class hierarchy, something |
75 | | /// we are trying to avoid. |
76 | | |
77 | | /// Each loop pass can override these simple analysis hooks to update |
78 | | /// desired analysis information. |
79 | | /// cloneBasicBlockAnalysis - Clone analysis info associated with basic block. |
80 | 342k | virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L) {} |
81 | | |
82 | | /// deleteAnalysisValue - Delete analysis info associated with value V. |
83 | 24.3k | virtual void deleteAnalysisValue(Value *V, Loop *L) {} |
84 | | |
85 | | /// Delete analysis info associated with Loop L. |
86 | | /// Called to notify a Pass that a loop has been deleted and any |
87 | | /// associated analysis values can be deleted. |
88 | 165k | virtual void deleteAnalysisLoop(Loop *L) {} |
89 | | |
90 | | protected: |
91 | | /// Optional passes call this function to check whether the pass should be |
92 | | /// skipped. This is the case when Attribute::OptimizeNone is set or when |
93 | | /// optimization bisect is over the limit. |
94 | | bool skipLoop(const Loop *L) const; |
95 | | }; |
96 | | |
97 | | class LPPassManager : public FunctionPass, public PMDataManager { |
98 | | public: |
99 | | static char ID; |
100 | | explicit LPPassManager(); |
101 | | |
102 | | /// run - Execute all of the passes scheduled for execution. Keep track of |
103 | | /// whether any of the passes modifies the module, and if so, return true. |
104 | | bool runOnFunction(Function &F) override; |
105 | | |
106 | | /// Pass Manager itself does not invalidate any analysis info. |
107 | | // LPPassManager needs LoopInfo. |
108 | | void getAnalysisUsage(AnalysisUsage &Info) const override; |
109 | | |
110 | 0 | StringRef getPassName() const override { return "Loop Pass Manager"; } |
111 | | |
112 | 155k | PMDataManager *getAsPMDataManager() override { return this; } |
113 | 461k | Pass *getAsPass() override { return this; } |
114 | | |
115 | | /// Print passes managed by this manager |
116 | | void dumpPassStructure(unsigned Offset) override; |
117 | | |
118 | 12.1M | LoopPass *getContainedPass(unsigned N) { |
119 | 12.1M | assert(N < PassVector.size() && "Pass number out of range!"); |
120 | 12.1M | LoopPass *LP = static_cast<LoopPass *>(PassVector[N]); |
121 | 12.1M | return LP; |
122 | 12.1M | } |
123 | | |
124 | 566k | PassManagerType getPassManagerType() const override { |
125 | 566k | return PMT_LoopPassManager; |
126 | 566k | } |
127 | | |
128 | | public: |
129 | | // Add a new loop into the loop queue. |
130 | | void addLoop(Loop &L); |
131 | | |
132 | | // Mark \p L as deleted. |
133 | | void markLoopAsDeleted(Loop &L); |
134 | | |
135 | | //===--------------------------------------------------------------------===// |
136 | | /// SimpleAnalysis - Provides simple interface to update analysis info |
137 | | /// maintained by various passes. Note, if required this interface can |
138 | | /// be extracted into a separate abstract class but it would require |
139 | | /// additional use of multiple inheritance in Pass class hierarchy, something |
140 | | /// we are trying to avoid. |
141 | | |
142 | | /// cloneBasicBlockSimpleAnalysis - Invoke cloneBasicBlockAnalysis hook for |
143 | | /// all passes that implement simple analysis interface. |
144 | | void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L); |
145 | | |
146 | | /// deleteSimpleAnalysisValue - Invoke deleteAnalysisValue hook for all passes |
147 | | /// that implement simple analysis interface. |
148 | | void deleteSimpleAnalysisValue(Value *V, Loop *L); |
149 | | |
150 | | /// Invoke deleteAnalysisLoop hook for all passes that implement simple |
151 | | /// analysis interface. |
152 | | void deleteSimpleAnalysisLoop(Loop *L); |
153 | | |
154 | | private: |
155 | | std::deque<Loop *> LQ; |
156 | | LoopInfo *LI; |
157 | | Loop *CurrentLoop; |
158 | | bool CurrentLoopDeleted; |
159 | | }; |
160 | | |
161 | | // This pass is required by the LCSSA transformation. It is used inside |
162 | | // LPPassManager to check if current pass preserves LCSSA form, and if it does |
163 | | // pass manager calls lcssa verification for the current loop. |
164 | | struct LCSSAVerificationPass : public FunctionPass { |
165 | | static char ID; |
166 | 123k | LCSSAVerificationPass() : FunctionPass(ID) { |
167 | 123k | initializeLCSSAVerificationPassPass(*PassRegistry::getPassRegistry()); |
168 | 123k | } |
169 | | |
170 | 3.40M | bool runOnFunction(Function &F) override { return false; } |
171 | | |
172 | 123k | void getAnalysisUsage(AnalysisUsage &AU) const override { |
173 | 123k | AU.setPreservesAll(); |
174 | 123k | } |
175 | | }; |
176 | | |
177 | | } // End llvm namespace |
178 | | |
179 | | #endif |