contrib/llvm/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/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 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 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 class MachineRegionInfoPass : public MachineFunctionPass {
  87   MachineRegionInfo RI;
  88
  89 public:
  90   static char ID;
  91
  92   explicit MachineRegionInfoPass();
  93   ~MachineRegionInfoPass() override;
  94
  95   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 RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion);
 131 RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock,
 132                       MachineRegion);
 133
 134 RegionGraphTraits(MachineRegion, MachineRegionNode);
 135 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