llvm/CodeGen/MachineRegionInfo.h

0001 //===- llvm/CodeGen/MachineRegionInfo.h -------------------------*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008
0009 #ifndef LLVM_CODEGEN_MACHINEREGIONINFO_H
0010 #define LLVM_CODEGEN_MACHINEREGIONINFO_H
0011
0012 #include "llvm/ADT/DepthFirstIterator.h"
0013 #include "llvm/Analysis/RegionInfo.h"
0014 #include "llvm/Analysis/RegionIterator.h"
0015 #include "llvm/CodeGen/MachineBasicBlock.h"
0016 #include "llvm/CodeGen/MachineDominanceFrontier.h"
0017 #include "llvm/CodeGen/MachineDominators.h"
0018 #include "llvm/CodeGen/MachineFunction.h"
0019 #include "llvm/CodeGen/MachineFunctionPass.h"
0020 #include "llvm/CodeGen/MachineLoopInfo.h"
0021 #include <cassert>
0022
0023 namespace llvm {
0024
0025 class MachinePostDominatorTree;
0026 class MachineRegion;
0027 class MachineRegionNode;
0028 class MachineRegionInfo;
0029
0030 template <> struct RegionTraits<MachineFunction> {
0031   using FuncT = MachineFunction;
0032   using BlockT = MachineBasicBlock;
0033   using RegionT = MachineRegion;
0034   using RegionNodeT = MachineRegionNode;
0035   using RegionInfoT = MachineRegionInfo;
0036   using DomTreeT = MachineDominatorTree;
0037   using DomTreeNodeT = MachineDomTreeNode;
0038   using PostDomTreeT = MachinePostDominatorTree;
0039   using DomFrontierT = MachineDominanceFrontier;
0040   using InstT = MachineInstr;
0041   using LoopT = MachineLoop;
0042   using LoopInfoT = MachineLoopInfo;
0043
0044   static unsigned getNumSuccessors(MachineBasicBlock *BB) {
0045     return BB->succ_size();
0046   }
0047 };
0048
0049 class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
0050 public:
0051   inline MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry,
0052                            bool isSubRegion = false)
0053       : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry,
0054                                                       isSubRegion) {}
0055
0056   bool operator==(const MachineRegion &RN) const {
0057     return this == reinterpret_cast<const MachineRegionNode *>(&RN);
0058   }
0059 };
0060
0061 class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
0062 public:
0063   MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
0064                 MachineRegionInfo *RI, MachineDominatorTree *DT,
0065                 MachineRegion *Parent = nullptr);
0066   ~MachineRegion();
0067
0068   bool operator==(const MachineRegionNode &RN) const {
0069     return &RN == reinterpret_cast<const MachineRegionNode *>(this);
0070   }
0071 };
0072
0073 class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
0074 public:
0075   explicit MachineRegionInfo();
0076   ~MachineRegionInfo() override;
0077
0078   // updateStatistics - Update statistic about created regions.
0079   void updateStatistics(MachineRegion *R) final;
0080
0081   void recalculate(MachineFunction &F, MachineDominatorTree *DT,
0082                    MachinePostDominatorTree *PDT, MachineDominanceFrontier *DF);
0083 };
0084
0085 class MachineRegionInfoPass : public MachineFunctionPass {
0086   MachineRegionInfo RI;
0087
0088 public:
0089   static char ID;
0090
0091   explicit MachineRegionInfoPass();
0092   ~MachineRegionInfoPass() override;
0093
0094   MachineRegionInfo &getRegionInfo() { return RI; }
0095
0096   const MachineRegionInfo &getRegionInfo() const { return RI; }
0097
0098   /// @name MachineFunctionPass interface
0099   //@{
0100   bool runOnMachineFunction(MachineFunction &F) override;
0101   void releaseMemory() override;
0102   void verifyAnalysis() const override;
0103   void getAnalysisUsage(AnalysisUsage &AU) const override;
0104   void print(raw_ostream &OS, const Module *) const override;
0105   void dump() const;
0106   //@}
0107 };
0108
0109 template <>
0110 template <>
0111 inline MachineBasicBlock *
0112 RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>()
0113     const {
0114   assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
0115   return getEntry();
0116 }
0117
0118 template <>
0119 template <>
0120 inline MachineRegion *
0121 RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>()
0122     const {
0123   assert(isSubRegion() && "This is not a subregion RegionNode!");
0124   auto Unconst =
0125       const_cast<RegionNodeBase<RegionTraits<MachineFunction>> *>(this);
0126   return reinterpret_cast<MachineRegion *>(Unconst);
0127 }
0128
0129 RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion);
0130 RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock,
0131                       MachineRegion);
0132
0133 RegionGraphTraits(MachineRegion, MachineRegionNode);
0134 RegionGraphTraits(const MachineRegion, const MachineRegionNode);
0135
0136 template <>
0137 struct GraphTraits<MachineRegionInfo *>
0138     : public GraphTraits<FlatIt<MachineRegionNode *>> {
0139   using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
0140                                      false, GraphTraits<FlatIt<NodeRef>>>;
0141
0142   static NodeRef getEntryNode(MachineRegionInfo *RI) {
0143     return GraphTraits<FlatIt<MachineRegion *>>::getEntryNode(
0144         RI->getTopLevelRegion());
0145   }
0146
0147   static nodes_iterator nodes_begin(MachineRegionInfo *RI) {
0148     return nodes_iterator::begin(getEntryNode(RI));
0149   }
0150
0151   static nodes_iterator nodes_end(MachineRegionInfo *RI) {
0152     return nodes_iterator::end(getEntryNode(RI));
0153   }
0154 };
0155
0156 template <>
0157 struct GraphTraits<MachineRegionInfoPass *>
0158     : public GraphTraits<MachineRegionInfo *> {
0159   using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
0160                                      false, GraphTraits<FlatIt<NodeRef>>>;
0161
0162   static NodeRef getEntryNode(MachineRegionInfoPass *RI) {
0163     return GraphTraits<MachineRegionInfo *>::getEntryNode(&RI->getRegionInfo());
0164   }
0165
0166   static nodes_iterator nodes_begin(MachineRegionInfoPass *RI) {
0167     return GraphTraits<MachineRegionInfo *>::nodes_begin(&RI->getRegionInfo());
0168   }
0169
0170   static nodes_iterator nodes_end(MachineRegionInfoPass *RI) {
0171     return GraphTraits<MachineRegionInfo *>::nodes_end(&RI->getRegionInfo());
0172   }
0173 };
0174
0175 extern template class RegionBase<RegionTraits<MachineFunction>>;
0176 extern template class RegionNodeBase<RegionTraits<MachineFunction>>;
0177 extern template class RegionInfoBase<RegionTraits<MachineFunction>>;
0178
0179 } // end namespace llvm
0180
0181 #endif // LLVM_CODEGEN_MACHINEREGIONINFO_H