[NewPM] -print-before/-print-after support for new pass manager

[fedor.sergeev]

Summary

Existing print-before/after options are using PassNameParser which has only been able to parse legacy pass names,
rejecting everything else.

Majority of this fix is an enhancement for PassNameParser to
allow -print-before/after to take arbitrary strings, not just those
corresponding to legacy pass option names.

PassNameParser was converted to a template that takes boolean argument
'AllowArbitraryNames' that allows to just accept names that do not
match legacy passes.

As soon as these names are accepted by parser everything else works since
new-pm IR printing does already call llvm::shouldPrintBeforePass/shouldPrintAfterPass.

One important consequence of this implementation change is that there
is no more checking for errors in legacy pass names in -print-before/-print-after.
Other options that use PassNameParser do not set AllowArbitraryNames to true
and thus continue to check its values for errors.

[philip.pfaffe]

Is the goal here anything beyond makeing -print-after/before work in the newpm?

Because if it isn't, then this change is way too complicated, and the instrumentation should just directly implement shouldPrintAfterPass, etc.

[fedor.sergeev]

In D54794#1305764, @philip.pfaffe wrote:

Is the goal here anything beyond makeing -print-after/before work in the newpm?

Because if it isn't, then this change is way too complicated, and the instrumentation should just directly implement shouldPrintAfterPass, etc.

The goal is to use the same -print-after *option* to control this functionality in newpm, and not just reimplement it with a different control.

[fedor.sergeev]

Eventually we should implement error checking for new-pm pass names.
That will require adding more new-pm related code to the parser, and introduce some
kind of an interface with PassBuilder. Definitely *not* planned for this patch.

[chandlerc]

I somewhat agree w/ Philip that this seems like too much complexity / machinery for what it does...

I'm personally not sure why we need to support what seems like a challenging interface to begin with to me...

I would personally be much more interested in making a single IR printing strategy that allows easy *post* processing along these lines. Here is a sketch of a design of something that would be more useful to me than these flags or the print-after-all flags, is sufficient to implement this logic with shell globs and cat, and likely not much more complex than this patch. Maybe even simpler:

Have a printer that accepts an optional directory parameter from the commandline. If unspecified, it creates a temporary director.

Within this directory, for each "nesting" pass run that is instrumented, it creates a directory named based on that pass name and a .N suffix where N is incremented from zero on each repeat of that pass at that level of nesting. While "inner" passes are running, set the target directory to the created one, and once finished, pop it back to the incoming target directory. For all passes, including "nesting" ones, write out a file <module-name>.<pass-name>.<run number at nest level>.{before,after}.ll that is a dump of the module.

Here, a "nesting" pass is just one that begins running, and another pass begins running before it ends running.

This seems easy to implement with some basic stack logic in the printer, etc.

If we want to get really fancy, give an option to write out a .tar or .zip file with this rather than an actual directory tree, and users can then implement these before/after things with a command to extract files matching a wildcard pattern.

What do you think?

[chandlerc]

In an IRC discussion, some interesting points were raised about this, and I wanted to try to give a better naming pattern and more concrete outline. I'll do it by giving a pseudo output tree I could imagine:

$PREFIX/mymodule.0.M2FA.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/0.InstCombine.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/0.InstCombine.after.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/1.SimplifyCFG.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/1.SimplifyCFG.after.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM.after.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM.before.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/0.InstCombine.before.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/0.InstCombine.after.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/1.SimplifyCFG.before.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/1.SimplifyCFG.after.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM.after.ll
$PREFIX/mymodule.0.M2FA.after.ll

Here I'm using $PREFIX to mean "however we get a a directory". I guess either a flag value or createUniqueDirectory stuff.

I'm also using M2FA as a short name for the module-to-function pass adapter, and FPM for a function pass manager.

For the each .ll file, we'll also want to offer one specific level of filtering that can only really be implemented in the compiler: how much of the module goes into the file?

My suggestion would be that there are three reasonable options here:

1. the entire module at that point in time
2. the smallest enclosing IR unit to the IR unit being processed which we can do the equivalent of llvm-extract to produce a stand-alone module around. We could start with just extracting a function passes for function pass and smaller. But a follow-up would be to extract the set of functions in the SCC for SCC passes, etc. The key thing here is that we would do the extract and produce a valid module in all cases, just minimizing the IR in it.
3. just the dump of the IR unit in question, despite it not necessarily being a complete module

While I think #3 is the right default for the print-after-all style flag, I think the default for the tree dump should be #2.

[chandlerc]

(just marking that this is waiting on update from Fedor)

[mtrofin]

This patch would be very useful (I stumbled upon it because I was about to do something similar) - any plans on reviving it?

[nuriamari]

In D54794#1306140, @chandlerc wrote:

In an IRC discussion, some interesting points were raised about this, and I wanted to try to give a better naming pattern and more concrete outline. I'll do it by giving a pseudo output tree I could imagine:

$PREFIX/mymodule.0.M2FA.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/0.InstCombine.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/0.InstCombine.after.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/1.SimplifyCFG.before.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM/1.SimplifyCFG.after.ll
$PREFIX/mymodule.0.M2FA/0.foo.FPM.after.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM.before.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/0.InstCombine.before.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/0.InstCombine.after.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/1.SimplifyCFG.before.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM/1.SimplifyCFG.after.ll
$PREFIX/mymodule.0.M2FA/1.bar.FPM.after.ll
$PREFIX/mymodule.0.M2FA.after.ll

Here I'm using $PREFIX to mean "however we get a a directory". I guess either a flag value or createUniqueDirectory stuff.

I'm also using M2FA as a short name for the module-to-function pass adapter, and FPM for a function pass manager.

For the each .ll file, we'll also want to offer one specific level of filtering that can only really be implemented in the compiler: how much of the module goes into the file?

My suggestion would be that there are three reasonable options here:

1. the entire module at that point in time
2. the smallest enclosing IR unit to the IR unit being processed which we can do the equivalent of llvm-extract to produce a stand-alone module around. We could start with just extracting a function passes for function pass and smaller. But a follow-up would be to extract the set of functions in the SCC for SCC passes, etc. The key thing here is that we would do the extract and produce a valid module in all cases, just minimizing the IR in it.
3. just the dump of the IR unit in question, despite it not necessarily being a complete module

While I think #3 is the right default for the print-after-all style flag, I think the default for the tree dump should be #2.

Hi @chandlerc I have a need for something like this, and have tried to implement something like you have suggested here: https://github.com/llvm/llvm-project/pull/65179. Would you mind giving me some feedback?

include/llvm/IR/LegacyPassNameParser.h

 //===- LegacyPassNameParser.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-//
-// This file contains the PassNameParser and FilteredPassNameParser<> classes,
-// which are used to add command line arguments to a utility for all of the
-// passes that have been registered into the system.
-//
-// The PassNameParser class adds ALL passes linked into the system (that are
-// creatable) as command line arguments to the tool (when instantiated with the
-// appropriate command line option template).  The FilteredPassNameParser<>
-// template is used for the same purposes as PassNameParser, except that it only
-// includes passes that have a PassType that are compatible with the filter
-// (which is the template argument).
-//
-// Note that this is part of the legacy pass manager infrastructure and will be
-// (eventually) going away.
-//
+///
+/// \file This file contains the PassNameParser and FilteredPassNameParser
+/// class templates, which are used to parse option values which correspond
+/// the names of (legacy) passes that have been registered into the system.
+///
+/// Note that this is part of the legacy pass manager infrastructure and will be
+/// (eventually) going away.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_LEGACYPASSNAMEPARSER_H
 #define LLVM_IR_LEGACYPASSNAMEPARSER_H
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 
 namespace llvm {
 
+namespace detail {
+
+struct PassNameParserValueType {
+  using LegacyPassType = const PassInfo *;
+
+  LegacyPassType P;
+  std::string PassID;
+
+  PassNameParserValueType(LegacyPassType P)
+      : P(P), PassID(P->getPassArgument()) {}
+  PassNameParserValueType(StringRef ID = StringRef())
+      : P(nullptr), PassID(ID) {}
+
+  operator std::string() const { return PassID; }
+  operator LegacyPassType() const { return P; }
+  bool operator!=(const PassNameParserValueType &x) const {
+    return PassID != x.PassID;
+  }
+};
+
+} // namespace detail
+
+template <>
+struct cl::OptionValue<detail::PassNameParserValueType> final
+    : OptionValueCopy<detail::PassNameParserValueType> {
+  OptionValue() = default;
+
+  OptionValue(const detail::PassNameParserValueType &V) { this->setValue(V); }
+
+  OptionValue &operator=(const detail::PassNameParserValueType &V) {
+    setValue(V);
+    return *this;
+  }
+
+private:
+  void anchor() override;
+};
+
 //===----------------------------------------------------------------------===//
-// PassNameParser class - Make use of the pass registration mechanism to
-// automatically add a command line argument to opt for each pass.
-//
+/// \class
+/// This class template parses names of passes.
+/// Makes use of the pass registration mechanism to automatically add a
+/// command line argument to the Option for each legacy pass being registered.
+///
+/// \p AllowArbitraryNames parameter when 'true' allows to skip error checking
+/// and accept option value that does not match any of registered (legacy)
+/// pass names. Currently used to allow new-pass-manager pass names.
+///
+template <bool AllowArbitraryNames = false>
 class PassNameParser : public PassRegistrationListener,
-                       public cl::parser<const PassInfo*> {
+                       public cl::parser<detail::PassNameParserValueType> {
+
 public:
+  using ValueType = detail::PassNameParserValueType;
+
   PassNameParser(cl::Option &O);
   ~PassNameParser() override;
 
   void initialize() {
-    cl::parser<const PassInfo*>::initialize();
+    this->parser::initialize();
 
     // Add all of the passes to the map that got initialized before 'this' did.
     enumeratePasses();
   }
 
+  // parse - Return true on error.
+  bool parse(cl::Option &O, StringRef ArgName, StringRef Arg, ValueType &V) {
+    StringRef ArgVal;
+    if (this->Owner.hasArgStr())
+      ArgVal = Arg;
+    else
+      ArgVal = ArgName;
+
+    for (size_t i = 0, e = this->Values.size(); i != e; ++i)
+      if (this->Values[i].Name == ArgVal) {
+        V = this->Values[i].V.getValue();
+        assert(V.P && "legacy passes should have PassInfo available");
+        return false;
+      }
+    if (AllowArbitraryNames) {
+      V = ValueType(ArgVal.str());
+      return false;
+    }
+    return O.error("Cannot find option named '" + ArgVal + "'!");
+  }
+
   // ignorablePassImpl - Can be overriden in subclasses to refine the list of
   // which passes we want to include.
   //
   virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
 
   inline bool ignorablePass(const PassInfo *P) const {
     // Ignore non-selectable and non-constructible passes!  Ignore
     // non-optimizations.
     return P->getPassArgument().empty() || P->getNormalCtor() == nullptr ||
            ignorablePassImpl(P);
   }
 
   // Implement the PassRegistrationListener callbacks used to populate our map
   //
   void passRegistered(const PassInfo *P) override {
     if (ignorablePass(P)) return;
-    if (findOption(P->getPassArgument().data()) != getNumOptions()) {
+    if (this->findOption(P->getPassArgument().data()) !=
+        this->getNumOptions()) {
       errs() << "Two passes with the same argument (-"
            << P->getPassArgument() << ") attempted to be registered!\n";
       llvm_unreachable(nullptr);
     }
-    addLiteralOption(P->getPassArgument().data(), P, P->getPassName().data());
+    this->template addLiteralOption<ValueType>(
+        P->getPassArgument().data(), ValueType{P}, P->getPassName().data());
   }
   void passEnumerate(const PassInfo *P) override { passRegistered(P); }
 
   // printOptionInfo - Print out information about this option.  Override the
   // default implementation to sort the table before we print...
   void printOptionInfo(const cl::Option &O, size_t GlobalWidth) const override {
     PassNameParser *PNP = const_cast<PassNameParser*>(this);
-    array_pod_sort(PNP->Values.begin(), PNP->Values.end(), ValCompare);
-    cl::parser<const PassInfo*>::printOptionInfo(O, GlobalWidth);
-  }
+    // Comparison function to order records by name.
+    auto orderByName = [](const typename PassNameParser::OptionInfo &A,
+                          const typename PassNameParser::OptionInfo &B) {
+      return A.Name < B.Name;
+    };
+    llvm::sort(PNP->Values.begin(), PNP->Values.end(), orderByName);
 
-private:
-  // ValCompare - Provide a sorting comparator for Values elements...
-  static int ValCompare(const PassNameParser::OptionInfo *VT1,
-                        const PassNameParser::OptionInfo *VT2) {
-    return VT1->Name.compare(VT2->Name);
+    this->parser::printOptionInfo(O, GlobalWidth);
   }
 };
 
+extern template class PassNameParser<false>;
+extern template class PassNameParser<true>;
+
 ///===----------------------------------------------------------------------===//
-/// FilteredPassNameParser class - Make use of the pass registration
-/// mechanism to automatically add a command line argument to opt for
-/// each pass that satisfies a filter criteria.  Filter should return
-/// true for passes to be registered as command-line options.
+///
+/// This class template parses pass names according to a filtered list
+/// of registered legacy passes.
+///
+/// It only accepts pass names for passes that have their PassInfo compatible
+/// with the filter \p Filter. Handling of legacy pass registration is performed
+/// by its base class PassNameParser.
+///
+/// \p Filter should return true for passes to be registered as values of
+/// command line options.
 ///
-template<typename Filter>
-class FilteredPassNameParser : public PassNameParser {
+template <typename Filter>
+class FilteredPassNameParser : public PassNameParser<false> {
 private:
   Filter filter;
 
 public:
   bool ignorablePassImpl(const PassInfo *P) const override {
     return !filter(*P);
   }
 };

lib/IR/LegacyPassManager.cpp

PassDebugging("debug-pass", cl::Hidden,
                   cl::values(
   clEnumVal(Disabled  , "disable debug output"),
   clEnumVal(Arguments , "print pass arguments to pass to 'opt'"),
   clEnumVal(Structure , "print pass structure before run()"),
   clEnumVal(Executions, "print pass name before it is executed"),
   clEnumVal(Details   , "print pass details when it is executed")));
 
 namespace {
-typedef llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
-PassOptionList;
+typedef llvm::cl::list<std::string, bool, PassNameParser<true>> PassOptionList;
 }
 
 // Print IR out before/after specified passes.
 static PassOptionList
 PrintBefore("print-before",
             llvm::cl::desc("Print IR before specified passes"),
             cl::Hidden);
 

 }
 
 bool llvm::shouldPrintAfterPass() {
   return PrintAfterAll || !PrintAfter.empty();
 }
 
 static bool ShouldPrintBeforeOrAfterPass(StringRef PassID,
                                          PassOptionList &PassesToPrint) {
-  for (auto *PassInf : PassesToPrint) {
-    if (PassInf)
-      if (PassInf->getPassArgument() == PassID) {
-        return true;
-      }
-  }
+  for (auto &PassInf : PassesToPrint)
+    if (PassInf == PassID)
   return false;
 }
 
 bool llvm::shouldPrintBeforePass(StringRef PassID) {
   return PrintBeforeAll || ShouldPrintBeforeOrAfterPass(PassID, PrintBefore);
 }
 
 bool llvm::shouldPrintAfterPass(StringRef PassID) {

lib/IR/Pass.cpp

 //
 
 // enumeratePasses - Iterate over the registered passes, calling the
 // passEnumerate callback on each PassInfo object.
 void PassRegistrationListener::enumeratePasses() {
   PassRegistry::getPassRegistry()->enumerateWith(this);
 }
 
-PassNameParser::PassNameParser(cl::Option &O)
-    : cl::parser<const PassInfo *>(O) {
+template <bool AllowArbitraryNames>
+PassNameParser<AllowArbitraryNames>::PassNameParser(cl::Option &O)
+    : PassNameParser::parser(O) {
   PassRegistry::getPassRegistry()->addRegistrationListener(this);
 }
 
 // This only gets called during static destruction, in which case the
 // PassRegistry will have already been destroyed by llvm_shutdown().  So
 // attempting to remove the registration listener is an error.
-PassNameParser::~PassNameParser() = default;
+template <bool AllowArbitraryNames>
+PassNameParser<AllowArbitraryNames>::~PassNameParser() = default;
+
+template class llvm::PassNameParser<false>;
+template class llvm::PassNameParser<true>;
+template class cl::parser<detail::PassNameParserValueType>;
+
+void cl::OptionValue<detail::PassNameParserValueType>::anchor() {}
 
 //===----------------------------------------------------------------------===//
 //   AnalysisUsage Class Implementation
 //
 
 namespace {
 
 struct GetCFGOnlyPasses : public PassRegistrationListener {

test/Other/loop-pass-printer.ll

 ; This test checks -print-after/before on loop passes
 ; Besides of the loop itself it should be dumping loop pre-header and exits.
 ;
 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -loop-deletion -print-before=loop-deletion \
 ; RUN:     | FileCheck %s -check-prefix=DEL
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes='loop(loop-deletion)' -print-before-all \
+; RUN:     -passes='loop(loop-deletion)' -print-before=LoopDeletionPass \
 ; RUN:     | FileCheck %s -check-prefix=DEL
 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -loop-unroll -print-after=loop-unroll -filter-print-funcs=bar \
 ; RUN:     | FileCheck %s -check-prefix=BAR -check-prefix=BAR-OLD
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes='require<opt-remark-emit>,loop(unroll-full)' -print-after-all -filter-print-funcs=bar \
+; RUN:     -passes='require<opt-remark-emit>,loop(unroll-full)' -print-after=LoopFullUnrollPass -filter-print-funcs=bar \
 ; RUN:     | FileCheck %s -check-prefix=BAR
 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -loop-unroll -print-after=loop-unroll -filter-print-funcs=foo -print-module-scope \
 ; RUN:     | FileCheck %s -check-prefix=FOO-MODULE -check-prefix=FOO-MODULE-OLD
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes='require<opt-remark-emit>,loop(unroll-full)' -print-after-all -filter-print-funcs=foo -print-module-scope \
+; RUN:     -passes='require<opt-remark-emit>,loop(unroll-full)' -print-after=LoopFullUnrollPass -filter-print-funcs=foo -print-module-scope \
 ; RUN:     | FileCheck %s -check-prefix=FOO-MODULE
 
 ; DEL:      IR Dump Before {{Delete dead loops|LoopDeletionPass}}
 ; DEL:      ; Preheader:
 ; DEL-NEXT:  %idx = alloca i32, align 4
 ; DEL:      ; Loop:
 ; DEL-NEXT:  loop:
 ; DEL:       cont:

test/Other/print-module-scope.ll

 ; This test is checking basic properties of -print-module-scope options:
 ;   - dumps all the module IR at once
 ;   - all the function attributes are shown, including those of declarations
 ;   - works on top of -print-after and -filter-print-funcs
 ;
 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -simplifycfg -print-after=simplifycfg -print-module-scope \
 ; RUN:     | FileCheck %s -check-prefix=CFG
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes=simplify-cfg -print-after-all -print-module-scope \
+; RUN:     -passes=simplify-cfg -print-after=SimplifyCFGPass -print-module-scope \
 ; RUN:     | FileCheck %s -check-prefix=CFG
 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -simplifycfg -print-after=simplifycfg -filter-print-funcs=foo -print-module-scope \
 ; RUN:     | FileCheck %s -check-prefix=FOO
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes=simplify-cfg -print-after-all -filter-print-funcs=foo -print-module-scope \
+; RUN:     -passes=simplify-cfg -print-after=SimplifyCFGPass -filter-print-funcs=foo -print-module-scope \
 ; RUN:     | FileCheck %s -check-prefix=FOO
 
 ; CFG:      IR Dump After {{Simplify the CFG|SimplifyCFGPass}}
 ; CFG-SAME:   function: foo
 ; CFG-NEXT: ModuleID =
 ; CFG: define void @foo
 ; CFG: define void @bar
 ; CFG: declare void @baz

test/Other/scc-deleted-printer.ll

 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -passes=inline -print-before-all -print-after-all | FileCheck %s -check-prefix=INL
 ; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -passes=inline -print-before=InlinerPass -print-after=InlinerPass | FileCheck %s -check-prefix=INL
+; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -passes=inline -print-before-all -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -passes=inline -print-before=InlinerPass -print-after=InlinerPass -print-module-scope | FileCheck %s -check-prefix=INL-MOD
 
 ; INL: IR Dump Before {{InlinerPass .*scc: .tester, foo}}
 ; INL-NOT: IR Dump After {{InlinerPass}}
 ; INL: IR Dump Before {{InlinerPass .*scc: .tester}}
 ; INL: IR Dump After {{InlinerPass .*scc: .tester}}
 
 ; INL-MOD: IR Dump Before {{InlinerPass .*scc: .tester, foo}}
 ; INL-MOD-NOT: IR Dump After {{InlinerPass}}

test/Other/scc-pass-printer.ll

 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -inline -print-after-all | FileCheck %s -check-prefix=INL
+; RUN:     -inline -print-after-all | FileCheck %s -check-prefixes=INL,INL-ALL
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes=inline -print-after-all | FileCheck %s -check-prefix=INL
+; RUN:     -passes=inline -print-after-all | FileCheck %s -check-prefixes=INL,INL-ALL
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -inline -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+; RUN:     -inline -print-after=inline | FileCheck %s -check-prefix=INL
 ; RUN: opt < %s 2>&1 -disable-output \
-; RUN:     -passes=inline -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+; RUN:     -passes=inline -print-after=InlinerPass | FileCheck %s -check-prefix=INL
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -inline -print-after-all -print-module-scope | FileCheck %s -check-prefixes=INL-MOD,INL-MOD-ALL
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -passes=inline -print-after-all -print-module-scope | FileCheck %s -check-prefixes=INL-MOD,INL-MOD-ALL
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -inline -print-after=inline -print-module-scope | FileCheck %s -check-prefix=INL-MOD
+; RUN: opt < %s 2>&1 -disable-output \
+; RUN:     -passes=inline -print-after=InlinerPass -print-module-scope | FileCheck %s -check-prefix=INL-MOD
 
 ; INL: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .bar, foo}}
 ; INL: define void @bar()
 ; INL-NEXT:  call void @foo()
 ; INL: define void @foo()
 ; INL-NEXT:   call void @bar()
 ; INL: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .tester}}
 ; INL: define void @tester()
 ; INL-NEXT:  call void @foo()
-; INL: IR Dump After
+; INL-ALL: IR Dump After
 
 ; INL-MOD: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .bar, foo}}
 ; INL-MOD-NEXT: ModuleID =
 ; INL-MOD-NEXT: source_filename =
 ; INL-MOD: define void @tester()
 ; INL-MOD-NEXT:  call void @foo()
 ; INL-MOD: define void @foo()
 ; INL-MOD-NEXT:   call void @bar()
 ; INL-MOD: define void @bar()
 ; INL-MOD-NEXT:  call void @foo()
 ; INL-MOD: IR Dump After {{Function Integration/Inlining|InlinerPass .*scc: .tester}}
 ; INL-MOD-NEXT: ModuleID =
 ; INL-MOD-NEXT: source_filename =
 ; INL-MOD: define void @tester()
 ; INL-MOD-NEXT:  call void @foo()
 ; INL-MOD: define void @foo()
 ; INL-MOD-NEXT:   call void @bar()
 ; INL-MOD: define void @bar()
 ; INL-MOD-NEXT:  call void @foo()
-; INL-MOD: IR Dump After
-; INL-MOD-NEXT: ModuleID =
-; INL-MOD-NEXT: source_filename =
-; INL-MOD-NOT: Printing <null> Function
+; INL-MOD-ALL: IR Dump After
+; INL-MOD-ALL-NEXT: ModuleID =
+; INL-MOD-ALL-NEXT: source_filename =
+; INL-MOD-ALL-NOT: Printing <null> Function
 
 define void @tester() noinline {
   call void @foo()
   ret void
 }
 
 define void @foo() noinline {
   call void @bar()
   ret void
 }
 
 define void @bar() noinline {
   call void @foo()
   ret void
 }

test/Transforms/Inline/null-function.ll

-; RUN: opt -print-before=always-inline -always-inline < %s -o /dev/null 2>&1 | FileCheck %s
+; RUN: opt -print-before=always-inline -always-inline < %s -o /dev/null 2>&1 | FileCheck %s -check-prefixes=COMMON,LEGACY
+; RUN: opt -print-before=AlwaysInlinerPass -passes=always-inline < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=COMMON
 
 define i32 @main() #0 {
 entry:
   ret i32 0
 }
 
-; CHECK: *** IR Dump Before Inliner for always_inline functions ***
-; CHECK: Printing <null> Function
+; COMMON:*** IR Dump Before {{Inliner for always_inline functions|AlwaysInlinerPass}} ***
+; COMMON: define i32 @main
+; LEGACY: *** IR Dump Before Inliner for always_inline functions ***
+; LEGACY: Printing <null> Function

tools/bugpoint/bugpoint.cpp

 
 static cl::opt<bool>
     UseValgrind("enable-valgrind",
                 cl::desc("Run optimizations through valgrind"));
 
 // The AnalysesList is automatically populated with registered Passes by the
 // PassNameParser.
 //
-static cl::list<const PassInfo *, bool, PassNameParser>
+static cl::list<const PassInfo *, bool, PassNameParser<>>
     PassList(cl::desc("Passes available:"), cl::ZeroOrMore);
 
 static cl::opt<bool>
     StandardLinkOpts("std-link-opts",
                      cl::desc("Include the standard link time optimizations"));
 
 static cl::opt<bool>
     OptLevelO1("O1", cl::desc("Optimization level 1. Identical to 'opt -O1'"));

tools/opt/opt.cpp

 #include <algorithm>
 #include <memory>
 using namespace llvm;
 using namespace opt_tool;
 
 // The OptimizationList is automatically populated with registered Passes by the
 // PassNameParser.
 //
-static cl::list<const PassInfo*, bool, PassNameParser>
+static cl::list<const PassInfo *, bool, PassNameParser<>>
     PassList(cl::desc("Optimizations available:"));
 
 // This flag specifies a textual description of the optimization pass pipeline
 // to run over the module. This flag switches opt to use the new pass manager
 // infrastructure, completely disabling all of the flags specific to the old
 // pass management.
 static cl::opt<std::string> PassPipeline(
     "passes",
     cl::desc("A textual description of the pass pipeline for optimizing"),