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) {
96     return PreservedAnalyses::all();
97   }
98 
99   static StringRef name() { return "TestPreservingModulePass"; }
100 };
101 
102 struct TestMinPreservingModulePass {
103   PreservedAnalyses run(Module *M, ModuleAnalysisManager *AM) {
104     PreservedAnalyses PA;
105 
106     // Force running an analysis.
107     (void)AM->getResult<TestModuleAnalysis>(M);
108 
109     PA.preserve<FunctionAnalysisManagerModuleProxy>();
110     return PA;
111   }
112 
113   static StringRef name() { return "TestMinPreservingModulePass"; }
114 };
115 
116 struct TestFunctionPass {
117   TestFunctionPass(int &RunCount, int &AnalyzedInstrCount,
118                    int &AnalyzedFunctionCount,
119                    bool OnlyUseCachedResults = false)
120       : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
121         AnalyzedFunctionCount(AnalyzedFunctionCount),
122         OnlyUseCachedResults(OnlyUseCachedResults) {}
123 
124   PreservedAnalyses run(Function *F, FunctionAnalysisManager *AM) {
125     ++RunCount;
126 
127     const ModuleAnalysisManager &MAM =
128         AM->getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
129     if (TestModuleAnalysis::Result *TMA =
130             MAM.getCachedResult<TestModuleAnalysis>(F->getParent()))
131       AnalyzedFunctionCount += TMA->FunctionCount;
132 
133     if (OnlyUseCachedResults) {
134       // Hack to force the use of the cached interface.
135       if (TestFunctionAnalysis::Result *AR =
136               AM->getCachedResult<TestFunctionAnalysis>(F))
137         AnalyzedInstrCount += AR->InstructionCount;
138     } else {
139       // Typical path just runs the analysis as needed.
140       TestFunctionAnalysis::Result &AR = AM->getResult<TestFunctionAnalysis>(F);
141       AnalyzedInstrCount += AR.InstructionCount;
142     }
143 
144     return PreservedAnalyses::all();
145   }
146 
147   static StringRef name() { return "TestFunctionPass"; }
148 
149   int &RunCount;
150   int &AnalyzedInstrCount;
151   int &AnalyzedFunctionCount;
152   bool OnlyUseCachedResults;
153 };
154 
155 // A test function pass that invalidates all function analyses for a function
156 // with a specific name.
157 struct TestInvalidationFunctionPass {
158   TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {}
159 
160   PreservedAnalyses run(Function *F) {
161     return F->getName() == Name ? PreservedAnalyses::none()
162                                 : PreservedAnalyses::all();
163   }
164 
165   static StringRef name() { return "TestInvalidationFunctionPass"; }
166 
167   StringRef Name;
168 };
169 
170 Module *parseIR(const char *IR) {
171   LLVMContext &C = getGlobalContext();
172   SMDiagnostic Err;
173   return ParseAssemblyString(IR, 0, Err, C);
174 }
175 
176 class PassManagerTest : public ::testing::Test {
177 protected:
178   OwningPtr<Module> M;
179 
180 public:
181   PassManagerTest()
182       : M(parseIR("define void @f() {\n"
183                   "entry:\n"
184                   "  call void @g()\n"
185                   "  call void @h()\n"
186                   "  ret void\n"
187                   "}\n"
188                   "define void @g() {\n"
189                   "  ret void\n"
190                   "}\n"
191                   "define void @h() {\n"
192                   "  ret void\n"
193                   "}\n")) {}
194 };
195 
196 TEST_F(PassManagerTest, Basic) {
197   FunctionAnalysisManager FAM;
198   int FunctionAnalysisRuns = 0;
199   FAM.registerPass(TestFunctionAnalysis(FunctionAnalysisRuns));
200 
201   ModuleAnalysisManager MAM;
202   int ModuleAnalysisRuns = 0;
203   MAM.registerPass(TestModuleAnalysis(ModuleAnalysisRuns));
204   MAM.registerPass(FunctionAnalysisManagerModuleProxy(FAM));
205   FAM.registerPass(ModuleAnalysisManagerFunctionProxy(MAM));
206 
207   ModulePassManager MPM;
208 
209   // Count the runs over a Function.
210   FunctionPassManager FPM1;
211   int FunctionPassRunCount1 = 0;
212   int AnalyzedInstrCount1 = 0;
213   int AnalyzedFunctionCount1 = 0;
214   FPM1.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1,
215                                 AnalyzedFunctionCount1));
216   MPM.addPass(createModuleToFunctionPassAdaptor(FPM1));
217 
218   // Count the runs over a module.
219   int ModulePassRunCount = 0;
220   MPM.addPass(TestModulePass(ModulePassRunCount));
221 
222   // Count the runs over a Function in a separate manager.
223   FunctionPassManager FPM2;
224   int FunctionPassRunCount2 = 0;
225   int AnalyzedInstrCount2 = 0;
226   int AnalyzedFunctionCount2 = 0;
227   FPM2.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2,
228                                 AnalyzedFunctionCount2));
229   MPM.addPass(createModuleToFunctionPassAdaptor(FPM2));
230 
231   // A third function pass manager but with only preserving intervening passes
232   // and with a function pass that invalidates exactly one analysis.
233   MPM.addPass(TestPreservingModulePass());
234   FunctionPassManager FPM3;
235   int FunctionPassRunCount3 = 0;
236   int AnalyzedInstrCount3 = 0;
237   int AnalyzedFunctionCount3 = 0;
238   FPM3.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3,
239                                 AnalyzedFunctionCount3));
240   FPM3.addPass(TestInvalidationFunctionPass("f"));
241   MPM.addPass(createModuleToFunctionPassAdaptor(FPM3));
242 
243   // A fourth function pass manager but with a minimal intervening passes.
244   MPM.addPass(TestMinPreservingModulePass());
245   FunctionPassManager FPM4;
246   int FunctionPassRunCount4 = 0;
247   int AnalyzedInstrCount4 = 0;
248   int AnalyzedFunctionCount4 = 0;
249   FPM4.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
250                                 AnalyzedFunctionCount4));
251   MPM.addPass(createModuleToFunctionPassAdaptor(FPM4));
252 
253   // A fifth function pass manager but which uses only cached results.
254   FunctionPassManager FPM5;
255   int FunctionPassRunCount5 = 0;
256   int AnalyzedInstrCount5 = 0;
257   int AnalyzedFunctionCount5 = 0;
258   FPM5.addPass(TestInvalidationFunctionPass("f"));
259   FPM5.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5,
260                                 AnalyzedFunctionCount5,
261                                 /*OnlyUseCachedResults=*/true));
262   MPM.addPass(createModuleToFunctionPassAdaptor(FPM5));
263 
264   MPM.run(M.get(), &MAM);
265 
266   // Validate module pass counters.
267   EXPECT_EQ(1, ModulePassRunCount);
268 
269   // Validate all function pass counter sets are the same.
270   EXPECT_EQ(3, FunctionPassRunCount1);
271   EXPECT_EQ(5, AnalyzedInstrCount1);
272   EXPECT_EQ(0, AnalyzedFunctionCount1);
273   EXPECT_EQ(3, FunctionPassRunCount2);
274   EXPECT_EQ(5, AnalyzedInstrCount2);
275   EXPECT_EQ(0, AnalyzedFunctionCount2);
276   EXPECT_EQ(3, FunctionPassRunCount3);
277   EXPECT_EQ(5, AnalyzedInstrCount3);
278   EXPECT_EQ(0, AnalyzedFunctionCount3);
279   EXPECT_EQ(3, FunctionPassRunCount4);
280   EXPECT_EQ(5, AnalyzedInstrCount4);
281   EXPECT_EQ(0, AnalyzedFunctionCount4);
282   EXPECT_EQ(3, FunctionPassRunCount5);
283   EXPECT_EQ(2, AnalyzedInstrCount5); // Only 'g' and 'h' were cached.
284   EXPECT_EQ(0, AnalyzedFunctionCount5);
285 
286   // Validate the analysis counters:
287   //   first run over 3 functions, then module pass invalidates
288   //   second run over 3 functions, nothing invalidates
289   //   third run over 0 functions, but 1 function invalidated
290   //   fourth run over 1 function
291   EXPECT_EQ(7, FunctionAnalysisRuns);
292 
293   EXPECT_EQ(1, ModuleAnalysisRuns);
294 }
295 }
296