maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[NewPM][PassInstrumentation] Add PreservedAnalyses parameter to AfterPass* callbacks 

Both AfterPass and AfterPassInvalidated pass instrumentation
callbacks get additional parameter of type PreservedAnalyses.
This patch was created by @fedor.sergeev. I have just slightly
changed it.

Reviewers: fedor.sergeev

Differential Revision: https://reviews.llvm.org/D81555
This commit is contained in:
Yevgeny Rouban 2020-08-21 15:52:26 +07:00
parent 33bb80bc7a
commit 18bc400f97
11 changed files with 85 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
llvm/include/llvm/Analysis/CGSCCPassManager.h
View File

@ -508,7 +508,7 @@ public:
PassPA = Pass.run(F, FAM); PassPA = Pass.run(F, FAM);
} }
PI.runAfterPass<Function>(Pass, F); PI.runAfterPass<Function>(Pass, F, PassPA);
// We know that the function pass couldn't have invalidated any other // We know that the function pass couldn't have invalidated any other
// function's analyses (that's the contract of a function pass), so // function's analyses (that's the contract of a function pass), so
@ -639,9 +639,9 @@ public:
PreservedAnalyses PassPA = Pass.run(*C, AM, CG, UR); PreservedAnalyses PassPA = Pass.run(*C, AM, CG, UR);
if (UR.InvalidatedSCCs.count(C)) if (UR.InvalidatedSCCs.count(C))
PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass); PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass, PassPA);
else else
PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C); PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C, PassPA);
// If the SCC structure has changed, bail immediately and let the outer // If the SCC structure has changed, bail immediately and let the outer
// CGSCC layer handle any iteration to reflect the refined structure. // CGSCC layer handle any iteration to reflect the refined structure.
@ -903,9 +903,9 @@ ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>::run(Module &M,
} }
if (UR.InvalidatedSCCs.count(C)) if (UR.InvalidatedSCCs.count(C))
PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass); PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass, PassPA);
else else
PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C); PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C, PassPA);
// Update the SCC and RefSCC if necessary. // Update the SCC and RefSCC if necessary.
C = UR.UpdatedC ? UR.UpdatedC : C; C = UR.UpdatedC ? UR.UpdatedC : C;

14
llvm/include/llvm/IR/PassInstrumentation.h
View File

@ -76,8 +76,8 @@ public:
using BeforePassFunc = bool(StringRef, Any); using BeforePassFunc = bool(StringRef, Any);
using BeforeSkippedPassFunc = void(StringRef, Any); using BeforeSkippedPassFunc = void(StringRef, Any);
using BeforeNonSkippedPassFunc = void(StringRef, Any); using BeforeNonSkippedPassFunc = void(StringRef, Any);
using AfterPassFunc = void(StringRef, Any); using AfterPassFunc = void(StringRef, Any, const PreservedAnalyses &);
using AfterPassInvalidatedFunc = void(StringRef); using AfterPassInvalidatedFunc = void(StringRef, const PreservedAnalyses &);
using BeforeAnalysisFunc = void(StringRef, Any); using BeforeAnalysisFunc = void(StringRef, Any);
using AfterAnalysisFunc = void(StringRef, Any); using AfterAnalysisFunc = void(StringRef, Any);
@ -199,20 +199,22 @@ public:
/// just been executed and constant reference to \p IR it operates on. /// just been executed and constant reference to \p IR it operates on.
/// \p IR is guaranteed to be valid at this point. /// \p IR is guaranteed to be valid at this point.
template <typename IRUnitT, typename PassT> template <typename IRUnitT, typename PassT>
void runAfterPass(const PassT &Pass, const IRUnitT &IR) const { void runAfterPass(const PassT &Pass, const IRUnitT &IR,
const PreservedAnalyses &PA) const {
if (Callbacks) if (Callbacks)
for (auto &C : Callbacks->AfterPassCallbacks) for (auto &C : Callbacks->AfterPassCallbacks)
C(Pass.name(), llvm::Any(&IR)); C(Pass.name(), llvm::Any(&IR), PA);
} }
/// AfterPassInvalidated instrumentation point - takes \p Pass instance /// AfterPassInvalidated instrumentation point - takes \p Pass instance
/// that has just been executed. For use when IR has been invalidated /// that has just been executed. For use when IR has been invalidated
/// by \p Pass execution. /// by \p Pass execution.
template <typename IRUnitT, typename PassT> template <typename IRUnitT, typename PassT>
void runAfterPassInvalidated(const PassT &Pass) const { void runAfterPassInvalidated(const PassT &Pass,
const PreservedAnalyses &PA) const {
if (Callbacks) if (Callbacks)
for (auto &C : Callbacks->AfterPassInvalidatedCallbacks) for (auto &C : Callbacks->AfterPassInvalidatedCallbacks)
C(Pass.name()); C(Pass.name(), PA);
} }
/// BeforeAnalysis instrumentation point - takes \p Analysis instance /// BeforeAnalysis instrumentation point - takes \p Analysis instance

9
llvm/include/llvm/IR/PassManager.h
View File

@ -519,7 +519,7 @@ public:
// Call onto PassInstrumentation's AfterPass callbacks immediately after // Call onto PassInstrumentation's AfterPass callbacks immediately after
// running the pass. // running the pass.
PI.runAfterPass<IRUnitT>(*P, IR); PI.runAfterPass<IRUnitT>(*P, IR, PassPA);
// Update the analysis manager as each pass runs and potentially // Update the analysis manager as each pass runs and potentially
// invalidates analyses. // invalidates analyses.
@ -1244,7 +1244,7 @@ public:
PassPA = Pass.run(F, FAM); PassPA = Pass.run(F, FAM);
} }
PI.runAfterPass(Pass, F); PI.runAfterPass(Pass, F, PassPA);
// We know that the function pass couldn't have invalidated any other // We know that the function pass couldn't have invalidated any other
// function's analyses (that's the contract of a function pass), so // function's analyses (that's the contract of a function pass), so
@ -1369,8 +1369,9 @@ public:
// false). // false).
if (!PI.runBeforePass<IRUnitT>(P, IR)) if (!PI.runBeforePass<IRUnitT>(P, IR))
continue; continue;
PA.intersect(P.run(IR, AM, std::forward<Ts>(Args)...)); PreservedAnalyses IterPA = P.run(IR, AM, std::forward<Ts>(Args)...);
PI.runAfterPass(P, IR); PA.intersect(IterPA);
PI.runAfterPass(P, IR, IterPA);
} }
return PA; return PA;
} }

6
llvm/include/llvm/Transforms/Scalar/LoopPassManager.h
View File

@ -253,7 +253,7 @@ public:
// canonicalization pipeline. // canonicalization pipeline.
if (PI.runBeforePass<Function>(LoopCanonicalizationFPM, F)) { if (PI.runBeforePass<Function>(LoopCanonicalizationFPM, F)) {
PA = LoopCanonicalizationFPM.run(F, AM); PA = LoopCanonicalizationFPM.run(F, AM);
PI.runAfterPass<Function>(LoopCanonicalizationFPM, F); PI.runAfterPass<Function>(LoopCanonicalizationFPM, F, PA);
} }
// Get the loop structure for this function // Get the loop structure for this function
@ -337,9 +337,9 @@ public:
// Do not pass deleted Loop into the instrumentation. // Do not pass deleted Loop into the instrumentation.
if (Updater.skipCurrentLoop()) if (Updater.skipCurrentLoop())
PI.runAfterPassInvalidated<Loop>(Pass); PI.runAfterPassInvalidated<Loop>(Pass, PassPA);
else else
PI.runAfterPass<Loop>(Pass, *L); PI.runAfterPass<Loop>(Pass, *L, PassPA);
// FIXME: We should verify the set of analyses relevant to Loop passes // FIXME: We should verify the set of analyses relevant to Loop passes
// are preserved. // are preserved.

4
llvm/lib/Analysis/CGSCCPassManager.cpp
View File

@ -85,9 +85,9 @@ PassManager<LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &,
} }
if (UR.InvalidatedSCCs.count(C)) if (UR.InvalidatedSCCs.count(C))
PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass); PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
else else
PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C); PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C, PassPA);
// Update the SCC if necessary. // Update the SCC if necessary.
C = UR.UpdatedC ? UR.UpdatedC : C; C = UR.UpdatedC ? UR.UpdatedC : C;

2
llvm/lib/CodeGen/MachinePassManager.cpp
View File

@ -99,7 +99,7 @@ Error MachineFunctionPassManager::run(Module &M,
// TODO: EmitSizeRemarks // TODO: EmitSizeRemarks
PreservedAnalyses PassPA = P->run(MF, MFAM); PreservedAnalyses PassPA = P->run(MF, MFAM);
PI.runAfterPass(*P, MF); PI.runAfterPass(*P, MF, PassPA);
MFAM.invalidate(MF, PassPA); MFAM.invalidate(MF, PassPA);
} }
} }

8
llvm/lib/IR/PassTimingInfo.cpp
View File

@ -260,9 +260,13 @@ void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) {
PIC.registerBeforeNonSkippedPassCallback( PIC.registerBeforeNonSkippedPassCallback(
[this](StringRef P, Any) { this->runBeforePass(P); }); [this](StringRef P, Any) { this->runBeforePass(P); });
PIC.registerAfterPassCallback( PIC.registerAfterPassCallback(
[this](StringRef P, Any) { this->runAfterPass(P); }); [this](StringRef P, Any, const PreservedAnalyses &) {
this->runAfterPass(P);
});
PIC.registerAfterPassInvalidatedCallback( PIC.registerAfterPassInvalidatedCallback(
[this](StringRef P) { this->runAfterPass(P); }); [this](StringRef P, const PreservedAnalyses &) {
this->runAfterPass(P);
});
PIC.registerBeforeAnalysisCallback( PIC.registerBeforeAnalysisCallback(
[this](StringRef P, Any) { this->runBeforePass(P); }); [this](StringRef P, Any) { this->runBeforePass(P); });
PIC.registerAfterAnalysisCallback( PIC.registerAfterAnalysisCallback(

8
llvm/lib/Passes/StandardInstrumentations.cpp
View File

@ -277,9 +277,13 @@ void PrintIRInstrumentation::registerCallbacks(
if (llvm::shouldPrintAfterPass()) { if (llvm::shouldPrintAfterPass()) {
PIC.registerAfterPassCallback( PIC.registerAfterPassCallback(
[this](StringRef P, Any IR) { this->printAfterPass(P, IR); }); [this](StringRef P, Any IR, const PreservedAnalyses &) {
this->printAfterPass(P, IR);
});
PIC.registerAfterPassInvalidatedCallback( PIC.registerAfterPassInvalidatedCallback(
[this](StringRef P) { this->printAfterPassInvalidated(P); }); [this](StringRef P, const PreservedAnalyses &) {
this->printAfterPassInvalidated(P);
});
} }
} }

4
llvm/lib/Transforms/Scalar/LoopPassManager.cpp
View File

@ -47,9 +47,9 @@ PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
// do not pass deleted Loop into the instrumentation // do not pass deleted Loop into the instrumentation
if (U.skipCurrentLoop()) if (U.skipCurrentLoop())
PI.runAfterPassInvalidated<Loop>(*Pass); PI.runAfterPassInvalidated<Loop>(*Pass, PassPA);
else else
PI.runAfterPass<Loop>(*Pass, L); PI.runAfterPass<Loop>(*Pass, L, PassPA);
// If the loop was deleted, abort the run and return to the outer walk. // If the loop was deleted, abort the run and return to the outer walk.
if (U.skipCurrentLoop()) { if (U.skipCurrentLoop()) {

76
llvm/unittests/IR/PassBuilderCallbacksTest.cpp
View File

@ -322,8 +322,10 @@ struct MockPassInstrumentationCallbacks {
MOCK_METHOD2(runBeforePass, bool(StringRef PassID, llvm::Any)); MOCK_METHOD2(runBeforePass, bool(StringRef PassID, llvm::Any));
MOCK_METHOD2(runBeforeSkippedPass, void(StringRef PassID, llvm::Any)); MOCK_METHOD2(runBeforeSkippedPass, void(StringRef PassID, llvm::Any));
MOCK_METHOD2(runBeforeNonSkippedPass, void(StringRef PassID, llvm::Any)); MOCK_METHOD2(runBeforeNonSkippedPass, void(StringRef PassID, llvm::Any));
MOCK_METHOD2(runAfterPass, void(StringRef PassID, llvm::Any)); MOCK_METHOD3(runAfterPass,
MOCK_METHOD1(runAfterPassInvalidated, void(StringRef PassID)); void(StringRef PassID, llvm::Any, const PreservedAnalyses &PA));
MOCK_METHOD2(runAfterPassInvalidated,
void(StringRef PassID, const PreservedAnalyses &PA));
MOCK_METHOD2(runBeforeAnalysis, void(StringRef PassID, llvm::Any)); MOCK_METHOD2(runBeforeAnalysis, void(StringRef PassID, llvm::Any));
MOCK_METHOD2(runAfterAnalysis, void(StringRef PassID, llvm::Any)); MOCK_METHOD2(runAfterAnalysis, void(StringRef PassID, llvm::Any));
@ -340,9 +342,13 @@ struct MockPassInstrumentationCallbacks {
this->runBeforeNonSkippedPass(P, IR); this->runBeforeNonSkippedPass(P, IR);
}); });
Callbacks.registerAfterPassCallback( Callbacks.registerAfterPassCallback(
[this](StringRef P, llvm::Any IR) { this->runAfterPass(P, IR); }); [this](StringRef P, llvm::Any IR, const PreservedAnalyses &PA) {
this->runAfterPass(P, IR, PA);
});
Callbacks.registerAfterPassInvalidatedCallback( Callbacks.registerAfterPassInvalidatedCallback(
[this](StringRef P) { this->runAfterPassInvalidated(P); }); [this](StringRef P, const PreservedAnalyses &PA) {
this->runAfterPassInvalidated(P, PA);
});
Callbacks.registerBeforeAnalysisCallback([this](StringRef P, llvm::Any IR) { Callbacks.registerBeforeAnalysisCallback([this](StringRef P, llvm::Any IR) {
return this->runBeforeAnalysis(P, IR); return this->runBeforeAnalysis(P, IR);
}); });
@ -365,7 +371,8 @@ struct MockPassInstrumentationCallbacks {
EXPECT_CALL(*this, runBeforeNonSkippedPass(Not(HasNameRegex("Mock")), EXPECT_CALL(*this, runBeforeNonSkippedPass(Not(HasNameRegex("Mock")),
HasName(IRName))) HasName(IRName)))
.Times(AnyNumber()); .Times(AnyNumber());
EXPECT_CALL(*this, runAfterPass(Not(HasNameRegex("Mock")), HasName(IRName))) EXPECT_CALL(*this,
runAfterPass(Not(HasNameRegex("Mock")), HasName(IRName), _))
.Times(AnyNumber()); .Times(AnyNumber());
EXPECT_CALL(*this, EXPECT_CALL(*this,
runBeforeAnalysis(Not(HasNameRegex("Mock")), HasName(IRName))) runBeforeAnalysis(Not(HasNameRegex("Mock")), HasName(IRName)))
@ -528,8 +535,8 @@ TEST_F(ModuleCallbacksTest, InstrumentedPasses) {
CallbacksHandle, CallbacksHandle,
runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("<string>"))) runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("<string>")))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"),
runAfterPass(HasNameRegex("MockPassHandle"), HasName("<string>"))) HasName("<string>"), _))
.InSequence(PISequence); .InSequence(PISequence);
// No passes are skipped, so there should be no calls to // No passes are skipped, so there should be no calls to
@ -569,7 +576,8 @@ TEST_F(ModuleCallbacksTest, InstrumentedSkippedPasses) {
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _)) runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _)) EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), _, _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _)) runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
@ -609,20 +617,20 @@ TEST_F(ModuleCallbacksTest, InstrumentedSkippedPasses) {
// The `runAfterPass` checks are the same as these of // The `runAfterPass` checks are the same as these of
// `runBeforeNonSkippedPass`. // `runBeforeNonSkippedPass`.
EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("PassManager"), _)) EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("PassManager"), _, _))
.Times(5); .Times(5);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("ModuleToFunctionPassAdaptor"), _)) runAfterPass(HasNameRegex("ModuleToFunctionPassAdaptor"), _, _))
.Times(1); .Times(1);
EXPECT_CALL( EXPECT_CALL(
CallbacksHandle, CallbacksHandle,
runAfterPass(HasNameRegex("ModuleToPostOrderCGSCCPassAdaptor"), _)) runAfterPass(HasNameRegex("ModuleToPostOrderCGSCCPassAdaptor"), _, _))
.Times(1); .Times(1);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("CGSCCToFunctionPassAdaptor"), _)) runAfterPass(HasNameRegex("CGSCCToFunctionPassAdaptor"), _, _))
.Times(1); .Times(1);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("FunctionToLoopPassAdaptor"), _)) runAfterPass(HasNameRegex("FunctionToLoopPassAdaptor"), _, _))
.Times(1); .Times(1);
// Ignore analyses introduced by adaptor passes. // Ignore analyses introduced by adaptor passes.
@ -701,7 +709,7 @@ TEST_F(FunctionCallbacksTest, InstrumentedPasses) {
runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("foo"))) runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("foo")))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), HasName("foo"))) runAfterPass(HasNameRegex("MockPassHandle"), HasName("foo"), _))
.InSequence(PISequence); .InSequence(PISequence);
// No passes are skipped, so there should be no calls to // No passes are skipped, so there should be no calls to
@ -713,7 +721,7 @@ TEST_F(FunctionCallbacksTest, InstrumentedPasses) {
// Our mock pass does not invalidate IR. // Our mock pass does not invalidate IR.
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
StringRef PipelineText = "test-transform"; StringRef PipelineText = "test-transform";
@ -746,12 +754,14 @@ TEST_F(FunctionCallbacksTest, InstrumentedSkippedPasses) {
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _)) runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _)) EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), _, _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _)) EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), _, _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _)) runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
@ -807,12 +817,12 @@ TEST_F(LoopCallbacksTest, InstrumentedPasses) {
runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop"))) runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop")))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), HasName("loop"))) runAfterPass(HasNameRegex("MockPassHandle"), HasName("loop"), _))
.InSequence(PISequence); .InSequence(PISequence);
// Our mock pass does not invalidate IR. // Our mock pass does not invalidate IR.
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
// No passes are skipped, so there should be no calls to // No passes are skipped, so there should be no calls to
@ -859,15 +869,15 @@ TEST_F(LoopCallbacksTest, InstrumentedInvalidatingPasses) {
runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop"))) runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop")))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("^PassManager"))) runAfterPassInvalidated(HasNameRegex("^PassManager"), _))
.InSequence(PISequence); .InSequence(PISequence);
// Our mock pass invalidates IR, thus normal runAfterPass is never called. // Our mock pass invalidates IR, thus normal runAfterPass is never called.
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), HasName("loop"))) runAfterPass(HasNameRegex("MockPassHandle"), HasName("loop"), _))
.Times(0); .Times(0);
StringRef PipelineText = "test-transform"; StringRef PipelineText = "test-transform";
@ -901,10 +911,11 @@ TEST_F(LoopCallbacksTest, InstrumentedSkippedPasses) {
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _)) runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _)) EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), _, _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _)) runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
@ -960,12 +971,12 @@ TEST_F(CGSCCCallbacksTest, InstrumentedPasses) {
runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)"))) runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)")))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)"))) runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)"), _))
.InSequence(PISequence); .InSequence(PISequence);
// Our mock pass does not invalidate IR. // Our mock pass does not invalidate IR.
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
// No passes are skipped, so there should be no calls to // No passes are skipped, so there should be no calls to
@ -1012,15 +1023,15 @@ TEST_F(CGSCCCallbacksTest, InstrumentedInvalidatingPasses) {
runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)"))) runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)")))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.InSequence(PISequence); .InSequence(PISequence);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("^PassManager"))) runAfterPassInvalidated(HasNameRegex("^PassManager"), _))
.InSequence(PISequence); .InSequence(PISequence);
// Our mock pass does invalidate IR, thus normal runAfterPass is never called. // Our mock pass does invalidate IR, thus normal runAfterPass is never called.
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)"))) runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)"), _))
.Times(0); .Times(0);
StringRef PipelineText = "test-transform"; StringRef PipelineText = "test-transform";
@ -1055,10 +1066,11 @@ TEST_F(CGSCCCallbacksTest, InstrumentedSkippedPasses) {
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _)) runBeforeNonSkippedPass(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _)) EXPECT_CALL(CallbacksHandle,
runAfterPass(HasNameRegex("MockPassHandle"), _, _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runAfterPassInvalidated(HasNameRegex("MockPassHandle"))) runAfterPassInvalidated(HasNameRegex("MockPassHandle"), _))
.Times(0); .Times(0);
EXPECT_CALL(CallbacksHandle, EXPECT_CALL(CallbacksHandle,
runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _)) runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))

6
llvm/unittests/IR/TimePassesTest.cpp
View File

@ -134,8 +134,8 @@ TEST(TimePassesTest, CustomOut) {
// Pretending that passes are running to trigger the timers. // Pretending that passes are running to trigger the timers.
PI.runBeforePass(Pass1, M); PI.runBeforePass(Pass1, M);
PI.runBeforePass(Pass2, M); PI.runBeforePass(Pass2, M);
PI.runAfterPass(Pass2, M); PI.runAfterPass(Pass2, M, PreservedAnalyses::all());
PI.runAfterPass(Pass1, M); PI.runAfterPass(Pass1, M, PreservedAnalyses::all());
// Generating report. // Generating report.
TimePasses->print(); TimePasses->print();
@ -154,7 +154,7 @@ TEST(TimePassesTest, CustomOut) {
// Now trigger just a single pass to populate timers again. // Now trigger just a single pass to populate timers again.
PI.runBeforePass(Pass2, M); PI.runBeforePass(Pass2, M);
PI.runAfterPass(Pass2, M); PI.runAfterPass(Pass2, M, PreservedAnalyses::all());
// Generate report by deleting the handler. // Generate report by deleting the handler.
TimePasses.reset(); TimePasses.reset();