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
21namespace llvm {
22
23///
24/// MachinePostDominatorTree - an analysis pass wrapper for DominatorTree
25/// used to compute the post-dominator tree for MachineFunctions.
26///
27class MachinePostDominatorTree : public MachineFunctionPass {
28 using PostDomTreeT = PostDomTreeBase<MachineBasicBlock>;
29 std::unique_ptr<PostDomTreeT> PDT;
30
31public:
32 static char ID;
33
34 MachinePostDominatorTree();
35
36 PostDomTreeT &getBase() {
37 if (!PDT)
38 PDT.reset(p: 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(A: 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(p: 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

source code of llvm/include/llvm/CodeGen/MachinePostDominators.h