[NewPM] Handle passes with params in -print-before/-print-after

[bjope]

Summary

To support options like -print-before=<pass> and -print-after=<pass>
the PassBuilder will register PassInstrumentation callbacks as well
as a mapping between internal pass class names and the pass names
used in those options (and other cmd line interfaces). But for
some reason all the passes that takes options where missing in those
maps, so for example "-print-after=loop-vectorize" didn't work.

This patch will add the missing entries by also taking care of
function and loop passes with params when setting up the class to
pass name maps.

One might notice that even with this patch it might be tricky to
know what pass name to use in options such as -print-after. This
because there only is a single mapping from class name to pass name,
while the PassRegistry currently is a bit messy as it sometimes
reuses the same class for different pass names (without using the
"pass with params" scheme, or the pass-name<variant> syntax).

It gets extra messy in some situations. For example the
MemorySanitizerPass can run like this (with debug and print-after)

opt -passes='kmsan' -print-after=msan-module -debug-only=msan

The 'kmsan' alias for 'msan<kernel>' is just confusing as one might
think that 'kmsan' is a separate pass (but the DEBUG_TYPE is still
just 'msan'). And since the module pass version of the pass adds
a mapping from 'MemorySanitizerPass' to 'msan-module' one need to
use 'msan-module' in the print-before and print-after options.

[bjope]

llvm/lib/IR/PassInstrumentation.cpp

22–23

By adding some printouts when this check fails, I get this (after also having applied D105007):

PassInstrumentation note: HWAddressSanitizerPass is already mapped to hwasan. It will not be mapped to hwasan<kernal;recover>
PassInstrumentation note: ModuleInlinerWrapperPass is already mapped to inliner-wrapper. It will not be mapped to inliner-wrapper-no-mandatory-first
PassInstrumentation note: ModuleInlinerWrapperPass is already mapped to inliner-wrapper. It will not be mapped to scc-oz-module-inliner
PassInstrumentation note: LoopExtractorPass is already mapped to loop-extract. It will not be mapped to loop-extract-single
PassInstrumentation note: ModuleAddressSanitizerPass is already mapped to asan-module. It will not be mapped to kasan-module
PassInstrumentation note: EarlyCSEPass is already mapped to early-cse. It will not be mapped to early-cse-memssa
PassInstrumentation note: EntryExitInstrumenterPass is already mapped to ee-instrument. It will not be mapped to post-inline-ee-instrument
PassInstrumentation note: LowerMatrixIntrinsicsPass is already mapped to lower-matrix-intrinsics. It will not be mapped to lower-matrix-intrinsics-minimal
PassInstrumentation note: AddressSanitizerPass is already mapped to asan. It will not be mapped to asan<kernel>
PassInstrumentation note: MemorySanitizerPass is already mapped to msan-module. It will not be mapped to msan
PassInstrumentation note: ThreadSanitizerPass is already mapped to tsan-module. It will not be mapped to tsan
PassInstrumentation note: MemorySanitizerPass is already mapped to msan-module. It will not be mapped to msan
PassInstrumentation note: SimplifyCFGPass is already mapped to simplifycfg. It will not be mapped to simplify-cfg
PassInstrumentation note: SimpleLoopUnswitchPass is already mapped to simple-loop-unswitch. It will not be mapped to unswitch

Not sure if we need to add a one-to-many map to handle some of the above. Or if for example early-cse-memssa should be called early-cse<memssa> to indicate that it is a specialized version of early-cse.

For passes like ee-instrument. and post-inline-ee-instrument it might be trickier. Should enabling print-after for one of those trigger IR printouts for both? I.e. should they be seen as two different passes, or parameterized versions of the same pass?

I also think it is just confusing to have both simplifycfg and simplify-cfg<>, as well as both simple-loop-unswitch and unswitch<>.

Not sure what to do with the sanitizer passes that both exist as module and function passes, using the same class name.

[ychen]

llvm/lib/IR/PassInstrumentation.cpp

22–23

By adding some printouts when this check fails, I get this (after also having applied D105007):

PassInstrumentation note: HWAddressSanitizerPass is already mapped to hwasan. It will not be mapped to hwasan<kernal;recover>
PassInstrumentation note: ModuleInlinerWrapperPass is already mapped to inliner-wrapper. It will not be mapped to inliner-wrapper-no-mandatory-first
PassInstrumentation note: ModuleInlinerWrapperPass is already mapped to inliner-wrapper. It will not be mapped to scc-oz-module-inliner
PassInstrumentation note: LoopExtractorPass is already mapped to loop-extract. It will not be mapped to loop-extract-single
PassInstrumentation note: ModuleAddressSanitizerPass is already mapped to asan-module. It will not be mapped to kasan-module
PassInstrumentation note: EarlyCSEPass is already mapped to early-cse. It will not be mapped to early-cse-memssa
PassInstrumentation note: EntryExitInstrumenterPass is already mapped to ee-instrument. It will not be mapped to post-inline-ee-instrument
PassInstrumentation note: LowerMatrixIntrinsicsPass is already mapped to lower-matrix-intrinsics. It will not be mapped to lower-matrix-intrinsics-minimal
PassInstrumentation note: AddressSanitizerPass is already mapped to asan. It will not be mapped to asan<kernel>
PassInstrumentation note: MemorySanitizerPass is already mapped to msan-module. It will not be mapped to msan
PassInstrumentation note: ThreadSanitizerPass is already mapped to tsan-module. It will not be mapped to tsan
PassInstrumentation note: MemorySanitizerPass is already mapped to msan-module. It will not be mapped to msan
PassInstrumentation note: SimplifyCFGPass is already mapped to simplifycfg. It will not be mapped to simplify-cfg
PassInstrumentation note: SimpleLoopUnswitchPass is already mapped to simple-loop-unswitch. It will not be mapped to unswitch

Not sure if we need to add a one-to-many map to handle some of the above. Or if for example early-cse-memssa should be called early-cse<memssa> to indicate that it is a specialized version of early-cse.

I think we really need to get rid of the global map. (D97722)

For passes like ee-instrument. and post-inline-ee-instrument it might be trickier. Should enabling print-after for one of those trigger IR printouts for both? I.e. should they be seen as two different passes, or parameterized versions of the same pass?

I think it should be "parameterized versions of the same pass" which is exactly what it is.

I also think it is just confusing to have both simplifycfg and simplify-cfg<>, as well as both simple-loop-unswitch and unswitch<>.

Agree. This is the same issue as "ee-instrument". We should have one name for a pass and using "<>" to pass parameters from commandline.

Not sure what to do with the sanitizer passes that both exist as module and function passes, using the same class name.

Maybe some mangling scheme, like "msan#m<>" for module pass, "msan#f<>" for function pass, and so on.

[aeubanks]

what's the actual use case for this? --print-before/after are hacky, there's usually a better way to accomplish something aside from --print-before/after

[bjope]

In D105006#2845860, @aeubanks wrote:

what's the actual use case for this? --print-before/after are hacky, there's usually a better way to accomplish something aside from --print-before/after

I actually tried to use getPassNameForClassName for something else when I noticed that all passes with parameteras were missing in the map. I kind of wanted to get a listing of all the "pass names" that were used when for example running with "-passes='default<O3>' by letting the PrintPassInstrumentation print both the class name and pass name. Maybe that could be solved by not using class names in the PassInstrumentation/PassInstrumentationCallbacks in the first place. It kind of looks like someone has assumed that there is a one-to-one mapping between class names and pass names, but currently it is a one-to-many relation.

Nevertheless. The print-before and print-after options do exist, so I guess they should work also for the passes with params. If you want to remove them, then I think that is a different story. Someone has bothered to add support for those options in new-PM, so if you want to remove them you better discuss it with the ones who added the option. I'm just trying to fix problems I see with new-PM where the implementation is broken/incomplete.

[bjope]

Seems like we agree that this only is a start (that we should follow up with fixes for other passes such as in D105007).

And I'm well aware that the PassRegistry might be refactored completely in the future (but for example D97722 isn't really moving forward). Fixing the current implementation like this might however show-case the need for a refactoring a bit more. And it also helps setting the requirement on the new solution (to avoid that we end up refactoring a broken implementation without also considering the currently missing use-cases).

So what is the verdict on this patch?

[ychen]

In D105006#2857688, @bjope wrote:

Seems like we agree that this only is a start (that we should follow up with fixes for other passes such as in D105007).

And I'm well aware that the PassRegistry might be refactored completely in the future (but for example D97722 isn't really moving forward). Fixing the current implementation like this might however show-case the need for a refactoring a bit more. And it also helps setting the requirement on the new solution (to avoid that we end up refactoring a broken implementation without also considering the currently missing use-cases).

So what is the verdict on this patch?

Sounds reasonable to me.

llvm/test/Other/print-before-after.ll

39

XXXCHECK-UNSWITCH?

[bjope]

llvm/test/Other/print-before-after.ll

39

Those are the printouts that still are missing, as explained in the FIXME. The goal would be to enable those checks by removing the "XXX". But then we need to remove the "unswitch" alias for "simple-loop-unswitch".

[ychen]

llvm/test/Other/print-before-after.ll

39

I'd use CHECK-UNSWITCH-NOT. It is unusual to use unchecked labels.

[bjope]

Updated test case after review comments.

[ychen]

LGTM

llvm/lib/IR/PassInstrumentation.cpp

 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 void PassInstrumentationCallbacks::addClassToPassName(StringRef ClassName,
                                                       StringRef PassName) {
+  if (ClassToPassName[ClassName].empty())
     ClassToPassName[ClassName] = PassName.str();
 }
 
 StringRef
 PassInstrumentationCallbacks::getPassNameForClassName(StringRef ClassName) {
   return ClassToPassName[ClassName];
 }
 
 AnalysisKey PassInstrumentationAnalysis::Key;

llvm/lib/Passes/PassBuilder.cpp

if (TM)
     TM->registerPassBuilderCallbacks(*this);
   if (PIC && shouldPopulateClassToPassNames()) {
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    \
+  PIC->addClassToPassName(CLASS, NAME);
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
+  PIC->addClassToPassName(CLASS, NAME);
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define CGSCC_PASS(NAME, CREATE_PASS)                                          \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 #include "PassRegistry.def"
   }
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
 
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
 
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME)                                                            \
     return true;
-#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)           \
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    \
   if (checkParametrizedPassName(Name, NAME))                                   \
     return true;
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
 static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks) {
   // Explicitly handle pass manager names.
   if (Name == "loop" || Name == "loop-mssa")
     return true;
 
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
 
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME)                                                            \
     return true;
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)               \
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
   if (checkParametrizedPassName(Name, NAME))                                   \
     return true;
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
if (Name == NAME) {                                                          \
     MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS));         \
     return Error::success();                                                   \
   }
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
     MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS));               \
     return Error::success();                                                   \
   }
-#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)           \
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
     return Error::success();                                                   \
   }
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
     MPM.addPass(createModuleToFunctionPassAdaptor(                             \
         createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)));          \
     return Error::success();                                                   \
   }
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)               \
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     MPM.addPass(                                                               \
         createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor(     \
             CREATE_PASS(Params.get()), false, false)));                        \
     return Error::success();                                                   \
CGPM.addPass(InvalidateAnalysisPass<                                       \
                  std::remove_reference<decltype(CREATE_PASS)>::type>());       \
     return Error::success();                                                   \
   }
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
     CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS));               \
     return Error::success();                                                   \
   }
-#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)           \
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
     return Error::success();                                                   \
   }
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
     CGPM.addPass(createCGSCCToFunctionPassAdaptor(                             \
         createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)));          \
     return Error::success();                                                   \
   }
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)               \
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     CGPM.addPass(                                                              \
         createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor(      \
             CREATE_PASS(Params.get()), false, false)));                        \
     return Error::success();                                                   \
Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
   }
 
 // Now expand the basic registered passes from the .inc file.
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
     FPM.addPass(CREATE_PASS);                                                  \
     return Error::success();                                                   \
   }
-#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)           \
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     FPM.addPass(CREATE_PASS(Params.get()));                                    \
     return Error::success();                                                   \
   }
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \

 //        bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
 //                              "guard-widening");
 //        The risk is that it may become obsolete if we're not careful.
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
     FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false));   \
     return Error::success();                                                   \
   }
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)               \
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()),     \
                                                 false, false));                \
     return Error::success();                                                   \
   }
Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
   }
 
 // Now expand the basic registered passes from the .inc file.
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
     LPM.addPass(CREATE_PASS);                                                  \
     return Error::success();                                                   \
   }
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)               \
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     LPM.addPass(CREATE_PASS(Params.get()));                                    \
     return Error::success();                                                   \
   }
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \

 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
 #include "PassRegistry.def"
 
   OS << "Function passes:\n";
 #define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
 #include "PassRegistry.def"
 
   OS << "Function passes with params:\n";
-#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)    \
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    \
   printPassName(NAME, PARAMS, OS);
 #include "PassRegistry.def"
 
   OS << "Function analyses:\n";
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
 #include "PassRegistry.def"
 
   OS << "Function alias analyses:\n";
 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
 #include "PassRegistry.def"
 
   OS << "Loop passes:\n";
 #define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
 #include "PassRegistry.def"
 
   OS << "Loop passes with params:\n";
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)        \
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)        \
   printPassName(NAME, PARAMS, OS);
 #include "PassRegistry.def"
 
   OS << "Loop analyses:\n";
 #define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerParseTopLevelPipelineCallback(
     const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
         &C) {
   TopLevelPipelineParsingCallbacks.push_back(C);
 }

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("kasan", AddressSanitizerPass(true, false, false))
 FUNCTION_PASS("msan", MemorySanitizerPass({}))
 FUNCTION_PASS("kmsan", MemorySanitizerPass({0, false, /*Kernel=*/true}))
 FUNCTION_PASS("tsan", ThreadSanitizerPass())
 FUNCTION_PASS("memprof", MemProfilerPass())
 #undef FUNCTION_PASS
 
 #ifndef FUNCTION_PASS_WITH_PARAMS
-#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)
+#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
 #endif
 FUNCTION_PASS_WITH_PARAMS("loop-unroll",
+                          "LoopUnrollPass",
                            [](LoopUnrollOptions Opts) {
                              return LoopUnrollPass(Opts);
                            },
                           parseLoopUnrollOptions,
                           "O0;O1;O2;O3;full-unroll-max=N;"
                           "no-partial;partial;"
                           "no-peeling;peeling;"
                           "no-profile-peeling;profile-peeling;"
                           "no-runtime;runtime;"
                           "no-upperbound;upperbound")
 FUNCTION_PASS_WITH_PARAMS("msan",
+                          "MemorySanitizerPass",
                            [](MemorySanitizerOptions Opts) {
                              return MemorySanitizerPass(Opts);
                            },
                           parseMSanPassOptions,
                           "recover;kernel;track-origins=N")
 FUNCTION_PASS_WITH_PARAMS("simplify-cfg",
+                          "SimplifyCFGPass",
                            [](SimplifyCFGOptions Opts) {
                              return SimplifyCFGPass(Opts);
                            },
                           parseSimplifyCFGOptions,
                           "no-forward-switch-cond;forward-switch-cond;"
                           "no-switch-to-lookup;switch-to-lookup;"
                           "no-keep-loops;keep-loops;"
                           "no-hoist-common-insts;hoist-common-insts;"
                           "no-sink-common-insts;sink-common-insts;"
                           "bonus-inst-threshold=N"
                           )
 FUNCTION_PASS_WITH_PARAMS("loop-vectorize",
+                          "LoopVectorizePass",
                            [](LoopVectorizeOptions Opts) {
                              return LoopVectorizePass(Opts);
                            },
                           parseLoopVectorizeOptions,
                           "no-interleave-forced-only;interleave-forced-only;"
                           "no-vectorize-forced-only;vectorize-forced-only")
 FUNCTION_PASS_WITH_PARAMS("mldst-motion",
+                          "MergedLoadStoreMotionPass",
                            [](MergedLoadStoreMotionOptions Opts) {
                              return MergedLoadStoreMotionPass(Opts);
                            },
                           parseMergedLoadStoreMotionOptions,
                           "no-split-footer-bb;split-footer-bb")
 FUNCTION_PASS_WITH_PARAMS("gvn",
+                          "GVN",
                            [](GVNOptions Opts) {
                              return GVN(Opts);
                            },
                           parseGVNOptions,
                           "no-pre;pre;"
                           "no-load-pre;load-pre;"
                           "no-split-backedge-load-pre;split-backedge-load-pre;"
                           "no-memdep;memdep")
 FUNCTION_PASS_WITH_PARAMS("print<stack-lifetime>",
+                          "StackLifetimePrinterPass",
                            [](StackLifetime::LivenessType Type) {
                              return StackLifetimePrinterPass(dbgs(), Type);
                            },
                           parseStackLifetimeOptions,
                           "may;must")
 #undef FUNCTION_PASS_WITH_PARAMS
 
 #ifndef LOOP_ANALYSIS

 LOOP_PASS("guard-widening", GuardWideningPass())
 LOOP_PASS("loop-bound-split", LoopBoundSplitPass())
 LOOP_PASS("simple-loop-unswitch", SimpleLoopUnswitchPass())
 LOOP_PASS("loop-reroll", LoopRerollPass())
 LOOP_PASS("loop-versioning-licm", LoopVersioningLICMPass())
 #undef LOOP_PASS
 
 #ifndef LOOP_PASS_WITH_PARAMS
-#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER, PARAMS)
+#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
 #endif
 LOOP_PASS_WITH_PARAMS("unswitch",
+                      "SimpleLoopUnswitchPass",
                       [](bool NonTrivial) {
                         return SimpleLoopUnswitchPass(NonTrivial);
                       },
                       parseLoopUnswitchOptions,
                       "no-nontrivial;nontrivial")
 #undef LOOP_PASS_WITH_PARAMS

llvm/test/Other/print-before-after.ll

 ; RUN: opt < %s -disable-output -passes='no-op-module' -print-before=bleh 2>&1 | FileCheck %s --check-prefix=NONE --allow-empty
 ; RUN: opt < %s -disable-output -passes='no-op-module' -print-after=bleh 2>&1 | FileCheck %s --check-prefix=NONE --allow-empty
 ; RUN: opt < %s -disable-output -passes='no-op-module' -print-before=no-op-function 2>&1 | FileCheck %s --check-prefix=NONE --allow-empty
 ; RUN: opt < %s -disable-output -passes='no-op-module' -print-after=no-op-function 2>&1 | FileCheck %s --check-prefix=NONE --allow-empty
 ; RUN: opt < %s -disable-output -passes='no-op-module,no-op-function' -print-before=no-op-module 2>&1 | FileCheck %s --check-prefix=ONCE
 ; RUN: opt < %s -disable-output -passes='no-op-module,no-op-function' -print-after=no-op-module 2>&1 | FileCheck %s --check-prefix=ONCE
 ; RUN: opt < %s -disable-output -passes='no-op-function' -print-before=no-op-function 2>&1 | FileCheck %s --check-prefix=ONCE
 ; RUN: opt < %s -disable-output -passes='no-op-function' -print-after=no-op-function 2>&1 | FileCheck %s --check-prefix=ONCE
 ; RUN: opt < %s -disable-output -passes='no-op-module,no-op-function' -print-before=no-op-function --print-module-scope 2>&1 | FileCheck %s --check-prefix=TWICE
 ; RUN: opt < %s -disable-output -passes='no-op-module,no-op-function' -print-after=no-op-function --print-module-scope 2>&1 | FileCheck %s --check-prefix=TWICE
+; RUN: opt < %s -disable-output -passes='loop-vectorize' -print-before=loop-vectorize -print-after=loop-vectorize 2>&1 | FileCheck %s --check-prefix=CHECK-LV --allow-empty
+; RUN: opt < %s -disable-output -passes='simple-loop-unswitch,unswitch' -print-before=unswitch -print-after=simple-loop-unswitch 2>&1 | FileCheck %s --check-prefix=CHECK-UNSWITCH --allow-empty
 
 ; NONE-NOT: @foo
 ; NONE-NOT: @bar
 
 ; ONCE: @foo
 ; ONCE: @bar
 ; ONCE-NOT: @foo
 ; ONCE-NOT: @bar
 
 ; TWICE: @foo
 ; TWICE: @bar
 ; TWICE: @foo
 ; TWICE: @bar
 ; TWICE-NOT: @foo
 ; TWICE-NOT: @bar
 
+; Verify that we can handle function passes with params.
+; CHECK-LV: *** IR Dump Before LoopVectorizePass on foo ***
+; CHECK-LV: *** IR Dump After LoopVectorizePass on foo ***
+; CHECK-LV: *** IR Dump Before LoopVectorizePass on bar ***
+; CHECK-LV: *** IR Dump After LoopVectorizePass on bar ***
+
+; Verify that we can handle loop passes with params.
+
+; FIXME: The SimpleLoopUnswitchPass is extra complicated as we have different
+; pass names mapping to the same class name. But we currently only use a 1-1
+; mapping, so we do not get the -print-before=unswitch printout here. So the
+; NOT checks below is currently verifying the "faulty" behavior and we
+; actually want to get those printout here in the future.
+; CHECK-UNSWITCH-NOT: *** IR Dump Before SimpleLoopUnswitchPass on Loop at depth 1 containing
+; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on Loop at depth 1 containing
+; CHECK-UNSWITCH-NOT: *** IR Dump Before SimpleLoopUnswitchPass on Loop at depth 1 containing
+; CHECK-UNSWITCH: *** IR Dump After SimpleLoopUnswitchPass on Loop at depth 1 containing
+
 define void @foo() {
   ret void
 }
 
 define void @bar() {
-  ret void
+entry:
+  br label %loop
+loop:
+  br label %loop
 }