Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 pmbaty 1
//===- llvm/Pass.h - Base class for Passes ----------------------*- C++ -*-===//
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 a base class that indicates that a specified class is a
10
// transformation pass implementation.
11
//
12
// Passes are designed this way so that it is possible to run passes in a cache
13
// and organizationally optimal order without having to specify it at the front
14
// end.  This allows arbitrary passes to be strung together and have them
15
// executed as efficiently as possible.
16
//
17
// Passes should extend one of the classes below, depending on the guarantees
18
// that it can make about what will be modified as it is run.  For example, most
19
// global optimizations should derive from FunctionPass, because they do not add
20
// or delete functions, they operate on the internals of the function.
21
//
22
// Note that this file #includes PassSupport.h and PassAnalysisSupport.h (at the
23
// bottom), so the APIs exposed by these files are also automatically available
24
// to all users of this file.
25
//
26
//===----------------------------------------------------------------------===//
27
 
28
#ifndef LLVM_PASS_H
29
#define LLVM_PASS_H
30
 
31
#include <string>
32
 
33
namespace llvm {
34
 
35
class AnalysisResolver;
36
class AnalysisUsage;
37
class Function;
38
class ImmutablePass;
39
class Module;
40
class PassInfo;
41
class PMDataManager;
42
class PMStack;
43
class raw_ostream;
44
class StringRef;
45
 
46
// AnalysisID - Use the PassInfo to identify a pass...
47
using AnalysisID = const void *;
48
 
49
/// Different types of internal pass managers. External pass managers
50
/// (PassManager and FunctionPassManager) are not represented here.
51
/// Ordering of pass manager types is important here.
52
enum PassManagerType {
53
  PMT_Unknown = 0,
54
  PMT_ModulePassManager = 1, ///< MPPassManager
55
  PMT_CallGraphPassManager,  ///< CGPassManager
56
  PMT_FunctionPassManager,   ///< FPPassManager
57
  PMT_LoopPassManager,       ///< LPPassManager
58
  PMT_RegionPassManager,     ///< RGPassManager
59
  PMT_Last
60
};
61
 
62
// Different types of passes.
63
enum PassKind {
64
  PT_Region,
65
  PT_Loop,
66
  PT_Function,
67
  PT_CallGraphSCC,
68
  PT_Module,
69
  PT_PassManager
70
};
71
 
72
/// This enumerates the LLVM full LTO or ThinLTO optimization phases.
73
enum class ThinOrFullLTOPhase {
74
  /// No LTO/ThinLTO behavior needed.
75
  None,
76
  /// ThinLTO prelink (summary) phase.
77
  ThinLTOPreLink,
78
  /// ThinLTO postlink (backend compile) phase.
79
  ThinLTOPostLink,
80
  /// Full LTO prelink phase.
81
  FullLTOPreLink,
82
  /// Full LTO postlink (backend compile) phase.
83
  FullLTOPostLink
84
};
85
 
86
//===----------------------------------------------------------------------===//
87
/// Pass interface - Implemented by all 'passes'.  Subclass this if you are an
88
/// interprocedural optimization or you do not fit into any of the more
89
/// constrained passes described below.
90
///
91
class Pass {
92
  AnalysisResolver *Resolver = nullptr;  // Used to resolve analysis
93
  const void *PassID;
94
  PassKind Kind;
95
 
96
public:
97
  explicit Pass(PassKind K, char &pid) : PassID(&pid), Kind(K) {}
98
  Pass(const Pass &) = delete;
99
  Pass &operator=(const Pass &) = delete;
100
  virtual ~Pass();
101
 
102
  PassKind getPassKind() const { return Kind; }
103
 
104
  /// getPassName - Return a nice clean name for a pass.  This usually
105
  /// implemented in terms of the name that is registered by one of the
106
  /// Registration templates, but can be overloaded directly.
107
  virtual StringRef getPassName() const;
108
 
109
  /// getPassID - Return the PassID number that corresponds to this pass.
110
  AnalysisID getPassID() const {
111
    return PassID;
112
  }
113
 
114
  /// doInitialization - Virtual method overridden by subclasses to do
115
  /// any necessary initialization before any pass is run.
116
  virtual bool doInitialization(Module &)  { return false; }
117
 
118
  /// doFinalization - Virtual method overriden by subclasses to do any
119
  /// necessary clean up after all passes have run.
120
  virtual bool doFinalization(Module &) { return false; }
121
 
122
  /// print - Print out the internal state of the pass.  This is called by
123
  /// Analyze to print out the contents of an analysis.  Otherwise it is not
124
  /// necessary to implement this method.  Beware that the module pointer MAY be
125
  /// null.  This automatically forwards to a virtual function that does not
126
  /// provide the Module* in case the analysis doesn't need it it can just be
127
  /// ignored.
128
  virtual void print(raw_ostream &OS, const Module *M) const;
129
 
130
  void dump() const; // dump - Print to stderr.
131
 
132
  /// createPrinterPass - Get a Pass appropriate to print the IR this
133
  /// pass operates on (Module, Function or MachineFunction).
134
  virtual Pass *createPrinterPass(raw_ostream &OS,
135
                                  const std::string &Banner) const = 0;
136
 
137
  /// Each pass is responsible for assigning a pass manager to itself.
138
  /// PMS is the stack of available pass manager.
139
  virtual void assignPassManager(PMStack &,
140
                                 PassManagerType) {}
141
 
142
  /// Check if available pass managers are suitable for this pass or not.
143
  virtual void preparePassManager(PMStack &);
144
 
145
  ///  Return what kind of Pass Manager can manage this pass.
146
  virtual PassManagerType getPotentialPassManagerType() const;
147
 
148
  // Access AnalysisResolver
149
  void setResolver(AnalysisResolver *AR);
150
  AnalysisResolver *getResolver() const { return Resolver; }
151
 
152
  /// getAnalysisUsage - This function should be overriden by passes that need
153
  /// analysis information to do their job.  If a pass specifies that it uses a
154
  /// particular analysis result to this function, it can then use the
155
  /// getAnalysis<AnalysisType>() function, below.
156
  virtual void getAnalysisUsage(AnalysisUsage &) const;
157
 
158
  /// releaseMemory() - This member can be implemented by a pass if it wants to
159
  /// be able to release its memory when it is no longer needed.  The default
160
  /// behavior of passes is to hold onto memory for the entire duration of their
161
  /// lifetime (which is the entire compile time).  For pipelined passes, this
162
  /// is not a big deal because that memory gets recycled every time the pass is
163
  /// invoked on another program unit.  For IP passes, it is more important to
164
  /// free memory when it is unused.
165
  ///
166
  /// Optionally implement this function to release pass memory when it is no
167
  /// longer used.
168
  virtual void releaseMemory();
169
 
170
  /// getAdjustedAnalysisPointer - This method is used when a pass implements
171
  /// an analysis interface through multiple inheritance.  If needed, it should
172
  /// override this to adjust the this pointer as needed for the specified pass
173
  /// info.
174
  virtual void *getAdjustedAnalysisPointer(AnalysisID ID);
175
  virtual ImmutablePass *getAsImmutablePass();
176
  virtual PMDataManager *getAsPMDataManager();
177
 
178
  /// verifyAnalysis() - This member can be implemented by a analysis pass to
179
  /// check state of analysis information.
180
  virtual void verifyAnalysis() const;
181
 
182
  // dumpPassStructure - Implement the -debug-passes=PassStructure option
183
  virtual void dumpPassStructure(unsigned Offset = 0);
184
 
185
  // lookupPassInfo - Return the pass info object for the specified pass class,
186
  // or null if it is not known.
187
  static const PassInfo *lookupPassInfo(const void *TI);
188
 
189
  // lookupPassInfo - Return the pass info object for the pass with the given
190
  // argument string, or null if it is not known.
191
  static const PassInfo *lookupPassInfo(StringRef Arg);
192
 
193
  // createPass - Create a object for the specified pass class,
194
  // or null if it is not known.
195
  static Pass *createPass(AnalysisID ID);
196
 
197
  /// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
198
  /// get analysis information that might be around, for example to update it.
199
  /// This is different than getAnalysis in that it can fail (if the analysis
200
  /// results haven't been computed), so should only be used if you can handle
201
  /// the case when the analysis is not available.  This method is often used by
202
  /// transformation APIs to update analysis results for a pass automatically as
203
  /// the transform is performed.
204
  template<typename AnalysisType> AnalysisType *
205
    getAnalysisIfAvailable() const; // Defined in PassAnalysisSupport.h
206
 
207
  /// mustPreserveAnalysisID - This method serves the same function as
208
  /// getAnalysisIfAvailable, but works if you just have an AnalysisID.  This
209
  /// obviously cannot give you a properly typed instance of the class if you
210
  /// don't have the class name available (use getAnalysisIfAvailable if you
211
  /// do), but it can tell you if you need to preserve the pass at least.
212
  bool mustPreserveAnalysisID(char &AID) const;
213
 
214
  /// getAnalysis<AnalysisType>() - This function is used by subclasses to get
215
  /// to the analysis information that they claim to use by overriding the
216
  /// getAnalysisUsage function.
217
  template<typename AnalysisType>
218
  AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h
219
 
220
  template <typename AnalysisType>
221
  AnalysisType &
222
  getAnalysis(Function &F,
223
              bool *Changed = nullptr); // Defined in PassAnalysisSupport.h
224
 
225
  template<typename AnalysisType>
226
  AnalysisType &getAnalysisID(AnalysisID PI) const;
227
 
228
  template <typename AnalysisType>
229
  AnalysisType &getAnalysisID(AnalysisID PI, Function &F,
230
                              bool *Changed = nullptr);
231
 
232
#ifdef EXPENSIVE_CHECKS
233
  /// Hash a module in order to detect when a module (or more specific) pass has
234
  /// modified it.
235
  uint64_t structuralHash(Module &M) const;
236
 
237
  /// Hash a function in order to detect when a function (or more specific) pass
238
  /// has modified it.
239
  virtual uint64_t structuralHash(Function &F) const;
240
#endif
241
};
242
 
243
//===----------------------------------------------------------------------===//
244
/// ModulePass class - This class is used to implement unstructured
245
/// interprocedural optimizations and analyses.  ModulePasses may do anything
246
/// they want to the program.
247
///
248
class ModulePass : public Pass {
249
public:
250
  explicit ModulePass(char &pid) : Pass(PT_Module, pid) {}
251
 
252
  // Force out-of-line virtual method.
253
  ~ModulePass() override;
254
 
255
  /// createPrinterPass - Get a module printer pass.
256
  Pass *createPrinterPass(raw_ostream &OS,
257
                          const std::string &Banner) const override;
258
 
259
  /// runOnModule - Virtual method overriden by subclasses to process the module
260
  /// being operated on.
261
  virtual bool runOnModule(Module &M) = 0;
262
 
263
  void assignPassManager(PMStack &PMS, PassManagerType T) override;
264
 
265
  ///  Return what kind of Pass Manager can manage this pass.
266
  PassManagerType getPotentialPassManagerType() const override;
267
 
268
protected:
269
  /// Optional passes call this function to check whether the pass should be
270
  /// skipped. This is the case when optimization bisect is over the limit.
271
  bool skipModule(Module &M) const;
272
};
273
 
274
//===----------------------------------------------------------------------===//
275
/// ImmutablePass class - This class is used to provide information that does
276
/// not need to be run.  This is useful for things like target information and
277
/// "basic" versions of AnalysisGroups.
278
///
279
class ImmutablePass : public ModulePass {
280
public:
281
  explicit ImmutablePass(char &pid) : ModulePass(pid) {}
282
 
283
  // Force out-of-line virtual method.
284
  ~ImmutablePass() override;
285
 
286
  /// initializePass - This method may be overriden by immutable passes to allow
287
  /// them to perform various initialization actions they require.  This is
288
  /// primarily because an ImmutablePass can "require" another ImmutablePass,
289
  /// and if it does, the overloaded version of initializePass may get access to
290
  /// these passes with getAnalysis<>.
291
  virtual void initializePass();
292
 
293
  ImmutablePass *getAsImmutablePass() override { return this; }
294
 
295
  /// ImmutablePasses are never run.
296
  bool runOnModule(Module &) override { return false; }
297
};
298
 
299
//===----------------------------------------------------------------------===//
300
/// FunctionPass class - This class is used to implement most global
301
/// optimizations.  Optimizations should subclass this class if they meet the
302
/// following constraints:
303
///
304
///  1. Optimizations are organized globally, i.e., a function at a time
305
///  2. Optimizing a function does not cause the addition or removal of any
306
///     functions in the module
307
///
308
class FunctionPass : public Pass {
309
public:
310
  explicit FunctionPass(char &pid) : Pass(PT_Function, pid) {}
311
 
312
  /// createPrinterPass - Get a function printer pass.
313
  Pass *createPrinterPass(raw_ostream &OS,
314
                          const std::string &Banner) const override;
315
 
316
  /// runOnFunction - Virtual method overriden by subclasses to do the
317
  /// per-function processing of the pass.
318
  virtual bool runOnFunction(Function &F) = 0;
319
 
320
  void assignPassManager(PMStack &PMS, PassManagerType T) override;
321
 
322
  ///  Return what kind of Pass Manager can manage this pass.
323
  PassManagerType getPotentialPassManagerType() const override;
324
 
325
protected:
326
  /// Optional passes call this function to check whether the pass should be
327
  /// skipped. This is the case when Attribute::OptimizeNone is set or when
328
  /// optimization bisect is over the limit.
329
  bool skipFunction(const Function &F) const;
330
};
331
 
332
/// If the user specifies the -time-passes argument on an LLVM tool command line
333
/// then the value of this boolean will be true, otherwise false.
334
/// This is the storage for the -time-passes option.
335
extern bool TimePassesIsEnabled;
336
/// If TimePassesPerRun is true, there would be one line of report for
337
/// each pass invocation.
338
/// If TimePassesPerRun is false, there would be only one line of
339
/// report for each pass (even there are more than one pass objects).
340
/// (For new pass manager only)
341
extern bool TimePassesPerRun;
342
 
343
} // end namespace llvm
344
 
345
// Include support files that contain important APIs commonly used by Passes,
346
// but that we want to separate out to make it easier to read the header files.
347
#include "llvm/PassAnalysisSupport.h"
348
#include "llvm/PassSupport.h"
349
 
350
#endif // LLVM_PASS_H