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