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

References

include/llvm/Analysis/DOTGraphTraitsPass.h

   44   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
   49     auto &Analysis = getAnalysis<AnalysisT>();
   49     auto &Analysis = getAnalysis<AnalysisT>();
   65     AU.addRequired<AnalysisT>();
   86   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
   91     auto &Analysis = getAnalysis<AnalysisT>();
   91     auto &Analysis = getAnalysis<AnalysisT>();
  117     AU.addRequired<AnalysisT>();

include/llvm/Pass.h

  213   AnalysisType &getAnalysisID(AnalysisID PI) const;
  216   AnalysisType &getAnalysisID(AnalysisID PI, Function &F);

include/llvm/PassAnalysisSupport.h

   66     return addRequiredID(PassClass::ID);
   72     return addRequiredTransitiveID(PassClass::ID);
   89     Preserved.push_back(&PassClass::ID);
  201 AnalysisType *Pass::getAnalysisIfAvailable() const {
  204   const void *PI = &AnalysisType::ID;
  220 AnalysisType &Pass::getAnalysis() const {
  222   return getAnalysisID<AnalysisType>(&AnalysisType::ID);
  222   return getAnalysisID<AnalysisType>(&AnalysisType::ID);
  248 AnalysisType &Pass::getAnalysis(Function &F) {
  251   return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
  251   return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);

include/llvm/PassSupport.h

   76 template <typename PassName> Pass *callDefaultCtor() { return new PassName(); }

lib/Analysis/BasicAliasAnalysis.cpp

 2074   auto &DTWP = getAnalysis<DominatorTreeWrapperPass>();
 2074   auto &DTWP = getAnalysis<DominatorTreeWrapperPass>();
 2090   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/BranchProbabilityInfo.cpp

 1021   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/DemandedBits.cpp

   72   AU.addRequired<DominatorTreeWrapperPass>();
  297   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/DomPrinter.cpp

  100   static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) {
  106                        DominatorTreeWrapperPass, false, DominatorTree *,
  118                            DominatorTreeWrapperPass, true, DominatorTree *,
  185                         DominatorTreeWrapperPass, false, DominatorTree *,
  197                             DominatorTreeWrapperPass, true, DominatorTree *,

lib/Analysis/DominanceFrontier.cpp

   49   DF.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
   55   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/IVUsers.cpp

  360   AU.addRequired<DominatorTreeWrapperPass>();
  369   auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/InstructionSimplify.cpp

 5494   auto *DTWP = P.getAnalysisIfAvailable<DominatorTreeWrapperPass>();
 5494   auto *DTWP = P.getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Analysis/LazyBlockFrequencyInfo.cpp

   47   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/LazyBranchProbabilityInfo.cpp

   48   AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/LazyValueInfo.cpp

 1627   DominatorTreeWrapperPass *DTWP =
 1628       getAnalysisIfAvailable<DominatorTreeWrapperPass>();
 2047     AU.addRequired<DominatorTreeWrapperPass>();
 2055     auto &DTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/LegacyDivergenceAnalysis.cpp

  297   AU.addRequired<DominatorTreeWrapperPass>();
  332   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/Lint.cpp

  150       AU.addRequired<DominatorTreeWrapperPass>();
  207   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/LoopAccessAnalysis.cpp

 2425   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 2434     AU.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/LoopInfo.cpp

 1063   LI.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
 1074     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1081   AU.addRequiredTransitive<DominatorTreeWrapperPass>();

lib/Analysis/LoopPass.cpp

  139   Info.addRequired<DominatorTreeWrapperPass>();

lib/Analysis/MemoryDependenceAnalysis.cpp

 1787   AU.addRequired<DominatorTreeWrapperPass>();
 1820   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/MemorySSA.cpp

 2309   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
 2314   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/MustExecute.cpp

  309       AU.addRequired<DominatorTreeWrapperPass>();
  438   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Analysis/RegionInfo.cpp

  128   auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  146   AU.addRequiredTransitive<DominatorTreeWrapperPass>();

lib/Analysis/ScalarEvolution.cpp

12038       getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
12060   AU.addRequiredTransitive<DominatorTreeWrapperPass>();

lib/CodeGen/DwarfEHPrepare.cpp

   96   AU.addRequired<DominatorTreeWrapperPass>();
  261   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/CodeGen/GCRootLowering.cpp

  101   AU.addPreserved<DominatorTreeWrapperPass>();

lib/CodeGen/HardwareLoops.cpp

   95       AU.addRequired<DominatorTreeWrapperPass>();
   96       AU.addPreserved<DominatorTreeWrapperPass>();
  182   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/CodeGen/InterleavedAccessPass.cpp

   95     AU.addRequired<DominatorTreeWrapperPass>();
   96     AU.addPreserved<DominatorTreeWrapperPass>();
  451   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/CodeGen/InterleavedLoadCombinePass.cpp

 1326                F, getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
 1334     AU.addRequired<DominatorTreeWrapperPass>();

lib/CodeGen/MachineFunctionPass.cpp

  114   AU.addPreserved<DominatorTreeWrapperPass>();

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  441   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  441   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/CodeGen/StackProtector.cpp

   74   AU.addPreserved<DominatorTreeWrapperPass>();
   80   DominatorTreeWrapperPass *DTWP =
   81       getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/CodeGen/UnreachableBlockElim.cpp

   57     AU.addPreserved<DominatorTreeWrapperPass>();

lib/IR/SafepointIRVerifier.cpp

  220     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  228     AU.addRequiredID(DominatorTreeWrapperPass::ID);

lib/Target/AArch64/AArch64FalkorHWPFFix.cpp

   93     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Target/AArch64/AArch64PromoteConstant.cpp

  141     AU.addRequired<DominatorTreeWrapperPass>();
  142     AU.addPreserved<DominatorTreeWrapperPass>();
  369   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(
  395   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(
  489   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();

lib/Target/AArch64/AArch64StackTagging.cpp

  589   if (auto *P = getAnalysisIfAvailable<DominatorTreeWrapperPass>())
  589   if (auto *P = getAnalysisIfAvailable<DominatorTreeWrapperPass>())

lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp

   63     AU.addPreserved<DominatorTreeWrapperPass>();
   85   DominatorTreeWrapperPass *const DTW =
   86       getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

   66     AU.addRequired<DominatorTreeWrapperPass>();
  585   auto DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

  116     AU.addRequired<DominatorTreeWrapperPass>();
  118     AU.addPreserved<DominatorTreeWrapperPass>();
  322   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Target/ARM/ARMParallelDSP.cpp

  249       AU.addRequired<DominatorTreeWrapperPass>();
  265       DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Target/Hexagon/HexagonCommonGEP.cpp

  108       AU.addRequired<DominatorTreeWrapperPass>();
  109       AU.addPreserved<DominatorTreeWrapperPass>();
 1282   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Target/Hexagon/HexagonGenExtract.cpp

   71       AU.addRequired<DominatorTreeWrapperPass>();
   72       AU.addPreserved<DominatorTreeWrapperPass>();
  254   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

  135       AU.addRequired<DominatorTreeWrapperPass>();
 2427   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Target/Mips/MipsSEISelDAGToDAG.cpp

   47   AU.addRequired<DominatorTreeWrapperPass>();

lib/Target/PowerPC/PPCBoolRetToInt.cpp

  272     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

   98       AU.addPreserved<DominatorTreeWrapperPass>();
  202   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  202   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

  282     AU.addRequired<DominatorTreeWrapperPass>();
  601   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();

lib/Target/WebAssembly/WebAssemblyOptimizeReturned.cpp

   32     AU.addRequired<DominatorTreeWrapperPass>();
   33     AU.addPreserved<DominatorTreeWrapperPass>();
   77   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

  363   AU.addRequired<DominatorTreeWrapperPass>();
  367   AU.addPreserved<DominatorTreeWrapperPass>();
  373   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Coroutines/CoroElide.cpp

  317     DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  326     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/IPO/GlobalOpt.cpp

 3006       return this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
 3026     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/IPO/LoopExtractor.cpp

   52       AU.addRequired<DominatorTreeWrapperPass>();
   97   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/IPO/SCCP.cpp

   57           this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
   72     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/IPO/WholeProgramDevirt.cpp

  648       return this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
  663     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/InstCombine/InstructionCombining.cpp

 3587   AU.addRequired<DominatorTreeWrapperPass>();
 3589   AU.addPreserved<DominatorTreeWrapperPass>();
 3605   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  115     AU.addRequired<DominatorTreeWrapperPass>();
 2077   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp

  116     AU.addPreserved<DominatorTreeWrapperPass>();
  431   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  431   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  264       return &this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
  277     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  556   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  763   AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/ADCE.cpp

  709     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  709     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  721       AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

   58     AU.addRequired<DominatorTreeWrapperPass>();
   64     AU.addPreserved<DominatorTreeWrapperPass>();
  379   DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/CallSiteSplitting.cpp

  556     AU.addRequired<DominatorTreeWrapperPass>();
  557     AU.addPreserved<DominatorTreeWrapperPass>();
  567     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/ConstantHoisting.cpp

  115     AU.addRequired<DominatorTreeWrapperPass>();
  151                    getAnalysis<DominatorTreeWrapperPass>().getDomTree(),

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  101       AU.addRequired<DominatorTreeWrapperPass>();
  104       AU.addPreserved<DominatorTreeWrapperPass>();
  920   DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/DeadStoreElimination.cpp

 1360     DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1372     AU.addRequired<DominatorTreeWrapperPass>();
 1376     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/DivRemPairs.cpp

  330     AU.addRequired<DominatorTreeWrapperPass>();
  333     AU.addPreserved<DominatorTreeWrapperPass>();
  342     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/EarlyCSE.cpp

 1365     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1377     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/Float2Int.cpp

   63       const DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   69       AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/GVN.cpp

 2667         getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
 2679     AU.addRequired<DominatorTreeWrapperPass>();
 2686     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/GVNHoist.cpp

 1152     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1163     AU.addRequired<DominatorTreeWrapperPass>();
 1168     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/GuardWidening.cpp

  856     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  868     AU.addRequired<DominatorTreeWrapperPass>();
  888     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/IndVarSimplify.cpp

 3169     auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

 1775   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/InstSimplifyPass.cpp

   89     AU.addRequired<DominatorTreeWrapperPass>();
  101         &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/JumpThreading.cpp

  141       AU.addRequired<DominatorTreeWrapperPass>();
  142       AU.addPreserved<DominatorTreeWrapperPass>();
  302   auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LICM.cpp

  222                           &getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
  234     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/LoopDataPrefetch.cpp

  112     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/LoopDeletion.cpp

  254   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopDistribute.cpp

 1021     auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1035     AU.addRequired<DominatorTreeWrapperPass>();
 1036     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/LoopFuse.cpp

 1573     AU.addRequired<DominatorTreeWrapperPass>();
 1580     AU.addPreserved<DominatorTreeWrapperPass>();
 1588     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  272     DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopInstSimplify.cpp

  189     DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  210     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/LoopInterchange.cpp

  459     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopLoadElimination.cpp

  643     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  661     AU.addRequired<DominatorTreeWrapperPass>();
  662     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/LoopRerollPass.cpp

 1649   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopRotation.cpp

   97     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopSimplifyCFG.cpp

  722     DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopSink.cpp

  364         getAnalysis<DominatorTreeWrapperPass>().getDomTree(),

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 5692   AU.addRequired<DominatorTreeWrapperPass>();
 5693   AU.addPreserved<DominatorTreeWrapperPass>();
 5742   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp

  446     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopUnrollPass.cpp

 1225     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopUnswitch.cpp

  526   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/LoopVersioningLICM.cpp

  131     AU.addRequired<DominatorTreeWrapperPass>();
  605     DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/MemCpyOptimizer.cpp

  273     AU.addRequired<DominatorTreeWrapperPass>();
 1448     return getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/MergeICmps.cpp

  904     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  904     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  915     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/NaryReassociate.cpp

  133     AU.addPreserved<DominatorTreeWrapperPass>();
  137     AU.addRequired<DominatorTreeWrapperPass>();
  171   auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/NewGVN.cpp

 4186     AU.addRequired<DominatorTreeWrapperPass>();
 4190     AU.addPreserved<DominatorTreeWrapperPass>();
 4200   return NewGVN(F, &getAnalysis<DominatorTreeWrapperPass>().getDomTree(),

lib/Transforms/Scalar/PlaceSafepoints.cpp

  132     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  142     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  189       auto &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
  207     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/SROA.cpp

 4633         F, getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
 4640     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

  354     AU.addRequired<DominatorTreeWrapperPass>();
 1121   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

 2931   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/Sink.cpp

  277       auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  288       AU.addRequired<DominatorTreeWrapperPass>();
  290       AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

  153     AU.addRequired<DominatorTreeWrapperPass>();
  711   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/StructurizeCFG.cpp

  279     AU.addRequired<DominatorTreeWrapperPass>();
  282     AU.addPreserved<DominatorTreeWrapperPass>();
 1036   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Scalar/TailRecursionElimination.cpp

  823     AU.addPreserved<DominatorTreeWrapperPass>();
  831     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  831     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Transforms/Utils/BreakCriticalEdges.cpp

   50       auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   50       auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   65       AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Utils/LCSSA.cpp

  439     AU.addRequired<DominatorTreeWrapperPass>();
  472   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Utils/LibCallsShrinkWrap.cpp

  517   AU.addPreserved<DominatorTreeWrapperPass>();
  537   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  537   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();

lib/Transforms/Utils/LoopSimplify.cpp

  757       AU.addRequired<DominatorTreeWrapperPass>();
  758       AU.addPreserved<DominatorTreeWrapperPass>();
  800   DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Utils/LoopUtils.cpp

  142   AU.addRequired<DominatorTreeWrapperPass>();
  143   AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Utils/LoopVersioning.cpp

  265     auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  300     AU.addRequired<DominatorTreeWrapperPass>();
  301     AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Utils/Mem2Reg.cpp

   87     DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   95     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Utils/PredicateInfo.cpp

  780   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
  799   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  225     AU.addRequired<DominatorTreeWrapperPass>();
  255   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

lib/Transforms/Vectorize/LoopVectorize.cpp

 1603     auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1624     AU.addRequired<DominatorTreeWrapperPass>();
 1639       AU.addPreserved<DominatorTreeWrapperPass>();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 5214     auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 5229     AU.addRequired<DominatorTreeWrapperPass>();
 5233     AU.addPreserved<DominatorTreeWrapperPass>();

tools/opt/GraphPrinters.cpp

   33       AU.addRequired<DominatorTreeWrapperPass>();
   37       getAnalysis<DominatorTreeWrapperPass>().print(dbgs());

tools/polly/lib/Analysis/ScopDetection.cpp

 1856   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 1865   AU.addRequired<DominatorTreeWrapperPass>();

tools/polly/lib/Analysis/ScopInfo.cpp

 2620   AU.addRequired<DominatorTreeWrapperPass>();
 2675   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 2796   AU.addRequired<DominatorTreeWrapperPass>();
 2811   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

tools/polly/lib/Analysis/ScopPass.cpp

   47   AU.addPreserved<DominatorTreeWrapperPass>();

tools/polly/lib/CodeGen/CodeGeneration.cpp

  331     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  342     AU.addRequired<DominatorTreeWrapperPass>();

tools/polly/lib/Support/ScopHelper.cpp

  213   auto *DTWP = P->getAnalysisIfAvailable<DominatorTreeWrapperPass>();
  213   auto *DTWP = P->getAnalysisIfAvailable<DominatorTreeWrapperPass>();

tools/polly/lib/Transform/CodePreparation.cpp

   90   AU.addPreserved<DominatorTreeWrapperPass>();

unittests/Analysis/CFGTest.cpp

   92         AU.addRequired<DominatorTreeWrapperPass>();
  101             &getAnalysis<DominatorTreeWrapperPass>().getDomTree();

unittests/Analysis/UnrollAnalyzerTest.cpp

   49     AU.addRequired<DominatorTreeWrapperPass>();