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