[PM] The assumption cache is fundamentally designed to be self-updating,

mark it as never invalidated in the new PM.

The old PM already required this to work, and after a discussion with
Hal this seems to really be the only sensible answer. The cache
gracefully degrades as the IR is mutated, and most things which do this
should already be incrementally updating the cache.

This gets rid of a bunch of logic preserving and testing the
invalidation of this analysis.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@292039 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/AssumptionCache.h b/include/llvm/Analysis/AssumptionCache.h
index b50545a0484be6de2b1d43b0cdb25a3a07ff155b..c3b5428c5ab9b5edea121c536de0d2effbb63631 100644 (file)
--- a/include/llvm/Analysis/AssumptionCache.h
+++ b/include/llvm/Analysis/AssumptionCache.h
@@ -84,6 +84,13 @@ public:
   /// its instructions.
   AssumptionCache(Function &F) : F(F), Scanned(false) {}
 
+  /// This cache is designed to be self-updating and so it should never be
+  /// invalidated.
+  bool invalidate(Function &, const PreservedAnalyses &,
+                  FunctionAnalysisManager::Invalidator &) {
+    return false;
+  }
+
   /// \brief Add an @llvm.assume intrinsic to this function's cache.
   ///
   /// The call passed in must be an instruction within this function and must

diff --git a/include/llvm/Transforms/Scalar/LoopPassManager.h b/include/llvm/Transforms/Scalar/LoopPassManager.h
index b0e6dd6f4c0817532fafd879c15eccb92ee41ef7..e9973fec6bdd1a3749a4f5c3a78dd9fe1dde7a1b 100644 (file)
--- a/include/llvm/Transforms/Scalar/LoopPassManager.h
+++ b/include/llvm/Transforms/Scalar/LoopPassManager.h
@@ -321,7 +321,6 @@ public:
     PA.preserveSet<AllAnalysesOn<Loop>>();
     PA.preserve<LoopAnalysisManagerFunctionProxy>();
     // We also preserve the set of standard analyses.
-    PA.preserve<AssumptionAnalysis>();
     PA.preserve<DominatorTreeAnalysis>();
     PA.preserve<LoopAnalysis>();
     PA.preserve<ScalarEvolutionAnalysis>();

diff --git a/lib/Analysis/LoopAnalysisManager.cpp b/lib/Analysis/LoopAnalysisManager.cpp
index 5be3ee341c9c237644870b614bfa2c9e8c1d6849..2946baef8aeb03450222fd1edd76fb12d858cf86 100644 (file)
--- a/lib/Analysis/LoopAnalysisManager.cpp
+++ b/lib/Analysis/LoopAnalysisManager.cpp
@@ -145,7 +145,6 @@ LoopAnalysisManagerFunctionProxy::run(Function &F,
 
 PreservedAnalyses llvm::getLoopPassPreservedAnalyses() {
   PreservedAnalyses PA;
-  PA.preserve<AssumptionAnalysis>();
   PA.preserve<DominatorTreeAnalysis>();
   PA.preserve<LoopAnalysis>();
   PA.preserve<LoopAnalysisManagerFunctionProxy>();

diff --git a/lib/Transforms/InstCombine/InstructionCombining.cpp b/lib/Transforms/InstCombine/InstructionCombining.cpp
index b2c4baae99b775e84bdd3ae5bb6b2bd596e3d11e..8ba19fd02f8e3b8386c7fc08caac5d977ba3bf5a 100644 (file)
--- a/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -3179,7 +3179,6 @@ PreservedAnalyses InstCombinePass::run(Function &F,
   // FIXME: This should also 'preserve the CFG'.
   PreservedAnalyses PA;
   PA.preserve<AAManager>();
-  PA.preserve<AssumptionAnalysis>();
   PA.preserve<DominatorTreeAnalysis>();
   PA.preserve<GlobalsAA>();
   return PA;

diff --git a/test/Analysis/MemoryDependenceAnalysis/invalidation.ll b/test/Analysis/MemoryDependenceAnalysis/invalidation.ll
index 6e5d4a4bf846f8febb0c132e53a461eb0eaf177c..478ffc2914b7a7d075604ff704b7b34fca947278 100644 (file)
--- a/test/Analysis/MemoryDependenceAnalysis/invalidation.ll
+++ b/test/Analysis/MemoryDependenceAnalysis/invalidation.ll
@@ -13,20 +13,6 @@
 ; CHECK-AA-INVALIDATE: Running pass: GVN
 ; CHECK-AA-INVALIDATE: Running analysis: MemoryDependenceAnalysis
 ;
-; Check the assumptions analysis specifically.
-; FIXME: We don't have any test cases that actually fail if the assumption
-; cache becomes stale. This just tests what we believe to be correct.
-; RUN: opt -disable-output -debug-pass-manager %s 2>&1 \
-; RUN:     -passes='require<memdep>,invalidate<assumptions>,gvn' \
-; RUN:     | FileCheck %s --check-prefix=CHECK-ASSUMPTIONS-INVALIDATE
-; CHECK-ASSUMPTIONS-INVALIDATE: Running pass: RequireAnalysisPass
-; CHECK-ASSUMPTIONS-INVALIDATE: Running analysis: MemoryDependenceAnalysis
-; CHECK-ASSUMPTIONS-INVALIDATE: Running pass: InvalidateAnalysisPass
-; CHECK-ASSUMPTIONS-INVALIDATE: Invalidating analysis: AssumptionAnalysis
-; CHECK-ASSUMPTIONS-INVALIDATE: Invalidating analysis: MemoryDependenceAnalysis
-; CHECK-ASSUMPTIONS-INVALIDATE: Running pass: GVN
-; CHECK-ASSUMPTIONS-INVALIDATE: Running analysis: MemoryDependenceAnalysis
-;
 ; Check domtree specifically.
 ; RUN: opt -disable-output -debug-pass-manager %s 2>&1 \
 ; RUN:     -passes='require<memdep>,invalidate<domtree>,gvn' \

diff --git a/test/Analysis/ScalarEvolution/invalidation.ll b/test/Analysis/ScalarEvolution/invalidation.ll
index 1fcaddb525e646f4015009747ca5d4ab8db7f3ee..f750b3d4e5c5a29eaa1abdeb1fbf2c093bc5ea10 100644 (file)
--- a/test/Analysis/ScalarEvolution/invalidation.ll
+++ b/test/Analysis/ScalarEvolution/invalidation.ll
@@ -8,19 +8,6 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-; RUN: opt < %s -passes='require<scalar-evolution>,invalidate<assumptions>,print<scalar-evolution>' \
-; RUN:     -debug-pass-manager -disable-output 2>&1 \
-; RUN:     | FileCheck %s -check-prefixes=CHECK,CHECK-AC-INVALIDATE
-;
-; CHECK-AC-INVALIDATE: Running pass: RequireAnalysisPass
-; CHECK-AC-INVALIDATE: Running analysis: ScalarEvolutionAnalysis
-; CHECK-AC-INVALIDATE: Running analysis: AssumptionAnalysis
-; CHECK-AC-INVALIDATE: Running pass: InvalidateAnalysisPass
-; CHECK-AC-INVALIDATE: Invalidating analysis: AssumptionAnalysis
-; CHECK-AC-INVALIDATE: Running pass: ScalarEvolutionPrinterPass
-; CHECK-AC-INVALIDATE: Running analysis: ScalarEvolutionAnalysis
-; CHECK-AC-INVALIDATE: Running analysis: AssumptionAnalysis
-
 ; RUN: opt < %s -passes='require<scalar-evolution>,invalidate<domtree>,print<scalar-evolution>' \
 ; RUN:     -debug-pass-manager -disable-output 2>&1 \
 ; RUN:     | FileCheck %s -check-prefixes=CHECK,CHECK-DT-INVALIDATE

diff --git a/unittests/Transforms/Scalar/LoopPassManagerTest.cpp b/unittests/Transforms/Scalar/LoopPassManagerTest.cpp
index a099e35c7f195a9c7b071b59103248d0763570be..8f5a0c91b55d4f4544e4a4821ad4b8cf43766b2b 100644 (file)
--- a/unittests/Transforms/Scalar/LoopPassManagerTest.cpp
+++ b/unittests/Transforms/Scalar/LoopPassManagerTest.cpp
@@ -551,7 +551,6 @@ TEST_F(LoopPassManagerTest, InvalidationOfBundledAnalyses) {
   EXPECT_CALL(MFPHandle, run(HasName("f"), _)).WillOnce(InvokeWithoutArgs([] {
     auto PA = PreservedAnalyses::none();
     // Not preserving `AAManager`.
-    PA.preserve<AssumptionAnalysis>();
     PA.preserve<DominatorTreeAnalysis>();
     PA.preserve<LoopAnalysis>();
     PA.preserve<LoopAnalysisManagerFunctionProxy>();
@@ -568,24 +567,6 @@ TEST_F(LoopPassManagerTest, InvalidationOfBundledAnalyses) {
   EXPECT_CALL(MFPHandle, run(HasName("f"), _)).WillOnce(InvokeWithoutArgs([] {
     auto PA = PreservedAnalyses::none();
     PA.preserve<AAManager>();
-    // Not preserving `AssumptionAnalysis`.
-    PA.preserve<DominatorTreeAnalysis>();
-    PA.preserve<LoopAnalysis>();
-    PA.preserve<LoopAnalysisManagerFunctionProxy>();
-    PA.preserve<ScalarEvolutionAnalysis>();
-    return PA;
-  }));
-  EXPECT_CALL(MLAHandle, run(HasName("loop.0.0"), _, _));
-  EXPECT_CALL(MLAHandle, run(HasName("loop.0.1"), _, _));
-  EXPECT_CALL(MLAHandle, run(HasName("loop.0"), _, _));
-  FPM.addPass(MFPHandle.getPass());
-  FPM.addPass(createFunctionToLoopPassAdaptor(
-      RequireAnalysisLoopPass<MockLoopAnalysisHandle::Analysis>()));
-
-  EXPECT_CALL(MFPHandle, run(HasName("f"), _)).WillOnce(InvokeWithoutArgs([] {
-    auto PA = PreservedAnalyses::none();
-    PA.preserve<AAManager>();
-    PA.preserve<AssumptionAnalysis>();
     // Not preserving `DominatorTreeAnalysis`.
     PA.preserve<LoopAnalysis>();
     PA.preserve<LoopAnalysisManagerFunctionProxy>();
@@ -602,7 +583,6 @@ TEST_F(LoopPassManagerTest, InvalidationOfBundledAnalyses) {
   EXPECT_CALL(MFPHandle, run(HasName("f"), _)).WillOnce(InvokeWithoutArgs([] {
     auto PA = PreservedAnalyses::none();
     PA.preserve<AAManager>();
-    PA.preserve<AssumptionAnalysis>();
     PA.preserve<DominatorTreeAnalysis>();
     // Not preserving the `LoopAnalysis`.
     PA.preserve<LoopAnalysisManagerFunctionProxy>();
@@ -619,7 +599,6 @@ TEST_F(LoopPassManagerTest, InvalidationOfBundledAnalyses) {
   EXPECT_CALL(MFPHandle, run(HasName("f"), _)).WillOnce(InvokeWithoutArgs([] {
     auto PA = PreservedAnalyses::none();
     PA.preserve<AAManager>();
-    PA.preserve<AssumptionAnalysis>();
     PA.preserve<DominatorTreeAnalysis>();
     PA.preserve<LoopAnalysis>();
     // Not preserving the `LoopAnalysisManagerFunctionProxy`.
@@ -636,7 +615,6 @@ TEST_F(LoopPassManagerTest, InvalidationOfBundledAnalyses) {
   EXPECT_CALL(MFPHandle, run(HasName("f"), _)).WillOnce(InvokeWithoutArgs([] {
     auto PA = PreservedAnalyses::none();
     PA.preserve<AAManager>();
-    PA.preserve<AssumptionAnalysis>();
     PA.preserve<DominatorTreeAnalysis>();
     PA.preserve<LoopAnalysis>();
     PA.preserve<LoopAnalysisManagerFunctionProxy>();
@@ -654,7 +632,7 @@ TEST_F(LoopPassManagerTest, InvalidationOfBundledAnalyses) {
   // 'g' once with a requires pass and then run our mock pass over g a bunch
   // but just get cached results each time.
   EXPECT_CALL(MLAHandle, run(HasName("loop.g.0"), _, _));
-  EXPECT_CALL(MFPHandle, run(HasName("g"), _)).Times(7);
+  EXPECT_CALL(MFPHandle, run(HasName("g"), _)).Times(6);
 
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
   MPM.run(*M, MAM);