[NewPM] Add options to PrintPassInstrumentation

[aeubanks]

Summary

To bring D99599's implementation in line with the existing
PrintPassInstrumentation, and to fix a FIXME, add more customizability
to PrintPassInstrumentation.

Introduce three new options. The first takes over the existing
"-debug-pass-manager-verbose" cl::opt.

The second and third option are specific to -fdebug-pass-structure. They
allow indentation, and also don't print analysis queries.

To avoid more golden file tests than necessary, prune down the
-fdebug-pass-structure tests.

[aeubanks]

assert Indent >= 0

clang/lib/CodeGen/BackendUtil.cpp

 }
 
 static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {
   SmallVector<const char *, 16> BackendArgs;
   BackendArgs.push_back("clang"); // Fake program name.
   if (!CodeGenOpts.DebugPass.empty()) {
     BackendArgs.push_back("-debug-pass");
     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
-    // New PM supports structure dumping. Old PM is still used for codegen,
-    // so we need to pass both options.
-    if (!CodeGenOpts.LegacyPassManager && CodeGenOpts.DebugPass == "Structure")
-      BackendArgs.push_back("-debug-pass-structure");
   }
   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
     BackendArgs.push_back("-limit-float-precision");
     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
   }
   // Check for the default "clang" invocation that won't set any cl::opt values.
   // Skip trying to parse the command line invocation to avoid the issues
   // described below.
void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
   PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
   PTO.Coroutines = LangOpts.Coroutines;
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 
+  bool DebugPassStructure = CodeGenOpts.DebugPass == "Structure";
   PassInstrumentationCallbacks PIC;
-  StandardInstrumentations SI(CodeGenOpts.DebugPassManager);
+  PrintPassOptions PrintPassOpts;
+  PrintPassOpts.Indent = DebugPassStructure;
+  PrintPassOpts.SkipAnalyses = DebugPassStructure;
+  StandardInstrumentations SI(CodeGenOpts.DebugPassManager ||
+                                  DebugPassStructure,
+                              /*VerifyEach*/ false, PrintPassOpts);
   SI.registerCallbacks(PIC, &FAM);
   PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
 
   // Attempt to load pass plugins and register their callbacks with PB.
   for (auto &PluginFN : CodeGenOpts.PassPlugins) {
     auto PassPlugin = PassPlugin::Load(PluginFN);
     if (PassPlugin) {
       PassPlugin->registerPassBuilderCallbacks(PB);

clang/test/Driver/debug-pass-structure.c

 // Test that we print pass structure with new and legacy PM.
-// RUN: %clang -fexperimental-new-pass-manager -fdebug-pass-structure -fintegrated-as -O3 -S -emit-llvm %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=NEWPM
+// RUN: %clang -fexperimental-new-pass-manager -fdebug-pass-structure -fintegrated-as -O3 -S -emit-llvm %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=NEWPM --strict-whitespace
 // RUN: %clang -flegacy-pass-manager -fdebug-pass-structure -O0 -S -emit-llvm %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LEGACYPM
 // REQUIRES: asserts
 
-// NEWPM: Annotation2MetadataPass on [module]
-// NEWPM-NEXT: ForceFunctionAttrsPass on [module]
-// NEWPM-NEXT: InferFunctionAttrsPass on [module]
-// NEWPM-NEXT:   InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
-// NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-// NEWPM-NEXT: OpenMPOptPass on [module]
-// NEWPM-NEXT: IPSCCPPass on [module]
-// NEWPM-NEXT: CalledValuePropagationPass on [module]
-// NEWPM-NEXT: GlobalOptPass on [module]
-// NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-// NEWPM-NEXT: DeadArgumentEliminationPass on [module]
-// NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-// NEWPM-NEXT: ModuleInlinerWrapperPass on [module]
-// NEWPM-NEXT:   InlineAdvisorAnalysis analysis on [module]
-// NEWPM-NEXT:   RequireAnalysisPass<{{.*}}> on [module]
-// NEWPM-NEXT:     GlobalsAA analysis on [module]
-// NEWPM-NEXT:       CallGraphAnalysis analysis on [module]
-// NEWPM-NEXT:   ModuleToFunctionPassAdaptor on [module]
-// NEWPM-NEXT:   RequireAnalysisPass<{{.*}}> on [module]
-// NEWPM-NEXT:     ProfileSummaryAnalysis analysis on [module]
-// NEWPM-NEXT:   ModuleToPostOrderCGSCCPassAdaptor on [module]
-// NEWPM-NEXT:     InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
-// NEWPM-NEXT:       LazyCallGraphAnalysis analysis on [module]
-// NEWPM-NEXT: GlobalOptPass on [module]
-// NEWPM-NEXT: GlobalDCEPass on [module]
-// NEWPM-NEXT: EliminateAvailableExternallyPass on [module]
-// NEWPM-NEXT: ReversePostOrderFunctionAttrsPass on [module]
-// NEWPM-NEXT: RequireAnalysisPass<{{.*}}> on [module]
-// NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-// CGProfilePass is disabled with non-integrated assemblers
-// NEWPM-NEXT: CGProfilePass on [module]
-// NEWPM-NEXT: GlobalDCEPass on [module]
-// NEWPM-NEXT: ConstantMergePass on [module]
-// NEWPM-NEXT: RelLookupTableConverterPass on [module]
-// NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-// NEWPM-NEXT: PrintModulePass on [module]
+// should have proper indentation, should not print any analysis information
+// NEWPM-NOT: Running analysis
+// NEWPM: {{^}}Running{{.*}}GlobalOptPass
+// NEWPM: {{^}}  Running{{.*}}RequireAnalysisPass{{.*}}GlobalsAA
+// NEWPM: GlobalOptPass
+// NEWPM-NOT: Invalidating analysis
 
-// LEGACYPM:      Pass Arguments:
+// LEGACYPM: Pass Arguments:
 
+void f() {}

llvm/include/llvm/Passes/StandardInstrumentations.h

 };
 
 class OptBisectInstrumentation {
 public:
   OptBisectInstrumentation() {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
+struct PrintPassOptions {
+  /// Print adaptors and pass managers.
+  bool Verbose = false;
+  /// Don't print information for analyses.
+  bool SkipAnalyses = false;
+  /// Indent based on hierarchy.
+  bool Indent = false;
+};
+
 // Debug logging for transformation and analysis passes.
 class PrintPassInstrumentation {
-  void printWithIdent(bool Expand, const Twine &Msg);
+  raw_ostream &print();
 
 public:
-  PrintPassInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
+  PrintPassInstrumentation(bool Enabled, PrintPassOptions Opts)
+      : Enabled(Enabled), Opts(Opts) {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
-  bool DebugLogging;
-  int Ident = 0;
-};
-
-// Pass structure dumper
-class PassStructurePrinter {
-  int Ident = 0;
-  void printWithIdent(bool Expand, const Twine &Msg);
-
-public:
-  PassStructurePrinter() {}
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+  bool Enabled;
+  PrintPassOptions Opts;
+  int Indent = 0;
 };
 
 class PreservedCFGCheckerInstrumentation {
 public:
   // Keeps sticky poisoned flag for the given basic block once it has been
   // deleted or RAUWed.
   struct BBGuard final : public CallbackVH {
     BBGuard(const BasicBlock *BB) : CallbackVH(BB) {}
public:
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
 /// This class provides an interface to register all the standard pass
 /// instrumentations and manages their state (if any).
 class StandardInstrumentations {
   PrintIRInstrumentation PrintIR;
   PrintPassInstrumentation PrintPass;
-  PassStructurePrinter StructurePrinter;
   TimePassesHandler TimePasses;
   OptNoneInstrumentation OptNone;
   OptBisectInstrumentation OptBisect;
   PreservedCFGCheckerInstrumentation PreservedCFGChecker;
   IRChangedPrinter PrintChangedIR;
   PseudoProbeVerifier PseudoProbeVerification;
   InLineChangePrinter PrintChangedDiff;
   VerifyInstrumentation Verify;
 
   bool VerifyEach;
 
 public:
-  StandardInstrumentations(bool DebugLogging, bool VerifyEach = false);
+  StandardInstrumentations(bool DebugLogging, bool VerifyEach = false,
+                           PrintPassOptions PrintPassOpts = PrintPassOptions());
 
   // Register all the standard instrumentation callbacks. If \p FAM is nullptr
   // then PreservedCFGChecker is not enabled.
   void registerCallbacks(PassInstrumentationCallbacks &PIC,
                          FunctionAnalysisManager *FAM = nullptr);
 
   TimePassesHandler &getTimePasses() { return TimePasses; }
 };

llvm/lib/Passes/StandardInstrumentations.cpp

 cl::opt<bool> PreservedCFGCheckerInstrumentation::VerifyPreservedCFG(
     "verify-cfg-preserved", cl::Hidden,
 #ifdef NDEBUG
     cl::init(false));
 #else
     cl::init(true));
 #endif
 
-// FIXME: Change `-debug-pass-manager` from boolean to enum type. Similar to
-// `-debug-pass` in legacy PM.
-static cl::opt<bool>
-    DebugPMVerbose("debug-pass-manager-verbose", cl::Hidden, cl::init(false),
-                   cl::desc("Print all pass management debugging information. "
-                            "`-debug-pass-manager` must also be specified"));
-
-static cl::opt<bool>
-    DebugPassStructure("debug-pass-structure", cl::Hidden, cl::init(false),
-                       cl::desc("Print pass structure information."));
-
 // An option that prints out the IR after passes, similar to
 // -print-after-all except that it only prints the IR after passes that
 // change the IR.  Those passes that do not make changes to the IR are
 // reported as not making any changes.  In addition, the initial IR is
 // also reported.  Other hidden options affect the output from this
 // option.  -filter-passes will limit the output to the named passes
 // that actually change the IR and other passes are reported as filtered out.
 // The specified passes will either be reported as making no changes (with
void OptBisectInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!OptBisector->isEnabled())
     return;
   PIC.registerShouldRunOptionalPassCallback([](StringRef PassID, Any IR) {
     return isIgnored(PassID) || OptBisector->checkPass(PassID, getIRName(IR));
   });
 }
 
+raw_ostream &PrintPassInstrumentation::print() {
+  if (Opts.Indent) {
+    assert(Indent >= 0);
+    dbgs().indent(Indent);
+  }
+  return dbgs();
+}
+
 void PrintPassInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
-  if (!DebugLogging)
+  if (!Enabled)
     return;
 
   std::vector<StringRef> SpecialPasses;
-  if (!DebugPMVerbose) {
+  if (!Opts.Verbose) {
     SpecialPasses.emplace_back("PassManager");
     SpecialPasses.emplace_back("PassAdaptor");
   }
 
   PIC.registerBeforeSkippedPassCallback(
-      [SpecialPasses](StringRef PassID, Any IR) {
+      [this, SpecialPasses](StringRef PassID, Any IR) {
         assert(!isSpecialPass(PassID, SpecialPasses) &&
                "Unexpectedly skipping special pass");
 
-        dbgs() << "Skipping pass: " << PassID << " on " << getIRName(IR)
+        print() << "Skipping pass: " << PassID << " on " << getIRName(IR)
                 << "\n";
       });
-
-  PIC.registerBeforeNonSkippedPassCallback(
-      [SpecialPasses](StringRef PassID, Any IR) {
-        if (isSpecialPass(PassID, SpecialPasses))
-          return;
+  PIC.registerBeforeNonSkippedPassCallback([this, SpecialPasses](
+                                               StringRef PassID, Any IR) {
 
-        dbgs() << "Running pass: " << PassID << " on " << getIRName(IR) << "\n";
-      });
-
-  PIC.registerBeforeAnalysisCallback([](StringRef PassID, Any IR) {
-    dbgs() << "Running analysis: " << PassID << " on " << getIRName(IR) << "\n";
-  });
-
-  PIC.registerAnalysisInvalidatedCallback([](StringRef PassID, Any IR) {
-    dbgs() << "Invalidating analysis: " << PassID << " on " << getIRName(IR)
-           << "\n";
-  });
-  PIC.registerAnalysesClearedCallback([](StringRef IRName) {
-    dbgs() << "Clearing all analysis results for: " << IRName << "\n";
-  });
-}
-
-void PassStructurePrinter::printWithIdent(bool Expand, const Twine &Msg) {
-  if (!Msg.isTriviallyEmpty())
-    dbgs().indent(Ident) << Msg << "\n";
-  Ident = Expand ? Ident + 2 : Ident - 2;
-  assert(Ident >= 0);
-}
-
-void PassStructurePrinter::registerCallbacks(
-    PassInstrumentationCallbacks &PIC) {
-  if (!DebugPassStructure)
+    print() << "Running pass: " << PassID << " on " << getIRName(IR) << "\n";
+    Indent += 2;
+  PIC.registerAfterPassCallback(
+      [this, SpecialPasses](StringRef PassID, Any IR,
+                            const PreservedAnalyses &) {
+        if (isSpecialPass(PassID, SpecialPasses))
           return;
 
-  PIC.registerBeforeNonSkippedPassCallback([this](StringRef PassID, Any IR) {
-    printWithIdent(true, PassID + " on " + getIRName(IR));
-  });
-  PIC.registerAfterPassCallback(
-      [this](StringRef PassID, Any IR, const PreservedAnalyses &) {
-        printWithIdent(false, Twine());
+        Indent -= 2;
       });
-
   PIC.registerAfterPassInvalidatedCallback(
-      [this](StringRef PassID, const PreservedAnalyses &) {
-        printWithIdent(false, Twine());
+      [this, SpecialPasses](StringRef PassID, Any IR) {
+        if (isSpecialPass(PassID, SpecialPasses))
+          return;
+
+        Indent -= 2;
       });
 
+  if (!Opts.SkipAnalyses) {
     PIC.registerBeforeAnalysisCallback([this](StringRef PassID, Any IR) {
-    printWithIdent(true, PassID + " analysis on " + getIRName(IR));
+      print() << "Running analysis: " << PassID << " on " << getIRName(IR)
+              << "\n";
+      Indent += 2;
     });
     PIC.registerAfterAnalysisCallback(
-      [this](StringRef PassID, Any IR) { printWithIdent(false, Twine()); });
+        [this](StringRef PassID, Any IR) { Indent -= 2; });
+    PIC.registerAnalysisInvalidatedCallback([this](StringRef PassID, Any IR) {
+      print() << "Invalidating analysis: " << PassID << " on " << getIRName(IR)
+              << "\n";
+    });
+    PIC.registerAnalysesClearedCallback([this](StringRef IRName) {
+      print() << "Clearing all analysis results for: " << IRName << "\n";
+    });
+  }
 }
 
 PreservedCFGCheckerInstrumentation::CFG::CFG(const Function *F,
                                              bool TrackBBLifetime) {
   if (TrackBBLifetime)
     BBGuards = DenseMap<intptr_t, BBGuard>(F->size());
   for (const auto &BB : *F) {
     if (BBGuards)

 void InLineChangePrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::PrintChangedDiffVerbose ||
       PrintChanged == ChangePrinter::PrintChangedDiffQuiet ||
       PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose ||
       PrintChanged == ChangePrinter::PrintChangedColourDiffQuiet)
     TextChangeReporter<ChangedIRData>::registerRequiredCallbacks(PIC);
 }
 
-StandardInstrumentations::StandardInstrumentations(bool DebugLogging,
-                                                   bool VerifyEach)
-    : PrintPass(DebugLogging), OptNone(DebugLogging),
+StandardInstrumentations::StandardInstrumentations(
+    bool DebugLogging, bool VerifyEach, PrintPassOptions PrintPassOpts)
+    : PrintPass(DebugLogging, PrintPassOpts), OptNone(DebugLogging),
       PrintChangedIR(PrintChanged == ChangePrinter::PrintChangedVerbose),
       PrintChangedDiff(
           PrintChanged == ChangePrinter::PrintChangedDiffVerbose ||
               PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose,
           PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose ||
               PrintChanged == ChangePrinter::PrintChangedColourDiffQuiet),
       Verify(DebugLogging), VerifyEach(VerifyEach) {}
 
 void StandardInstrumentations::registerCallbacks(
     PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM) {
   PrintIR.registerCallbacks(PIC);
   PrintPass.registerCallbacks(PIC);
-  StructurePrinter.registerCallbacks(PIC);
   TimePasses.registerCallbacks(PIC);
   OptNone.registerCallbacks(PIC);
   OptBisect.registerCallbacks(PIC);
   if (FAM)
     PreservedCFGChecker.registerCallbacks(PIC, *FAM);
   PrintChangedIR.registerCallbacks(PIC);
   PseudoProbeVerification.registerCallbacks(PIC);
   if (VerifyEach)

llvm/test/Other/new-pass-manager-cgscc-fct-proxy.ll

-; RUN: opt %s -disable-verify -disable-output -passes='default<O2>' -debug-pass-manager -debug-pass-manager-verbose -cgscc-npm-no-fp-rerun=1 \
+; RUN: opt %s -disable-verify -disable-output -passes='default<O2>' -debug-pass-manager=verbose -cgscc-npm-no-fp-rerun=1 \
 ; RUN:  2>&1 | FileCheck %s -check-prefixes=CHECK,NOREPS
-; RUN: opt %s -disable-verify -disable-output -passes='default<O2>' -debug-pass-manager -debug-pass-manager-verbose -cgscc-npm-no-fp-rerun=0 \
+; RUN: opt %s -disable-verify -disable-output -passes='default<O2>' -debug-pass-manager=verbose -cgscc-npm-no-fp-rerun=0 \
 ; RUN:  2>&1 | FileCheck %s -check-prefixes=CHECK,REPS
 
 ; Pre-attribute the functions to avoid the PostOrderFunctionAttrsPass cause
 ; changes (and keep the test simple)
 attributes #0 = { nofree noreturn nosync nounwind readnone }
 
 define void @f1(void()* %p) {
   call void %p()

llvm/test/Other/opt-O3-pipeline.ll

 ; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -O3 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=CHECK,%llvmcheckext %s
-; RUN: opt -enable-new-pm=1 -mtriple=x86_64-- -O3 -debug-pass-structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=NEWPM,%llvmcheckext %s
 
 ; REQUIRES: asserts
 
 ; CHECK-LABEL: Pass Arguments:
 ; CHECK-NEXT: Target Transform Information
 ; CHECK-NEXT: Type-Based Alias Analysis
 ; CHECK-NEXT: Scoped NoAlias Alias Analysis
 ; CHECK-NEXT: Assumption Cache Tracker

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Dominator Tree Construction
 ; CHECK-NEXT:     Natural Loop Information
 ; CHECK-NEXT:     Post-Dominator Tree Construction
 ; CHECK-NEXT:     Branch Probability Analysis
 ; CHECK-NEXT:     Block Frequency Analysis
 
-; NEWPM:      VerifierPass on [module]
-; NEWPM-NEXT:   VerifierAnalysis analysis on [module]
-; NEWPM-NEXT: Annotation2MetadataPass on [module]
-; NEWPM-NEXT: ForceFunctionAttrsPass on [module]
-; NEWPM-NEXT: InferFunctionAttrsPass on [module]
-; NEWPM-NEXT:   InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
-; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-; NEWPM-NEXT:   PassManager<{{.*}}> on f
-; NEWPM-NEXT:     PreservedCFGCheckerAnalysis analysis on f
-; NEWPM-NEXT:     LowerExpectIntrinsicPass on f
-; NEWPM-NEXT:     SimplifyCFGPass on f
-; NEWPM-NEXT:       TargetIRAnalysis analysis on f
-; NEWPM-NEXT:       AssumptionAnalysis analysis on f
-; NEWPM-NEXT:     SROA on f
-; NEWPM-NEXT:       DominatorTreeAnalysis analysis on f
-; NEWPM-NEXT:     EarlyCSEPass on f
-; NEWPM-NEXT:       TargetLibraryAnalysis analysis on f
-; NEWPM-NEXT:     CallSiteSplittingPass on f
-; NEWPM-NEXT: OpenMPOptPass on [module]
-; NEWPM-NEXT: IPSCCPPass on [module]
-; NEWPM-NEXT: CalledValuePropagationPass on [module]
-; NEWPM-NEXT: GlobalOptPass on [module]
-; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-; NEWPM-NEXT:   InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
-; NEWPM-NEXT:   PromotePass on f
-; NEWPM-NEXT:     PreservedCFGCheckerAnalysis analysis on f
-; NEWPM-NEXT:     DominatorTreeAnalysis analysis on f
-; NEWPM-NEXT:     AssumptionAnalysis analysis on f
-; NEWPM-NEXT: DeadArgumentEliminationPass on [module]
-; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-; NEWPM-NEXT:   PassManager<{{.*}}> on f
-; NEWPM-NEXT:     InstCombinePass on f
-; NEWPM-NEXT:       TargetLibraryAnalysis analysis on f
-; NEWPM-NEXT:       OptimizationRemarkEmitterAnalysis analysis on f
-; NEWPM-NEXT:       TargetIRAnalysis analysis on f
-; NEWPM-NEXT:       AAManager analysis on f
-; NEWPM-NEXT:         BasicAA analysis on f
-; NEWPM-NEXT:       OuterAnalysisManagerProxy<{{.*}}> analysis on f
-; NEWPM-NEXT:     SimplifyCFGPass on f
-; NEWPM-NEXT: ModuleInlinerWrapperPass on [module]
-; NEWPM-NEXT:   InlineAdvisorAnalysis analysis on [module]
-; NEWPM-NEXT:   RequireAnalysisPass<{{.*}}> on [module]
-; NEWPM-NEXT:     GlobalsAA analysis on [module]
-; NEWPM-NEXT:       CallGraphAnalysis analysis on [module]
-; NEWPM-NEXT:   ModuleToFunctionPassAdaptor on [module]
-; NEWPM-NEXT:   InvalidateAnalysisPass<{{.*}}> on f
-; NEWPM-NEXT:   RequireAnalysisPass<{{.*}}> on [module]
-; NEWPM-NEXT:     ProfileSummaryAnalysis analysis on [module]
-; NEWPM-NEXT:   ModuleToPostOrderCGSCCPassAdaptor on [module]
-; NEWPM-NEXT:     InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
-; NEWPM-NEXT:       LazyCallGraphAnalysis analysis on [module]
-; NEWPM-NEXT:     FunctionAnalysisManagerCGSCCProxy analysis on (f)
-; NEWPM-NEXT:       OuterAnalysisManagerProxy<{{.*}}> analysis on (f)
-; NEWPM-NEXT:     DevirtSCCRepeatedPass on (f)
-; NEWPM-NEXT:       PassManager<{{.*}}> on (f)
-; NEWPM-NEXT:         InlinerPass on (f)
-; NEWPM-NEXT:         InlinerPass on (f)
-; NEWPM-NEXT:         PostOrderFunctionAttrsPass on (f)
-; NEWPM-NEXT:           AAManager analysis on f
-; NEWPM-NEXT:         ArgumentPromotionPass on (f)
-; NEWPM-NEXT:         OpenMPOptCGSCCPass on (f)
-; NEWPM-NEXT:         CGSCCToFunctionPassAdaptor on (f)
-; NEWPM-NEXT:           PassManager<{{.*}}> on f
-; NEWPM-NEXT:             SROA on f
-; NEWPM-NEXT:             EarlyCSEPass on f
-; NEWPM-NEXT:               MemorySSAAnalysis analysis on f
-; NEWPM-NEXT:             SpeculativeExecutionPass on f
-; NEWPM-NEXT:             JumpThreadingPass on f
-; NEWPM-NEXT:               LazyValueAnalysis analysis on f
-; NEWPM-NEXT:             CorrelatedValuePropagationPass on f
-; NEWPM-NEXT:             SimplifyCFGPass on f
-; NEWPM-NEXT:             AggressiveInstCombinePass on f
-; NEWPM-NEXT:             InstCombinePass on f
-; NEWPM-NEXT:             LibCallsShrinkWrapPass on f
-; NEWPM-NEXT:             TailCallElimPass on f
-; NEWPM-NEXT:             SimplifyCFGPass on f
-; NEWPM-NEXT:             ReassociatePass on f
-; NEWPM-NEXT:             RequireAnalysisPass<{{.*}}> on f
-; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
-; NEWPM-NEXT:               PassManager<{{.*}}> on f
-; NEWPM-NEXT:                 LoopSimplifyPass on f
-; NEWPM-NEXT:                   LoopAnalysis analysis on f
-; NEWPM-NEXT:                 LCSSAPass on f
-; NEWPM-NEXT:             SimplifyCFGPass on f
-; NEWPM-NEXT:             InstCombinePass on f
-; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
-; NEWPM-NEXT:               PassManager<{{.*}}> on f
-; NEWPM-NEXT:                 LoopSimplifyPass on f
-; NEWPM-NEXT:                 LCSSAPass on f
-; NEWPM-NEXT:             SROA on f
-; NEWPM-NEXT:             MergedLoadStoreMotionPass on f
-; NEWPM-NEXT:             GVN on f
-; NEWPM-NEXT:               MemoryDependenceAnalysis analysis on f
-; NEWPM-NEXT:                 PhiValuesAnalysis analysis on f
-; NEWPM-NEXT:             SCCPPass on f
-; NEWPM-NEXT:             BDCEPass on f
-; NEWPM-NEXT:               DemandedBitsAnalysis analysis on f
-; NEWPM-NEXT:             InstCombinePass on f
-; NEWPM-NEXT:             JumpThreadingPass on f
-; NEWPM-NEXT:               LazyValueAnalysis analysis on f
-; NEWPM-NEXT:             CorrelatedValuePropagationPass on f
-; NEWPM-NEXT:             ADCEPass on f
-; NEWPM-NEXT:               PostDominatorTreeAnalysis analysis on f
-; NEWPM-NEXT:             MemCpyOptPass on f
-; NEWPM-NEXT:             DSEPass on f
-; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
-; NEWPM-NEXT:               PassManager<{{.*}}> on f
-; NEWPM-NEXT:                 LoopSimplifyPass on f
-; NEWPM-NEXT:                 LCSSAPass on f
-; NEWPM-NEXT:             SimplifyCFGPass on f
-; NEWPM-NEXT:             InstCombinePass on f
-; NEWPM-NEXT: GlobalOptPass on [module]
-; NEWPM-NEXT: GlobalDCEPass on [module]
-; NEWPM-NEXT: EliminateAvailableExternallyPass on [module]
-; NEWPM-NEXT: ReversePostOrderFunctionAttrsPass on [module]
-; NEWPM-NEXT:   CallGraphAnalysis analysis on [module]
-; NEWPM-NEXT: RequireAnalysisPass<{{.*}}> on [module]
-; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-; NEWPM-NEXT:   PassManager<{{.*}}> on f
-; NEWPM-NEXT:     Float2IntPass on f
-; NEWPM-NEXT:     LowerConstantIntrinsicsPass on f
-; NEWPM-NEXT:     FunctionToLoopPassAdaptor on f
-; NEWPM-NEXT:       PassManager<{{.*}}> on f
-; NEWPM-NEXT:         LoopSimplifyPass on f
-; NEWPM-NEXT:         LCSSAPass on f
-; NEWPM-NEXT:     LoopDistributePass on f
-; NEWPM-NEXT:       ScalarEvolutionAnalysis analysis on f
-; NEWPM-NEXT:       InnerAnalysisManagerProxy<{{.*}}> analysis on f
-; NEWPM-NEXT:     InjectTLIMappings on f
-; NEWPM-NEXT:     LoopVectorizePass on f
-; NEWPM-NEXT:       BlockFrequencyAnalysis analysis on f
-; NEWPM-NEXT:         BranchProbabilityAnalysis analysis on f
-; NEWPM-NEXT:     LoopLoadEliminationPass on f
-; NEWPM-NEXT:     InstCombinePass on f
-; NEWPM-NEXT:     SimplifyCFGPass on f
-; NEWPM-NEXT:     SLPVectorizerPass on f
-; NEWPM-NEXT:     VectorCombinePass on f
-; NEWPM-NEXT:     InstCombinePass on f
-; NEWPM-NEXT:     LoopUnrollPass on f
-; NEWPM-NEXT:     WarnMissedTransformationsPass on f
-; NEWPM-NEXT:     InstCombinePass on f
-; NEWPM-NEXT:     RequireAnalysisPass<{{.*}}> on f
-; NEWPM-NEXT:     FunctionToLoopPassAdaptor on f
-; NEWPM-NEXT:       PassManager<{{.*}}> on f
-; NEWPM-NEXT:         LoopSimplifyPass on f
-; NEWPM-NEXT:         LCSSAPass on f
-; NEWPM-NEXT:     AlignmentFromAssumptionsPass on f
-; NEWPM-NEXT:     LoopSinkPass on f
-; NEWPM-NEXT:     InstSimplifyPass on f
-; NEWPM-NEXT:     DivRemPairsPass on f
-; NEWPM-NEXT:     SimplifyCFGPass on f
-; NEWPM-NEXT:     SpeculateAroundPHIsPass on f
-; NEWPM-NEXT: CGProfilePass on [module]
-; NEWPM-NEXT: GlobalDCEPass on [module]
-; NEWPM-NEXT: ConstantMergePass on [module]
-; NEWPM-NEXT: RelLookupTableConverterPass on [module]
-; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
-; NEWPM-NEXT:   PassManager<{{.*}}> on f
-; NEWPM-NEXT:     AnnotationRemarksPass on f
-; NEWPM-NEXT: VerifierPass on [module]
-; NEWPM-NEXT:   VerifierAnalysis analysis on [module]
-; NEWPM-NEXT: BitcodeWriterPass on [module]
-
 define void @f() {
   ret void
 }

llvm/test/Other/pass-pipeline-parsing.ll

 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='loop(no-op-loop)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-NESTED-FP-LP
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='no-op-loop' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-NESTED-FP-LP
 ; CHECK-NESTED-FP-LP: Running pass: NoOpLoopPass
 
-; RUN: opt -disable-output -debug-pass-manager -debug-pass-manager-verbose \
+; RUN: opt -disable-output -debug-pass-manager=verbose \
 ; RUN:     -passes='module(no-op-function,no-op-loop,no-op-cgscc,cgscc(no-op-function,no-op-loop),function(no-op-loop))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-ADAPTORS
 ; CHECK-ADAPTORS: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpFunctionPass
 ; CHECK-ADAPTORS: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: FunctionToLoopPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop
 ; CHECK-ADAPTORS: Running pass: ModuleToPostOrderCGSCCPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpCGSCCPass
 ; CHECK-ADAPTORS: Running pass: ModuleToPostOrderCGSCCPassAdaptor
 ; CHECK-ADAPTORS: Running pass: PassManager{{.*}}SCC
 ; CHECK-ADAPTORS: Running pass: CGSCCToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpFunctionPass
 ; CHECK-ADAPTORS: Running pass: CGSCCToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: FunctionToLoopPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop
 ; CHECK-ADAPTORS: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-ADAPTORS: Running pass: PassManager{{.*}}Function
 ; CHECK-ADAPTORS: Running pass: FunctionToLoopPassAdaptor
 ; CHECK-ADAPTORS: Running pass: NoOpLoopPass on Loop at depth 1 containing: %loop
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='module(function(no-op-function,loop(no-op-loop,no-op-loop)))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MANAGERS-NO-VERBOSE
-; RUN: opt -disable-output -debug-pass-manager -debug-pass-manager-verbose \
+; RUN: opt -disable-output -debug-pass-manager=verbose \
 ; RUN:     -passes='module(function(no-op-function,loop(no-op-loop,no-op-loop)))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MANAGERS
 ; CHECK-MANAGERS: Running pass: PassManager{{.*}}Function
 ; CHECK-MANAGERS: Running pass: PassManager{{.*}}Loop
 ; CHECK-MANAGERS-NO-VERBOSE-NOT: PassManager
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='cgscc(print)' %s 2>&1 \

llvm/tools/opt/NewPMDriver.cpp

cl::opt<bool> DebugifyEach(
     cl::desc("Start each pass with debugify and end it with check-debugify"));
 
 cl::opt<std::string>
     DebugifyExport("debugify-export",
                    cl::desc("Export per-pass debugify statistics to this file"),
                    cl::value_desc("filename"));
 } // namespace llvm
 
-static cl::opt<bool>
-    DebugPM("debug-pass-manager", cl::Hidden,
-            cl::desc("Print pass management debugging information"));
+enum class DebugLogging { None, Normal, Verbose };
+
+static cl::opt<DebugLogging> DebugPM(
+    "debug-pass-manager", cl::Hidden, cl::ValueOptional,
+    cl::desc("Print pass management debugging information"),
+    cl::init(DebugLogging::None),
+    cl::values(
+        clEnumValN(DebugLogging::Normal, "", ""),
+        clEnumValN(
+            DebugLogging::Verbose, "verbose",
+            "Print extra information about adaptors and pass managers")));
 
 static cl::list<std::string>
     PassPlugins("load-pass-plugin",
                 cl::desc("Load passes from plugin library"));
 
 // This flag specifies a textual description of the alias analysis pipeline to
 // use when querying for aliasing information. It only works in concert with
 // the "passes" flag above.
if (CSPGOKindFlag != NoCSPGO) {
     }
   }
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 
   PassInstrumentationCallbacks PIC;
-  StandardInstrumentations SI(DebugPM, VerifyEachPass);
+  PrintPassOptions PrintPassOpts;
+  PrintPassOpts.Verbose = DebugPM == DebugLogging::Verbose;
+  StandardInstrumentations SI(DebugPM != DebugLogging::None, VerifyEachPass,
+                              PrintPassOpts);
   SI.registerCallbacks(PIC, &FAM);
   DebugifyEachInstrumentation Debugify;
   if (DebugifyEach)
     Debugify.registerCallbacks(PIC);
 
   PipelineTuningOptions PTO;
   // LoopUnrolling defaults on to true and DisableLoopUnrolling is initialized
   // to false above so we shouldn't necessarily need to check whether or not the