[llvm] r352036 - [HotColdSplitting] Get DT and PDT from the pass manager.

[Florian Hahn via llvm-commits]

Author: fhahn
Date: Thu Jan 24 01:44:52 2019
New Revision: 352036

URL: http://llvm.org/viewvc/llvm-project?rev=352036&view=rev
Log:
[HotColdSplitting] Get DT and PDT from the pass manager.

Instead of manually computing DT and PDT, we can get the from the pass
manager, which ideally has them already cached. With the new pass
manager, we could even preserve DT/PDT on a per function basis in a
module pass.

I think this also addresses the TODO about re-using the computed DTs for
BFI. IIUC, GetBFI will fetch the DT from the pass manager and when we
will fetch the cached version later.

Reviewers: vsk, hiraditya, tejohnson, thegameg, sebpop

Reviewed By: vsk

Differential Revision: https://reviews.llvm.org/D57092

Modified:
    llvm/trunk/lib/Transforms/IPO/HotColdSplitting.cpp

Modified: llvm/trunk/lib/Transforms/IPO/HotColdSplitting.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/HotColdSplitting.cpp?rev=352036&r1=352035&r2=352036&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/HotColdSplitting.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/HotColdSplitting.cpp Thu Jan 24 01:44:52 2019
@@ -168,8 +168,11 @@ public:
   HotColdSplitting(ProfileSummaryInfo *ProfSI,
                    function_ref<BlockFrequencyInfo *(Function &)> GBFI,
                    function_ref<TargetTransformInfo &(Function &)> GTTI,
+                   function_ref<DominatorTree *(Function &)> GetDT,
+                   function_ref<PostDominatorTree *(Function &)> GetPDT,
                    std::function<OptimizationRemarkEmitter &(Function &)> *GORE)
-      : PSI(ProfSI), GetBFI(GBFI), GetTTI(GTTI), GetORE(GORE) {}
+      : PSI(ProfSI), GetBFI(GBFI), GetTTI(GTTI), GetDT(GetDT), GetPDT(GetPDT),
+        GetORE(GORE) {}
   bool run(Module &M);
 
 private:
@@ -182,6 +185,8 @@ private:
   ProfileSummaryInfo *PSI;
   function_ref<BlockFrequencyInfo *(Function &)> GetBFI;
   function_ref<TargetTransformInfo &(Function &)> GetTTI;
+  function_ref<DominatorTree *(Function &)> GetDT;
+  function_ref<PostDominatorTree *(Function &)> GetPDT;
   std::function<OptimizationRemarkEmitter &(Function &)> *GetORE;
 };
 
@@ -195,6 +200,8 @@ public:
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<BlockFrequencyInfoWrapperPass>();
+    AU.addRequired<DominatorTreeWrapperPass>();
+    AU.addRequired<PostDominatorTreeWrapperPass>();
     AU.addRequired<ProfileSummaryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
   }
@@ -462,12 +469,11 @@ bool HotColdSplitting::outlineColdRegion
   ReversePostOrderTraversal<Function *> RPOT(&F);
 
   // Calculate domtrees lazily. This reduces compile-time significantly.
-  std::unique_ptr<DominatorTree> DT;
-  std::unique_ptr<PostDominatorTree> PDT;
+  DominatorTree *DT = nullptr;
+  PostDominatorTree *PDT = nullptr;
 
   // Calculate BFI lazily (it's only used to query ProfileSummaryInfo). This
-  // reduces compile-time significantly. TODO: When we *do* use BFI, we should
-  // be able to salvage its domtrees instead of recomputing them.
+  // reduces compile-time significantly.
   BlockFrequencyInfo *BFI = nullptr;
   if (HasProfileSummary)
     BFI = GetBFI(F);
@@ -492,9 +498,9 @@ bool HotColdSplitting::outlineColdRegion
     });
 
     if (!DT)
-      DT = make_unique<DominatorTree>(F);
+      DT = GetDT(F);
     if (!PDT)
-      PDT = make_unique<PostDominatorTree>(F);
+      PDT = GetPDT(F);
 
     auto Region = OutliningRegion::create(*BB, *DT, *PDT);
     if (Region.empty())
@@ -595,6 +601,13 @@ bool HotColdSplittingLegacyPass::runOnMo
   auto GBFI = [this](Function &F) {
     return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
   };
+  auto GetDT = [this](Function &F) {
+    return &this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
+  };
+  auto GetPDT = [this](Function &F) {
+    return &this->getAnalysis<PostDominatorTreeWrapperPass>(F).getPostDomTree();
+  };
+
   std::unique_ptr<OptimizationRemarkEmitter> ORE;
   std::function<OptimizationRemarkEmitter &(Function &)> GetORE =
       [&ORE](Function &F) -> OptimizationRemarkEmitter & {
@@ -602,7 +615,7 @@ bool HotColdSplittingLegacyPass::runOnMo
     return *ORE.get();
   };
 
-  return HotColdSplitting(PSI, GBFI, GTTI, &GetORE).run(M);
+  return HotColdSplitting(PSI, GBFI, GTTI, GetDT, GetPDT, &GetORE).run(M);
 }
 
 PreservedAnalyses
@@ -623,6 +636,14 @@ HotColdSplittingPass::run(Module &M, Mod
     return FAM.getResult<TargetIRAnalysis>(F);
   };
 
+  auto GetDT = [&FAM](Function &F) {
+    return &FAM.getResult<DominatorTreeAnalysis>(F);
+  };
+
+  auto GetPDT = [&FAM](Function &F) {
+    return &FAM.getResult<PostDominatorTreeAnalysis>(F);
+  };
+
   std::unique_ptr<OptimizationRemarkEmitter> ORE;
   std::function<OptimizationRemarkEmitter &(Function &)> GetORE =
       [&ORE](Function &F) -> OptimizationRemarkEmitter & {
@@ -632,7 +653,7 @@ HotColdSplittingPass::run(Module &M, Mod
 
   ProfileSummaryInfo *PSI = &AM.getResult<ProfileSummaryAnalysis>(M);
 
-  if (HotColdSplitting(PSI, GBFI, GTTI, &GetORE).run(M))
+  if (HotColdSplitting(PSI, GBFI, GTTI, GetDT, GetPDT, &GetORE).run(M))
     return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
@@ -642,6 +663,8 @@ INITIALIZE_PASS_BEGIN(HotColdSplittingLe
                       "Hot Cold Splitting", false, false)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
 INITIALIZE_PASS_END(HotColdSplittingLegacyPass, "hotcoldsplit",
                     "Hot Cold Splitting", false, false)