1 //===- unittests/IR/PassBuilderCallbacksTest.cpp - PB Callback 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/Testing/Support/Error.h"
11 #include <functional>
12 #include <gmock/gmock.h>
13 #include <gtest/gtest.h>
14 #include <llvm/ADT/Any.h>
15 #include <llvm/Analysis/CGSCCPassManager.h>
16 #include <llvm/Analysis/LoopAnalysisManager.h>
17 #include <llvm/AsmParser/Parser.h>
18 #include <llvm/IR/LLVMContext.h>
19 #include <llvm/IR/PassInstrumentation.h>
20 #include <llvm/IR/PassManager.h>
21 #include <llvm/Passes/PassBuilder.h>
22 #include <llvm/Support/Regex.h>
23 #include <llvm/Support/SourceMgr.h>
24 #include <llvm/Transforms/Scalar/LoopPassManager.h>
25 
26 using namespace llvm;
27 
28 namespace {
29 using testing::AnyNumber;
30 using testing::AtLeast;
31 using testing::DoDefault;
32 using testing::Not;
33 using testing::Return;
34 using testing::Expectation;
35 using testing::Invoke;
36 using testing::WithArgs;
37 using testing::_;
38 
39 /// A CRTP base for analysis mock handles
40 ///
41 /// This class reconciles mocking with the value semantics implementation of the
42 /// AnalysisManager. Analysis mock handles should derive from this class and
43 /// call \c setDefault() in their constroctur for wiring up the defaults defined
44 /// by this base with their mock run() and invalidate() implementations.
45 template <typename DerivedT, typename IRUnitT,
46           typename AnalysisManagerT = AnalysisManager<IRUnitT>,
47           typename... ExtraArgTs>
48 class MockAnalysisHandleBase {
49 public:
50   class Analysis : public AnalysisInfoMixin<Analysis> {
51     friend AnalysisInfoMixin<Analysis>;
52     friend MockAnalysisHandleBase;
53     static AnalysisKey Key;
54 
55     DerivedT *Handle;
56 
57     Analysis(DerivedT &Handle) : Handle(&Handle) {
58       static_assert(std::is_base_of<MockAnalysisHandleBase, DerivedT>::value,
59                     "Must pass the derived type to this template!");
60     }
61 
62   public:
63     class Result {
64       friend MockAnalysisHandleBase;
65 
66       DerivedT *Handle;
67 
68       Result(DerivedT &Handle) : Handle(&Handle) {}
69 
70     public:
71       // Forward invalidation events to the mock handle.
72       bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
73                       typename AnalysisManagerT::Invalidator &Inv) {
74         return Handle->invalidate(IR, PA, Inv);
75       }
76     };
77 
78     Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
79       return Handle->run(IR, AM, ExtraArgs...);
80     }
81   };
82 
83   Analysis getAnalysis() { return Analysis(static_cast<DerivedT &>(*this)); }
84   typename Analysis::Result getResult() {
85     return typename Analysis::Result(static_cast<DerivedT &>(*this));
86   }
87   static StringRef getName() { return llvm::getTypeName<DerivedT>(); }
88 
89 protected:
90   // FIXME: MSVC seems unable to handle a lambda argument to Invoke from within
91   // the template, so we use a boring static function.
92   static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
93                                  typename AnalysisManagerT::Invalidator &Inv) {
94     auto PAC = PA.template getChecker<Analysis>();
95     return !PAC.preserved() &&
96            !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
97   }
98 
99   /// Derived classes should call this in their constructor to set up default
100   /// mock actions. (We can't do this in our constructor because this has to
101   /// run after the DerivedT is constructed.)
102   void setDefaults() {
103     ON_CALL(static_cast<DerivedT &>(*this),
104             run(_, _, testing::Matcher<ExtraArgTs>(_)...))
105         .WillByDefault(Return(this->getResult()));
106     ON_CALL(static_cast<DerivedT &>(*this), invalidate(_, _, _))
107         .WillByDefault(Invoke(&invalidateCallback));
108   }
109 };
110 
111 /// A CRTP base for pass mock handles
112 ///
113 /// This class reconciles mocking with the value semantics implementation of the
114 /// PassManager. Pass mock handles should derive from this class and
115 /// call \c setDefault() in their constroctur for wiring up the defaults defined
116 /// by this base with their mock run() and invalidate() implementations.
117 template <typename DerivedT, typename IRUnitT, typename AnalysisManagerT,
118           typename... ExtraArgTs>
119 AnalysisKey MockAnalysisHandleBase<DerivedT, IRUnitT, AnalysisManagerT,
120                                    ExtraArgTs...>::Analysis::Key;
121 
122 template <typename DerivedT, typename IRUnitT,
123           typename AnalysisManagerT = AnalysisManager<IRUnitT>,
124           typename... ExtraArgTs>
125 class MockPassHandleBase {
126 public:
127   class Pass : public PassInfoMixin<Pass> {
128     friend MockPassHandleBase;
129 
130     DerivedT *Handle;
131 
132     Pass(DerivedT &Handle) : Handle(&Handle) {
133       static_assert(std::is_base_of<MockPassHandleBase, DerivedT>::value,
134                     "Must pass the derived type to this template!");
135     }
136 
137   public:
138     PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
139                           ExtraArgTs... ExtraArgs) {
140       return Handle->run(IR, AM, ExtraArgs...);
141     }
142   };
143 
144   static StringRef getName() { return llvm::getTypeName<DerivedT>(); }
145 
146   Pass getPass() { return Pass(static_cast<DerivedT &>(*this)); }
147 
148 protected:
149   /// Derived classes should call this in their constructor to set up default
150   /// mock actions. (We can't do this in our constructor because this has to
151   /// run after the DerivedT is constructed.)
152   void setDefaults() {
153     ON_CALL(static_cast<DerivedT &>(*this),
154             run(_, _, testing::Matcher<ExtraArgTs>(_)...))
155         .WillByDefault(Return(PreservedAnalyses::all()));
156   }
157 };
158 
159 /// Mock handles for passes for the IRUnits Module, CGSCC, Function, Loop.
160 /// These handles define the appropriate run() mock interface for the respective
161 /// IRUnit type.
162 template <typename IRUnitT> struct MockPassHandle;
163 template <>
164 struct MockPassHandle<Loop>
165     : MockPassHandleBase<MockPassHandle<Loop>, Loop, LoopAnalysisManager,
166                          LoopStandardAnalysisResults &, LPMUpdater &> {
167   MOCK_METHOD4(run,
168                PreservedAnalyses(Loop &, LoopAnalysisManager &,
169                                  LoopStandardAnalysisResults &, LPMUpdater &));
170   static void invalidateLoop(Loop &L, LoopAnalysisManager &,
171                              LoopStandardAnalysisResults &,
172                              LPMUpdater &Updater) {
173     Updater.markLoopAsDeleted(L, L.getName());
174   }
175   MockPassHandle() { setDefaults(); }
176 };
177 
178 template <>
179 struct MockPassHandle<Function>
180     : MockPassHandleBase<MockPassHandle<Function>, Function> {
181   MOCK_METHOD2(run, PreservedAnalyses(Function &, FunctionAnalysisManager &));
182 
183   MockPassHandle() { setDefaults(); }
184 };
185 
186 template <>
187 struct MockPassHandle<LazyCallGraph::SCC>
188     : MockPassHandleBase<MockPassHandle<LazyCallGraph::SCC>, LazyCallGraph::SCC,
189                          CGSCCAnalysisManager, LazyCallGraph &,
190                          CGSCCUpdateResult &> {
191   MOCK_METHOD4(run,
192                PreservedAnalyses(LazyCallGraph::SCC &, CGSCCAnalysisManager &,
193                                  LazyCallGraph &G, CGSCCUpdateResult &UR));
194 
195   static void invalidateSCC(LazyCallGraph::SCC &C, CGSCCAnalysisManager &,
196                             LazyCallGraph &, CGSCCUpdateResult &UR) {
197     UR.InvalidatedSCCs.insert(&C);
198   }
199 
200   MockPassHandle() { setDefaults(); }
201 };
202 
203 template <>
204 struct MockPassHandle<Module>
205     : MockPassHandleBase<MockPassHandle<Module>, Module> {
206   MOCK_METHOD2(run, PreservedAnalyses(Module &, ModuleAnalysisManager &));
207 
208   MockPassHandle() { setDefaults(); }
209 };
210 
211 /// Mock handles for analyses for the IRUnits Module, CGSCC, Function, Loop.
212 /// These handles define the appropriate run() and invalidate() mock interfaces
213 /// for the respective IRUnit type.
214 template <typename IRUnitT> struct MockAnalysisHandle;
215 template <>
216 struct MockAnalysisHandle<Loop>
217     : MockAnalysisHandleBase<MockAnalysisHandle<Loop>, Loop,
218                              LoopAnalysisManager,
219                              LoopStandardAnalysisResults &> {
220 
221   MOCK_METHOD3_T(run, typename Analysis::Result(Loop &, LoopAnalysisManager &,
222                                                 LoopStandardAnalysisResults &));
223 
224   MOCK_METHOD3_T(invalidate, bool(Loop &, const PreservedAnalyses &,
225                                   LoopAnalysisManager::Invalidator &));
226 
227   MockAnalysisHandle<Loop>() { this->setDefaults(); }
228 };
229 
230 template <>
231 struct MockAnalysisHandle<Function>
232     : MockAnalysisHandleBase<MockAnalysisHandle<Function>, Function> {
233   MOCK_METHOD2(run, Analysis::Result(Function &, FunctionAnalysisManager &));
234 
235   MOCK_METHOD3(invalidate, bool(Function &, const PreservedAnalyses &,
236                                 FunctionAnalysisManager::Invalidator &));
237 
238   MockAnalysisHandle<Function>() { setDefaults(); }
239 };
240 
241 template <>
242 struct MockAnalysisHandle<LazyCallGraph::SCC>
243     : MockAnalysisHandleBase<MockAnalysisHandle<LazyCallGraph::SCC>,
244                              LazyCallGraph::SCC, CGSCCAnalysisManager,
245                              LazyCallGraph &> {
246   MOCK_METHOD3(run, Analysis::Result(LazyCallGraph::SCC &,
247                                      CGSCCAnalysisManager &, LazyCallGraph &));
248 
249   MOCK_METHOD3(invalidate, bool(LazyCallGraph::SCC &, const PreservedAnalyses &,
250                                 CGSCCAnalysisManager::Invalidator &));
251 
252   MockAnalysisHandle<LazyCallGraph::SCC>() { setDefaults(); }
253 };
254 
255 template <>
256 struct MockAnalysisHandle<Module>
257     : MockAnalysisHandleBase<MockAnalysisHandle<Module>, Module> {
258   MOCK_METHOD2(run, Analysis::Result(Module &, ModuleAnalysisManager &));
259 
260   MOCK_METHOD3(invalidate, bool(Module &, const PreservedAnalyses &,
261                                 ModuleAnalysisManager::Invalidator &));
262 
263   MockAnalysisHandle<Module>() { setDefaults(); }
264 };
265 
266 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
267   SMDiagnostic Err;
268   return parseAssemblyString(IR, Err, C);
269 }
270 
271 /// Helper for HasName matcher that returns getName both for IRUnit and
272 /// for IRUnit pointer wrapper into llvm::Any (wrapped by PassInstrumentation).
273 template <typename IRUnitT> std::string getName(const IRUnitT &IR) {
274   return IR.getName();
275 }
276 
277 template <> std::string getName(const StringRef &name) { return name; }
278 
279 template <> std::string getName(const llvm::Any &WrappedIR) {
280   if (any_isa<const Module *>(WrappedIR))
281     return any_cast<const Module *>(WrappedIR)->getName().str();
282   if (any_isa<const Function *>(WrappedIR))
283     return any_cast<const Function *>(WrappedIR)->getName().str();
284   if (any_isa<const Loop *>(WrappedIR))
285     return any_cast<const Loop *>(WrappedIR)->getName().str();
286   if (any_isa<const LazyCallGraph::SCC *>(WrappedIR))
287     return any_cast<const LazyCallGraph::SCC *>(WrappedIR)->getName();
288   return "<UNKNOWN>";
289 }
290 /// Define a custom matcher for objects which support a 'getName' method.
291 ///
292 /// LLVM often has IR objects or analysis objects which expose a name
293 /// and in tests it is convenient to match these by name for readability.
294 /// Usually, this name is either a StringRef or a plain std::string. This
295 /// matcher supports any type exposing a getName() method of this form whose
296 /// return value is compatible with an std::ostream. For StringRef, this uses
297 /// the shift operator defined above.
298 ///
299 /// It should be used as:
300 ///
301 ///   HasName("my_function")
302 ///
303 /// No namespace or other qualification is required.
304 MATCHER_P(HasName, Name, "") {
305   *result_listener << "has name '" << getName(arg) << "'";
306   return Name == getName(arg);
307 }
308 
309 MATCHER_P(HasNameRegex, Name, "") {
310   *result_listener << "has name '" << getName(arg) << "'";
311   llvm::Regex r(Name);
312   return r.match(getName(arg));
313 }
314 
315 struct MockPassInstrumentationCallbacks {
316   PassInstrumentationCallbacks Callbacks;
317 
318   MockPassInstrumentationCallbacks() {
319     ON_CALL(*this, runBeforePass(_, _)).WillByDefault(Return(true));
320   }
321   MOCK_METHOD2(runBeforePass, bool(StringRef PassID, llvm::Any));
322   MOCK_METHOD2(runAfterPass, void(StringRef PassID, llvm::Any));
323   MOCK_METHOD1(runAfterPassInvalidated, void(StringRef PassID));
324   MOCK_METHOD2(runBeforeAnalysis, void(StringRef PassID, llvm::Any));
325   MOCK_METHOD2(runAfterAnalysis, void(StringRef PassID, llvm::Any));
326 
327   void registerPassInstrumentation() {
328     Callbacks.registerBeforePassCallback([this](StringRef P, llvm::Any IR) {
329       return this->runBeforePass(P, IR);
330     });
331     Callbacks.registerAfterPassCallback(
332         [this](StringRef P, llvm::Any IR) { this->runAfterPass(P, IR); });
333     Callbacks.registerAfterPassInvalidatedCallback(
334         [this](StringRef P) { this->runAfterPassInvalidated(P); });
335     Callbacks.registerBeforeAnalysisCallback([this](StringRef P, llvm::Any IR) {
336       return this->runBeforeAnalysis(P, IR);
337     });
338     Callbacks.registerAfterAnalysisCallback(
339         [this](StringRef P, llvm::Any IR) { this->runAfterAnalysis(P, IR); });
340   }
341 
342   void ignoreNonMockPassInstrumentation(StringRef IRName) {
343     // Generic EXPECT_CALLs are needed to match instrumentation on unimportant
344     // parts of a pipeline that we do not care about (e.g. various passes added
345     // by default by PassBuilder - Verifier pass etc).
346     // Make sure to avoid ignoring Mock passes/analysis, we definitely want
347     // to check these explicitly.
348     EXPECT_CALL(*this,
349                 runBeforePass(Not(HasNameRegex("Mock")), HasName(IRName)))
350         .Times(AnyNumber());
351     EXPECT_CALL(*this, runAfterPass(Not(HasNameRegex("Mock")), HasName(IRName)))
352         .Times(AnyNumber());
353     EXPECT_CALL(*this,
354                 runBeforeAnalysis(Not(HasNameRegex("Mock")), HasName(IRName)))
355         .Times(AnyNumber());
356     EXPECT_CALL(*this,
357                 runAfterAnalysis(Not(HasNameRegex("Mock")), HasName(IRName)))
358         .Times(AnyNumber());
359   }
360 };
361 
362 template <typename PassManagerT> class PassBuilderCallbacksTest;
363 
364 /// This test fixture is shared between all the actual tests below and
365 /// takes care of setting up appropriate defaults.
366 ///
367 /// The template specialization serves to extract the IRUnit and AM types from
368 /// the given PassManagerT.
369 template <typename TestIRUnitT, typename... ExtraPassArgTs,
370           typename... ExtraAnalysisArgTs>
371 class PassBuilderCallbacksTest<PassManager<
372     TestIRUnitT, AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>,
373     ExtraPassArgTs...>> : public testing::Test {
374 protected:
375   using IRUnitT = TestIRUnitT;
376   using AnalysisManagerT = AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>;
377   using PassManagerT =
378       PassManager<TestIRUnitT, AnalysisManagerT, ExtraPassArgTs...>;
379   using AnalysisT = typename MockAnalysisHandle<IRUnitT>::Analysis;
380 
381   LLVMContext Context;
382   std::unique_ptr<Module> M;
383 
384   MockPassInstrumentationCallbacks CallbacksHandle;
385 
386   PassBuilder PB;
387   ModulePassManager PM;
388   LoopAnalysisManager LAM;
389   FunctionAnalysisManager FAM;
390   CGSCCAnalysisManager CGAM;
391   ModuleAnalysisManager AM;
392 
393   MockPassHandle<IRUnitT> PassHandle;
394   MockAnalysisHandle<IRUnitT> AnalysisHandle;
395 
396   static PreservedAnalyses getAnalysisResult(IRUnitT &U, AnalysisManagerT &AM,
397                                              ExtraAnalysisArgTs &&... Args) {
398     (void)AM.template getResult<AnalysisT>(
399         U, std::forward<ExtraAnalysisArgTs>(Args)...);
400     return PreservedAnalyses::all();
401   }
402 
403   PassBuilderCallbacksTest()
404       : M(parseIR(Context,
405                   "declare void @bar()\n"
406                   "define void @foo(i32 %n) {\n"
407                   "entry:\n"
408                   "  br label %loop\n"
409                   "loop:\n"
410                   "  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]\n"
411                   "  %iv.next = add i32 %iv, 1\n"
412                   "  tail call void @bar()\n"
413                   "  %cmp = icmp eq i32 %iv, %n\n"
414                   "  br i1 %cmp, label %exit, label %loop\n"
415                   "exit:\n"
416                   "  ret void\n"
417                   "}\n")),
418         CallbacksHandle(), PB(nullptr, None, &CallbacksHandle.Callbacks),
419         PM(true), LAM(true), FAM(true), CGAM(true), AM(true) {
420 
421     /// Register a callback for analysis registration.
422     ///
423     /// The callback is a function taking a reference to an AnalyisManager
424     /// object. When called, the callee gets to register its own analyses with
425     /// this PassBuilder instance.
426     PB.registerAnalysisRegistrationCallback([this](AnalysisManagerT &AM) {
427       // Register our mock analysis
428       AM.registerPass([this] { return AnalysisHandle.getAnalysis(); });
429     });
430 
431     /// Register a callback for pipeline parsing.
432     ///
433     /// During parsing of a textual pipeline, the PassBuilder will call these
434     /// callbacks for each encountered pass name that it does not know. This
435     /// includes both simple pass names as well as names of sub-pipelines. In
436     /// the latter case, the InnerPipeline is not empty.
437     PB.registerPipelineParsingCallback(
438         [this](StringRef Name, PassManagerT &PM,
439                ArrayRef<PassBuilder::PipelineElement> InnerPipeline) {
440           /// Handle parsing of the names of analysis utilities such as
441           /// require<test-analysis> and invalidate<test-analysis> for our
442           /// analysis mock handle
443           if (parseAnalysisUtilityPasses<AnalysisT>("test-analysis", Name, PM))
444             return true;
445 
446           /// Parse the name of our pass mock handle
447           if (Name == "test-transform") {
448             PM.addPass(PassHandle.getPass());
449             return true;
450           }
451           return false;
452         });
453 
454     /// Register builtin analyses and cross-register the analysis proxies
455     PB.registerModuleAnalyses(AM);
456     PB.registerCGSCCAnalyses(CGAM);
457     PB.registerFunctionAnalyses(FAM);
458     PB.registerLoopAnalyses(LAM);
459     PB.crossRegisterProxies(LAM, FAM, CGAM, AM);
460   }
461 };
462 
463 using ModuleCallbacksTest = PassBuilderCallbacksTest<ModulePassManager>;
464 using CGSCCCallbacksTest = PassBuilderCallbacksTest<CGSCCPassManager>;
465 using FunctionCallbacksTest = PassBuilderCallbacksTest<FunctionPassManager>;
466 using LoopCallbacksTest = PassBuilderCallbacksTest<LoopPassManager>;
467 
468 /// Test parsing of the name of our mock pass for all IRUnits.
469 ///
470 /// The pass should by default run our mock analysis and then preserve it.
471 TEST_F(ModuleCallbacksTest, Passes) {
472   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
473   EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
474       .WillOnce(Invoke(getAnalysisResult));
475 
476   StringRef PipelineText = "test-transform";
477   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
478       << "Pipeline was: " << PipelineText;
479 
480   PM.run(*M, AM);
481 }
482 
483 TEST_F(ModuleCallbacksTest, InstrumentedPasses) {
484   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
485   EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
486       .WillOnce(Invoke(getAnalysisResult));
487 
488   CallbacksHandle.registerPassInstrumentation();
489   // Non-mock instrumentation not specifically mentioned below can be ignored.
490   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
491 
492   // PassInstrumentation calls should happen in-sequence, in the same order
493   // as passes/analyses are scheduled.
494   ::testing::Sequence PISequence;
495   EXPECT_CALL(CallbacksHandle, runBeforePass(HasNameRegex("MockPassHandle"),
496                                              HasName("<string>")))
497       .InSequence(PISequence);
498   EXPECT_CALL(CallbacksHandle,
499               runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
500                                 HasName("<string>")))
501       .InSequence(PISequence);
502   EXPECT_CALL(
503       CallbacksHandle,
504       runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("<string>")))
505       .InSequence(PISequence);
506   EXPECT_CALL(CallbacksHandle,
507               runAfterPass(HasNameRegex("MockPassHandle"), HasName("<string>")))
508       .InSequence(PISequence);
509 
510   StringRef PipelineText = "test-transform";
511   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
512       << "Pipeline was: " << PipelineText;
513 
514   PM.run(*M, AM);
515 }
516 
517 TEST_F(ModuleCallbacksTest, InstrumentedSkippedPasses) {
518   CallbacksHandle.registerPassInstrumentation();
519   // Non-mock instrumentation run here can safely be ignored.
520   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
521 
522   // Skip the pass by returning false.
523   EXPECT_CALL(CallbacksHandle, runBeforePass(HasNameRegex("MockPassHandle"),
524                                              HasName("<string>")))
525       .WillOnce(Return(false));
526 
527   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _)).Times(0);
528   EXPECT_CALL(PassHandle, run(HasName("<string>"), _)).Times(0);
529 
530   // As the pass is skipped there is no afterPass, beforeAnalysis/afterAnalysis
531   // as well.
532   EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _))
533       .Times(0);
534   EXPECT_CALL(CallbacksHandle,
535               runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
536       .Times(0);
537   EXPECT_CALL(CallbacksHandle,
538               runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), _))
539       .Times(0);
540 
541   StringRef PipelineText = "test-transform";
542   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
543       << "Pipeline was: " << PipelineText;
544 
545   PM.run(*M, AM);
546 }
547 
548 TEST_F(FunctionCallbacksTest, Passes) {
549   EXPECT_CALL(AnalysisHandle, run(HasName("foo"), _));
550   EXPECT_CALL(PassHandle, run(HasName("foo"), _))
551       .WillOnce(Invoke(getAnalysisResult));
552 
553   StringRef PipelineText = "test-transform";
554   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
555       << "Pipeline was: " << PipelineText;
556   PM.run(*M, AM);
557 }
558 
559 TEST_F(FunctionCallbacksTest, InstrumentedPasses) {
560   CallbacksHandle.registerPassInstrumentation();
561   // Non-mock instrumentation not specifically mentioned below can be ignored.
562   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
563   CallbacksHandle.ignoreNonMockPassInstrumentation("foo");
564 
565   EXPECT_CALL(AnalysisHandle, run(HasName("foo"), _));
566   EXPECT_CALL(PassHandle, run(HasName("foo"), _))
567       .WillOnce(Invoke(getAnalysisResult));
568 
569   // PassInstrumentation calls should happen in-sequence, in the same order
570   // as passes/analyses are scheduled.
571   ::testing::Sequence PISequence;
572   EXPECT_CALL(CallbacksHandle,
573               runBeforePass(HasNameRegex("MockPassHandle"), HasName("foo")))
574       .InSequence(PISequence);
575   EXPECT_CALL(
576       CallbacksHandle,
577       runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("foo")))
578       .InSequence(PISequence);
579   EXPECT_CALL(
580       CallbacksHandle,
581       runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("foo")))
582       .InSequence(PISequence);
583   EXPECT_CALL(CallbacksHandle,
584               runAfterPass(HasNameRegex("MockPassHandle"), HasName("foo")))
585       .InSequence(PISequence);
586 
587   // Our mock pass does not invalidate IR.
588   EXPECT_CALL(CallbacksHandle,
589               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
590       .Times(0);
591 
592   StringRef PipelineText = "test-transform";
593   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
594       << "Pipeline was: " << PipelineText;
595   PM.run(*M, AM);
596 }
597 
598 TEST_F(FunctionCallbacksTest, InstrumentedSkippedPasses) {
599   CallbacksHandle.registerPassInstrumentation();
600   // Non-mock instrumentation run here can safely be ignored.
601   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
602   CallbacksHandle.ignoreNonMockPassInstrumentation("foo");
603 
604   // Skip the pass by returning false.
605   EXPECT_CALL(CallbacksHandle,
606               runBeforePass(HasNameRegex("MockPassHandle"), HasName("foo")))
607       .WillOnce(Return(false));
608 
609   EXPECT_CALL(AnalysisHandle, run(HasName("foo"), _)).Times(0);
610   EXPECT_CALL(PassHandle, run(HasName("foo"), _)).Times(0);
611 
612   // As the pass is skipped there is no afterPass, beforeAnalysis/afterAnalysis
613   // as well.
614   EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _))
615       .Times(0);
616   EXPECT_CALL(CallbacksHandle,
617               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
618       .Times(0);
619   EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _))
620       .Times(0);
621   EXPECT_CALL(CallbacksHandle,
622               runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
623       .Times(0);
624   EXPECT_CALL(CallbacksHandle,
625               runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), _))
626       .Times(0);
627 
628   StringRef PipelineText = "test-transform";
629   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
630       << "Pipeline was: " << PipelineText;
631   PM.run(*M, AM);
632 }
633 
634 TEST_F(LoopCallbacksTest, Passes) {
635   EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _));
636   EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _))
637       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
638 
639   StringRef PipelineText = "test-transform";
640   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
641       << "Pipeline was: " << PipelineText;
642   PM.run(*M, AM);
643 }
644 
645 TEST_F(LoopCallbacksTest, InstrumentedPasses) {
646   CallbacksHandle.registerPassInstrumentation();
647   // Non-mock instrumentation not specifically mentioned below can be ignored.
648   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
649   CallbacksHandle.ignoreNonMockPassInstrumentation("foo");
650   CallbacksHandle.ignoreNonMockPassInstrumentation("loop");
651 
652   EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _));
653   EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _))
654       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
655 
656   // PassInstrumentation calls should happen in-sequence, in the same order
657   // as passes/analyses are scheduled.
658   ::testing::Sequence PISequence;
659   EXPECT_CALL(CallbacksHandle,
660               runBeforePass(HasNameRegex("MockPassHandle"), HasName("loop")))
661       .InSequence(PISequence);
662   EXPECT_CALL(
663       CallbacksHandle,
664       runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop")))
665       .InSequence(PISequence);
666   EXPECT_CALL(
667       CallbacksHandle,
668       runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop")))
669       .InSequence(PISequence);
670   EXPECT_CALL(CallbacksHandle,
671               runAfterPass(HasNameRegex("MockPassHandle"), HasName("loop")))
672       .InSequence(PISequence);
673 
674   // Our mock pass does not invalidate IR.
675   EXPECT_CALL(CallbacksHandle,
676               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
677       .Times(0);
678 
679   StringRef PipelineText = "test-transform";
680   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
681       << "Pipeline was: " << PipelineText;
682   PM.run(*M, AM);
683 }
684 
685 TEST_F(LoopCallbacksTest, InstrumentedInvalidatingPasses) {
686   CallbacksHandle.registerPassInstrumentation();
687   // Non-mock instrumentation not specifically mentioned below can be ignored.
688   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
689   CallbacksHandle.ignoreNonMockPassInstrumentation("foo");
690   CallbacksHandle.ignoreNonMockPassInstrumentation("loop");
691 
692   EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _));
693   EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _))
694       .WillOnce(DoAll(WithArgs<0, 1, 2, 3>(Invoke(PassHandle.invalidateLoop)),
695                       WithArgs<0, 1, 2>(Invoke(getAnalysisResult))));
696 
697   // PassInstrumentation calls should happen in-sequence, in the same order
698   // as passes/analyses are scheduled.
699   ::testing::Sequence PISequence;
700   EXPECT_CALL(CallbacksHandle,
701               runBeforePass(HasNameRegex("MockPassHandle"), HasName("loop")))
702       .InSequence(PISequence);
703   EXPECT_CALL(
704       CallbacksHandle,
705       runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop")))
706       .InSequence(PISequence);
707   EXPECT_CALL(
708       CallbacksHandle,
709       runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("loop")))
710       .InSequence(PISequence);
711   EXPECT_CALL(CallbacksHandle,
712               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
713       .InSequence(PISequence);
714   EXPECT_CALL(CallbacksHandle,
715               runAfterPassInvalidated(HasNameRegex("^PassManager")))
716       .InSequence(PISequence);
717 
718   // Our mock pass invalidates IR, thus normal runAfterPass is never called.
719   EXPECT_CALL(CallbacksHandle,
720               runAfterPass(HasNameRegex("MockPassHandle"), HasName("loop")))
721       .Times(0);
722 
723   StringRef PipelineText = "test-transform";
724   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
725       << "Pipeline was: " << PipelineText;
726   PM.run(*M, AM);
727 }
728 
729 TEST_F(LoopCallbacksTest, InstrumentedSkippedPasses) {
730   CallbacksHandle.registerPassInstrumentation();
731   // Non-mock instrumentation run here can safely be ignored.
732   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
733   CallbacksHandle.ignoreNonMockPassInstrumentation("foo");
734   CallbacksHandle.ignoreNonMockPassInstrumentation("loop");
735 
736   // Skip the pass by returning false.
737   EXPECT_CALL(CallbacksHandle,
738               runBeforePass(HasNameRegex("MockPassHandle"), HasName("loop")))
739       .WillOnce(Return(false));
740 
741   EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _)).Times(0);
742   EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _)).Times(0);
743 
744   // As the pass is skipped there is no afterPass, beforeAnalysis/afterAnalysis
745   // as well.
746   EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _))
747       .Times(0);
748   EXPECT_CALL(CallbacksHandle,
749               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
750       .Times(0);
751   EXPECT_CALL(CallbacksHandle,
752               runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
753       .Times(0);
754   EXPECT_CALL(CallbacksHandle,
755               runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), _))
756       .Times(0);
757 
758   StringRef PipelineText = "test-transform";
759   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
760       << "Pipeline was: " << PipelineText;
761   PM.run(*M, AM);
762 }
763 
764 TEST_F(CGSCCCallbacksTest, Passes) {
765   EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _));
766   EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _))
767       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
768 
769   StringRef PipelineText = "test-transform";
770   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
771       << "Pipeline was: " << PipelineText;
772   PM.run(*M, AM);
773 }
774 
775 TEST_F(CGSCCCallbacksTest, InstrumentedPasses) {
776   CallbacksHandle.registerPassInstrumentation();
777   // Non-mock instrumentation not specifically mentioned below can be ignored.
778   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
779   CallbacksHandle.ignoreNonMockPassInstrumentation("(foo)");
780 
781   EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _));
782   EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _))
783       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
784 
785   // PassInstrumentation calls should happen in-sequence, in the same order
786   // as passes/analyses are scheduled.
787   ::testing::Sequence PISequence;
788   EXPECT_CALL(CallbacksHandle,
789               runBeforePass(HasNameRegex("MockPassHandle"), HasName("(foo)")))
790       .InSequence(PISequence);
791   EXPECT_CALL(
792       CallbacksHandle,
793       runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)")))
794       .InSequence(PISequence);
795   EXPECT_CALL(
796       CallbacksHandle,
797       runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)")))
798       .InSequence(PISequence);
799   EXPECT_CALL(CallbacksHandle,
800               runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)")))
801       .InSequence(PISequence);
802 
803   // Our mock pass does not invalidate IR.
804   EXPECT_CALL(CallbacksHandle,
805               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
806       .Times(0);
807 
808   StringRef PipelineText = "test-transform";
809   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
810       << "Pipeline was: " << PipelineText;
811   PM.run(*M, AM);
812 }
813 
814 TEST_F(CGSCCCallbacksTest, InstrumentedInvalidatingPasses) {
815   CallbacksHandle.registerPassInstrumentation();
816   // Non-mock instrumentation not specifically mentioned below can be ignored.
817   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
818   CallbacksHandle.ignoreNonMockPassInstrumentation("(foo)");
819 
820   EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _));
821   EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _))
822       .WillOnce(DoAll(WithArgs<0, 1, 2, 3>(Invoke(PassHandle.invalidateSCC)),
823                       WithArgs<0, 1, 2>(Invoke(getAnalysisResult))));
824 
825   // PassInstrumentation calls should happen in-sequence, in the same order
826   // as passes/analyses are scheduled.
827   ::testing::Sequence PISequence;
828   EXPECT_CALL(CallbacksHandle,
829               runBeforePass(HasNameRegex("MockPassHandle"), HasName("(foo)")))
830       .InSequence(PISequence);
831   EXPECT_CALL(
832       CallbacksHandle,
833       runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)")))
834       .InSequence(PISequence);
835   EXPECT_CALL(
836       CallbacksHandle,
837       runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), HasName("(foo)")))
838       .InSequence(PISequence);
839   EXPECT_CALL(CallbacksHandle,
840               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
841       .InSequence(PISequence);
842   EXPECT_CALL(CallbacksHandle,
843               runAfterPassInvalidated(HasNameRegex("^PassManager")))
844       .InSequence(PISequence);
845 
846   // Our mock pass does invalidate IR, thus normal runAfterPass is never called.
847   EXPECT_CALL(CallbacksHandle,
848               runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)")))
849       .Times(0);
850 
851   StringRef PipelineText = "test-transform";
852   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
853       << "Pipeline was: " << PipelineText;
854   PM.run(*M, AM);
855 }
856 
857 TEST_F(CGSCCCallbacksTest, InstrumentedSkippedPasses) {
858   CallbacksHandle.registerPassInstrumentation();
859   // Non-mock instrumentation run here can safely be ignored.
860   CallbacksHandle.ignoreNonMockPassInstrumentation("<string>");
861   CallbacksHandle.ignoreNonMockPassInstrumentation("(foo)");
862 
863   // Skip the pass by returning false.
864   EXPECT_CALL(CallbacksHandle,
865               runBeforePass(HasNameRegex("MockPassHandle"), HasName("(foo)")))
866       .WillOnce(Return(false));
867 
868   // neither Analysis nor Pass are called.
869   EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _)).Times(0);
870   EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _)).Times(0);
871 
872   // As the pass is skipped there is no afterPass, beforeAnalysis/afterAnalysis
873   // as well.
874   EXPECT_CALL(CallbacksHandle, runAfterPass(HasNameRegex("MockPassHandle"), _))
875       .Times(0);
876   EXPECT_CALL(CallbacksHandle,
877               runAfterPassInvalidated(HasNameRegex("MockPassHandle")))
878       .Times(0);
879   EXPECT_CALL(CallbacksHandle,
880               runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"), _))
881       .Times(0);
882   EXPECT_CALL(CallbacksHandle,
883               runAfterAnalysis(HasNameRegex("MockAnalysisHandle"), _))
884       .Times(0);
885 
886   StringRef PipelineText = "test-transform";
887   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
888       << "Pipeline was: " << PipelineText;
889   PM.run(*M, AM);
890 }
891 
892 /// Test parsing of the names of analysis utilities for our mock analysis
893 /// for all IRUnits.
894 ///
895 /// We first require<>, then invalidate<> it, expecting the analysis to be run
896 /// once and subsequently invalidated.
897 TEST_F(ModuleCallbacksTest, AnalysisUtilities) {
898   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
899   EXPECT_CALL(AnalysisHandle, invalidate(HasName("<string>"), _, _));
900 
901   StringRef PipelineText = "require<test-analysis>,invalidate<test-analysis>";
902   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
903       << "Pipeline was: " << PipelineText;
904   PM.run(*M, AM);
905 }
906 
907 TEST_F(CGSCCCallbacksTest, PassUtilities) {
908   EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _));
909   EXPECT_CALL(AnalysisHandle, invalidate(HasName("(foo)"), _, _));
910 
911   StringRef PipelineText = "require<test-analysis>,invalidate<test-analysis>";
912   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
913       << "Pipeline was: " << PipelineText;
914   PM.run(*M, AM);
915 }
916 
917 TEST_F(FunctionCallbacksTest, AnalysisUtilities) {
918   EXPECT_CALL(AnalysisHandle, run(HasName("foo"), _));
919   EXPECT_CALL(AnalysisHandle, invalidate(HasName("foo"), _, _));
920 
921   StringRef PipelineText = "require<test-analysis>,invalidate<test-analysis>";
922   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
923       << "Pipeline was: " << PipelineText;
924   PM.run(*M, AM);
925 }
926 
927 TEST_F(LoopCallbacksTest, PassUtilities) {
928   EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _));
929   EXPECT_CALL(AnalysisHandle, invalidate(HasName("loop"), _, _));
930 
931   StringRef PipelineText = "require<test-analysis>,invalidate<test-analysis>";
932 
933   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
934       << "Pipeline was: " << PipelineText;
935   PM.run(*M, AM);
936 }
937 
938 /// Test parsing of the top-level pipeline.
939 ///
940 /// The ParseTopLevelPipeline callback takes over parsing of the entire pipeline
941 /// from PassBuilder if it encounters an unknown pipeline entry at the top level
942 /// (i.e., the first entry on the pipeline).
943 /// This test parses a pipeline named 'another-pipeline', whose only elements
944 /// may be the test-transform pass or the analysis utilities
945 TEST_F(ModuleCallbacksTest, ParseTopLevelPipeline) {
946   PB.registerParseTopLevelPipelineCallback([this](
947       ModulePassManager &MPM, ArrayRef<PassBuilder::PipelineElement> Pipeline,
948       bool VerifyEachPass, bool DebugLogging) {
949     auto &FirstName = Pipeline.front().Name;
950     auto &InnerPipeline = Pipeline.front().InnerPipeline;
951     if (FirstName == "another-pipeline") {
952       for (auto &E : InnerPipeline) {
953         if (parseAnalysisUtilityPasses<AnalysisT>("test-analysis", E.Name, PM))
954           continue;
955 
956         if (E.Name == "test-transform") {
957           PM.addPass(PassHandle.getPass());
958           continue;
959         }
960         return false;
961       }
962     }
963     return true;
964   });
965 
966   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
967   EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
968       .WillOnce(Invoke(getAnalysisResult));
969   EXPECT_CALL(AnalysisHandle, invalidate(HasName("<string>"), _, _));
970 
971   StringRef PipelineText =
972       "another-pipeline(test-transform,invalidate<test-analysis>)";
973   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
974       << "Pipeline was: " << PipelineText;
975   PM.run(*M, AM);
976 
977   /// Test the negative case
978   PipelineText = "another-pipeline(instcombine)";
979   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Failed())
980       << "Pipeline was: " << PipelineText;
981 }
982 } // end anonymous namespace
983