[PM] Add a generic 'repeat N times' pass wrapper to the new pass manager.

[chandlerc]

Summary

While this has some utility for debugging and testing on its own, it is
primarily intended to demonstrate the technique for adding custom
wrappers that can provide more interesting interation behavior in
a nice, orthogonal, and composable layer.

Being able to write these kinds of very dynamic and customized controls
for running passes was one of the motivating use cases of the new pass
manager design, and this gives a hint at how they might look. The actual
logic is tiny here, and most of this is just wiring in the pipeline
parsing so that this can be widely used.

I'm adding this now to show the wiring without a lot of business logic.
This is a precursor patch for showing how a "iterate up to N times as
long as we devirtualize a call" utility can be added as a separable and
composable component along side the CGSCC pass management.

[chandlerc]

Update to be based on the cleaned up parsing in https://reviews.llvm.org/D22724

[hfinkel]

Nice example ;)

LGTM

[silvas]

lib/Passes/PassBuilder.cpp

266

It worries me that we're going down the path of "no proper lexer". D22724 improved the state of things somewhat.

I just have scars. Every time I've decided to not put a proper lexer or tokenization step in front of any kind of "parsing" I have always regretted it down the road.

It would be great if you could improve this in future patches (this would also probably make source location reporting much easier too since the token can store a source location).

Just an FYI. I think this is fine for now.

test/Other/new-pass-manager.ll

432

Please don't just blindly check the exact output. Check for what you are looking for (e.g. a particular pass being run a particular number of times).
Same for the other tests.

[chandlerc]

lib/Passes/PassBuilder.cpp

266

Yea, I don't completely disagree and expect at some point this will become more formalized. I'm mostly trying to follow a lazy design principle so that we don't over-engineer this early on because I'm not yet sure what some of the constraints will be. As things settle in terms of functionality, it'll probably become more worthwhile to then harden this properly.

test/Other/new-pass-manager.ll

432

I'm not just blindly checking the full output.

At several points, I had bugs with too many intermediate pass managers. Having the precise output checked made it really obvious.

While I don't think we should have very many places that check the *exact* pipeline construction details in this way, I think it is reasonable to have roughly one place that surfaces any change in the pipeline structure so that the structure doesn't change in unintended ways. I could reduce the repeatition count to 2 to make this a bit less chatty if that would help, but not sure that it would.

(It is a bit unfortunate that I have to check the *analysis* runs here, and I actually thought about how to avoid that and didn't come up with anything better. It would end up being giant hunks of -NOT checks to blacklist everything that shouldn't go in the space the analysis runs did, and would still end up hard coding the analysis runs go in that space. This is just a fundamental problem with FileCheck based tests -- when you want the test to fail if *new* things show up, you end up hard coding more than you wanted.)

[davidxl]

lib/Passes/PassBuilder.cpp

266

I agree with Sean. It would be useful to document the grammar of the pass specification language. This is of course a future item, but doing it earlier allows identifying inconsistency earlier.

It seems to me the grammar is:

<pass_pipeline> := <pass_specification>, <pass_pipeline> | <pass_specification>
<pass_specification>:= <pass_description>|<pre-requisite>| <post_invalidation>
<pass_description> := <irunit>(<pass_pipeline>) | <pass_name>
<irunit> := module | cgscc | function | loop
<pre_requisite> := require< <pass_pipeline> >
<post_invalidation> := invalidate< <pass_pipeline> >

Question: for consistency reason, why using '< >' for require/invalidate' ? using <> for 'repeat<..>' seems making sense.

Also it seems more consistent to make aa-pipeline to adopt similar syntax as 'aa-pipeline(basic_aa, scev)' instead of the current form that uses '=' and it can be specified as part of the passes specification;

-passes=aa-pipeline(basicaa, ...),module(function(jump_threading), globaldce)

Also some of the pass names are allowed to use '< >' in their names such as printer passes -- it should be disallowed.

[silvas]

test/Other/new-pass-manager.ll

432

I disagree, but only mildly. If you feel strongly about keeping this feel free to commit as-is.

[silvas]

lib/Passes/PassBuilder.cpp

266

Also it seems more consistent to make aa-pipeline to adopt similar syntax as 'aa-pipeline(basic_aa, scev)' instead of the current form that uses '=' and it can be specified as part of the passes specification;

-passes=aa-pipeline(basicaa, ...),module(function(jump_threading), globaldce)

This is a bit inconsistent, because aa-pipeline(basicaa, ...) doesn't create a transformation. Notice that all other items in the -passes= argument create transformations (even printer passes have the PreservedAnalyses run(IRUnitT &IR, AnalysisManager &AM) signature). aa-pipeline configures something for the overall pipeline, and it is the only such configuration aspect currently (actually, -debug-pass-manager could be considered to be "configuration" as well).

That is, the intent is that <pass_specification> production currently always expands to something that is a transformation (has signature PreservedAnalyses run(IRUnitT &IR, AnalysisManager &AM)).

[chandlerc]

Thanks all, landing momentarily.

lib/Passes/PassBuilder.cpp

266

As Sean said, the AA stuff is really different.

The reason there is an '=' in there is because the AA pipeline is actually a separate commandline flag. So it is a separate parsed entity, and its grammar is just a comma separated list of names.

Regarding <>s, I think there is a consistent set of passes that accept some parameter and use <>s for that parameter. The "require" or "print" passes accept a parameter indicating what is required or what is printed (resp.). The repeat pass accepts an integer for the number of repeatitions. The ()s are different -- in every case currently (I think) they form a pass manager populated by passing a nested pipeline.

Still, this would certainly (eventually) benefit from formalization. I'd like to have the infrastructure in place first so that it can reflect all the variations we end up needing at least for the initial cut. I have one particular piece of infrastructure queued up that may influence this syntax depending on which design we take.

But none of this is really for this patch. =D So we should resume this discussion when things have settled a bit and someone has time to push this particular aspect forward.

test/Other/new-pass-manager.ll

432

Thanks. This specific case showed me a bug that was obviated by the cleaner parsing logic in an earlier iteration of this patch, so I'd like to keep it. But I am 100% sympathetic to the concern over brittle tests here, and I'll keep thinking about if there is a better way to make changes in the exact pass structure (that may be unintended) visible without making it a burden for future maintainers. So far, comments and a "golden test" style test is the best idea I've got but that doesn't make it especially good...

include/llvm/IR/PassManager.h

 struct InvalidateAllAnalysesPass : PassInfoMixin<InvalidateAllAnalysesPass> {
   /// \brief Run this pass over some unit of IR.
   template <typename IRUnitT>
   PreservedAnalyses run(IRUnitT &, AnalysisManager<IRUnitT> &) {
     return PreservedAnalyses::none();
   }
 };
 
+/// A utility pass template that simply runs another pass multiple times.
+///
+/// This can be useful when debugging or testing passes. It also serves as an
+/// example of how to extend the pass manager in ways beyond composition.
+template <typename PassT>
+class RepeatingPassWrapper : public PassInfoMixin<RepeatingPassWrapper<PassT>> {
+public:
+  RepeatingPassWrapper(int Count, PassT P) : Count(Count), P(std::move(P)) {}
+
+  template <typename IRUnitT, typename... Ts>
+  PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM,
+                        Ts... Args) {
+    auto PA = PreservedAnalyses::all();
+    for (int i = 0; i < Count; ++i)
+      PA.intersect(P.run(Arg, AM, Args...));
+    return PA;
+  }
+
+private:
+  const int Count;
+  PassT P;
+};
+
+template <typename PassT>
+RepeatingPassWrapper<PassT> createRepeatingPassWrapper(int Count, PassT P) {
+  return RepeatingPassWrapper<PassT>(Count, std::move(P));
+}
+
 }
 
 #endif

lib/Passes/PassBuilder.cpp

void PassBuilder::addLTODefaultPipeline(ModulePassManager &MPM,
   FunctionPassManager LateFPM(DebugLogging);
   LateFPM.addPass(InstCombinePass());
   LateFPM.addPass(SimplifyCFGPass());
 
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(LateFPM)));
 }
 
 #ifndef NDEBUG
 static bool isModulePassName(StringRef Name) {
   // Manually handle aliases for pre-configured pipeline fragments.
   if (Name.startswith("default") || Name.startswith("lto"))
     return DefaultAliasRegex.match(Name);
 
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   if (Name == NAME)                                                            \
     return true;
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
AA.registerFunctionAnalysis<                                               \
         std::remove_reference<decltype(CREATE_PASS)>::type>();                 \
     return true;                                                               \
   }
 #include "PassRegistry.def"
 
   return false;
 }
 
+template <typename PassManagerT, typename ParseCallbackT>
+static bool parseRepeatedPipeline(PassManagerT &PM, StringRef &PipelineText,
+                                 bool DebugLogging,
+                                 ParseCallbackT &&ParseCallback) {
+  assert(PipelineText.startswith("repeat(") &&
+         "Must be parsing a repeated pipeline!");
+  PipelineText = PipelineText.substr(strlen("repeat("));
+  // Otherwise try to parse a pass name.
+  size_t End = PipelineText.find_first_of(",");
+  int Count;
+  if (PipelineText.substr(0, End).getAsInteger(0, Count))
+    return false;
+  if (Count <= 0)
+    return false;
+  PipelineText = PipelineText.substr(End + 1);
+
+  // Now build up the repeated pipeline in an implicit pass manager.
+  PassManagerT RepeatedPM(DebugLogging);
+  if (!ParseCallback(RepeatedPM, PipelineText) || PipelineText.empty())
+    return false;
+  assert(PipelineText[0] == ')');
+  PipelineText = PipelineText.substr(1);
+
+  // Finally, embed this repeated pass manager in the repeated pass wrapper.
+  PM.addPass(createRepeatingPassWrapper(Count, std::move(RepeatedPM)));
+  return true;
+}
+
 bool PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
                                         StringRef &PipelineText,
                                         bool VerifyEachPass,
                                         bool DebugLogging) {
   for (;;) {
     // Parse nested pass managers by recursing.
     if (PipelineText.startswith("loop(")) {
       LoopPassManager NestedLPM(DebugLogging);
 
       // Parse the inner pipeline inte the nested manager.
       PipelineText = PipelineText.substr(strlen("loop("));
       if (!parseLoopPassPipeline(NestedLPM, PipelineText, VerifyEachPass,
                                  DebugLogging) ||
           PipelineText.empty())
         return false;
       assert(PipelineText[0] == ')');
       PipelineText = PipelineText.substr(1);
 
       // Add the nested pass manager with the appropriate adaptor.
       LPM.addPass(std::move(NestedLPM));
+    } else if (PipelineText.startswith("repeat(")) {
+      if (!parseRepeatedPipeline(
+              LPM, PipelineText, DebugLogging,
+              [&](LoopPassManager &RepeatedLPM, StringRef &PipelineText) {
+                return parseLoopPassPipeline(RepeatedLPM, PipelineText,
+                                             VerifyEachPass, DebugLogging);
+              }))
+        return false;
     } else {
       // Otherwise try to parse a pass name.
       size_t End = PipelineText.find_first_of(",)");
       if (!parseLoopPassName(LPM, PipelineText.substr(0, End)))
         return false;
       // TODO: Ideally, we would run a LoopVerifierPass() here in the
       // VerifyEachPass case, but we don't have such a verifier yet.
 
if (PipelineText.startswith("function(")) {
                                  DebugLogging) ||
           PipelineText.empty())
         return false;
       assert(PipelineText[0] == ')');
       PipelineText = PipelineText.substr(1);
 
       // Add the nested pass manager with the appropriate adaptor.
       FPM.addPass(createFunctionToLoopPassAdaptor(std::move(NestedLPM)));
+    } else if (PipelineText.startswith("repeat(")) {
+      if (!parseRepeatedPipeline(
+              FPM, PipelineText, DebugLogging,
+              [&](FunctionPassManager &RepeatedFPM, StringRef &PipelineText) {
+                return parseFunctionPassPipeline(RepeatedFPM, PipelineText,
+                                                 VerifyEachPass, DebugLogging);
+              }))
+        return false;
     } else {
       // Otherwise try to parse a pass name.
       size_t End = PipelineText.find_first_of(",)");
       if (!parseFunctionPassName(FPM, PipelineText.substr(0, End)))
         return false;
       if (VerifyEachPass)
         FPM.addPass(VerifierPass());
 
if (PipelineText.startswith("cgscc(")) {
           PipelineText.empty())
         return false;
       assert(PipelineText[0] == ')');
       PipelineText = PipelineText.substr(1);
 
       // Add the nested pass manager with the appropriate adaptor.
       CGPM.addPass(
           createCGSCCToFunctionPassAdaptor(std::move(NestedFPM), DebugLogging));
+    } else if (PipelineText.startswith("repeat(")) {
+      if (!parseRepeatedPipeline(
+              CGPM, PipelineText, DebugLogging,
+              [&](CGSCCPassManager &RepeatedCGPM, StringRef &PipelineText) {
+                return parseCGSCCPassPipeline(RepeatedCGPM, PipelineText,
+                                              VerifyEachPass, DebugLogging);
+              }))
+        return false;
     } else {
       // Otherwise try to parse a pass name.
       size_t End = PipelineText.find_first_of(",)");
       if (!parseCGSCCPassName(CGPM, PipelineText.substr(0, End)))
         return false;
       // FIXME: No verifier support for CGSCC passes!
 
       PipelineText = PipelineText.substr(End);
if (PipelineText.startswith("module(")) {
                                      DebugLogging) ||
           PipelineText.empty())
         return false;
       assert(PipelineText[0] == ')');
       PipelineText = PipelineText.substr(1);
 
       // Add the nested pass manager with the appropriate adaptor.
       MPM.addPass(createModuleToFunctionPassAdaptor(std::move(NestedFPM)));
+    } else if (PipelineText.startswith("repeat(")) {
+      if (!parseRepeatedPipeline(
+              MPM, PipelineText, DebugLogging,
+              [&](ModulePassManager &RepeatedMPM, StringRef &PipelineText) {
+                return parseModulePassPipeline(RepeatedMPM, PipelineText,
+                                               VerifyEachPass, DebugLogging);
+              }))
+        return false;
     } else {
       // Otherwise try to parse a pass name.
       size_t End = PipelineText.find_first_of(",)");
       if (!parseModulePassName(MPM, PipelineText.substr(0, End), DebugLogging))
         return false;
       if (VerifyEachPass)
         MPM.addPass(VerifierPass());
 

test/Other/new-pass-manager.ll

 ; CHECK-FUNCTION-PASS-NEXT: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager -passes=print %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MODULE-PRINT
 ; CHECK-MODULE-PRINT: Starting llvm::Module pass manager run
 ; CHECK-MODULE-PRINT: Running pass: VerifierPass
 ; CHECK-MODULE-PRINT: Running pass: PrintModulePass
 ; CHECK-MODULE-PRINT: ModuleID
-; CHECK-MODULE-PRINT: define void @foo()
+; CHECK-MODULE-PRINT: define void @foo(i1 %x)
 ; CHECK-MODULE-PRINT: Running pass: VerifierPass
 ; CHECK-MODULE-PRINT: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager -disable-verify -passes='print,verify' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MODULE-VERIFY
 ; CHECK-MODULE-VERIFY: Starting llvm::Module pass manager run
 ; CHECK-MODULE-VERIFY: Running pass: PrintModulePass
 ; CHECK-MODULE-VERIFY: ModuleID
-; CHECK-MODULE-VERIFY: define void @foo()
+; CHECK-MODULE-VERIFY: define void @foo(i1 %x)
 ; CHECK-MODULE-VERIFY: Running pass: VerifierPass
 ; CHECK-MODULE-VERIFY: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager -passes='function(print)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PRINT
 ; CHECK-FUNCTION-PRINT: Starting llvm::Module pass manager run
 ; CHECK-FUNCTION-PRINT: Running pass: VerifierPass
 ; CHECK-FUNCTION-PRINT: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-FUNCTION-PRINT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
 ; CHECK-FUNCTION-PRINT: Starting llvm::Function pass manager run
 ; CHECK-FUNCTION-PRINT: Running pass: PrintFunctionPass
 ; CHECK-FUNCTION-PRINT-NOT: ModuleID
-; CHECK-FUNCTION-PRINT: define void @foo()
+; CHECK-FUNCTION-PRINT: define void @foo(i1 %x)
 ; CHECK-FUNCTION-PRINT: Finished llvm::Function pass manager run
 ; CHECK-FUNCTION-PRINT: Running pass: VerifierPass
 ; CHECK-FUNCTION-PRINT: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager -disable-verify -passes='function(print,verify)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-VERIFY
 ; CHECK-FUNCTION-VERIFY: Starting llvm::Module pass manager run
 ; CHECK-FUNCTION-VERIFY: Starting llvm::Function pass manager run
 ; CHECK-FUNCTION-VERIFY: Running pass: PrintFunctionPass
 ; CHECK-FUNCTION-VERIFY-NOT: ModuleID
-; CHECK-FUNCTION-VERIFY: define void @foo()
+; CHECK-FUNCTION-VERIFY: define void @foo(i1 %x)
 ; CHECK-FUNCTION-VERIFY: Running pass: VerifierPass
 ; CHECK-FUNCTION-VERIFY: Finished llvm::Function pass manager run
 ; CHECK-FUNCTION-VERIFY: Finished llvm::Module pass manager run
 
 ; RUN: opt -S -o - -passes='no-op-module,no-op-module' %s \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-NOOP
-; CHECK-NOOP: define void @foo() {
+; CHECK-NOOP: define void @foo(i1 %x) {
+; CHECK-NOOP: entry:
+; CHECK-NOOP:   br i1 %x, label %loop, label %exit
+; CHECK-NOOP: loop:
+; CHECK-NOOP:   br label %loop
+; CHECK-NOOP: exit:
 ; CHECK-NOOP:   ret void
 ; CHECK-NOOP: }
 
 ; Round trip through bitcode.
 ; RUN: opt -f -o - -passes='no-op-module,no-op-module' %s \
 ; RUN:     | llvm-dis \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-NOOP
 

 
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes='lto<O2>' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LTO-O2
 ; CHECK-LTO-O2: Starting llvm::Module pass manager run
 ; CHECK-LTO-O2: Running pass: InstCombinePass
 ; CHECK-LTO-O2: Running pass: SimplifyCFGPass
 
-define void @foo() {
+; RUN: opt -disable-output -disable-verify -debug-pass-manager \
+; RUN:     -passes='repeat(3,no-op-module)' %s 2>&1 \
+; RUN:     | FileCheck %s --check-prefix=CHECK-REPEAT-MODULE-PASS
+; CHECK-REPEAT-MODULE-PASS: Starting llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Running pass: RepeatingPassWrapper
+; CHECK-REPEAT-MODULE-PASS-NEXT: Starting llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Running pass: NoOpModulePass
+; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Starting llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Running pass: NoOpModulePass
+; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Starting llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Running pass: NoOpModulePass
+; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
+; CHECK-REPEAT-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
+
+; RUN: opt -disable-output -disable-verify -debug-pass-manager \
+; RUN:     -passes='cgscc(repeat(3,no-op-cgscc))' %s 2>&1 \
+; RUN:     | FileCheck %s --check-prefix=CHECK-REPEAT-CGSCC-PASS
+; CHECK-REPEAT-CGSCC-PASS: Starting llvm::Module pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running an SCC pass across the RefSCC: [(foo)]
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: RepeatingPassWrapper
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run
+
+; RUN: opt -disable-output -disable-verify -debug-pass-manager \
+; RUN:     -passes='function(repeat(3,no-op-function))' %s 2>&1 \
+; RUN:     | FileCheck %s --check-prefix=CHECK-REPEAT-FUNCTION-PASS
+; CHECK-REPEAT-FUNCTION-PASS: Starting llvm::Module pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: RepeatingPassWrapper
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Finished llvm::Module pass manager run
+
+; RUN: opt -disable-output -disable-verify -debug-pass-manager \
+; RUN:     -passes='loop(repeat(3,no-op-loop))' %s 2>&1 \
+; RUN:     | FileCheck %s --check-prefix=CHECK-REPEAT-LOOP-PASS
+; CHECK-REPEAT-LOOP-PASS: Starting llvm::Module pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: FunctionToLoopPassAdaptor
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: LoopAnalysis
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: DominatorTreeAnalysis
+; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: PassManager<{{.*}}> on loop
+; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: RepeatingPassWrapper
+; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Function pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Module pass manager run
+
+define void @foo(i1 %x) {
+entry:
+  br i1 %x, label %loop, label %exit
+
+loop:
+  br label %loop
+
+exit:
   ret void
 }
 
 declare void @bar()