1 //===- llvm/unittest/IR/PassManager.cpp - PassManager tests ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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"
22 class TestFunctionAnalysis {
25 Result(int Count) : InstructionCount(Count) {}
29 /// \brief Returns an opaque, unique ID for this pass type.
30 static void *ID() { return (void *)&PassID; }
32 TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
34 /// \brief Run the analysis pass over the function and return a result.
35 Result run(Function *F, FunctionAnalysisManager *AM) {
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;
46 /// \brief Private static data to provide unique ID.
52 char TestFunctionAnalysis::PassID;
54 class TestModuleAnalysis {
57 Result(int Count) : FunctionCount(Count) {}
61 static void *ID() { return (void * )&PassID; }
63 TestModuleAnalysis(int &Runs) : Runs(Runs) {}
65 Result run(Module *M, ModuleAnalysisManager *AM) {
68 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
79 char TestModuleAnalysis::PassID;
81 struct TestModulePass {
82 TestModulePass(int &RunCount) : RunCount(RunCount) {}
84 PreservedAnalyses run(Module *M) {
86 return PreservedAnalyses::none();
89 static StringRef name() { return "TestModulePass"; }
94 struct TestPreservingModulePass {
95 PreservedAnalyses run(Module *M) {
96 return PreservedAnalyses::all();
99 static StringRef name() { return "TestPreservingModulePass"; }
102 struct TestMinPreservingModulePass {
103 PreservedAnalyses run(Module *M, ModuleAnalysisManager *AM) {
104 PreservedAnalyses PA;
106 // Force running an analysis.
107 (void)AM->getResult<TestModuleAnalysis>(M);
109 PA.preserve<FunctionAnalysisManagerModuleProxy>();
113 static StringRef name() { return "TestMinPreservingModulePass"; }
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) {}
124 PreservedAnalyses run(Function *F, FunctionAnalysisManager *AM) {
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;
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;
139 // Typical path just runs the analysis as needed.
140 TestFunctionAnalysis::Result &AR = AM->getResult<TestFunctionAnalysis>(F);
141 AnalyzedInstrCount += AR.InstructionCount;
144 return PreservedAnalyses::all();
147 static StringRef name() { return "TestFunctionPass"; }
150 int &AnalyzedInstrCount;
151 int &AnalyzedFunctionCount;
152 bool OnlyUseCachedResults;
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) {}
160 PreservedAnalyses run(Function *F) {
161 return F->getName() == Name ? PreservedAnalyses::none()
162 : PreservedAnalyses::all();
165 static StringRef name() { return "TestInvalidationFunctionPass"; }
170 Module *parseIR(const char *IR) {
171 LLVMContext &C = getGlobalContext();
173 return ParseAssemblyString(IR, 0, Err, C);
176 class PassManagerTest : public ::testing::Test {
178 std::unique_ptr<Module> M;
182 : M(parseIR("define void @f() {\n"
188 "define void @g() {\n"
191 "define void @h() {\n"
196 TEST_F(PassManagerTest, Basic) {
197 FunctionAnalysisManager FAM;
198 int FunctionAnalysisRuns = 0;
199 FAM.registerPass(TestFunctionAnalysis(FunctionAnalysisRuns));
201 ModuleAnalysisManager MAM;
202 int ModuleAnalysisRuns = 0;
203 MAM.registerPass(TestModuleAnalysis(ModuleAnalysisRuns));
204 MAM.registerPass(FunctionAnalysisManagerModuleProxy(FAM));
205 FAM.registerPass(ModuleAnalysisManagerFunctionProxy(MAM));
207 ModulePassManager MPM;
209 // Count the runs over a Function.
210 int FunctionPassRunCount1 = 0;
211 int AnalyzedInstrCount1 = 0;
212 int AnalyzedFunctionCount1 = 0;
214 FunctionPassManager FPM;
215 FPM.addPass(TestFunctionPass(FunctionPassRunCount1, AnalyzedInstrCount1,
216 AnalyzedFunctionCount1));
217 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
220 // Count the runs over a module.
221 int ModulePassRunCount = 0;
222 MPM.addPass(TestModulePass(ModulePassRunCount));
224 // Count the runs over a Function in a separate manager.
225 int FunctionPassRunCount2 = 0;
226 int AnalyzedInstrCount2 = 0;
227 int AnalyzedFunctionCount2 = 0;
229 FunctionPassManager FPM;
230 FPM.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2,
231 AnalyzedFunctionCount2));
232 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
235 // A third function pass manager but with only preserving intervening passes
236 // and with a function pass that invalidates exactly one analysis.
237 MPM.addPass(TestPreservingModulePass());
238 int FunctionPassRunCount3 = 0;
239 int AnalyzedInstrCount3 = 0;
240 int AnalyzedFunctionCount3 = 0;
242 FunctionPassManager FPM;
243 FPM.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3,
244 AnalyzedFunctionCount3));
245 FPM.addPass(TestInvalidationFunctionPass("f"));
246 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
249 // A fourth function pass manager but with a minimal intervening passes.
250 MPM.addPass(TestMinPreservingModulePass());
251 int FunctionPassRunCount4 = 0;
252 int AnalyzedInstrCount4 = 0;
253 int AnalyzedFunctionCount4 = 0;
255 FunctionPassManager FPM;
256 FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
257 AnalyzedFunctionCount4));
258 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
261 // A fifth function pass manager but which uses only cached results.
262 int FunctionPassRunCount5 = 0;
263 int AnalyzedInstrCount5 = 0;
264 int AnalyzedFunctionCount5 = 0;
266 FunctionPassManager FPM;
267 FPM.addPass(TestInvalidationFunctionPass("f"));
268 FPM.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5,
269 AnalyzedFunctionCount5,
270 /*OnlyUseCachedResults=*/true));
271 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
274 MPM.run(M.get(), &MAM);
276 // Validate module pass counters.
277 EXPECT_EQ(1, ModulePassRunCount);
279 // Validate all function pass counter sets are the same.
280 EXPECT_EQ(3, FunctionPassRunCount1);
281 EXPECT_EQ(5, AnalyzedInstrCount1);
282 EXPECT_EQ(0, AnalyzedFunctionCount1);
283 EXPECT_EQ(3, FunctionPassRunCount2);
284 EXPECT_EQ(5, AnalyzedInstrCount2);
285 EXPECT_EQ(0, AnalyzedFunctionCount2);
286 EXPECT_EQ(3, FunctionPassRunCount3);
287 EXPECT_EQ(5, AnalyzedInstrCount3);
288 EXPECT_EQ(0, AnalyzedFunctionCount3);
289 EXPECT_EQ(3, FunctionPassRunCount4);
290 EXPECT_EQ(5, AnalyzedInstrCount4);
291 EXPECT_EQ(0, AnalyzedFunctionCount4);
292 EXPECT_EQ(3, FunctionPassRunCount5);
293 EXPECT_EQ(2, AnalyzedInstrCount5); // Only 'g' and 'h' were cached.
294 EXPECT_EQ(0, AnalyzedFunctionCount5);
296 // Validate the analysis counters:
297 // first run over 3 functions, then module pass invalidates
298 // second run over 3 functions, nothing invalidates
299 // third run over 0 functions, but 1 function invalidated
300 // fourth run over 1 function
301 EXPECT_EQ(7, FunctionAnalysisRuns);
303 EXPECT_EQ(1, ModuleAnalysisRuns);