Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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.