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   PostDomTreeT &getBase() {
37     if (!PDT)
38       PDT.reset(new PostDomTreeT());
39     return *PDT;
40   }
41 
42   FunctionPass *createMachinePostDominatorTreePass();
43 
44   MachineDomTreeNode *getRootNode() const { return PDT->getRootNode(); }
45 
46   MachineDomTreeNode *operator[](MachineBasicBlock *BB) const {
47     return PDT->getNode(BB);
48   }
49 
50   MachineDomTreeNode *getNode(MachineBasicBlock *BB) const {
51     return PDT->getNode(BB);
52   }
53 
54   bool dominates(const MachineDomTreeNode *A,
55                  const MachineDomTreeNode *B) const {
56     return PDT->dominates(A, B);
57   }
58 
59   bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const {
60     return PDT->dominates(A, B);
61   }
62 
63   bool properlyDominates(const MachineDomTreeNode *A,
64                          const MachineDomTreeNode *B) const {
65     return PDT->properlyDominates(A, B);
66   }
67 
68   bool properlyDominates(const MachineBasicBlock *A,
69                          const MachineBasicBlock *B) const {
70     return PDT->properlyDominates(A, B);
71   }
72 
73   bool isVirtualRoot(const MachineDomTreeNode *Node) const {
74     return PDT->isVirtualRoot(Node);
75   }
76 
77   MachineBasicBlock *findNearestCommonDominator(MachineBasicBlock *A,
78                                                 MachineBasicBlock *B) const {
79     return PDT->findNearestCommonDominator(A, B);
80   }
81 
82   /// Returns the nearest common dominator of the given blocks.
83   /// If that tree node is a virtual root, a nullptr will be returned.
84   MachineBasicBlock *
85   findNearestCommonDominator(ArrayRef<MachineBasicBlock *> Blocks) const;
86 
87   bool runOnMachineFunction(MachineFunction &MF) override;
88   void getAnalysisUsage(AnalysisUsage &AU) const override;
89   void releaseMemory() override { PDT.reset(nullptr); }
90   void verifyAnalysis() const override;
91   void print(llvm::raw_ostream &OS, const Module *M = nullptr) const override;
92 };
93 } //end of namespace llvm
94 
95 #endif
96