• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 {
Result__anonb9c59d210111::TestFunctionAnalysis::Result25     Result(int Count) : InstructionCount(Count) {}
26     int InstructionCount;
27   };
28 
29   /// \brief Returns an opaque, unique ID for this pass type.
ID()30   static void *ID() { return (void *)&PassID; }
31 
TestFunctionAnalysis(int & Runs)32   TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
33 
34   /// \brief Run the analysis pass over the function and return a result.
run(Function * F,FunctionAnalysisManager * AM)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 {
Result__anonb9c59d210111::TestModuleAnalysis::Result57     Result(int Count) : FunctionCount(Count) {}
58     int FunctionCount;
59   };
60 
ID()61   static void *ID() { return (void *)&PassID; }
62 
TestModuleAnalysis(int & Runs)63   TestModuleAnalysis(int &Runs) : Runs(Runs) {}
64 
run(Module * M,ModuleAnalysisManager * AM)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 {
TestModulePass__anonb9c59d210111::TestModulePass82   TestModulePass(int &RunCount) : RunCount(RunCount) {}
83 
run__anonb9c59d210111::TestModulePass84   PreservedAnalyses run(Module *M) {
85     ++RunCount;
86     return PreservedAnalyses::none();
87   }
88 
name__anonb9c59d210111::TestModulePass89   static StringRef name() { return "TestModulePass"; }
90 
91   int &RunCount;
92 };
93 
94 struct TestPreservingModulePass {
run__anonb9c59d210111::TestPreservingModulePass95   PreservedAnalyses run(Module *M) { return PreservedAnalyses::all(); }
96 
name__anonb9c59d210111::TestPreservingModulePass97   static StringRef name() { return "TestPreservingModulePass"; }
98 };
99 
100 struct TestMinPreservingModulePass {
run__anonb9c59d210111::TestMinPreservingModulePass101   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 
name__anonb9c59d210111::TestMinPreservingModulePass111   static StringRef name() { return "TestMinPreservingModulePass"; }
112 };
113 
114 struct TestFunctionPass {
TestFunctionPass__anonb9c59d210111::TestFunctionPass115   TestFunctionPass(int &RunCount, int &AnalyzedInstrCount,
116                    int &AnalyzedFunctionCount,
117                    bool OnlyUseCachedResults = false)
118       : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
119         AnalyzedFunctionCount(AnalyzedFunctionCount),
120         OnlyUseCachedResults(OnlyUseCachedResults) {}
121 
run__anonb9c59d210111::TestFunctionPass122   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 
name__anonb9c59d210111::TestFunctionPass145   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 {
TestInvalidationFunctionPass__anonb9c59d210111::TestInvalidationFunctionPass156   TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {}
157 
run__anonb9c59d210111::TestInvalidationFunctionPass158   PreservedAnalyses run(Function *F) {
159     return F->getName() == Name ? PreservedAnalyses::none()
160                                 : PreservedAnalyses::all();
161   }
162 
name__anonb9c59d210111::TestInvalidationFunctionPass163   static StringRef name() { return "TestInvalidationFunctionPass"; }
164 
165   StringRef Name;
166 };
167 
parseIR(const char * IR)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:
PassManagerTest()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 
TEST_F(PassManagerTest,BasicPreservedAnalyses)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 
TEST_F(PassManagerTest,Basic)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 }
345