[IPSCCP,PM] Preserve PDT in the new pass manager.

[fhahn]

I've updated the test to explicitly use function(require<domtree>,require<postdomtree> before and after ipsccp to make sure the analyses are preserved. I couldn't find a flag to verify the PDT unfortunately.

[brzycki]

LGTM. Thanks again for doing this. :)

[NutshellySima]

LGTM, thanks for the patch :)

include/llvm/Transforms/Scalar/SCCP.h

 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 /// Helper struct for bundling up the analysis results per function for IPSCCP.
 struct AnalysisResultsForFn {
   std::unique_ptr<PredicateInfo> PredInfo;
   DominatorTree *DT;
+  PostDominatorTree *PDT;
 };
 
 bool runIPSCCP(Module &M, const DataLayout &DL, const TargetLibraryInfo *TLI,
                function_ref<AnalysisResultsForFn(Function &)> getAnalysis);
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SCCP_H

lib/Transforms/IPO/SCCP.cpp

 #include "llvm/Transforms/IPO/SCCP.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 
 using namespace llvm;
 
 PreservedAnalyses IPSCCPPass::run(Module &M, ModuleAnalysisManager &AM) {
   const DataLayout &DL = M.getDataLayout();
   auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
   auto getAnalysis = [&FAM](Function &F) -> AnalysisResultsForFn {
     DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F);
     return {
         make_unique<PredicateInfo>(F, DT, FAM.getResult<AssumptionAnalysis>(F)),
-        &DT};
+        &DT, FAM.getCachedResult<PostDominatorTreeAnalysis>(F)};
   };
 
   if (!runIPSCCP(M, DL, &TLI, getAnalysis))
     return PreservedAnalyses::all();
 
   PreservedAnalyses PA;
   PA.preserve<DominatorTreeAnalysis>();
+  PA.preserve<PostDominatorTreeAnalysis>();
   PA.preserve<FunctionAnalysisManagerModuleProxy>();
   return PA;
 }
 
 namespace {
 
 //===--------------------------------------------------------------------===//
 //
bool runOnModule(Module &M) override {
     auto getAnalysis = [this](Function &F) -> AnalysisResultsForFn {
       DominatorTree &DT =
           this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
       return {
           make_unique<PredicateInfo>(
               F, DT,
               this->getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
                   F)),
-          nullptr}; // We cannot preserve the DT with the legacy pass manager,
-                    // so so set it to nullptr.
+          nullptr,  // We cannot preserve the DT or PDT with the legacy pass
+          nullptr}; // manager, so set them to nullptr.
     };
 
     return runIPSCCP(M, DL, TLI, getAnalysis);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transforms/Scalar/SCCP.cpp

public:
 
   const PredicateBase *getPredicateInfoFor(Instruction *I) {
     auto A = AnalysisResults.find(I->getParent()->getParent());
     if (A == AnalysisResults.end())
       return nullptr;
     return A->second.PredInfo->getPredicateInfoFor(I);
   }
 
-  DominatorTree *getDomTree(Function &F) {
+  DomTreeUpdater getDTU(Function &F) {
     auto A = AnalysisResults.find(&F);
     assert(A != AnalysisResults.end() && "Need analysis results for function.");
-    return A->second.DT;
+    return {A->second.DT, A->second.PDT, DomTreeUpdater::UpdateStrategy::Lazy};
   }
 
   SCCPSolver(const DataLayout &DL, const TargetLibraryInfo *tli)
       : DL(DL), TLI(tli) {}
 
   /// MarkBlockExecutable - This method can be used by clients to mark all of
   /// the blocks that are known to be intrinsically live in the processed unit.
   ///
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
             Inst->eraseFromParent();
           // Hey, we just changed something!
           MadeChanges = true;
           ++IPNumInstRemoved;
         }
       }
     }
 
-    DomTreeUpdater DTU(Solver.getDomTree(F),
-                       DomTreeUpdater::UpdateStrategy::Lazy);
+    DomTreeUpdater DTU = Solver.getDTU(F);
     // Change dead blocks to unreachable. We do it after replacing constants
     // in all executable blocks, because changeToUnreachable may remove PHI
     // nodes in executable blocks we found values for. The function's entry
     // block is not part of BlocksToErase, so we have to handle it separately.
     for (BasicBlock *BB : BlocksToErase) {
       NumInstRemoved +=
           changeToUnreachable(BB->getFirstNonPHI(), /*UseLLVMTrap=*/false,
                               /*PreserveLCSSA=*/false, &DTU);

test/Transforms/SCCP/ipsccp-preserve-analysis.ll

+; Basic test to check that DominatorTreeAnalysis is preserved by IPSCCP and
+; the following analysis can re-use it. The test contains two trivial functions
+; IPSCCP can simplify, so we can test the case where IPSCCP makes changes.
+
+; RUN: opt -disable-verify -debug-pass-manager \
+; RUN:     -passes='function(require<domtree>,require<postdomtree>),ipsccp,function(require<domtree>,require<postdomtree>)' -S  %s 2>&1 \
+; RUN:     | FileCheck -check-prefixes='IR,NEW-PM' %s
+
+; RUN: opt -passes='function(require<postdomtree>),ipsccp,function(verify<domtree>)' -S  %s | FileCheck -check-prefixes='IR' %s
+
+; NEW-PM: Starting llvm::Module pass manager run.
+; NEW-PM: Running analysis: DominatorTreeAnalysis on f1
+; NEW-PM: Running analysis: PostDominatorTreeAnalysis on f1
+; NEW-PM: Running analysis: DominatorTreeAnalysis on f2
+; NEW-PM: Running analysis: PostDominatorTreeAnalysis on f2
+; NEW-PM: Running pass: IPSCCPPass
+; NEW-PM-DAG: Running analysis: AssumptionAnalysis on f1
+; NEW-PM-DAG: Running analysis: AssumptionAnalysis on f2
+; NEW-PM-NEXT: Invalidating all non-preserved analyses for:
+; NEW-PM-NEXT: Invalidating all non-preserved analyses for: f1
+; NEW-PM-NEXT: Invalidating all non-preserved analyses for: f2
+; NEW-PM-NEXT: Running pass: ModuleToFunctionPassAdaptor
+; NEW-PM-NOT: Running analysis:
+
+; IR-LABEL: @f1
+; IR-LABEL: entry:
+; IR-NEXT: br label %bb2
+; IR-LABEL: bb2:
+; IR-NEXT: undef
+
+; IR-LABEL: @f2
+; IR-NOT: icmp
+; IR:    br label %bbtrue
+; IR-LABEL: bbtrue:
+; IR-NEXT:   ret i32 0
+define internal i32 @f1() readnone {
+entry:
+  br i1 false, label %bb1, label %bb2
+bb1:
+  ret i32 10
+bb2:
+  ret i32 10
+}
+
+define i32 @f2(i32 %n) {
+  %i = call i32 @f1()
+  %cmp = icmp eq i32 %i, 10
+  br i1 %cmp, label %bbtrue, label %bbfalse
+
+bbtrue:
+  ret i32 0
+
+bbfalse:
+  %res = add i32 %n, %i
+  ret i32 %res
+}

test/Transforms/SCCP/ipsccp-preserve-domtree.ll

-; Basic test to check that DominatorTreeAnalysis is preserved by IPSCCP and
-; the following analysis can re-use it. The test contains two trivial functions
-; IPSCCP can simplify, so we can test the case where IPSCCP makes changes.
-
-; RUN: opt -disable-verify -debug-pass-manager \
-; RUN:     -passes='ipsccp,globalopt' -S  %s 2>&1 \
-; RUN:     | FileCheck -check-prefixes='IR,NEW-PM' %s
-
-; RUN: opt -passes='ipsccp,function(verify<domtree>)' -S  %s | FileCheck -check-prefixes='IR' %s
-
-; NEW-PM: Starting llvm::Module pass manager run.
-; NEW-PM-NEXT: Running pass: IPSCCPPass
-; NEW-PM-DAG: Running analysis: TargetLibraryAnalysis
-; NEW-PM-DAG: Running analysis: InnerAnalysisManagerProxy
-; NEW-PM-DAG: Running analysis: AssumptionAnalysis on f1
-; NEW-PM-DAG: Running analysis: DominatorTreeAnalysis on f1
-; NEW-PM-DAG: Running analysis: PassInstrumentationAnalysis on f1
-; NEW-PM-DAG: Running analysis: DominatorTreeAnalysis on f2
-; NEW-PM-DAG: Running analysis: AssumptionAnalysis on f2
-; NEW-PM-DAG: Running analysis: PassInstrumentationAnalysis on f2
-; NEW-PM-NEXT: Invalidating all non-preserved analyses for:
-; NEW-PM-NEXT: Invalidating all non-preserved analyses for: f1
-; NEW-PM-NEXT: Invalidating all non-preserved analyses for: f2
-; NEW-PM-NEXT: Running pass: GlobalOptPass on
-; NEW-PM-DAG: Running analysis: BlockFrequencyAnalysis on f2
-; NEW-PM-DAG: Running analysis: LoopAnalysis on f2
-; NEW-PM-DAG: Running analysis: BranchProbabilityAnalysis on f2
-; NEW-PM-DAG: Running analysis: TargetLibraryAnalysis on f2
-; NEW-PM-NEXT: Running analysis: TargetIRAnalysis on f1
-; NEW-PM-NEXT: Invalidating all non-preserved analyses for:
-
-; IR-LABEL: @f1
-; IR-LABEL: entry:
-; IR-NEXT: br label %bb2
-; IR-LABEL: bb2:
-; IR-NEXT: undef
-
-; IR-LABEL: @f2
-; IR-NOT: icmp
-; IR:    br label %bbtrue
-; IR-LABEL: bbtrue:
-; IR-NEXT:   ret i32 0
-define internal i32 @f1() readnone {
-entry:
-  br i1 false, label %bb1, label %bb2
-bb1:
-  ret i32 10
-bb2:
-  ret i32 10
-}
-
-define i32 @f2(i32 %n) {
-  %i = call i32 @f1()
-  %cmp = icmp eq i32 %i, 10
-  br i1 %cmp, label %bbtrue, label %bbfalse
-
-bbtrue:
-  ret i32 0
-
-bbfalse:
-  %res = add i32 %n, %i
-  ret i32 %res
-}