reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

include/llvm/IR/PassManagerInternal.h

  137   template <typename T> struct Checker : CheckerBase, T {};

Declarations

include/llvm/Analysis/RegionInfo.h

   65 class PostDominatorTree;

include/llvm/Analysis/SyncDependenceAnalysis.h

   30 class PostDominatorTree;

include/llvm/Transforms/Scalar/SCCP.h

   33 class PostDominatorTree;

include/llvm/Transforms/Utils/BasicBlockUtils.h

   38 class PostDominatorTree;

References

include/llvm/Analysis/DivergenceAnalysis.h

  186                         const PostDominatorTree &PDT, const LoopInfo &LI,

include/llvm/Analysis/DomTreeUpdater.h

   35   DomTreeUpdater(PostDominatorTree &PDT_, UpdateStrategy Strategy_)
   37   DomTreeUpdater(PostDominatorTree *PDT_, UpdateStrategy Strategy_)
   39   DomTreeUpdater(DominatorTree &DT_, PostDominatorTree &PDT_,
   42   DomTreeUpdater(DominatorTree *DT_, PostDominatorTree *PDT_,
  231   PostDominatorTree &getPostDomTree();
  264   PostDominatorTree *PDT = nullptr;

include/llvm/Analysis/PostDominators.h

   48   using Result = PostDominatorTree;
   52   PostDominatorTree run(Function &F, FunctionAnalysisManager &);
   69   PostDominatorTree DT;
   75   PostDominatorTree &getPostDomTree() { return DT; }
   76   const PostDominatorTree &getPostDomTree() const { return DT; }
   97   static NodeRef getEntryNode(PostDominatorTree *DT) {
  101   static nodes_iterator nodes_begin(PostDominatorTree *N) {
  108   static nodes_iterator nodes_end(PostDominatorTree *N) {

include/llvm/Analysis/RegionInfo.h

   95   using PostDomTreeT = PostDominatorTree;
  929   void recalculate(Function &F, DominatorTree *DT, PostDominatorTree *PDT,

include/llvm/Analysis/SyncDependenceAnalysis.h

   47   SyncDependenceAnalysis(const DominatorTree &DT, const PostDominatorTree &PDT,
   75   const PostDominatorTree &PDT;

include/llvm/IR/PassManagerInternal.h

  137   template <typename T> struct Checker : CheckerBase, T {};
  147   enum { Value = sizeof(check<ResultT>(rank<2>())) == sizeof(EnabledType) };
  208   explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
  231   ResultT Result;

include/llvm/Transforms/Scalar/SCCP.h

   45   PostDominatorTree *PDT;

include/llvm/Transforms/Utils/BasicBlockUtils.h

  119   PostDominatorTree *PDT;
  130                                PostDominatorTree *PDT = nullptr)

lib/Analysis/DivergenceAnalysis.cpp

  434                                              const PostDominatorTree &PDT,

lib/Analysis/DomPrinter.cpp

   72   static std::string getGraphName(PostDominatorTree *DT) {
   76   std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) {
  130   static PostDominatorTree *getGraph(PostDominatorTreeWrapperPass *PDTWP) {
  137                           PostDominatorTree *,
  151                             PostDominatorTree *,
  211                             PostDominatorTree *,
  226                             PostDominatorTree *,

lib/Analysis/DomTreeUpdater.cpp

  310 PostDominatorTree &DomTreeUpdater::getPostDomTree() {

lib/Analysis/LegacyDivergenceAnalysis.cpp

   96                        PostDominatorTree &PDT, DenseSet<const Value *> &DV,
  119   PostDominatorTree &PDT;
  333   auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();

lib/Analysis/PostDominators.cpp

   69 PostDominatorTree PostDominatorTreeAnalysis::run(Function &F,
   71   PostDominatorTree PDT(F);

lib/Analysis/RegionInfo.cpp

   98                              PostDominatorTree *PDT_, DominanceFrontier *DF_) {
  192   auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F);

lib/Analysis/SyncDependenceAnalysis.cpp

  121                                                const PostDominatorTree &PDT,
  133   const PostDominatorTree &PDT;
  153                        const PostDominatorTree &PDT, const LoopInfo &LI)

lib/Target/AArch64/AArch64StackTagging.cpp

  496 static bool postDominates(const PostDominatorTree *PDT, const IntrinsicInst *A,
  598   std::unique_ptr<PostDominatorTree> DeletePDT;
  599   PostDominatorTree *PDT = nullptr;
  604     DeletePDT = std::make_unique<PostDominatorTree>(*F);

lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp

  161   auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();

lib/Target/Hexagon/HexagonCommonGEP.cpp

  157     PostDominatorTree *PDT;

lib/Transforms/IPO/HotColdSplitting.cpp

  392                                              const PostDominatorTree &PDT) {
  546   std::unique_ptr<PostDominatorTree> PDT;
  578       PDT = std::make_unique<PostDominatorTree>(F);

lib/Transforms/IPO/SampleProfile.cpp

  360   std::unique_ptr<PostDominatorTree> PDT;
 1547   PDT.reset(new PostDominatorTree(F));

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  182     function_ref<const PostDominatorTree *(Function &F)>;
  494                                 const PostDominatorTree *PDT) {
  508                                   const PostDominatorTree *PDT,
  601   const PostDominatorTree *PDT = PDTCallback(F);

lib/Transforms/Scalar/ADCE.cpp

  120   PostDominatorTree &PDT;
  195                                 PostDominatorTree &PDT)
  682   auto &PDT = FAM.getResult<PostDominatorTreeAnalysis>(F);
  711     auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();

lib/Transforms/Scalar/GVNHoist.cpp

  257   GVNHoist(DominatorTree *DT, PostDominatorTree *PDT, AliasAnalysis *AA,
  331   PostDominatorTree *PDT;
 1153     auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
 1178   PostDominatorTree &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);

lib/Transforms/Scalar/GuardWidening.cpp

  127   PostDominatorTree *PDT;
  289   explicit GuardWideningImpl(DominatorTree &DT, PostDominatorTree *PDT,
  807   auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
  858     auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
  891     auto *PDT = PDTWP ? &PDTWP->getPostDomTree() : nullptr;

lib/Transforms/Scalar/LoopFuse.cpp

  158   const PostDominatorTree *PDT;
  163                   const PostDominatorTree *PDT, OptimizationRemarkEmitter &ORE)
  510   PostDominatorTree &PDT;
  515             ScalarEvolution &SE, PostDominatorTree &PDT,
 1591     auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
 1606   auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);

lib/Transforms/Scalar/TailRecursionElimination.cpp

  834     auto *PDT = PDTWP ? &PDTWP->getPostDomTree() : nullptr;
  868   auto *PDT = AM.getCachedResult<PostDominatorTreeAnalysis>(F);

lib/Transforms/Utils/BreakCriticalEdges.cpp

   54       auto *PDT = PDTWP ? &PDTWP->getPostDomTree() : nullptr;
  213   auto *PDT = Options.PDT;

unittests/Analysis/DivergenceAnalysisTest.cpp

   51   std::unique_ptr<PostDominatorTree> PDT;
   59     PDT.reset(new PostDominatorTree(F));

unittests/Analysis/DomTreeUpdaterTest.cpp

   55   PostDominatorTree PDT(*F);
  166   PostDominatorTree PDT(*F);
  240   PostDominatorTree *PDT = nullptr;
  329   PostDominatorTree *PDT = nullptr;
  458   PostDominatorTree PDT(*F);
  541   PostDominatorTree PDT(*F);
  630   PostDominatorTree PDT(*F);

unittests/IR/DominatorTreeBatchUpdatesTest.cpp

   27     std::is_same<DomUpdate, PostDominatorTree::UpdateType>::value,
   99   PostDominatorTree PDT(*Holder.F);
  121   PostDominatorTree PDT(*Holder.F);
  147   PostDominatorTree PDT(*Holder.F);
  180   PostDominatorTree PDT(*Holder.F);
  211   PostDominatorTree PDT(*Holder.F);
  244     PostDominatorTree PDT(*Holder.F);
  277   PostDominatorTree PDT(*Holder.F);
  310   PostDominatorTree PDT(*Holder.F);
  340   PostDominatorTree PDT(*Holder.F);

unittests/IR/DominatorTreeTest.cpp

   28     function_ref<void(Function &F, DominatorTree *DT, PostDominatorTree *PDT)>
   34   PostDominatorTree PDT(*F);
  407         PostDominatorTree NPDT(F);
  499         PostDominatorTree NPDT(F);
  594         PostDominatorTree NPDT(F);
  691   PostDominatorTree PDT(*Holder.F);
  717   PostDominatorTree PDT(*Holder.F);
  745   PostDominatorTree PDT(*Holder.F);
  766   PostDominatorTree PDT(*Holder.F);
  796   PostDominatorTree PDT(*Holder.F);
  826     PostDominatorTree PDT(*Holder.F);
  853   PostDominatorTree PDT(*Holder.F);
  879   PostDominatorTree PDT(*Holder.F);
  909   PostDominatorTree PDT(*Holder.F);
  947     PostDominatorTree PDT(*Holder.F);

unittests/Transforms/Utils/BasicBlockUtilsTest.cpp

  132   PostDominatorTree PDT(*F);

unittests/Transforms/Utils/LocalTest.cpp

  235     PostDominatorTree PDT = PostDominatorTree(F);
  252     PostDominatorTree PDT = PostDominatorTree(F);
  261     PostDominatorTree PDT = PostDominatorTree(F);
  270     PostDominatorTree PDT = PostDominatorTree(F);
  286     PostDominatorTree PDT = PostDominatorTree(F);
  303     PostDominatorTree PDT = PostDominatorTree(F);
  312     PostDominatorTree PDT = PostDominatorTree(F);
  321     PostDominatorTree PDT = PostDominatorTree(F);
  436     PostDominatorTree PDT = PostDominatorTree(F);
  448     PostDominatorTree PDT = PostDominatorTree(F);
  903     PostDominatorTree PDT = PostDominatorTree(F);
  911     PostDominatorTree PDT = PostDominatorTree(F);

usr/include/c++/7.4.0/bits/move.h

   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept

usr/include/c++/7.4.0/bits/unique_ptr.h

   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

usr/include/c++/7.4.0/type_traits

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 2253     inline typename add_rvalue_reference<_Tp>::type