[PM] Add a module analysis pass proxy for the function analysis manager.

This proxy will fill the role of proxying invalidation events down IR
unit layers so that when a module changes we correctly invalidate
function analyses. Currently this is a very coarse solution -- any
change blows away the entire thing -- but the next step is to make
invalidation handling more nuanced so that we can propagate specific
amounts of invalidation from one layer to the next.

The test is extended to place a module pass between two function pass
managers each of which have preserved function analyses which get
correctly invalidated by the module pass that might have changed what
functions are even in the module.

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

1 files changed, 37 insertions, 12 deletions

diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp
index f2ce221476..7cb4f8d8b0 100644
--- a/unittests/IR/PassManagerTest.cpp
+++ b/unittests/IR/PassManagerTest.cpp
@@ -32,8 +32,11 @@ public:
   /// \brief Returns an opaque, unique ID for this pass type.
   static void *ID() { return (void *)&PassID; }
 
+  TestAnalysisPass(int &Runs) : Runs(Runs) {}
+
   /// \brief Run the analysis pass over the function and return a result.
   Result run(Function *F) {
+    ++Runs;
     int Count = 0;
     for (Function::iterator BBI = F->begin(), BBE = F->end(); BBI != BBE; ++BBI)
       for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE;
@@ -45,6 +48,8 @@ public:
 private:
   /// \brief Private static data to provide unique ID.
   static char PassID;
+
+  int &Runs;
 };
 
 char TestAnalysisPass::PassID;
@@ -71,7 +76,7 @@ struct TestFunctionPass {
     const TestAnalysisPass::Result &AR = AM.getResult<TestAnalysisPass>(F);
     AnalyzedInstrCount += AR.InstructionCount;
 
-    return PreservedAnalyses::none();
+    return PreservedAnalyses::all();
   }
 
   FunctionAnalysisManager &AM;
@@ -106,25 +111,45 @@ public:
 };
 
 TEST_F(PassManagerTest, Basic) {
-  FunctionAnalysisManager AM;
-  AM.registerPass(TestAnalysisPass());
+  FunctionAnalysisManager FAM;
+  int AnalysisRuns = 0;
+  FAM.registerPass(TestAnalysisPass(AnalysisRuns));
+
+  ModuleAnalysisManager MAM;
+  MAM.registerPass(FunctionAnalysisModuleProxy(FAM));
+
+  ModulePassManager MPM(&MAM);
 
-  ModulePassManager MPM;
-  FunctionPassManager FPM(&AM);
+  // Count the runs over a Function.
+  FunctionPassManager FPM1(&FAM);
+  int FunctionPassRunCount1 = 0;
+  int AnalyzedInstrCount1 = 0;
+  FPM1.addPass(TestFunctionPass(FAM, FunctionPassRunCount1, AnalyzedInstrCount1));
+  MPM.addPass(createModuleToFunctionPassAdaptor(FPM1, &MAM));
 
   // Count the runs over a module.
   int ModulePassRunCount = 0;
   MPM.addPass(TestModulePass(ModulePassRunCount));
 
-  // Count the runs over a Function.
-  int FunctionPassRunCount = 0;
-  int AnalyzedInstrCount = 0;
-  FPM.addPass(TestFunctionPass(AM, FunctionPassRunCount, AnalyzedInstrCount));
-  MPM.addPass(createModuleToFunctionPassAdaptor(FPM));
+  // Count the runs over a Function in a separate manager.
+  FunctionPassManager FPM2(&FAM);
+  int FunctionPassRunCount2 = 0;
+  int AnalyzedInstrCount2 = 0;
+  FPM2.addPass(TestFunctionPass(FAM, FunctionPassRunCount2, AnalyzedInstrCount2));
+  MPM.addPass(createModuleToFunctionPassAdaptor(FPM2, &MAM));
 
   MPM.run(M.get());
+
+  // Validate module pass counters.
   EXPECT_EQ(1, ModulePassRunCount);
-  EXPECT_EQ(3, FunctionPassRunCount);
-  EXPECT_EQ(5, AnalyzedInstrCount);
+
+  // Validate both function pass counter sets.
+  EXPECT_EQ(3, FunctionPassRunCount1);
+  EXPECT_EQ(5, AnalyzedInstrCount1);
+  EXPECT_EQ(3, FunctionPassRunCount2);
+  EXPECT_EQ(5, AnalyzedInstrCount2);
+
+  // Validate the analysis counters.
+  EXPECT_EQ(6, AnalysisRuns);
 }
 }