1//===- llvm/CodeGen/MachineRegionInfo.h -------------------------*- 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#ifndef LLVM_CODEGEN_MACHINEREGIONINFO_H
10#define LLVM_CODEGEN_MACHINEREGIONINFO_H
11
12#include "llvm/ADT/DepthFirstIterator.h"
13#include "llvm/Analysis/RegionInfo.h"
14#include "llvm/Analysis/RegionIterator.h"
15#include "llvm/CodeGen/MachineBasicBlock.h"
16#include "llvm/CodeGen/MachineDominanceFrontier.h"
17#include "llvm/CodeGen/MachineDominators.h"
18#include "llvm/CodeGen/MachineFunction.h"
19#include "llvm/CodeGen/MachineFunctionPass.h"
20#include "llvm/CodeGen/MachineLoopInfo.h"
21#include <cassert>
22
23namespace llvm {
24
25class MachinePostDominatorTree;
26class MachineRegion;
27class MachineRegionNode;
28class MachineRegionInfo;
29
30template <> struct RegionTraits<MachineFunction> {
31 using FuncT = MachineFunction;
32 using BlockT = MachineBasicBlock;
33 using RegionT = MachineRegion;
34 using RegionNodeT = MachineRegionNode;
35 using RegionInfoT = MachineRegionInfo;
36 using DomTreeT = MachineDominatorTree;
37 using DomTreeNodeT = MachineDomTreeNode;
38 using PostDomTreeT = MachinePostDominatorTree;
39 using DomFrontierT = MachineDominanceFrontier;
40 using InstT = MachineInstr;
41 using LoopT = MachineLoop;
42 using LoopInfoT = MachineLoopInfo;
43
44 static unsigned getNumSuccessors(MachineBasicBlock *BB) {
45 return BB->succ_size();
46 }
47};
48
49class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
50public:
51 inline MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry,
52 bool isSubRegion = false)
53 : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry,
54 isSubRegion) {}
55
56 bool operator==(const MachineRegion &RN) const {
57 return this == reinterpret_cast<const MachineRegionNode *>(&RN);
58 }
59};
60
61class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
62public:
63 MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
64 MachineRegionInfo *RI, MachineDominatorTree *DT,
65 MachineRegion *Parent = nullptr);
66 ~MachineRegion();
67
68 bool operator==(const MachineRegionNode &RN) const {
69 return &RN == reinterpret_cast<const MachineRegionNode *>(this);
70 }
71};
72
73class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
74public:
75 explicit MachineRegionInfo();
76 ~MachineRegionInfo() override;
77
78 // updateStatistics - Update statistic about created regions.
79 void updateStatistics(MachineRegion *R) final;
80
81 void recalculate(MachineFunction &F, MachineDominatorTree *DT,
82 MachinePostDominatorTree *PDT, MachineDominanceFrontier *DF);
83};
84
85class MachineRegionInfoPass : public MachineFunctionPass {
86 MachineRegionInfo RI;
87
88public:
89 static char ID;
90
91 explicit MachineRegionInfoPass();
92 ~MachineRegionInfoPass() override;
93
94 MachineRegionInfo &getRegionInfo() { return RI; }
95
96 const MachineRegionInfo &getRegionInfo() const { return RI; }
97
98 /// @name MachineFunctionPass interface
99 //@{
100 bool runOnMachineFunction(MachineFunction &F) override;
101 void releaseMemory() override;
102 void verifyAnalysis() const override;
103 void getAnalysisUsage(AnalysisUsage &AU) const override;
104 void print(raw_ostream &OS, const Module *) const override;
105 void dump() const;
106 //@}
107};
108
109template <>
110template <>
111inline MachineBasicBlock *
112RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>()
113 const {
114 assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
115 return getEntry();
116}
117
118template <>
119template <>
120inline MachineRegion *
121RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>()
122 const {
123 assert(isSubRegion() && "This is not a subregion RegionNode!");
124 auto Unconst =
125 const_cast<RegionNodeBase<RegionTraits<MachineFunction>> *>(this);
126 return reinterpret_cast<MachineRegion *>(Unconst);
127}
128
129RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion);
130RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock,
131 MachineRegion);
132
133RegionGraphTraits(MachineRegion, MachineRegionNode);
134RegionGraphTraits(const MachineRegion, const MachineRegionNode);
135
136template <>
137struct GraphTraits<MachineRegionInfo *>
138 : public GraphTraits<FlatIt<MachineRegionNode *>> {
139 using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
140 false, GraphTraits<FlatIt<NodeRef>>>;
141
142 static NodeRef getEntryNode(MachineRegionInfo *RI) {
143 return GraphTraits<FlatIt<MachineRegion *>>::getEntryNode(
144 R: RI->getTopLevelRegion());
145 }
146
147 static nodes_iterator nodes_begin(MachineRegionInfo *RI) {
148 return nodes_iterator::begin(G: getEntryNode(RI));
149 }
150
151 static nodes_iterator nodes_end(MachineRegionInfo *RI) {
152 return nodes_iterator::end(G: getEntryNode(RI));
153 }
154};
155
156template <>
157struct GraphTraits<MachineRegionInfoPass *>
158 : public GraphTraits<MachineRegionInfo *> {
159 using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
160 false, GraphTraits<FlatIt<NodeRef>>>;
161
162 static NodeRef getEntryNode(MachineRegionInfoPass *RI) {
163 return GraphTraits<MachineRegionInfo *>::getEntryNode(RI: &RI->getRegionInfo());
164 }
165
166 static nodes_iterator nodes_begin(MachineRegionInfoPass *RI) {
167 return GraphTraits<MachineRegionInfo *>::nodes_begin(RI: &RI->getRegionInfo());
168 }
169
170 static nodes_iterator nodes_end(MachineRegionInfoPass *RI) {
171 return GraphTraits<MachineRegionInfo *>::nodes_end(RI: &RI->getRegionInfo());
172 }
173};
174
175extern template class RegionBase<RegionTraits<MachineFunction>>;
176extern template class RegionNodeBase<RegionTraits<MachineFunction>>;
177extern template class RegionInfoBase<RegionTraits<MachineFunction>>;
178
179} // end namespace llvm
180
181#endif // LLVM_CODEGEN_MACHINEREGIONINFO_H
182

source code of llvm/include/llvm/CodeGen/MachineRegionInfo.h