unittests/IR/PassManagerTest.cpp

   1 //===- llvm/unittest/IR/PassManager.cpp - PassManager tests ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/AsmParser/Parser.h"
  11 #include "llvm/IR/Function.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Module.h"
  14 #include "llvm/IR/PassManager.h"
  15 #include "llvm/Support/SourceMgr.h"
  16 #include "gtest/gtest.h"
  17
  18 using namespace llvm;
  19
  20 namespace {
  21
  22 class TestFunctionAnalysis {
  23 public:
  24   struct Result {
  25     Result(int Count) : InstructionCount(Count) {}
  26     int InstructionCount;
  27   };
  28
  29   /// \brief Returns an opaque, unique ID for this pass type.
  30   static void *ID() { return (void *)&PassID; }
  31
  32   TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
  33
  34   /// \brief Run the analysis pass over the function and return a result.
  35   Result run(Function *F, FunctionAnalysisManager *AM) {
  36     ++Runs;
  37     int Count = 0;
  38     for (Function::iterator BBI = F->begin(), BBE = F->end(); BBI != BBE; ++BBI)
  39       for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE;
  40            ++II)
  41         ++Count;
  42     return Result(Count);
  43   }
  44
  45 private:
  46   /// \brief Private static data to provide unique ID.
  47   static char PassID;
  48
  49   int &Runs;
  50 };
  51
  52 char TestFunctionAnalysis::PassID;
  53
  54 class TestModuleAnalysis {
  55 public:
  56   struct Result {
  57     Result(int Count) : FunctionCount(Count) {}
  58     int FunctionCount;
  59   };
  60
  61   static void *ID() { return (void *)&PassID; }
  62
  63   TestModuleAnalysis(int &Runs) : Runs(Runs) {}
  64
  65   Result run(Module *M, ModuleAnalysisManager *AM) {
  66     ++Runs;
  67     int Count = 0;
  68     for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
  69       ++Count;
  70     return Result(Count);
  71   }
  72
  73 private:
  74   static char PassID;
  75
  76   int &Runs;
  77 };
  78
  79 char TestModuleAnalysis::PassID;
  80
  81 struct TestModulePass {
  82   TestModulePass(int &RunCount) : RunCount(RunCount) {}
  83
  84   PreservedAnalyses run(Module *M) {
  85     ++RunCount;
  86     return PreservedAnalyses::none();
  87   }
  88
  89   static StringRef name() { return "TestModulePass"; }
  90
  91   int &RunCount;
  92 };
  93
  94 struct TestPreservingModulePass {
  95   PreservedAnalyses run(Module *M) { return PreservedAnalyses::all(); }
  96
  97   static StringRef name() { return "TestPreservingModulePass"; }
  98 };
  99
 100 struct TestMinPreservingModulePass {
 101   PreservedAnalyses run(Module *M, ModuleAnalysisManager *AM) {
 102     PreservedAnalyses PA;
 103
 104     // Force running an analysis.
 105     (void)AM->getResult<TestModuleAnalysis>(M);
 106
 107     PA.preserve<FunctionAnalysisManagerModuleProxy>();
 108     return PA;
 109   }
 110
 111   static StringRef name() { return "TestMinPreservingModulePass"; }
 112 };
 113
 114 struct TestFunctionPass {
 115   TestFunctionPass(int &RunCount, int &AnalyzedInstrCount,
 116                    int &AnalyzedFunctionCount,
 117                    bool OnlyUseCachedResults = false)
 118       : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
 119         AnalyzedFunctionCount(AnalyzedFunctionCount),
 120         OnlyUseCachedResults(OnlyUseCachedResults) {}
 121
 122   PreservedAnalyses run(Function *F, FunctionAnalysisManager *AM) {
 123     ++RunCount;
 124
 125     const ModuleAnalysisManager &MAM =
 126         AM->getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
 127     if (TestModuleAnalysis::Result *TMA =
 128             MAM.getCachedResult<TestModuleAnalysis>(F->getParent()))
 129       AnalyzedFunctionCount += TMA->FunctionCount;
 130
 131     if (OnlyUseCachedResults) {
 132       // Hack to force the use of the cached interface.
 133       if (TestFunctionAnalysis::Result *AR =
 134               AM->getCachedResult<TestFunctionAnalysis>(F))
 135         AnalyzedInstrCount += AR->InstructionCount;
 136     } else {
 137       // Typical path just runs the analysis as needed.
 138       TestFunctionAnalysis::Result &AR = AM->getResult<TestFunctionAnalysis>(F);
 139       AnalyzedInstrCount += AR.InstructionCount;
 140     }
 141
 142     return PreservedAnalyses::all();
 143   }
 144
 145   static StringRef name() { return "TestFunctionPass"; }
 146
 147   int &RunCount;
 148   int &AnalyzedInstrCount;
 149   int &AnalyzedFunctionCount;
 150   bool OnlyUseCachedResults;
 151 };
 152
 153 // A test function pass that invalidates all function analyses for a function
 154 // with a specific name.
 155 struct TestInvalidationFunctionPass {
 156   TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {}
 157
 158   PreservedAnalyses run(Function *F) {
 159     return F->getName() == Name ? PreservedAnalyses::none()
 160                                 : PreservedAnalyses::all();
 161   }
 162
 163   static StringRef name() { return "TestInvalidationFunctionPass"; }
 164
 165   StringRef Name;
 166 };
 167
 168 Module *parseIR(const char *IR) {
 169   LLVMContext &C = getGlobalContext();
 170   SMDiagnostic Err;
 171   return ParseAssemblyString(IR, nullptr, Err, C);
 172 }
 173
 174 class PassManagerTest : public ::testing::Test {
 175 protected:
 176   std::unique_ptr<Module> M;
 177
 178 public:
 179   PassManagerTest()
 180       : M(parseIR("define void @f() {\n"
 181                   "entry:\n"
 182                   "  call void @g()\n"
 183                   "  call void @h()\n"
 184                   "  ret void\n"
 185                   "}\n"
 186                   "define void @g() {\n"
 187                   "  ret void\n"
 188                   "}\n"
 189                   "define void @h() {\n"
 190                   "  ret void\n"
 191                   "}\n")) {}
 192 };
 193
 194 TEST_F(PassManagerTest, BasicPreservedAnalyses) {
 195   PreservedAnalyses PA1 = PreservedAnalyses();
 196   EXPECT_FALSE(PA1.preserved<TestFunctionAnalysis>());
 197   EXPECT_FALSE(PA1.preserved<TestModuleAnalysis>());
 198   PreservedAnalyses PA2 = PreservedAnalyses::none();
 199   EXPECT_FALSE(PA2.preserved<TestFunctionAnalysis>());
 200   EXPECT_FALSE(PA2.preserved<TestModuleAnalysis>());
 201   PreservedAnalyses PA3 = PreservedAnalyses::all();
 202   EXPECT_TRUE(PA3.preserved<TestFunctionAnalysis>());
 203   EXPECT_TRUE(PA3.preserved<TestModuleAnalysis>());
 204   PreservedAnalyses PA4 = PA1;
 205   EXPECT_FALSE(PA4.preserved<TestFunctionAnalysis>());
 206   EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
 207   PA4 = PA3;
 208   EXPECT_TRUE(PA4.preserved<TestFunctionAnalysis>());
 209   EXPECT_TRUE(PA4.preserved<TestModuleAnalysis>());
 210   PA4 = std::move(PA2);
 211   EXPECT_FALSE(PA4.preserved<TestFunctionAnalysis>());
 212   EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
 213   PA4.preserve<TestFunctionAnalysis>();
 214   EXPECT_TRUE(PA4.preserved<TestFunctionAnalysis>());
 215   EXPECT_FALSE(PA4.preserved<TestModuleAnalysis>());
 216   PA1.preserve<TestModuleAnalysis>();
 217   EXPECT_FALSE(PA1.preserved<TestFunctionAnalysis>());
 218   EXPECT_TRUE(PA1.preserved<TestModuleAnalysis>());
 219   PA1.preserve<TestFunctionAnalysis>();
 220   EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>());
 221   EXPECT_TRUE(PA1.preserved<TestModuleAnalysis>());
 222   PA1.intersect(PA4);
 223   EXPECT_TRUE(PA1.preserved<TestFunctionAnalysis>());
 224   EXPECT_FALSE(PA1.preserved<TestModuleAnalysis>());
 225 }
 226
 227 TEST_F(PassManagerTest, Basic) {
 228   FunctionAnalysisManager FAM;
 229   int FunctionAnalysisRuns = 0;
 230   FAM.registerPass(TestFunctionAnalysis(FunctionAnalysisRuns));
 231
 232   ModuleAnalysisManager MAM;
 233   int ModuleAnalysisRuns = 0;
 234   MAM.registerPass(TestModuleAnalysis(ModuleAnalysisRuns));
 235   MAM.registerPass(FunctionAnalysisManagerModuleProxy(FAM));
 236   FAM.registerPass(ModuleAnalysisManagerFunctionProxy(MAM));
 237
 238   ModulePassManager MPM;
 239
 240   // Count the runs over a Function.
 241   int FunctionPassRunCount1 = 0;
 242   int AnalyzedInstrCount1 = 0;
 243   int AnalyzedFunctionCount1 = 0;
 244   {
 245     // Pointless scoped copy to test move assignment.
 246     ModulePassManager NestedMPM;
 247     FunctionPassManager FPM;
 248     {
 249       // Pointless scope to test move assignment.
 250       FunctionPassManager NestedFPM;
 251       NestedFPM.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1,
 252                                    AnalyzedFunctionCount1));
 253       FPM = std::move(NestedFPM);
 254     }
 255     NestedMPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 256     MPM = std::move(NestedMPM);
 257   }
 258
 259   // Count the runs over a module.
 260   int ModulePassRunCount = 0;
 261   MPM.addPass(TestModulePass(ModulePassRunCount));
 262
 263   // Count the runs over a Function in a separate manager.
 264   int FunctionPassRunCount2 = 0;
 265   int AnalyzedInstrCount2 = 0;
 266   int AnalyzedFunctionCount2 = 0;
 267   {
 268     FunctionPassManager FPM;
 269     FPM.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2,
 270                                  AnalyzedFunctionCount2));
 271     MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 272   }
 273
 274   // A third function pass manager but with only preserving intervening passes
 275   // and with a function pass that invalidates exactly one analysis.
 276   MPM.addPass(TestPreservingModulePass());
 277   int FunctionPassRunCount3 = 0;
 278   int AnalyzedInstrCount3 = 0;
 279   int AnalyzedFunctionCount3 = 0;
 280   {
 281     FunctionPassManager FPM;
 282     FPM.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3,
 283                                  AnalyzedFunctionCount3));
 284     FPM.addPass(TestInvalidationFunctionPass("f"));
 285     MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 286   }
 287
 288   // A fourth function pass manager but with a minimal intervening passes.
 289   MPM.addPass(TestMinPreservingModulePass());
 290   int FunctionPassRunCount4 = 0;
 291   int AnalyzedInstrCount4 = 0;
 292   int AnalyzedFunctionCount4 = 0;
 293   {
 294     FunctionPassManager FPM;
 295     FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
 296                                  AnalyzedFunctionCount4));
 297     MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 298   }
 299
 300   // A fifth function pass manager but which uses only cached results.
 301   int FunctionPassRunCount5 = 0;
 302   int AnalyzedInstrCount5 = 0;
 303   int AnalyzedFunctionCount5 = 0;
 304   {
 305     FunctionPassManager FPM;
 306     FPM.addPass(TestInvalidationFunctionPass("f"));
 307     FPM.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5,
 308                                  AnalyzedFunctionCount5,
 309                                  /*OnlyUseCachedResults=*/true));
 310     MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 311   }
 312
 313   MPM.run(M.get(), &MAM);
 314
 315   // Validate module pass counters.
 316   EXPECT_EQ(1, ModulePassRunCount);
 317
 318   // Validate all function pass counter sets are the same.
 319   EXPECT_EQ(3, FunctionPassRunCount1);
 320   EXPECT_EQ(5, AnalyzedInstrCount1);
 321   EXPECT_EQ(0, AnalyzedFunctionCount1);
 322   EXPECT_EQ(3, FunctionPassRunCount2);
 323   EXPECT_EQ(5, AnalyzedInstrCount2);
 324   EXPECT_EQ(0, AnalyzedFunctionCount2);
 325   EXPECT_EQ(3, FunctionPassRunCount3);
 326   EXPECT_EQ(5, AnalyzedInstrCount3);
 327   EXPECT_EQ(0, AnalyzedFunctionCount3);
 328   EXPECT_EQ(3, FunctionPassRunCount4);
 329   EXPECT_EQ(5, AnalyzedInstrCount4);
 330   EXPECT_EQ(0, AnalyzedFunctionCount4);
 331   EXPECT_EQ(3, FunctionPassRunCount5);
 332   EXPECT_EQ(2, AnalyzedInstrCount5); // Only 'g' and 'h' were cached.
 333   EXPECT_EQ(0, AnalyzedFunctionCount5);
 334
 335   // Validate the analysis counters:
 336   //   first run over 3 functions, then module pass invalidates
 337   //   second run over 3 functions, nothing invalidates
 338   //   third run over 0 functions, but 1 function invalidated
 339   //   fourth run over 1 function
 340   EXPECT_EQ(7, FunctionAnalysisRuns);
 341
 342   EXPECT_EQ(1, ModuleAnalysisRuns);
 343 }
 344 }