X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=unittests%2FIR%2FPassManagerTest.cpp;h=41af0b0bd25c4165b98b34b4e4a3679619a8a765;hb=d0dc794073ee74622a4af86e5553d7926e4b8aec;hp=f2ce22147649bc03e851c14c6693c9d5a6e76202;hpb=c49e7e6aeedc8d6fbe6cabb5b61551556fdcbb0b;p=oota-llvm.git

diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp
index f2ce2214764..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,23 +19,26 @@ using namespace llvm;
 
 namespace {
 
-class TestAnalysisPass {
+class TestFunctionAnalysis {
 public:
-  typedef Function IRUnitT;
-
   struct Result {
     Result(int Count) : InstructionCount(Count) {}
-    bool invalidate(Function *) { return true; }
     int InstructionCount;
   };
 
   /// \brief Returns an opaque, unique ID for this pass type.
   static void *ID() { return (void *)&PassID; }
 
+  /// \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;
@@ -45,49 +48,137 @@ public:
 private:
   /// \brief Private static data to provide unique ID.
   static char PassID;
+
+  int &Runs;
+};
+
+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 TestAnalysisPass::PassID;
+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(); }
+
+  static StringRef name() { return "TestPreservingModulePass"; }
+};
+
+struct TestMinPreservingModulePass {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) {
+    PreservedAnalyses PA;
+
+    // Force running an analysis.
+    (void)AM->getResult<TestModuleAnalysis>(M);
+
+    PA.preserve<FunctionAnalysisManagerModuleProxy>();
+    return PA;
+  }
+
+  static StringRef name() { return "TestMinPreservingModulePass"; }
+};
+
 struct TestFunctionPass {
-  TestFunctionPass(FunctionAnalysisManager &AM, int &RunCount,
-                   int &AnalyzedInstrCount)
-      : AM(AM), RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount) {}
+  TestFunctionPass(int &RunCount, int &AnalyzedInstrCount,
+                   int &AnalyzedFunctionCount,
+                   bool OnlyUseCachedResults = false)
+      : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
+        AnalyzedFunctionCount(AnalyzedFunctionCount),
+        OnlyUseCachedResults(OnlyUseCachedResults) {}
 
-  PreservedAnalyses run(Function *F) {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager *AM) {
     ++RunCount;
 
-    const TestAnalysisPass::Result &AR = AM.getResult<TestAnalysisPass>(F);
-    AnalyzedInstrCount += AR.InstructionCount;
+    const ModuleAnalysisManager &MAM =
+        AM->getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
+    if (TestModuleAnalysis::Result *TMA =
+            MAM.getCachedResult<TestModuleAnalysis>(*F.getParent()))
+      AnalyzedFunctionCount += TMA->FunctionCount;
 
-    return PreservedAnalyses::none();
+    if (OnlyUseCachedResults) {
+      // Hack to force the use of the cached interface.
+      if (TestFunctionAnalysis::Result *AR =
+              AM->getCachedResult<TestFunctionAnalysis>(F))
+        AnalyzedInstrCount += AR->InstructionCount;
+    } else {
+      // Typical path just runs the analysis as needed.
+      TestFunctionAnalysis::Result &AR = AM->getResult<TestFunctionAnalysis>(F);
+      AnalyzedInstrCount += AR.InstructionCount;
+    }
+
+    return PreservedAnalyses::all();
   }
 
-  FunctionAnalysisManager &AM;
+  static StringRef name() { return "TestFunctionPass"; }
+
   int &RunCount;
   int &AnalyzedInstrCount;
+  int &AnalyzedFunctionCount;
+  bool OnlyUseCachedResults;
 };
 
-Module *parseIR(const char *IR) {
+// 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;
+};
+
+std::unique_ptr<Module> 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<Module> M;
+  std::unique_ptr<Module> M;
 
 public:
   PassManagerTest()
@@ -105,26 +196,154 @@ public:
                   "}\n")) {}
 };
 
+TEST_F(PassManagerTest, BasicPreservedAnalyses) {
+  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>());
+  PreservedAnalyses PA4 = PA1;
+  EXPECT_FALSE(PA4.preserved<TestFunctionAnalysis>());
+  EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
+  PA4 = PA3;
+  EXPECT_TRUE(PA4.preserved<TestFunctionAnalysis>());
+  EXPECT_TRUE(PA4.preserved<TestModuleAnalysis>());
+  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>());
+  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>());
+}
+
 TEST_F(PassManagerTest, Basic) {
-  FunctionAnalysisManager AM;
-  AM.registerPass(TestAnalysisPass());
+  FunctionAnalysisManager FAM;
+  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;
-  FunctionPassManager FPM(&AM);
+
+  // Count the runs over a Function.
+  int FunctionPassRunCount1 = 0;
+  int AnalyzedInstrCount1 = 0;
+  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.
-  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.
+  int FunctionPassRunCount2 = 0;
+  int AnalyzedInstrCount2 = 0;
+  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
+  // and with a function pass that invalidates exactly one analysis.
+  MPM.addPass(TestPreservingModulePass());
+  int FunctionPassRunCount3 = 0;
+  int AnalyzedInstrCount3 = 0;
+  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());
+  int FunctionPassRunCount4 = 0;
+  int AnalyzedInstrCount4 = 0;
+  int AnalyzedFunctionCount4 = 0;
+  {
+    FunctionPassManager FPM;
+    FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
+                                 AnalyzedFunctionCount4));
+    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+  }
+
+  // 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);
 
-  MPM.run(M.get());
+  // Validate module pass counters.
   EXPECT_EQ(1, ModulePassRunCount);
-  EXPECT_EQ(3, FunctionPassRunCount);
-  EXPECT_EQ(5, AnalyzedInstrCount);
+
+  // 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);
+  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);
 }
 }