LLVM  8.0.0svn
RegionPass.h
Go to the documentation of this file.
1 //===- RegionPass.h - RegionPass class --------------------------*- C++ -*-===//
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 the RegionPass class. All region based analysis,
11 // optimization and transformation passes are derived from RegionPass.
12 // This class is implemented following the some ideas of the LoopPass.h class.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_ANALYSIS_REGIONPASS_H
17 #define LLVM_ANALYSIS_REGIONPASS_H
18 
20 #include "llvm/IR/Function.h"
22 #include "llvm/Pass.h"
23 #include <deque>
24 
25 namespace llvm {
26 
27 class RGPassManager;
28 class Function;
29 
30 //===----------------------------------------------------------------------===//
31 /// A pass that runs on each Region in a function.
32 ///
33 /// RegionPass is managed by RGPassManager.
34 class RegionPass : public Pass {
35 public:
36  explicit RegionPass(char &pid) : Pass(PT_Region, pid) {}
37 
38  //===--------------------------------------------------------------------===//
39  /// @name To be implemented by every RegionPass
40  ///
41  //@{
42  /// Run the pass on a specific Region
43  ///
44  /// Accessing regions not contained in the current region is not allowed.
45  ///
46  /// @param R The region this pass is run on.
47  /// @param RGM The RegionPassManager that manages this Pass.
48  ///
49  /// @return True if the pass modifies this Region.
50  virtual bool runOnRegion(Region *R, RGPassManager &RGM) = 0;
51 
52  /// Get a pass to print the LLVM IR in the region.
53  ///
54  /// @param O The output stream to print the Region.
55  /// @param Banner The banner to separate different printed passes.
56  ///
57  /// @return The pass to print the LLVM IR in the region.
59  const std::string &Banner) const override;
60 
63 
64  virtual bool doInitialization(Region *R, RGPassManager &RGM) { return false; }
65  virtual bool doFinalization() { return false; }
66  //@}
67 
68  //===--------------------------------------------------------------------===//
69  /// @name PassManager API
70  ///
71  //@{
72  void preparePassManager(PMStack &PMS) override;
73 
74  void assignPassManager(PMStack &PMS,
75  PassManagerType PMT = PMT_RegionPassManager) override;
76 
78  return PMT_RegionPassManager;
79  }
80  //@}
81 
82 protected:
83  /// Optional passes call this function to check whether the pass should be
84  /// skipped. This is the case when optimization bisect is over the limit.
85  bool skipRegion(Region &R) const;
86 };
87 
88 /// The pass manager to schedule RegionPasses.
89 class RGPassManager : public FunctionPass, public PMDataManager {
90  std::deque<Region*> RQ;
91  bool skipThisRegion;
92  bool redoThisRegion;
93  RegionInfo *RI;
94  Region *CurrentRegion;
95 
96 public:
97  static char ID;
98  explicit RGPassManager();
99 
100  /// Execute all of the passes scheduled for execution.
101  ///
102  /// @return True if any of the passes modifies the function.
103  bool runOnFunction(Function &F) override;
104 
105  /// Pass Manager itself does not invalidate any analysis info.
106  /// RGPassManager needs RegionInfo.
107  void getAnalysisUsage(AnalysisUsage &Info) const override;
108 
109  StringRef getPassName() const override { return "Region Pass Manager"; }
110 
111  PMDataManager *getAsPMDataManager() override { return this; }
112  Pass *getAsPass() override { return this; }
113 
114  /// Print passes managed by this manager.
115  void dumpPassStructure(unsigned Offset) override;
116 
117  /// Get passes contained by this manager.
118  Pass *getContainedPass(unsigned N) {
119  assert(N < PassVector.size() && "Pass number out of range!");
120  Pass *FP = static_cast<Pass *>(PassVector[N]);
121  return FP;
122  }
123 
125  return PMT_RegionPassManager;
126  }
127 };
128 
129 } // End llvm namespace
130 
131 #endif
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
PassManagerType getPassManagerType() const override
Definition: RegionPass.h:124
PassManagerType
Different types of internal pass managers.
Definition: Pass.h:54
This class represents lattice values for constants.
Definition: AllocatorList.h:24
virtual void dumpPassStructure(unsigned Offset=0)
Definition: Pass.cpp:68
Pass * createPrinterPass(raw_ostream &O, const std::string &Banner) const override
Get a pass to print the LLVM IR in the region.
Definition: RegionPass.cpp:277
bool skipRegion(Region &R) const
Optional passes call this function to check whether the pass should be skipped.
Definition: RegionPass.cpp:282
F(f)
The pass manager to schedule RegionPasses.
Definition: RegionPass.h:89
virtual bool doInitialization(Region *R, RGPassManager &RGM)
Definition: RegionPass.h:64
virtual bool doFinalization(Module &)
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Definition: Pass.h:110
static char ID
Definition: RegionPass.h:97
PMStack - This class implements a stack data structure of PMDataManager pointers. ...
PMDataManager * getAsPMDataManager() override
Definition: RegionPass.h:111
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:92
virtual bool doFinalization()
Definition: RegionPass.h:65
virtual bool doInitialization(Module &)
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
Definition: Pass.h:106
static bool runOnFunction(Function &F, bool PostInlining)
void assignPassManager(PMStack &PMS, PassManagerType PMT=PMT_RegionPassManager) override
Assign pass manager to manage this pass.
Definition: RegionPass.cpp:240
void preparePassManager(PMStack &PMS) override
Check if available pass managers are suitable for this pass or not.
Definition: RegionPass.cpp:223
A pass that runs on each Region in a function.
Definition: RegionPass.h:34
Pass * getAsPass() override
Definition: RegionPass.h:112
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
Pass * getContainedPass(unsigned N)
Get passes contained by this manager.
Definition: RegionPass.h:118
PassManagerType getPotentialPassManagerType() const override
Return what kind of Pass Manager can manage this pass.
Definition: RegionPass.h:77
#define N
RGPassManager.
Definition: Pass.h:60
virtual bool runOnRegion(Region *R, RGPassManager &RGM)=0
Run the pass on a specific Region.
PMDataManager provides the common place to manage the analysis data used by pass managers.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
RegionPass(char &pid)
Definition: RegionPass.h:36
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: RegionPass.h:109