X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=unittests%2FIR%2FPassManagerTest.cpp;h=41af0b0bd25c4165b98b34b4e4a3679619a8a765;hb=00552e3875ee5f382db6c98286a241a7d0efe1b8;hp=b0d4cbe031844376d1fe1f4d435fcbfdcbfa50b4;hpb=d984cdc17ea0b2b8aa638b512eb27059721d9662;p=oota-llvm.git diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp index b0d4cbe0318..41af0b0bd25 100644 --- a/unittests/IR/PassManagerTest.cpp +++ b/unittests/IR/PassManagerTest.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Assembly/Parser.h" +#include "llvm/AsmParser/Parser.h" #include "llvm/IR/Function.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" @@ -19,7 +19,7 @@ using namespace llvm; namespace { -class TestAnalysisPass { +class TestFunctionAnalysis { public: struct Result { Result(int Count) : InstructionCount(Count) {} @@ -29,13 +29,16 @@ public: /// \brief Returns an opaque, unique ID for this pass type. static void *ID() { return (void *)&PassID; } - TestAnalysisPass(int &Runs) : Runs(Runs) {} + /// \brief Returns the name of the analysis. + static StringRef name() { return "TestFunctionAnalysis"; } + + TestFunctionAnalysis(int &Runs) : Runs(Runs) {} /// \brief Run the analysis pass over the function and return a result. - Result run(Function *F) { + Result run(Function &F, FunctionAnalysisManager *AM) { ++Runs; int Count = 0; - for (Function::iterator BBI = F->begin(), BBE = F->end(); BBI != BBE; ++BBI) + for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE; ++II) ++Count; @@ -49,59 +52,133 @@ private: int &Runs; }; -char TestAnalysisPass::PassID; +char TestFunctionAnalysis::PassID; + +class TestModuleAnalysis { +public: + struct Result { + Result(int Count) : FunctionCount(Count) {} + int FunctionCount; + }; + + static void *ID() { return (void *)&PassID; } + + static StringRef name() { return "TestModuleAnalysis"; } + + TestModuleAnalysis(int &Runs) : Runs(Runs) {} + + Result run(Module &M, ModuleAnalysisManager *AM) { + ++Runs; + int Count = 0; + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + ++Count; + return Result(Count); + } + +private: + static char PassID; + + int &Runs; +}; + +char TestModuleAnalysis::PassID; struct TestModulePass { TestModulePass(int &RunCount) : RunCount(RunCount) {} - PreservedAnalyses run(Module *M) { + PreservedAnalyses run(Module &M) { ++RunCount; return PreservedAnalyses::none(); } + static StringRef name() { return "TestModulePass"; } + int &RunCount; }; struct TestPreservingModulePass { - PreservedAnalyses run(Module *M) { - return PreservedAnalyses::all(); - } + PreservedAnalyses run(Module &M) { return PreservedAnalyses::all(); } + + static StringRef name() { return "TestPreservingModulePass"; } }; struct TestMinPreservingModulePass { - PreservedAnalyses run(Module *M) { + PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) { PreservedAnalyses PA; + + // Force running an analysis. + (void)AM->getResult(M); + PA.preserve(); return PA; } + + static StringRef name() { return "TestMinPreservingModulePass"; } }; struct TestFunctionPass { - TestFunctionPass(int &RunCount, int &AnalyzedInstrCount) - : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount) {} - - PreservedAnalyses run(Function *F, FunctionAnalysisManager *AM) { + TestFunctionPass(int &RunCount, int &AnalyzedInstrCount, + int &AnalyzedFunctionCount, + bool OnlyUseCachedResults = false) + : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount), + AnalyzedFunctionCount(AnalyzedFunctionCount), + OnlyUseCachedResults(OnlyUseCachedResults) {} + + PreservedAnalyses run(Function &F, FunctionAnalysisManager *AM) { ++RunCount; - const TestAnalysisPass::Result &AR = AM->getResult(F); - AnalyzedInstrCount += AR.InstructionCount; + const ModuleAnalysisManager &MAM = + AM->getResult(F).getManager(); + if (TestModuleAnalysis::Result *TMA = + MAM.getCachedResult(*F.getParent())) + AnalyzedFunctionCount += TMA->FunctionCount; + + if (OnlyUseCachedResults) { + // Hack to force the use of the cached interface. + if (TestFunctionAnalysis::Result *AR = + AM->getCachedResult(F)) + AnalyzedInstrCount += AR->InstructionCount; + } else { + // Typical path just runs the analysis as needed. + TestFunctionAnalysis::Result &AR = AM->getResult(F); + AnalyzedInstrCount += AR.InstructionCount; + } return PreservedAnalyses::all(); } + static StringRef name() { return "TestFunctionPass"; } + int &RunCount; int &AnalyzedInstrCount; + int &AnalyzedFunctionCount; + bool OnlyUseCachedResults; +}; + +// A test function pass that invalidates all function analyses for a function +// with a specific name. +struct TestInvalidationFunctionPass { + TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {} + + PreservedAnalyses run(Function &F) { + return F.getName() == Name ? PreservedAnalyses::none() + : PreservedAnalyses::all(); + } + + static StringRef name() { return "TestInvalidationFunctionPass"; } + + StringRef Name; }; -Module *parseIR(const char *IR) { +std::unique_ptr parseIR(const char *IR) { LLVMContext &C = getGlobalContext(); SMDiagnostic Err; - return ParseAssemblyString(IR, 0, Err, C); + return parseAssemblyString(IR, Err, C); } class PassManagerTest : public ::testing::Test { protected: - OwningPtr M; + std::unique_ptr M; public: PassManagerTest() @@ -119,66 +196,154 @@ public: "}\n")) {} }; +TEST_F(PassManagerTest, BasicPreservedAnalyses) { + PreservedAnalyses PA1 = PreservedAnalyses(); + EXPECT_FALSE(PA1.preserved()); + EXPECT_FALSE(PA1.preserved()); + PreservedAnalyses PA2 = PreservedAnalyses::none(); + EXPECT_FALSE(PA2.preserved()); + EXPECT_FALSE(PA2.preserved()); + PreservedAnalyses PA3 = PreservedAnalyses::all(); + EXPECT_TRUE(PA3.preserved()); + EXPECT_TRUE(PA3.preserved()); + PreservedAnalyses PA4 = PA1; + EXPECT_FALSE(PA4.preserved()); + EXPECT_FALSE(PA4.preserved()); + PA4 = PA3; + EXPECT_TRUE(PA4.preserved()); + EXPECT_TRUE(PA4.preserved()); + PA4 = std::move(PA2); + EXPECT_FALSE(PA4.preserved()); + EXPECT_FALSE(PA4.preserved()); + PA4.preserve(); + EXPECT_TRUE(PA4.preserved()); + EXPECT_FALSE(PA4.preserved()); + PA1.preserve(); + EXPECT_FALSE(PA1.preserved()); + EXPECT_TRUE(PA1.preserved()); + PA1.preserve(); + EXPECT_TRUE(PA1.preserved()); + EXPECT_TRUE(PA1.preserved()); + PA1.intersect(PA4); + EXPECT_TRUE(PA1.preserved()); + EXPECT_FALSE(PA1.preserved()); +} + TEST_F(PassManagerTest, Basic) { FunctionAnalysisManager FAM; - int AnalysisRuns = 0; - FAM.registerPass(TestAnalysisPass(AnalysisRuns)); + int FunctionAnalysisRuns = 0; + FAM.registerPass(TestFunctionAnalysis(FunctionAnalysisRuns)); ModuleAnalysisManager MAM; + int ModuleAnalysisRuns = 0; + MAM.registerPass(TestModuleAnalysis(ModuleAnalysisRuns)); MAM.registerPass(FunctionAnalysisManagerModuleProxy(FAM)); + FAM.registerPass(ModuleAnalysisManagerFunctionProxy(MAM)); ModulePassManager MPM; // Count the runs over a Function. - FunctionPassManager FPM1; int FunctionPassRunCount1 = 0; int AnalyzedInstrCount1 = 0; - FPM1.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1)); - MPM.addPass(createModuleToFunctionPassAdaptor(FPM1)); + int AnalyzedFunctionCount1 = 0; + { + // Pointless scoped copy to test move assignment. + ModulePassManager NestedMPM; + FunctionPassManager FPM; + { + // Pointless scope to test move assignment. + FunctionPassManager NestedFPM; + NestedFPM.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1, + AnalyzedFunctionCount1)); + FPM = std::move(NestedFPM); + } + NestedMPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); + MPM = std::move(NestedMPM); + } // Count the runs over a module. int ModulePassRunCount = 0; MPM.addPass(TestModulePass(ModulePassRunCount)); // Count the runs over a Function in a separate manager. - FunctionPassManager FPM2; int FunctionPassRunCount2 = 0; int AnalyzedInstrCount2 = 0; - FPM2.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2)); - MPM.addPass(createModuleToFunctionPassAdaptor(FPM2)); + int AnalyzedFunctionCount2 = 0; + { + FunctionPassManager FPM; + FPM.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2, + AnalyzedFunctionCount2)); + MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); + } - // A third function pass manager but with only preserving intervening passes. + // A third function pass manager but with only preserving intervening passes + // and with a function pass that invalidates exactly one analysis. MPM.addPass(TestPreservingModulePass()); - FunctionPassManager FPM3; int FunctionPassRunCount3 = 0; int AnalyzedInstrCount3 = 0; - FPM3.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3)); - MPM.addPass(createModuleToFunctionPassAdaptor(FPM3)); + int AnalyzedFunctionCount3 = 0; + { + FunctionPassManager FPM; + FPM.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3, + AnalyzedFunctionCount3)); + FPM.addPass(TestInvalidationFunctionPass("f")); + MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); + } // A fourth function pass manager but with a minimal intervening passes. MPM.addPass(TestMinPreservingModulePass()); - FunctionPassManager FPM4; int FunctionPassRunCount4 = 0; int AnalyzedInstrCount4 = 0; - FPM4.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4)); - MPM.addPass(createModuleToFunctionPassAdaptor(FPM4)); + int AnalyzedFunctionCount4 = 0; + { + FunctionPassManager FPM; + FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4, + AnalyzedFunctionCount4)); + MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); + } - MPM.run(M.get(), &MAM); + // A fifth function pass manager but which uses only cached results. + int FunctionPassRunCount5 = 0; + int AnalyzedInstrCount5 = 0; + int AnalyzedFunctionCount5 = 0; + { + FunctionPassManager FPM; + FPM.addPass(TestInvalidationFunctionPass("f")); + FPM.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5, + AnalyzedFunctionCount5, + /*OnlyUseCachedResults=*/true)); + MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); + } + + MPM.run(*M, &MAM); // Validate module pass counters. EXPECT_EQ(1, ModulePassRunCount); - // Validate both function pass counter sets. + // Validate all function pass counter sets are the same. EXPECT_EQ(3, FunctionPassRunCount1); EXPECT_EQ(5, AnalyzedInstrCount1); + EXPECT_EQ(0, AnalyzedFunctionCount1); EXPECT_EQ(3, FunctionPassRunCount2); EXPECT_EQ(5, AnalyzedInstrCount2); + EXPECT_EQ(0, AnalyzedFunctionCount2); EXPECT_EQ(3, FunctionPassRunCount3); EXPECT_EQ(5, AnalyzedInstrCount3); + EXPECT_EQ(0, AnalyzedFunctionCount3); EXPECT_EQ(3, FunctionPassRunCount4); EXPECT_EQ(5, AnalyzedInstrCount4); - - // Validate the analysis counters. - EXPECT_EQ(9, AnalysisRuns); + EXPECT_EQ(0, AnalyzedFunctionCount4); + EXPECT_EQ(3, FunctionPassRunCount5); + EXPECT_EQ(2, AnalyzedInstrCount5); // Only 'g' and 'h' were cached. + EXPECT_EQ(0, AnalyzedFunctionCount5); + + // Validate the analysis counters: + // first run over 3 functions, then module pass invalidates + // second run over 3 functions, nothing invalidates + // third run over 0 functions, but 1 function invalidated + // fourth run over 1 function + EXPECT_EQ(7, FunctionAnalysisRuns); + + EXPECT_EQ(1, ModuleAnalysisRuns); } }