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/Analysis/RegionInfo.h" 14 #include "llvm/Analysis/RegionIterator.h" 15 #include "llvm/CodeGen/MachineDominanceFrontier.h" 16 #include "llvm/CodeGen/MachineDominators.h" 17 #include "llvm/CodeGen/MachineFunction.h" 18 #include "llvm/CodeGen/MachineFunctionPass.h" 19 #include "llvm/CodeGen/MachineLoopInfo.h" 20 21 22 namespace llvm { 23 24 class MachineDominatorTree; 25 struct MachinePostDominatorTree; 26 class MachineRegion; 27 class MachineRegionNode; 28 class MachineRegionInfo; 29 30 template<> 31 struct RegionTraits<MachineFunction> { 32 typedef MachineFunction FuncT; 33 typedef MachineBasicBlock BlockT; 34 typedef MachineRegion RegionT; 35 typedef MachineRegionNode RegionNodeT; 36 typedef MachineRegionInfo RegionInfoT; 37 typedef MachineDominatorTree DomTreeT; 38 typedef MachineDomTreeNode DomTreeNodeT; 39 typedef MachinePostDominatorTree PostDomTreeT; 40 typedef MachineDominanceFrontier DomFrontierT; 41 typedef MachineInstr InstT; 42 typedef MachineLoop LoopT; 43 typedef MachineLoopInfo LoopInfoT; 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: 53 inline MachineRegionNode(MachineRegion *Parent, 54 MachineBasicBlock *Entry, 55 bool isSubRegion = false) 56 : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry, isSubRegion) { 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: 67 MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit, 68 MachineRegionInfo* RI, 69 MachineDominatorTree *DT, MachineRegion *Parent = nullptr); 70 ~MachineRegion(); 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 86 void recalculate(MachineFunction &F, 87 MachineDominatorTree *DT, 88 MachinePostDominatorTree *PDT, 89 MachineDominanceFrontier *DF); 90 }; 91 92 class MachineRegionInfoPass : public MachineFunctionPass { 93 MachineRegionInfo RI; 94 95 public: 96 static char ID; 97 explicit MachineRegionInfoPass(); 98 99 ~MachineRegionInfoPass() override; 100 101 MachineRegionInfo &getRegionInfo() { 102 return RI; 103 } 104 105 const MachineRegionInfo &getRegionInfo() const { 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 137 RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion); 138 RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock, MachineRegion); 139 140 RegionGraphTraits(MachineRegion, MachineRegionNode); 141 RegionGraphTraits(const MachineRegion, const MachineRegionNode); 142 143 template <> struct GraphTraits<MachineRegionInfo*> 144 : public GraphTraits<FlatIt<MachineRegionNode*> > { 145 typedef df_iterator<NodeType*, SmallPtrSet<NodeType*, 8>, false, 146 GraphTraits<FlatIt<NodeType*> > > nodes_iterator; 147 148 static NodeType *getEntryNode(MachineRegionInfo *RI) { 149 return GraphTraits<FlatIt<MachineRegion*> >::getEntryNode(RI->getTopLevelRegion()); 150 } 151 static nodes_iterator nodes_begin(MachineRegionInfo* RI) { 152 return nodes_iterator::begin(getEntryNode(RI)); 153 } 154 static nodes_iterator nodes_end(MachineRegionInfo *RI) { 155 return nodes_iterator::end(getEntryNode(RI)); 156 } 157 }; 158 159 template <> struct GraphTraits<MachineRegionInfoPass*> 160 : public GraphTraits<MachineRegionInfo *> { 161 typedef df_iterator<NodeType*, SmallPtrSet<NodeType*, 8>, false, 162 GraphTraits<FlatIt<NodeType*> > > nodes_iterator; 163 164 static NodeType *getEntryNode(MachineRegionInfoPass *RI) { 165 return GraphTraits<MachineRegionInfo*>::getEntryNode(&RI->getRegionInfo()); 166 } 167 static nodes_iterator nodes_begin(MachineRegionInfoPass* RI) { 168 return GraphTraits<MachineRegionInfo*>::nodes_begin(&RI->getRegionInfo()); 169 } 170 static nodes_iterator nodes_end(MachineRegionInfoPass *RI) { 171 return GraphTraits<MachineRegionInfo*>::nodes_end(&RI->getRegionInfo()); 172 } 173 }; 174 175 extern template class RegionBase<RegionTraits<MachineFunction>>; 176 extern template class RegionNodeBase<RegionTraits<MachineFunction>>; 177 extern template class RegionInfoBase<RegionTraits<MachineFunction>>; 178 } 179 180 #endif 181