include/llvm/CodeGen/MachineRegionInfo.h

   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