[C++11] Replace LLVM_STATIC_ASSERT with static_assert, we now have

[oota-llvm.git] / unittests / IR / PassManagerTest.cpp

diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp
index 801d8d86bfc5ef5e8962ef15657374997ce70f53..ee1deff8df67ae99c004bd2521f89f167b7aaaa8 100644 (file)
--- 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,7 +29,7 @@ public:
   /// \brief Returns an opaque, unique ID for this pass type.
   static void *ID() { return (void *)&PassID; }
 
-  TestAnalysisPass(int &Runs) : Runs(Runs) {}
+  TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
 
   /// \brief Run the analysis pass over the function and return a result.
   Result run(Function *F, FunctionAnalysisManager *AM) {
@@ -49,7 +49,34 @@ 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; }
+
+  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) {}
@@ -59,6 +86,8 @@ struct TestModulePass {
     return PreservedAnalyses::none();
   }
 
+  static StringRef name() { return "TestModulePass"; }
+
   int &RunCount;
 };
 
@@ -66,31 +95,61 @@ struct TestPreservingModulePass {
   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<TestModuleAnalysis>(M);
+
     PA.preserve<FunctionAnalysisManagerModuleProxy>();
     return PA;
   }
+
+  static StringRef name() { return "TestMinPreservingModulePass"; }
 };
 
 struct TestFunctionPass {
-  TestFunctionPass(int &RunCount, int &AnalyzedInstrCount)
-      : 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, 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;
+
+    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();
   }
 
+  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
@@ -103,6 +162,8 @@ struct TestInvalidationFunctionPass {
                                 : PreservedAnalyses::all();
   }
 
+  static StringRef name() { return "TestInvalidationFunctionPass"; }
+
   StringRef Name;
 };
 
@@ -134,11 +195,14 @@ public:
 
 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;
 
@@ -146,7 +210,9 @@ TEST_F(PassManagerTest, Basic) {
   FunctionPassManager FPM1;
   int FunctionPassRunCount1 = 0;
   int AnalyzedInstrCount1 = 0;
-  FPM1.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1));
+  int AnalyzedFunctionCount1 = 0;
+  FPM1.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1,
+                                AnalyzedFunctionCount1));
   MPM.addPass(createModuleToFunctionPassAdaptor(FPM1));
 
   // Count the runs over a module.
@@ -157,7 +223,9 @@ TEST_F(PassManagerTest, Basic) {
   FunctionPassManager FPM2;
   int FunctionPassRunCount2 = 0;
   int AnalyzedInstrCount2 = 0;
-  FPM2.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2));
+  int AnalyzedFunctionCount2 = 0;
+  FPM2.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2,
+                                AnalyzedFunctionCount2));
   MPM.addPass(createModuleToFunctionPassAdaptor(FPM2));
 
   // A third function pass manager but with only preserving intervening passes
@@ -166,7 +234,9 @@ TEST_F(PassManagerTest, Basic) {
   FunctionPassManager FPM3;
   int FunctionPassRunCount3 = 0;
   int AnalyzedInstrCount3 = 0;
-  FPM3.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3));
+  int AnalyzedFunctionCount3 = 0;
+  FPM3.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3,
+                                AnalyzedFunctionCount3));
   FPM3.addPass(TestInvalidationFunctionPass("f"));
   MPM.addPass(createModuleToFunctionPassAdaptor(FPM3));
 
@@ -175,9 +245,22 @@ TEST_F(PassManagerTest, Basic) {
   FunctionPassManager FPM4;
   int FunctionPassRunCount4 = 0;
   int AnalyzedInstrCount4 = 0;
-  FPM4.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4));
+  int AnalyzedFunctionCount4 = 0;
+  FPM4.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
+                                AnalyzedFunctionCount4));
   MPM.addPass(createModuleToFunctionPassAdaptor(FPM4));
 
+  // A fifth function pass manager but which uses only cached results.
+  FunctionPassManager FPM5;
+  int FunctionPassRunCount5 = 0;
+  int AnalyzedInstrCount5 = 0;
+  int AnalyzedFunctionCount5 = 0;
+  FPM5.addPass(TestInvalidationFunctionPass("f"));
+  FPM5.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5,
+                                AnalyzedFunctionCount5,
+                                /*OnlyUseCachedResults=*/true));
+  MPM.addPass(createModuleToFunctionPassAdaptor(FPM5));
+
   MPM.run(M.get(), &MAM);
 
   // Validate module pass counters.
@@ -186,18 +269,27 @@ TEST_F(PassManagerTest, Basic) {
   // 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, AnalysisRuns);
+  EXPECT_EQ(7, FunctionAnalysisRuns);
+
+  EXPECT_EQ(1, ModuleAnalysisRuns);
 }
 }