1 //===- llvm/CodeGen/MachinePostDominators.h ----------------------*- C++ -*-==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file exposes interfaces to post dominance information for
10 // target-specific code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_MACHINEPOSTDOMINATORS_H
15 #define LLVM_CODEGEN_MACHINEPOSTDOMINATORS_H
16 
17 #include "llvm/CodeGen/MachineDominators.h"
18 #include "llvm/CodeGen/MachineFunctionPass.h"
19 #include <memory>
20 
21 namespace llvm {
22 
23 ///
24 /// MachinePostDominatorTree - an analysis pass wrapper for DominatorTree
25 /// used to compute the post-dominator tree for MachineFunctions.
26 ///
27 class MachinePostDominatorTree : public MachineFunctionPass {
28   using PostDomTreeT = PostDomTreeBase<MachineBasicBlock>;
29   std::unique_ptr<PostDomTreeT> PDT;
30 
31 public:
32   static char ID;
33 
34   MachinePostDominatorTree();
35 
36   FunctionPass *createMachinePostDominatorTreePass();
37 
getRoots()38   const SmallVectorImpl<MachineBasicBlock *> &getRoots() const {
39     return PDT->getRoots();
40   }
41 
getRootNode()42   MachineDomTreeNode *getRootNode() const { return PDT->getRootNode(); }
43 
44   MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
45     return PDT->getNode(BB);
46   }
47 
getNode(MachineBasicBlock * BB)48   MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
49     return PDT->getNode(BB);
50   }
51 
dominates(const MachineDomTreeNode * A,const MachineDomTreeNode * B)52   bool dominates(const MachineDomTreeNode *A,
53                  const MachineDomTreeNode *B) const {
54     return PDT->dominates(A, B);
55   }
56 
dominates(const MachineBasicBlock * A,const MachineBasicBlock * B)57   bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
58     return PDT->dominates(A, B);
59   }
60 
properlyDominates(const MachineDomTreeNode * A,const MachineDomTreeNode * B)61   bool properlyDominates(const MachineDomTreeNode *A,
62                          const MachineDomTreeNode *B) const {
63     return PDT->properlyDominates(A, B);
64   }
65 
properlyDominates(const MachineBasicBlock * A,const MachineBasicBlock * B)66   bool properlyDominates(const MachineBasicBlock *A,
67                          const MachineBasicBlock *B) const {
68     return PDT->properlyDominates(A, B);
69   }
70 
isVirtualRoot(const MachineDomTreeNode * Node)71   bool isVirtualRoot(const MachineDomTreeNode *Node) const {
72     return PDT->isVirtualRoot(Node);
73   }
74 
findNearestCommonDominator(MachineBasicBlock * A,MachineBasicBlock * B)75   MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
76                                                 MachineBasicBlock *B) const {
77     return PDT->findNearestCommonDominator(A, B);
78   }
79 
80   /// Returns the nearest common dominator of the given blocks.
81   /// If that tree node is a virtual root, a nullptr will be returned.
82   MachineBasicBlock *
83   findNearestCommonDominator(ArrayRef<MachineBasicBlock *> Blocks) const;
84 
85   bool runOnMachineFunction(MachineFunction &MF) override;
86   void getAnalysisUsage(AnalysisUsage &AU) const override;
releaseMemory()87   void releaseMemory() override { PDT.reset(nullptr); }
88   void verifyAnalysis() const override;
89   void print(llvm::raw_ostream &OS, const Module *M = nullptr) const override;
90 };
91 } //end of namespace llvm
92 
93 #endif
94