From d4e80a9615639942f62ac808cdb195105218f813 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Fri, 2 Sep 2016 01:08:04 +0000 Subject: [PM] (NFC) Refactor the CGSCC pass manager tests to use lambda-based passes. This simplifies the test some and makes it more focused and clear what is being tested. It will also make it much easier to extend with further testing of different pass behaviors. I've also replaced a pointless module pass with running the requires pass directly as that is all that it was really doing. llvm-svn: 280444 --- llvm/unittests/Analysis/CGSCCPassManagerTest.cpp | 122 ++++++++--------------- 1 file changed, 43 insertions(+), 79 deletions(-) (limited to 'llvm/unittests/Analysis/CGSCCPassManagerTest.cpp') diff --git a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp index fa3a09483f8..828ec991e1b 100644 --- a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp +++ b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp @@ -126,87 +126,27 @@ private: char TestImmutableFunctionAnalysis::PassID; -struct TestModulePass { - TestModulePass(int &RunCount) : RunCount(RunCount) {} - - PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { - ++RunCount; - (void)AM.getResult(M); - return PreservedAnalyses::all(); - } - - static StringRef name() { return "TestModulePass"; } - - int &RunCount; -}; - -struct TestSCCPass { - TestSCCPass(int &RunCount, int &AnalyzedInstrCount, - int &AnalyzedSCCFunctionCount, int &AnalyzedModuleFunctionCount, - bool OnlyUseCachedResults = false) - : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount), - AnalyzedSCCFunctionCount(AnalyzedSCCFunctionCount), - AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount), - OnlyUseCachedResults(OnlyUseCachedResults) {} +struct LambdaSCCPass : public PassInfoMixin { + template LambdaSCCPass(T &&Arg) : Func(std::forward(Arg)) {} PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR) { - ++RunCount; - - const ModuleAnalysisManager &MAM = - AM.getResult(C, CG).getManager(); - FunctionAnalysisManager &FAM = - AM.getResult(C, CG).getManager(); - if (TestModuleAnalysis::Result *TMA = - MAM.getCachedResult( - *C.begin()->getFunction().getParent())) - AnalyzedModuleFunctionCount += TMA->FunctionCount; - - if (OnlyUseCachedResults) { - // Hack to force the use of the cached interface. - if (TestSCCAnalysis::Result *AR = AM.getCachedResult(C)) - AnalyzedSCCFunctionCount += AR->FunctionCount; - for (LazyCallGraph::Node &N : C) - if (TestFunctionAnalysis::Result *FAR = - FAM.getCachedResult(N.getFunction())) - AnalyzedInstrCount += FAR->InstructionCount; - } else { - // Typical path just runs the analysis as needed. - TestSCCAnalysis::Result &AR = AM.getResult(C, CG); - AnalyzedSCCFunctionCount += AR.FunctionCount; - for (LazyCallGraph::Node &N : C) { - TestFunctionAnalysis::Result &FAR = - FAM.getResult(N.getFunction()); - AnalyzedInstrCount += FAR.InstructionCount; - - // Just ensure we get the immutable results. - (void)FAM.getResult(N.getFunction()); - } - } - - return PreservedAnalyses::all(); + return Func(C, AM, CG, UR); } - static StringRef name() { return "TestSCCPass"; } - - int &RunCount; - int &AnalyzedInstrCount; - int &AnalyzedSCCFunctionCount; - int &AnalyzedModuleFunctionCount; - bool OnlyUseCachedResults; + std::function + Func; }; -struct TestFunctionPass { - TestFunctionPass(int &RunCount) : RunCount(RunCount) {} +struct LambdaFunctionPass : public PassInfoMixin { + template LambdaFunctionPass(T &&Arg) : Func(std::forward(Arg)) {} - PreservedAnalyses run(Function &F, FunctionAnalysisManager &) { - ++RunCount; - return PreservedAnalyses::none(); + PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { + return Func(F, AM); } - static StringRef name() { return "TestFunctionPass"; } - - int &RunCount; + std::function Func; }; std::unique_ptr parseIR(const char *IR) { @@ -276,28 +216,52 @@ TEST(CGSCCPassManagerTest, Basic) { FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); }); ModulePassManager MPM(/*DebugLogging*/ true); - int ModulePassRunCount1 = 0; - MPM.addPass(TestModulePass(ModulePassRunCount1)); + MPM.addPass(RequireAnalysisPass()); CGSCCPassManager CGPM1(/*DebugLogging*/ true); int SCCPassRunCount1 = 0; int AnalyzedInstrCount1 = 0; int AnalyzedSCCFunctionCount1 = 0; int AnalyzedModuleFunctionCount1 = 0; - CGPM1.addPass(TestSCCPass(SCCPassRunCount1, AnalyzedInstrCount1, - AnalyzedSCCFunctionCount1, - AnalyzedModuleFunctionCount1)); + CGPM1.addPass( + LambdaSCCPass([&](LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, + LazyCallGraph &CG, CGSCCUpdateResult &UR) { + ++SCCPassRunCount1; + + const ModuleAnalysisManager &MAM = + AM.getResult(C, CG).getManager(); + FunctionAnalysisManager &FAM = + AM.getResult(C, CG).getManager(); + if (TestModuleAnalysis::Result *TMA = + MAM.getCachedResult( + *C.begin()->getFunction().getParent())) + AnalyzedModuleFunctionCount1 += TMA->FunctionCount; + + TestSCCAnalysis::Result &AR = AM.getResult(C, CG); + AnalyzedSCCFunctionCount1 += AR.FunctionCount; + for (LazyCallGraph::Node &N : C) { + TestFunctionAnalysis::Result &FAR = + FAM.getResult(N.getFunction()); + AnalyzedInstrCount1 += FAR.InstructionCount; + + // Just ensure we get the immutable results. + (void)FAM.getResult(N.getFunction()); + } + + return PreservedAnalyses::all(); + })); FunctionPassManager FPM1(/*DebugLogging*/ true); int FunctionPassRunCount1 = 0; - FPM1.addPass(TestFunctionPass(FunctionPassRunCount1)); + FPM1.addPass(LambdaFunctionPass([&](Function &, FunctionAnalysisManager &) { + ++FunctionPassRunCount1; + return PreservedAnalyses::all(); + })); CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1))); MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1))); MPM.run(*M, MAM); - EXPECT_EQ(1, ModulePassRunCount1); - EXPECT_EQ(1, ModuleAnalysisRuns); EXPECT_EQ(4, SCCAnalysisRuns); EXPECT_EQ(6, FunctionAnalysisRuns); -- cgit v1.2.3