[PM] Introduce the facilities for registering cross-IR-unit dependencies
that require deferred invalidation.
This handles the other real-world invalidation scenario that we have
cases of: a function analysis which caches references to a module
analysis. We currently do this in the AA aggregation layer and might
well do this in other places as well.
Since this is relative rare, the technique is somewhat more cumbersome.
Analyses need to register themselves when accessing the outer analysis
manager's proxy. This proxy is already necessarily present to allow
access to the outer IR unit's analyses. By registering here we can track
and trigger invalidation when that outer analysis goes away.
To make this work we need to enhance the PreservedAnalyses
infrastructure to support a (slightly) more explicit model for "sets" of
analyses, and allow abandoning a single specific analyses even when
a set covering that analysis is preserved. That allows us to describe
the scenario of preserving all Function analyses *except* for the one
where deferred invalidation has triggered.
We also need to teach the invalidator API to support direct ID calls
instead of always going through a template to dispatch so that we can
just record the ID mapping.
I've introduced testing of all of this both for simple module<->function
cases as well as for more complex cases involving a CGSCC layer.
Much like the previous patch I've not tried to fully update the loop
pass management layer because that layer is due to be heavily reworked
to use similar techniques to the CGSCC to handle updates. As that
happens, we'll have a better testing basis for adding support like this.
Many thanks to both Justin and Sean for the extensive reviews on this to
help bring the API design and documentation into a better state.
Differential Revision: https://reviews.llvm.org/D27198
llvm-svn: 290594
diff --git a/llvm/unittests/IR/PassManagerTest.cpp b/llvm/unittests/IR/PassManagerTest.cpp
index d7515ba..b3a039a 100644
--- a/llvm/unittests/IR/PassManagerTest.cpp
+++ b/llvm/unittests/IR/PassManagerTest.cpp
@@ -168,37 +168,224 @@
"}\n")) {}
};
-TEST_F(PassManagerTest, BasicPreservedAnalyses) {
+TEST(PreservedAnalysesTest, Basic) {
PreservedAnalyses PA1 = PreservedAnalyses();
- EXPECT_FALSE(PA1.preserved<TestFunctionAnalysis>());
- EXPECT_FALSE(PA1.preserved<TestModuleAnalysis>());
- PreservedAnalyses PA2 = PreservedAnalyses::none();
- EXPECT_FALSE(PA2.preserved<TestFunctionAnalysis>());
- EXPECT_FALSE(PA2.preserved<TestModuleAnalysis>());
- PreservedAnalyses PA3 = PreservedAnalyses::all();
- EXPECT_TRUE(PA3.preserved<TestFunctionAnalysis>());
- EXPECT_TRUE(PA3.preserved<TestModuleAnalysis>());
+ {
+ auto PAC = PA1.getChecker<TestFunctionAnalysis>();
+ EXPECT_FALSE(PAC.preserved());
+ EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
+ }
+ {
+ auto PAC = PA1.getChecker<TestModuleAnalysis>();
+ EXPECT_FALSE(PAC.preserved());
+ EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Module>>());
+ }
+ auto PA2 = PreservedAnalyses::none();
+ {
+ auto PAC = PA2.getChecker<TestFunctionAnalysis>();
+ EXPECT_FALSE(PAC.preserved());
+ EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
+ }
+ auto PA3 = PreservedAnalyses::all();
+ {
+ auto PAC = PA3.getChecker<TestFunctionAnalysis>();
+ EXPECT_TRUE(PAC.preserved());
+ EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
+ }
PreservedAnalyses PA4 = PA1;
- EXPECT_FALSE(PA4.preserved<TestFunctionAnalysis>());
- EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
+ {
+ auto PAC = PA4.getChecker<TestFunctionAnalysis>();
+ EXPECT_FALSE(PAC.preserved());
+ EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
+ }
PA4 = PA3;
- EXPECT_TRUE(PA4.preserved<TestFunctionAnalysis>());
- EXPECT_TRUE(PA4.preserved<TestModuleAnalysis>());
+ {
+ auto PAC = PA4.getChecker<TestFunctionAnalysis>();
+ EXPECT_TRUE(PAC.preserved());
+ EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
+ }
PA4 = std::move(PA2);
- EXPECT_FALSE(PA4.preserved<TestFunctionAnalysis>());
- EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
- PA4.preserve<TestFunctionAnalysis>();
- EXPECT_TRUE(PA4.preserved<TestFunctionAnalysis>());
- EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
- PA1.preserve<TestModuleAnalysis>();
- EXPECT_FALSE(PA1.preserved<TestFunctionAnalysis>());
- EXPECT_TRUE(PA1.preserved<TestModuleAnalysis>());
+ {
+ auto PAC = PA4.getChecker<TestFunctionAnalysis>();
+ EXPECT_FALSE(PAC.preserved());
+ EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
+ }
+}
+
+TEST(PreservedAnalysesTest, Preserve) {
+ auto PA = PreservedAnalyses::none();
+ PA.preserve<TestFunctionAnalysis>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>().preserved());
+ PA.preserve<TestModuleAnalysis>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>().preserved());
+
+ // Redundant calls are fine.
+ PA.preserve<TestFunctionAnalysis>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>().preserved());
+}
+
+TEST(PreservedAnalysesTest, PreserveSets) {
+ auto PA = PreservedAnalyses::none();
+ PA.preserveSet<AllAnalysesOn<Function>>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+ PA.preserveSet<AllAnalysesOn<Module>>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Mixing is fine.
+ PA.preserve<TestFunctionAnalysis>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Redundant calls are fine.
+ PA.preserveSet<AllAnalysesOn<Module>>();
+ EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+}
+
+TEST(PreservedAnalysisTest, Intersect) {
+ // Setup the initial sets.
+ auto PA1 = PreservedAnalyses::none();
PA1.preserve<TestFunctionAnalysis>();
- EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>());
- EXPECT_TRUE(PA1.preserved<TestModuleAnalysis>());
- PA1.intersect(PA4);
- EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>());
- EXPECT_FALSE(PA1.preserved<TestModuleAnalysis>());
+ PA1.preserveSet<AllAnalysesOn<Module>>();
+ auto PA2 = PreservedAnalyses::none();
+ PA2.preserve<TestFunctionAnalysis>();
+ PA2.preserveSet<AllAnalysesOn<Function>>();
+ PA2.preserve<TestModuleAnalysis>();
+ PA2.preserveSet<AllAnalysesOn<Module>>();
+ auto PA3 = PreservedAnalyses::none();
+ PA3.preserve<TestModuleAnalysis>();
+ PA3.preserveSet<AllAnalysesOn<Function>>();
+
+ // Self intersection is a no-op.
+ auto Intersected = PA1;
+ Intersected.intersect(PA1);
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting with all is a no-op.
+ Intersected.intersect(PreservedAnalyses::all());
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting a narrow set with a more broad set is the narrow set.
+ Intersected.intersect(PA2);
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting a broad set with a more narrow set is the narrow set.
+ Intersected = PA2;
+ Intersected.intersect(PA1);
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting with empty clears.
+ Intersected.intersect(PreservedAnalyses::none());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting non-overlapping clears.
+ Intersected = PA1;
+ Intersected.intersect(PA3);
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting with moves works in when there is storage on both sides.
+ Intersected = PA1;
+ auto Tmp = PA2;
+ Intersected.intersect(std::move(Tmp));
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // Intersecting with move works for incoming all and existing all.
+ auto Tmp2 = PreservedAnalyses::all();
+ Intersected.intersect(std::move(Tmp2));
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+ Intersected = PreservedAnalyses::all();
+ auto Tmp3 = PA1;
+ Intersected.intersect(std::move(Tmp3));
+ EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
+ EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
+ EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+}
+
+TEST(PreservedAnalysisTest, Abandon) {
+ auto PA = PreservedAnalyses::none();
+
+ // We can abandon things after they are preserved.
+ PA.preserve<TestFunctionAnalysis>();
+ PA.abandon<TestFunctionAnalysis>();
+ EXPECT_FALSE(PA.getChecker<TestFunctionAnalysis>().preserved());
+
+ // Repeated is fine, and abandoning if they were never preserved is fine.
+ PA.abandon<TestFunctionAnalysis>();
+ EXPECT_FALSE(PA.getChecker<TestFunctionAnalysis>().preserved());
+ PA.abandon<TestModuleAnalysis>();
+ EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>().preserved());
+
+ // Even if the sets are preserved, the abandoned analyses' checker won't
+ // return true for those sets.
+ PA.preserveSet<AllAnalysesOn<Function>>();
+ PA.preserveSet<AllAnalysesOn<Module>>();
+ EXPECT_FALSE(PA.getChecker<TestFunctionAnalysis>()
+ .preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>()
+ .preservedSet<AllAnalysesOn<Module>>());
+
+ // But an arbitrary (opaque) analysis will still observe the sets as
+ // preserved. This also checks that we can use an explicit ID rather than
+ // a type.
+ AnalysisKey FakeKey, *FakeID = &FakeKey;
+ EXPECT_TRUE(PA.getChecker(FakeID).preservedSet<AllAnalysesOn<Function>>());
+ EXPECT_TRUE(PA.getChecker(FakeID).preservedSet<AllAnalysesOn<Module>>());
}
TEST_F(PassManagerTest, Basic) {
@@ -385,12 +572,16 @@
struct TestIndirectFunctionAnalysis
: public AnalysisInfoMixin<TestIndirectFunctionAnalysis> {
struct Result {
- Result(TestFunctionAnalysis::Result &Dep) : Dep(Dep) {}
- TestFunctionAnalysis::Result &Dep;
+ Result(TestFunctionAnalysis::Result &FDep, TestModuleAnalysis::Result &MDep)
+ : FDep(FDep), MDep(MDep) {}
+ TestFunctionAnalysis::Result &FDep;
+ TestModuleAnalysis::Result &MDep;
bool invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &Inv) {
- return !PA.preserved<TestIndirectFunctionAnalysis>() ||
+ auto PAC = PA.getChecker<TestIndirectFunctionAnalysis>();
+ return !(PAC.preserved() ||
+ PAC.preservedSet<AllAnalysesOn<Function>>()) ||
Inv.invalidate<TestFunctionAnalysis>(F, PA);
}
};
@@ -400,7 +591,17 @@
/// Run the analysis pass over the function and return a result.
Result run(Function &F, FunctionAnalysisManager &AM) {
++Runs;
- return Result(AM.getResult<TestFunctionAnalysis>(F));
+ auto &FDep = AM.getResult<TestFunctionAnalysis>(F);
+ auto &Proxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
+ const ModuleAnalysisManager &MAM = Proxy.getManager();
+ // For the test, we insist that the module analysis starts off in the
+ // cache.
+ auto &MDep = *MAM.getCachedResult<TestModuleAnalysis>(*F.getParent());
+ // And register the dependency as module analysis dependencies have to be
+ // pre-registered on the proxy.
+ Proxy.registerOuterAnalysisInvalidation<TestModuleAnalysis,
+ TestIndirectFunctionAnalysis>();
+ return Result(FDep, MDep);
}
private:
@@ -412,6 +613,46 @@
AnalysisKey TestIndirectFunctionAnalysis::Key;
+/// A test analysis pass which chaches in its result the result from the above
+/// indirect analysis pass.
+///
+/// This allows us to ensure that whenever an analysis pass is invalidated due
+/// to dependencies (especially dependencies across IR units that trigger
+/// asynchronous invalidation) we correctly detect that this may in turn cause
+/// other analysis to be invalidated.
+struct TestDoublyIndirectFunctionAnalysis
+ : public AnalysisInfoMixin<TestDoublyIndirectFunctionAnalysis> {
+ struct Result {
+ Result(TestIndirectFunctionAnalysis::Result &IDep) : IDep(IDep) {}
+ TestIndirectFunctionAnalysis::Result &IDep;
+
+ bool invalidate(Function &F, const PreservedAnalyses &PA,
+ FunctionAnalysisManager::Invalidator &Inv) {
+ auto PAC = PA.getChecker<TestDoublyIndirectFunctionAnalysis>();
+ return !(PAC.preserved() ||
+ PAC.preservedSet<AllAnalysesOn<Function>>()) ||
+ Inv.invalidate<TestIndirectFunctionAnalysis>(F, PA);
+ }
+ };
+
+ TestDoublyIndirectFunctionAnalysis(int &Runs) : Runs(Runs) {}
+
+ /// Run the analysis pass over the function and return a result.
+ Result run(Function &F, FunctionAnalysisManager &AM) {
+ ++Runs;
+ auto &IDep = AM.getResult<TestIndirectFunctionAnalysis>(F);
+ return Result(IDep);
+ }
+
+private:
+ friend AnalysisInfoMixin<TestDoublyIndirectFunctionAnalysis>;
+ static AnalysisKey Key;
+
+ int &Runs;
+};
+
+AnalysisKey TestDoublyIndirectFunctionAnalysis::Key;
+
struct LambdaPass : public PassInfoMixin<LambdaPass> {
using FuncT = std::function<PreservedAnalyses(Function &, FunctionAnalysisManager &)>;
@@ -426,23 +667,31 @@
TEST_F(PassManagerTest, IndirectAnalysisInvalidation) {
FunctionAnalysisManager FAM(/*DebugLogging*/ true);
- int AnalysisRuns = 0, IndirectAnalysisRuns = 0;
- FAM.registerPass([&] { return TestFunctionAnalysis(AnalysisRuns); });
+ int FunctionAnalysisRuns = 0, ModuleAnalysisRuns = 0,
+ IndirectAnalysisRuns = 0, DoublyIndirectAnalysisRuns = 0;
+ FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
FAM.registerPass(
[&] { return TestIndirectFunctionAnalysis(IndirectAnalysisRuns); });
+ FAM.registerPass([&] {
+ return TestDoublyIndirectFunctionAnalysis(DoublyIndirectAnalysisRuns);
+ });
ModuleAnalysisManager MAM(/*DebugLogging*/ true);
+ MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
- int InstrCount = 0;
+ int InstrCount = 0, FunctionCount = 0;
ModulePassManager MPM(/*DebugLogging*/ true);
FunctionPassManager FPM(/*DebugLogging*/ true);
// First just use the analysis to get the instruction count, and preserve
// everything.
FPM.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
- InstrCount +=
- AM.getResult<TestIndirectFunctionAnalysis>(F).Dep.InstructionCount;
+ auto &DoublyIndirectResult =
+ AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
+ auto &IndirectResult = DoublyIndirectResult.IDep;
+ InstrCount += IndirectResult.FDep.InstructionCount;
+ FunctionCount += IndirectResult.MDep.FunctionCount;
return PreservedAnalyses::all();
}));
// Next, invalidate
@@ -450,8 +699,11 @@
// - just the underlying (indirect) analysis for "g", and
// - just the direct analysis for "h".
FPM.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
- InstrCount +=
- AM.getResult<TestIndirectFunctionAnalysis>(F).Dep.InstructionCount;
+ auto &DoublyIndirectResult =
+ AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
+ auto &IndirectResult = DoublyIndirectResult.IDep;
+ InstrCount += IndirectResult.FDep.InstructionCount;
+ FunctionCount += IndirectResult.MDep.FunctionCount;
auto PA = PreservedAnalyses::none();
if (F.getName() == "g")
PA.preserve<TestFunctionAnalysis>();
@@ -462,23 +714,55 @@
// Finally, use the analysis again on each function, forcing re-computation
// for all of them.
FPM.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
- InstrCount +=
- AM.getResult<TestIndirectFunctionAnalysis>(F).Dep.InstructionCount;
+ auto &DoublyIndirectResult =
+ AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
+ auto &IndirectResult = DoublyIndirectResult.IDep;
+ InstrCount += IndirectResult.FDep.InstructionCount;
+ FunctionCount += IndirectResult.MDep.FunctionCount;
return PreservedAnalyses::all();
}));
+
+ // Create a second function pass manager. This will cause the module-level
+ // invalidation to occur, which will force yet another invalidation of the
+ // indirect function-level analysis as the module analysis it depends on gets
+ // invalidated.
+ FunctionPassManager FPM2(/*DebugLogging*/ true);
+ FPM2.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
+ auto &DoublyIndirectResult =
+ AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
+ auto &IndirectResult = DoublyIndirectResult.IDep;
+ InstrCount += IndirectResult.FDep.InstructionCount;
+ FunctionCount += IndirectResult.MDep.FunctionCount;
+ return PreservedAnalyses::all();
+ }));
+
+ // Add a requires pass to populate the module analysis and then our function
+ // pass pipeline.
+ MPM.addPass(RequireAnalysisPass<TestModuleAnalysis, Module>());
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+ // Now require the module analysis again (it will have been invalidated once)
+ // and then use it again from a function pass manager.
+ MPM.addPass(RequireAnalysisPass<TestModuleAnalysis, Module>());
+ MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM2)));
MPM.run(*M, MAM);
// There are generally two possible runs for each of the three functions. But
// for one function, we only invalidate the indirect analysis so the base one
// only gets run five times.
- EXPECT_EQ(5, AnalysisRuns);
+ EXPECT_EQ(5, FunctionAnalysisRuns);
+ // The module analysis pass should be run twice here.
+ EXPECT_EQ(2, ModuleAnalysisRuns);
// The indirect analysis is invalidated for each function (either directly or
// indirectly) and run twice for each.
- EXPECT_EQ(6, IndirectAnalysisRuns);
+ EXPECT_EQ(9, IndirectAnalysisRuns);
+ EXPECT_EQ(9, DoublyIndirectAnalysisRuns);
- // There are five instructions in the module and we add the count three
+ // There are five instructions in the module and we add the count four
// times.
- EXPECT_EQ(5 * 3, InstrCount);
+ EXPECT_EQ(5 * 4, InstrCount);
+
+ // There are three functions and we count them four times for each of the
+ // three functions.
+ EXPECT_EQ(3 * 4 * 3, FunctionCount);
}
}