1 //===- llvm/CodeGen/MachineRegionInfo.h -------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_CODEGEN_MACHINEREGIONINFO_H
11 #define LLVM_CODEGEN_MACHINEREGIONINFO_H
13 #include "llvm/ADT/DepthFirstIterator.h"
14 #include "llvm/Analysis/RegionInfo.h"
15 #include "llvm/Analysis/RegionIterator.h"
16 #include "llvm/CodeGen/MachineBasicBlock.h"
17 #include "llvm/CodeGen/MachineDominanceFrontier.h"
18 #include "llvm/CodeGen/MachineDominators.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineFunctionPass.h"
21 #include "llvm/CodeGen/MachineLoopInfo.h"
26 struct MachinePostDominatorTree;
28 class MachineRegionNode;
29 class MachineRegionInfo;
31 template <> struct RegionTraits<MachineFunction> {
32 using FuncT = MachineFunction;
33 using BlockT = MachineBasicBlock;
34 using RegionT = MachineRegion;
35 using RegionNodeT = MachineRegionNode;
36 using RegionInfoT = MachineRegionInfo;
37 using DomTreeT = MachineDominatorTree;
38 using DomTreeNodeT = MachineDomTreeNode;
39 using PostDomTreeT = MachinePostDominatorTree;
40 using DomFrontierT = MachineDominanceFrontier;
41 using InstT = MachineInstr;
42 using LoopT = MachineLoop;
43 using LoopInfoT = MachineLoopInfo;
45 static unsigned getNumSuccessors(MachineBasicBlock *BB) {
46 return BB->succ_size();
50 class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
52 inline MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry,
53 bool isSubRegion = false)
54 : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry,
57 bool operator==(const MachineRegion &RN) const {
58 return this == reinterpret_cast<const MachineRegionNode *>(&RN);
62 class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
64 MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
65 MachineRegionInfo *RI, MachineDominatorTree *DT,
66 MachineRegion *Parent = nullptr);
69 bool operator==(const MachineRegionNode &RN) const {
70 return &RN == reinterpret_cast<const MachineRegionNode *>(this);
74 class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
76 explicit MachineRegionInfo();
77 ~MachineRegionInfo() override;
79 // updateStatistics - Update statistic about created regions.
80 void updateStatistics(MachineRegion *R) final;
82 void recalculate(MachineFunction &F, MachineDominatorTree *DT,
83 MachinePostDominatorTree *PDT, MachineDominanceFrontier *DF);
86 class MachineRegionInfoPass : public MachineFunctionPass {
92 explicit MachineRegionInfoPass();
93 ~MachineRegionInfoPass() override;
95 MachineRegionInfo &getRegionInfo() { return RI; }
97 const MachineRegionInfo &getRegionInfo() const { return RI; }
99 /// @name MachineFunctionPass interface
101 bool runOnMachineFunction(MachineFunction &F) override;
102 void releaseMemory() override;
103 void verifyAnalysis() const override;
104 void getAnalysisUsage(AnalysisUsage &AU) const override;
105 void print(raw_ostream &OS, const Module *) const override;
112 inline MachineBasicBlock *
113 RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>()
115 assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
121 inline MachineRegion *
122 RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>()
124 assert(isSubRegion() && "This is not a subregion RegionNode!");
126 const_cast<RegionNodeBase<RegionTraits<MachineFunction>> *>(this);
127 return reinterpret_cast<MachineRegion *>(Unconst);
130 RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion);
131 RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock,
134 RegionGraphTraits(MachineRegion, MachineRegionNode);
135 RegionGraphTraits(const MachineRegion, const MachineRegionNode);
138 struct GraphTraits<MachineRegionInfo *>
139 : public GraphTraits<FlatIt<MachineRegionNode *>> {
140 using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
141 false, GraphTraits<FlatIt<NodeRef>>>;
143 static NodeRef getEntryNode(MachineRegionInfo *RI) {
144 return GraphTraits<FlatIt<MachineRegion *>>::getEntryNode(
145 RI->getTopLevelRegion());
148 static nodes_iterator nodes_begin(MachineRegionInfo *RI) {
149 return nodes_iterator::begin(getEntryNode(RI));
152 static nodes_iterator nodes_end(MachineRegionInfo *RI) {
153 return nodes_iterator::end(getEntryNode(RI));
158 struct GraphTraits<MachineRegionInfoPass *>
159 : public GraphTraits<MachineRegionInfo *> {
160 using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
161 false, GraphTraits<FlatIt<NodeRef>>>;
163 static NodeRef getEntryNode(MachineRegionInfoPass *RI) {
164 return GraphTraits<MachineRegionInfo *>::getEntryNode(&RI->getRegionInfo());
167 static nodes_iterator nodes_begin(MachineRegionInfoPass *RI) {
168 return GraphTraits<MachineRegionInfo *>::nodes_begin(&RI->getRegionInfo());
171 static nodes_iterator nodes_end(MachineRegionInfoPass *RI) {
172 return GraphTraits<MachineRegionInfo *>::nodes_end(&RI->getRegionInfo());
176 extern template class RegionBase<RegionTraits<MachineFunction>>;
177 extern template class RegionNodeBase<RegionTraits<MachineFunction>>;
178 extern template class RegionInfoBase<RegionTraits<MachineFunction>>;
180 } // end namespace llvm
182 #endif // LLVM_CODEGEN_MACHINEREGIONINFO_H