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 38 const SmallVectorImpl<MachineBasicBlock *> &getRoots() const { 39 return PDT->getRoots(); 40 } 41 42 MachineDomTreeNode *getRootNode() const { return PDT->getRootNode(); } 43 44 MachineDomTreeNode *operator[](MachineBasicBlock *BB) const { 45 return PDT->getNode(BB); 46 } 47 48 MachineDomTreeNode *getNode(MachineBasicBlock *BB) const { 49 return PDT->getNode(BB); 50 } 51 52 bool dominates(const MachineDomTreeNode *A, 53 const MachineDomTreeNode *B) const { 54 return PDT->dominates(A, B); 55 } 56 57 bool dominates(const MachineBasicBlock *A, const MachineBasicBlock *B) const { 58 return PDT->dominates(A, B); 59 } 60 61 bool properlyDominates(const MachineDomTreeNode *A, 62 const MachineDomTreeNode *B) const { 63 return PDT->properlyDominates(A, B); 64 } 65 66 bool properlyDominates(const MachineBasicBlock *A, 67 const MachineBasicBlock *B) const { 68 return PDT->properlyDominates(A, B); 69 } 70 71 bool isVirtualRoot(const MachineDomTreeNode *Node) const { 72 return PDT->isVirtualRoot(Node); 73 } 74 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; 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