LLVM  4.0.0
MachineRegionInfo.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/MachineRegionInfo.h -------------------------*- 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 #ifndef LLVM_CODEGEN_MACHINEREGIONINFO_H
11 #define LLVM_CODEGEN_MACHINEREGIONINFO_H
12 
20 
21 
22 namespace llvm {
23 
24 class MachineDominatorTree;
25 struct MachinePostDominatorTree;
26 class MachineRegion;
27 class MachineRegionNode;
28 class MachineRegionInfo;
29 
30 template<>
42  typedef MachineLoop LoopT;
44 
45  static unsigned getNumSuccessors(MachineBasicBlock *BB) {
46  return BB->succ_size();
47  }
48 };
49 
50 
51 class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
52 public:
54  MachineBasicBlock *Entry,
55  bool isSubRegion = false)
57 
58  }
59 
60  bool operator==(const MachineRegion &RN) const {
61  return this == reinterpret_cast<const MachineRegionNode*>(&RN);
62  }
63 };
64 
65 class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
66 public:
69  MachineDominatorTree *DT, MachineRegion *Parent = nullptr);
71 
72  bool operator==(const MachineRegionNode &RN) const {
73  return &RN == reinterpret_cast<const MachineRegionNode*>(this);
74  }
75 };
76 
77 class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
78 public:
79  explicit MachineRegionInfo();
80 
81  ~MachineRegionInfo() override;
82 
83  // updateStatistics - Update statistic about created regions.
84  void updateStatistics(MachineRegion *R) final;
85 
90 };
91 
94 
95 public:
96  static char ID;
97  explicit MachineRegionInfoPass();
98 
99  ~MachineRegionInfoPass() override;
100 
102  return RI;
103  }
104 
106  return RI;
107  }
108 
109  /// @name MachineFunctionPass interface
110  //@{
111  bool runOnMachineFunction(MachineFunction &F) override;
112  void releaseMemory() override;
113  void verifyAnalysis() const override;
114  void getAnalysisUsage(AnalysisUsage &AU) const override;
115  void print(raw_ostream &OS, const Module *) const override;
116  void dump() const;
117  //@}
118 };
119 
120 
121 template <>
122 template <>
123 inline MachineBasicBlock* RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>() const {
124  assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
125  return getEntry();
126 }
127 
128 template<>
129 template<>
130 inline MachineRegion* RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>() const {
131  assert(isSubRegion() && "This is not a subregion RegionNode!");
132  auto Unconst = const_cast<RegionNodeBase<RegionTraits<MachineFunction>>*>(this);
133  return reinterpret_cast<MachineRegion*>(Unconst);
134 }
135 
136 
139 
142 
143 template <> struct GraphTraits<MachineRegionInfo*>
148 
150  return GraphTraits<FlatIt<MachineRegion*> >::getEntryNode(RI->getTopLevelRegion());
151  }
153  return nodes_iterator::begin(getEntryNode(RI));
154  }
156  return nodes_iterator::end(getEntryNode(RI));
157  }
158 };
159 
160 template <> struct GraphTraits<MachineRegionInfoPass*>
165 
168  }
171  }
174  }
175 };
176 
177 extern template class RegionBase<RegionTraits<MachineFunction>>;
178 extern template class RegionNodeBase<RegionTraits<MachineFunction>>;
179 extern template class RegionInfoBase<RegionTraits<MachineFunction>>;
180 }
181 
182 #endif
unsigned succ_size() const
MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit, MachineRegionInfo *RI, MachineDominatorTree *DT, MachineRegion *Parent=nullptr)
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:241
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
const_iterator begin(StringRef path)
Get begin iterator over path.
Definition: Path.cpp:233
bool isSubRegion() const
Is this RegionNode a subregion?
Definition: RegionInfo.h:183
RegionT * getTopLevelRegion() const
Definition: RegionInfo.h:838
bool operator==(const MachineRegionNode &RN) const
Analysis that detects all canonical Regions.
Definition: RegionInfo.h:77
static NodeRef getEntryNode(MachineRegionInfoPass *RI)
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
bool runOnMachineFunction(MachineFunction &F) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
A RegionNode represents a subregion or a BasicBlock that is part of a Region.
Definition: RegionInfo.h:112
static nodes_iterator nodes_end(MachineRegionInfoPass *RI)
MachineDominanceFrontier DomFrontierT
#define F(x, y, z)
Definition: MD5.cpp:51
static nodes_iterator nodes_begin(MachineRegionInfoPass *RI)
void updateStatistics(MachineRegion *R) final
MachinePostDominatorTree PostDomTreeT
df_iterator< NodeRef, df_iterator_default_set< NodeRef >, false, GraphTraits< FlatIt< NodeRef > > > nodes_iterator
Base class for the actual dominator tree node.
RegionNodeGraphTraits(RegionNode, BasicBlock, Region)
df_iterator< NodeRef, df_iterator_default_set< NodeRef >, false, GraphTraits< FlatIt< NodeRef > > > nodes_iterator
FlatIt< MachineRegionNode * >::UnknownGraphTypeError NodeRef
Definition: GraphTraits.h:61
Represent the analysis usage information of a pass.
void print(raw_ostream &OS, const Module *) const override
print - Print out the internal state of the pass.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
bool operator==(const MachineRegion &RN) const
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
static nodes_iterator nodes_begin(MachineRegionInfo *RI)
MachineRegionInfo & getRegionInfo()
RegionGraphTraits(Region, RegionNode)
A single entry single exit Region.
Definition: RegionInfo.h:73
static unsigned getNumSuccessors(MachineBasicBlock *BB)
static NodeRef getEntryNode(MachineRegionInfo *RI)
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
Representation of each machine instruction.
Definition: MachineInstr.h:52
void recalculate(MachineFunction &F, MachineDominatorTree *DT, MachinePostDominatorTree *PDT, MachineDominanceFrontier *DF)
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static nodes_iterator nodes_end(MachineRegionInfo *RI)
const MachineRegionInfo & getRegionInfo() const
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry, bool isSubRegion=false)