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 ~MachineRegionNode() { } 61 62 bool operator==(const MachineRegion &RN) const { 63 return this == reinterpret_cast<const MachineRegionNode*>(&RN); 64 } 65 }; 66 67 class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> { 68 public: 69 MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit, 70 MachineRegionInfo* RI, 71 MachineDominatorTree *DT, MachineRegion *Parent = nullptr); 72 ~MachineRegion(); 73 74 bool operator==(const MachineRegionNode &RN) const { 75 return &RN == reinterpret_cast<const MachineRegionNode*>(this); 76 } 77 }; 78 79 class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> { 80 public: 81 explicit MachineRegionInfo(); 82 83 virtual ~MachineRegionInfo(); 84 85 // updateStatistics - Update statistic about created regions. 86 void updateStatistics(MachineRegion *R) final; 87 88 void recalculate(MachineFunction &F, 89 MachineDominatorTree *DT, 90 MachinePostDominatorTree *PDT, 91 MachineDominanceFrontier *DF); 92 }; 93 94 class MachineRegionInfoPass : public MachineFunctionPass { 95 MachineRegionInfo RI; 96 97 public: 98 static char ID; 99 explicit MachineRegionInfoPass(); 100 101 ~MachineRegionInfoPass(); 102 103 MachineRegionInfo &getRegionInfo() { 104 return RI; 105 } 106 107 const MachineRegionInfo &getRegionInfo() const { 108 return RI; 109 } 110 111 /// @name MachineFunctionPass interface 112 //@{ 113 bool runOnMachineFunction(MachineFunction &F) override; 114 void releaseMemory() override; 115 void verifyAnalysis() const override; 116 void getAnalysisUsage(AnalysisUsage &AU) const override; 117 void print(raw_ostream &OS, const Module *) const override; 118 void dump() const; 119 //@} 120 }; 121 122 123 template <> 124 template <> 125 inline MachineBasicBlock* RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>() const { 126 assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!"); 127 return getEntry(); 128 } 129 130 template<> 131 template<> 132 inline MachineRegion* RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>() const { 133 assert(isSubRegion() && "This is not a subregion RegionNode!"); 134 auto Unconst = const_cast<RegionNodeBase<RegionTraits<MachineFunction>>*>(this); 135 return reinterpret_cast<MachineRegion*>(Unconst); 136 } 137 138 139 RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion); 140 RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock, MachineRegion); 141 142 RegionGraphTraits(MachineRegion, MachineRegionNode); 143 RegionGraphTraits(const MachineRegion, const MachineRegionNode); 144 145 template <> struct GraphTraits<MachineRegionInfo*> 146 : public GraphTraits<FlatIt<MachineRegionNode*> > { 147 typedef df_iterator<NodeType*, SmallPtrSet<NodeType*, 8>, false, 148 GraphTraits<FlatIt<NodeType*> > > nodes_iterator; 149 150 static NodeType *getEntryNode(MachineRegionInfo *RI) { 151 return GraphTraits<FlatIt<MachineRegion*> >::getEntryNode(RI->getTopLevelRegion()); 152 } 153 static nodes_iterator nodes_begin(MachineRegionInfo* RI) { 154 return nodes_iterator::begin(getEntryNode(RI)); 155 } 156 static nodes_iterator nodes_end(MachineRegionInfo *RI) { 157 return nodes_iterator::end(getEntryNode(RI)); 158 } 159 }; 160 161 template <> struct GraphTraits<MachineRegionInfoPass*> 162 : public GraphTraits<MachineRegionInfo *> { 163 typedef df_iterator<NodeType*, SmallPtrSet<NodeType*, 8>, false, 164 GraphTraits<FlatIt<NodeType*> > > nodes_iterator; 165 166 static NodeType *getEntryNode(MachineRegionInfoPass *RI) { 167 return GraphTraits<MachineRegionInfo*>::getEntryNode(&RI->getRegionInfo()); 168 } 169 static nodes_iterator nodes_begin(MachineRegionInfoPass* RI) { 170 return GraphTraits<MachineRegionInfo*>::nodes_begin(&RI->getRegionInfo()); 171 } 172 static nodes_iterator nodes_end(MachineRegionInfoPass *RI) { 173 return GraphTraits<MachineRegionInfo*>::nodes_end(&RI->getRegionInfo()); 174 } 175 }; 176 177 EXTERN_TEMPLATE_INSTANTIATION(class RegionBase<RegionTraits<MachineFunction>>); 178 EXTERN_TEMPLATE_INSTANTIATION(class RegionNodeBase<RegionTraits<MachineFunction>>); 179 EXTERN_TEMPLATE_INSTANTIATION(class RegionInfoBase<RegionTraits<MachineFunction>>); 180 181 } 182 183 #endif 184