Line data Source code
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 :
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"
22 : #include <cassert>
23 :
24 : namespace llvm {
25 :
26 : struct MachinePostDominatorTree;
27 : class MachineRegion;
28 : class MachineRegionNode;
29 : class MachineRegionInfo;
30 :
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;
44 :
45 : static unsigned getNumSuccessors(MachineBasicBlock *BB) {
46 : return BB->succ_size();
47 : }
48 : };
49 :
50 : class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
51 : public:
52 : inline MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry,
53 : bool isSubRegion = false)
54 : : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry,
55 : isSubRegion) {}
56 :
57 : bool operator==(const MachineRegion &RN) const {
58 : return this == reinterpret_cast<const MachineRegionNode *>(&RN);
59 : }
60 : };
61 :
62 0 : class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
63 : public:
64 : MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
65 : MachineRegionInfo *RI, MachineDominatorTree *DT,
66 : MachineRegion *Parent = nullptr);
67 : ~MachineRegion();
68 :
69 : bool operator==(const MachineRegionNode &RN) const {
70 : return &RN == reinterpret_cast<const MachineRegionNode *>(this);
71 : }
72 : };
73 :
74 0 : class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
75 : public:
76 : explicit MachineRegionInfo();
77 : ~MachineRegionInfo() override;
78 :
79 : // updateStatistics - Update statistic about created regions.
80 : void updateStatistics(MachineRegion *R) final;
81 :
82 : void recalculate(MachineFunction &F, MachineDominatorTree *DT,
83 : MachinePostDominatorTree *PDT, MachineDominanceFrontier *DF);
84 : };
85 :
86 0 : class MachineRegionInfoPass : public MachineFunctionPass {
87 : MachineRegionInfo RI;
88 :
89 : public:
90 : static char ID;
91 :
92 : explicit MachineRegionInfoPass();
93 : ~MachineRegionInfoPass() override;
94 :
95 0 : MachineRegionInfo &getRegionInfo() { return RI; }
96 :
97 : const MachineRegionInfo &getRegionInfo() const { return RI; }
98 :
99 : /// @name MachineFunctionPass interface
100 : //@{
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;
106 : void dump() const;
107 : //@}
108 : };
109 :
110 : template <>
111 : template <>
112 : inline MachineBasicBlock *
113 : RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>()
114 : const {
115 : assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
116 : return getEntry();
117 : }
118 :
119 : template <>
120 : template <>
121 : inline MachineRegion *
122 : RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>()
123 : const {
124 : assert(isSubRegion() && "This is not a subregion RegionNode!");
125 : auto Unconst =
126 : const_cast<RegionNodeBase<RegionTraits<MachineFunction>> *>(this);
127 : return reinterpret_cast<MachineRegion *>(Unconst);
128 : }
129 :
130 0 : RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion);
131 0 : RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock,
132 : MachineRegion);
133 :
134 0 : RegionGraphTraits(MachineRegion, MachineRegionNode);
135 0 : RegionGraphTraits(const MachineRegion, const MachineRegionNode);
136 :
137 : template <>
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>>>;
142 :
143 : static NodeRef getEntryNode(MachineRegionInfo *RI) {
144 : return GraphTraits<FlatIt<MachineRegion *>>::getEntryNode(
145 : RI->getTopLevelRegion());
146 : }
147 :
148 : static nodes_iterator nodes_begin(MachineRegionInfo *RI) {
149 : return nodes_iterator::begin(getEntryNode(RI));
150 : }
151 :
152 : static nodes_iterator nodes_end(MachineRegionInfo *RI) {
153 : return nodes_iterator::end(getEntryNode(RI));
154 : }
155 : };
156 :
157 : template <>
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>>>;
162 :
163 : static NodeRef getEntryNode(MachineRegionInfoPass *RI) {
164 : return GraphTraits<MachineRegionInfo *>::getEntryNode(&RI->getRegionInfo());
165 : }
166 :
167 : static nodes_iterator nodes_begin(MachineRegionInfoPass *RI) {
168 : return GraphTraits<MachineRegionInfo *>::nodes_begin(&RI->getRegionInfo());
169 : }
170 :
171 : static nodes_iterator nodes_end(MachineRegionInfoPass *RI) {
172 : return GraphTraits<MachineRegionInfo *>::nodes_end(&RI->getRegionInfo());
173 : }
174 : };
175 :
176 : extern template class RegionBase<RegionTraits<MachineFunction>>;
177 : extern template class RegionNodeBase<RegionTraits<MachineFunction>>;
178 : extern template class RegionInfoBase<RegionTraits<MachineFunction>>;
179 :
180 : } // end namespace llvm
181 :
182 : #endif // LLVM_CODEGEN_MACHINEREGIONINFO_H
|
