[New PM][PassInstrumentation] IR printing support for New Pass Manager

[fedor.sergeev]

Summary

Implementing -print-before-all/-print-after-all/-filter-print-func support
through PassInstrumentation callbacks.

• PrintIR routines implement printing callbacks.

• StandardInstrumentations class provides a central place to manage all the "standard" in-tree pass instrumentations. Currently it registers PrintIR callbacks.

[fedor.sergeev]

switching from IRUnitWrapper to llvm::Any

[fedor.sergeev]

removing Before/After-Analysis callbacks mistakenly added to this commit

[fedor.sergeev]

rebased on top of the changes in D47858

[fedor.sergeev]

rebased on top of base changes. Management of PassInstrumentation object changed.
Now it just staysi locally on the same level as PassBuilder.

[fedor.sergeev]

rebased

[fedor.sergeev]

rebased

[fedor.sergeev]

rebased

[philip.pfaffe]

This implementation is modeled unnecessarily close to the legacy behavior. opt should just manually add the printer instrumentation if a print option is given. In particular., this shouldn't use the ShouldPrint* functions. This way there's no need to involve the PassBuilder API, and you also don't pay for the instrumentation if you don't want to print.

[fedor.sergeev]

In D50923#1235550, @philip.pfaffe wrote:

This implementation is modeled unnecessarily close to the legacy behavior. opt should just manually add the printer instrumentation if a print option is given.
In particular., this shouldn't use the ShouldPrint* functions.

I want all the debugging options to work the same manner whether it is opt or any other tool/way to run the pipeline
(say, in our JIT compiler we do sometimes use -print options). And I want them to work the same way both in legacy and new pass manager.
That means the main controlling interface should better be joined (and thats where ShouldPrint come into play).

This way there's no need to involve the PassBuilder API,

PassBuilder API is there again for an easy setup in tools *like* opt.
Somehow I thought providing a central way to install all the "blessed" callbacks would be adequate, even if right now there is only a single tool that calls it.

and you also don't pay for the instrumentation if you don't want to print.

Callbacks are not installed if printing is not enabled.
And empty instrumentation iteration is a price that we will always pay for simplicity sake. As discussed with Chandler.

[philip.pfaffe]

In D50923#1235572, @fedor.sergeev wrote:

I want all the debugging options to work the same manner whether it is opt or any other tool/way to run the pipeline
(say, in our JIT compiler we do sometimes use -print options). And I want them to work the same way both in legacy and new pass manager.
That means the main controlling interface should better be joined (and thats where ShouldPrint come into play).

Note that I'm not saying we should abandon the -print command line options, just that the ShouldPrint functions are the entirely wrong place to access them. This indirection is simply not necessary anymore.

This way there's no need to involve the PassBuilder API,

PassBuilder API is there again for an easy setup in tools *like* opt.
Somehow I thought providing a central way to install all the "blessed" callbacks would be adequate, even if right now there is only a single tool that calls it.

I understand the motivation. Given my oversight below I don't have very strong feelings about this anymore. Since I suspect this will also house the timing instrumentation registration, that's a stronger argument for this API then.

Callbacks are not installed if printing is not enabled.

You're right, I overlooked that bit.

[fedor.sergeev]

rebased

[fedor.sergeev]

rebased, removed PassBuilder::registerDefaultInstrumentation.
Subsequent patches will add a different way to manage default instrumentations.

[philip.pfaffe]

See my comment to D52329. Analysis isn't the right place for this implementation. This should be part of the Passes library, and even live directly in the StandardInstrumentations implementation.

[fedor.sergeev]

moving PrintIR callbacks into StandardInstrumentations.

[philip.pfaffe]

LGTM, but I wonder why the PIC object is set up and used only in this change. Did we miss that in the change introducing it?

tools/opt/NewPMDriver.cpp

221 ↗

(On Diff #166443)

Why is this part of this particular change?

[fedor.sergeev]

tools/opt/NewPMDriver.cpp

221 ↗

(On Diff #166443)

Our PassInstrumentation wrapper is capable of working with Callbacks == nullptr, and in that case it will essentially be no-op.
This change intends doing something real within default invocations of opt, so it intiializes PassBuilder with nontrivially initialized callbacks and that causes proper PassInstrumentationAnalyses being installed as part of the PassBuilder scrutiny.

llvm/trunk/include/llvm/IR/IRPrintingPasses.h

 ///
 /// The name is surrounded with ""'s and escaped if it has any special or
 /// non-printable characters in it.
 void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name);
 
 /// Return true if a pass is for IR printing.
 bool isIRPrintingPass(Pass *P);
 
+/// isFunctionInPrintList - returns true if a function should be printed via
+//  debugging options like -print-after-all/-print-before-all.
+//  Tells if the function IR should be printed by PrinterPass.
+extern bool isFunctionInPrintList(StringRef FunctionName);
+
+/// forcePrintModuleIR - returns true if IR printing passes should
+//  be printing module IR (even for local-pass printers e.g. function-pass)
+//  to provide more context, as enabled by debugging option -print-module-scope
+//  Tells if IR printer should be printing module IR
+extern bool forcePrintModuleIR();
+
+extern bool shouldPrintBeforePass();
+extern bool shouldPrintBeforePass(StringRef);
+extern bool shouldPrintAfterPass();
+extern bool shouldPrintAfterPass(StringRef);
+
 /// Pass for printing a Module as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
 class PrintModulePass {
   raw_ostream &OS;
   std::string Banner;
   bool ShouldPreserveUseListOrder;

llvm/trunk/include/llvm/Pass.h

protected:
   bool skipBasicBlock(const BasicBlock &BB) const;
 };
 
 /// If the user specifies the -time-passes argument on an LLVM tool command line
 /// then the value of this boolean will be true, otherwise false.
 /// This is the storage for the -time-passes option.
 extern bool TimePassesIsEnabled;
 
-/// isFunctionInPrintList - returns true if a function should be printed via
-//  debugging options like -print-after-all/-print-before-all.
-//  Tells if the function IR should be printed by PrinterPass.
-extern bool isFunctionInPrintList(StringRef FunctionName);
-
-/// forcePrintModuleIR - returns true if IR printing passes should
-//  be printing module IR (even for local-pass printers e.g. function-pass)
-//  to provide more context, as enabled by debugging option -print-module-scope
-//  Tells if IR printer should be printing module IR
-extern bool forcePrintModuleIR();
-
 } // end namespace llvm
 
 // Include support files that contain important APIs commonly used by Passes,
 // but that we want to separate out to make it easier to read the header files.
 #include "llvm/InitializePasses.h"
 #include "llvm/PassAnalysisSupport.h"
 #include "llvm/PassSupport.h"
 
 #endif // LLVM_PASS_H

llvm/trunk/include/llvm/Passes/StandardInstrumentations.h

+//===- StandardInstrumentations.h ------------------------------*- C++ -*--===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This header defines a class that provides bookkeeping for all standard
+/// (i.e in-tree) pass instrumentations.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PASSES_STANDARDINSTRUMENTATIONS_H
+#define LLVM_PASSES_STANDARDINSTRUMENTATIONS_H
+
+#include "llvm/IR/PassInstrumentation.h"
+
+namespace llvm {
+
+/// This class provides an interface to register all the standard pass
+/// instrumentations and manages their state (if any).
+class StandardInstrumentations {
+  // for now we do not have instrumentations with state
+public:
+  StandardInstrumentations() = default;
+
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+};
+} // namespace llvm
+
+#endif

llvm/trunk/lib/Analysis/CallGraphSCCPass.cpp

 
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManagers.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/IR/PassTimingInfo.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"

llvm/trunk/lib/Analysis/LoopInfo.cpp

 #include "llvm/Analysis/LoopInfoImpl.h"
 #include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>

llvm/trunk/lib/CodeGen/MachineFunctionPrinterPass.cpp

 // MachineFunctionPrinterPass implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 namespace {
 /// MachineFunctionPrinterPass - This is a pass to dump the IR of a
 /// MachineFunction.

llvm/trunk/lib/IR/LegacyPassManager.cpp

PrintFuncsList("filter-print-funcs", cl::value_desc("function names"),
                    cl::desc("Only print IR for functions whose name "
                             "match this for all print-[before|after][-all] "
                             "options"),
                    cl::CommaSeparated, cl::Hidden);
 
 /// This is a helper to determine whether to print IR before or
 /// after a pass.
 
-static bool ShouldPrintBeforeOrAfterPass(const PassInfo *PI,
+bool llvm::shouldPrintBeforePass() {
+  return PrintBeforeAll || !PrintBefore.empty();
+}
+
+bool llvm::shouldPrintAfterPass() {
+  return PrintAfterAll || !PrintAfter.empty();
+}
+
+static bool ShouldPrintBeforeOrAfterPass(StringRef PassID,
                                          PassOptionList &PassesToPrint) {
   for (auto *PassInf : PassesToPrint) {
     if (PassInf)
-      if (PassInf->getPassArgument() == PI->getPassArgument()) {
+      if (PassInf->getPassArgument() == PassID) {
         return true;
       }
   }
   return false;
 }
 
-/// This is a utility to check whether a pass should have IR dumped
-/// before it.
-static bool ShouldPrintBeforePass(const PassInfo *PI) {
-  return PrintBeforeAll || ShouldPrintBeforeOrAfterPass(PI, PrintBefore);
+bool llvm::shouldPrintBeforePass(StringRef PassID) {
+  return PrintBeforeAll || ShouldPrintBeforeOrAfterPass(PassID, PrintBefore);
 }
 
-/// This is a utility to check whether a pass should have IR dumped
-/// after it.
-static bool ShouldPrintAfterPass(const PassInfo *PI) {
-  return PrintAfterAll || ShouldPrintBeforeOrAfterPass(PI, PrintAfter);
+bool llvm::shouldPrintAfterPass(StringRef PassID) {
+  return PrintAfterAll || ShouldPrintBeforeOrAfterPass(PassID, PrintAfter);
 }
 
 bool llvm::forcePrintModuleIR() { return PrintModuleScope; }
 
 bool llvm::isFunctionInPrintList(StringRef FunctionName) {
   static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(),
                                                         PrintFuncsList.end());
   return PrintFuncNames.empty() || PrintFuncNames.count(FunctionName);
if (ImmutablePass *IP = P->getAsImmutablePass()) {
     AnalysisResolver *AR = new AnalysisResolver(*DM);
     P->setResolver(AR);
     DM->initializeAnalysisImpl(P);
     addImmutablePass(IP);
     DM->recordAvailableAnalysis(IP);
     return;
   }
 
-  if (PI && !PI->isAnalysis() && ShouldPrintBeforePass(PI)) {
+  if (PI && !PI->isAnalysis() && shouldPrintBeforePass(PI->getPassArgument())) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump Before " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
 
   // Add the requested pass to the best available pass manager.
   P->assignPassManager(activeStack, getTopLevelPassManagerType());
 
-  if (PI && !PI->isAnalysis() && ShouldPrintAfterPass(PI)) {
+  if (PI && !PI->isAnalysis() && shouldPrintAfterPass(PI->getPassArgument())) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump After " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
 }
 
 /// Find the pass that implements Analysis AID. Search immutable
 /// passes and all pass managers. If desired pass is not found

llvm/trunk/lib/Passes/CMakeLists.txt

 if (MSVC)
   set_source_files_properties(PassBuilder.cpp PROPERTIES COMPILE_FLAGS /bigobj)
 endif()
 
 add_llvm_library(LLVMPasses
   PassBuilder.cpp
   PassPlugin.cpp
+  StandardInstrumentations.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Passes
 
   DEPENDS
   intrinsics_gen
   )

llvm/trunk/lib/Passes/StandardInstrumentations.cpp

+//===- Standard pass instrumentations handling ----------------*- C++ -*--===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines IR-printing pass instrumentation callbacks as well as
+/// StandardInstrumentations class that manages standard pass instrumentations.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Passes/StandardInstrumentations.h"
+#include "llvm/Analysis/CallGraphSCCPass.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRPrintingPasses.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassInstrumentation.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+namespace {
+namespace PrintIR {
+
+//===----------------------------------------------------------------------===//
+// IR-printing instrumentation
+//===----------------------------------------------------------------------===//
+
+/// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
+/// llvm::Any and does actual print job.
+void unwrapAndPrint(StringRef Banner, Any IR) {
+  if (any_isa<const CallGraphSCC *>(IR) ||
+      any_isa<const LazyCallGraph::SCC *>(IR))
+    return;
+
+  SmallString<40> Extra{"\n"};
+  const Module *M = nullptr;
+  if (any_isa<const Module *>(IR)) {
+    M = any_cast<const Module *>(IR);
+  } else if (any_isa<const Function *>(IR)) {
+    const Function *F = any_cast<const Function *>(IR);
+    if (!llvm::isFunctionInPrintList(F->getName()))
+      return;
+    if (!llvm::forcePrintModuleIR()) {
+      dbgs() << Banner << Extra << static_cast<const Value &>(*F);
+      return;
+    }
+    M = F->getParent();
+    Extra = formatv(" (function: {0})\n", F->getName());
+  } else if (any_isa<const Loop *>(IR)) {
+    const Loop *L = any_cast<const Loop *>(IR);
+    const Function *F = L->getHeader()->getParent();
+    if (!isFunctionInPrintList(F->getName()))
+      return;
+    if (!llvm::forcePrintModuleIR()) {
+      llvm::printLoop(const_cast<Loop &>(*L), dbgs(), Banner);
+      return;
+    }
+    M = F->getParent();
+    {
+      std::string LoopName;
+      raw_string_ostream ss(LoopName);
+      L->getHeader()->printAsOperand(ss, false);
+      Extra = formatv(" (loop: {0})\n", ss.str());
+    }
+  }
+  if (M) {
+    dbgs() << Banner << Extra;
+    M->print(dbgs(), nullptr, false);
+  } else {
+    llvm_unreachable("Unknown wrapped IR type");
+  }
+}
+
+bool printBeforePass(StringRef PassID, Any IR) {
+  if (!llvm::shouldPrintBeforePass(PassID))
+    return true;
+
+  if (PassID.startswith("PassManager<") || PassID.contains("PassAdaptor<"))
+    return true;
+
+  SmallString<20> Banner = formatv("*** IR Dump Before {0} ***", PassID);
+  unwrapAndPrint(Banner, IR);
+  return true;
+}
+
+void printAfterPass(StringRef PassID, Any IR) {
+  if (!llvm::shouldPrintAfterPass(PassID))
+    return;
+
+  if (PassID.startswith("PassManager<") || PassID.contains("PassAdaptor<"))
+    return;
+
+  SmallString<20> Banner = formatv("*** IR Dump After {0} ***", PassID);
+  unwrapAndPrint(Banner, IR);
+  return;
+}
+} // namespace PrintIR
+} // namespace
+
+void StandardInstrumentations::registerCallbacks(
+    PassInstrumentationCallbacks &PIC) {
+  if (llvm::shouldPrintBeforePass())
+    PIC.registerBeforePassCallback(PrintIR::printBeforePass);
+  if (llvm::shouldPrintAfterPass())
+    PIC.registerAfterPassCallback(PrintIR::printAfterPass);
+}

llvm/trunk/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:     | 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:     | 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:     | FileCheck %s -check-prefix=FOO-MODULE
 
-; DEL:      IR Dump Before
-; DEL-SAME: dead loops
+; DEL:      IR Dump Before {{Delete dead loops|LoopDeletionPass}}
 ; DEL:      ; Preheader:
 ; DEL-NEXT:  %idx = alloca i32, align 4
 ; DEL:      ; Loop:
 ; DEL-NEXT:  loop:
 ; DEL:       cont:
 ; DEL:      ; Exit blocks
 ; DEL:       done:
-; DEL:      IR Dump Before
-; DEL-SAME: dead loops
+; DEL:      IR Dump Before {{Delete dead loops|LoopDeletionPass}}
 ; DEL:      ; Preheader:
 ; DEL-NEXT:  br label %loop
 ; DEL:      ; Loop:
 ; DEL-NEXT:  loop:
 ; DEL:      ; Exit blocks
 ; DEL:       end:
 
-; BAR:      IR Dump After
-; BAR-SAME: Unroll
+; BAR:      IR Dump After {{Unroll|LoopFullUnrollPass}}
 ; BAR:      ; Preheader:
 ; BAR-NEXT:  br label %loop
 ; BAR:      ; Loop:
 ; BAR-NEXT:  loop:
 ; BAR:      ; Exit blocks
 ; BAR:       end:
-; BAR-NOT: IR Dump
-; BAR-NOT:  ; Loop
+; BAR-OLD-NOT: IR Dump
+; BAR-OLD-NOT:  ; Loop
 
-; FOO-MODULE: IR Dump After
-; FOO-MODULE-SAME: Unroll
+; FOO-MODULE: IR Dump After {{Unroll|LoopFullUnrollPass}}
 ; FOO-MODULE-SAME: loop: %loop
 ; FOO-MODULE-NEXT: ModuleID =
 ; FOO-MODULE: define void @foo
 ; FOO-MODULE: define void @bar
-; FOO-MODULE-NOT: IR Dump
+; FOO-MODULE-OLD-NOT: IR Dump
 
 define void @foo(){
   %idx = alloca i32, align 4
   store i32 0, i32* %idx, align 4
   br label %loop
 
 loop:
   %1 = load i32, i32* %idx, align 4

llvm/trunk/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:     | 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:     | FileCheck %s -check-prefix=FOO
 
-; CFG:      IR Dump After
+; 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
 ; CFG: IR Dump After
 ; CFG-SAME:   function: bar
 ; CFG-NEXT: ModuleID =
 ; CFG: define void @foo
 ; CFG: define void @bar
 ; CFG: declare void @baz
 
-; FOO:      IR Dump After
+; FOO:      IR Dump After {{Simplify the CFG|SimplifyCFGPass}}
 ; FOO-NOT:    function: bar
 ; FOO-SAME:   function: foo
 ; FOO-NEXT: ModuleID =
 ; FOO:   Function Attrs: nounwind ssp
 ; FOO: define void @foo
 ; FOO:   Function Attrs: nounwind
 ; FOO: define void @bar
 ; FOO:   Function Attrs: nounwind readnone ssp

 
 attributes #0 = { nounwind "no-frame-pointer-elim"="true" }
 
 attributes #1 = { nounwind readnone ssp "use-soft-float"="false" }
 ; FOO: attributes #{{[0-9]}} = { nounwind "no-frame-pointer-elim"="true" }
 
 ; FOO: attributes #{{[0-9]}} = { nounwind readnone ssp "use-soft-float"="false" }
 
-; FOO-NOT: IR Dump
+; FOO-NOT: IR Dump After {{Simplify the CFG|SimplifyCFGPass}}

llvm/trunk/test/Other/printer.ll

-; RUN: opt -mem2reg -instcombine -print-after-all -S < %s 2>&1 | FileCheck %s
+; RUN: opt -mem2reg -instcombine -print-after-all -disable-output < %s 2>&1 | FileCheck %s
+; RUN: opt -passes='mem2reg,instcombine' -print-after-all -disable-output < %s 2>&1 | FileCheck %s
 define void @tester(){
   ret void
 }
 
 define void @foo(){
   ret void
 }
 
-;CHECK: IR Dump After Promote Memory to Register
-;CHECK: IR Dump After Combine redundant instructions
-;CHECK: IR Dump After Module Verifier
+;CHECK-NOT: IR Dump After PassManager
+;CHECK-NOT: IR Dump After ModuleToFunctionPassAdaptor
+;
+;CHECK:     *** IR Dump After {{Promote Memory to Register|PromotePass}}
+;CHECK:     define void @tester
+;CHECK-NOT: define void @foo
+;CHECK:     *** IR Dump After {{Combine redundant instructions|InstCombinePass}}
+;CHECK:     define void @tester
+;CHECK-NOT: define void @foo
+;CHECK:     *** IR Dump After {{Promote Memory to Register|PromotePass}}
+;CHECK:     define void @foo
+;CHECK-NOT: define void @tester
+;CHECK:     *** IR Dump After {{Combine redundant instructions|InstCombinePass}}
+;CHECK:     define void @foo
+;CHECK-NOT: define void @tester
+;CHECK:     *** IR Dump After {{Module Verifier|VerifierPass}}
+;
 ;CHECK-NOT: IR Dump After Print Module IR

llvm/trunk/tools/opt/NewPMDriver.cpp

 //===- NewPMDriver.cpp - Driver for opt with new PM -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file is just a split of the code that logically belongs in opt.cpp but
 /// that includes the new pass manager headers.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "Debugify.h"
 #include "NewPMDriver.h"
+#include "Debugify.h"
 #include "PassPrinters.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
+#include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 using namespace llvm;
case SampleUse:
       P = PGOOptions("", "", ProfileFile, false);
       break;
     case NoPGO:
       if (DebugInfoForProfiling)
         P = PGOOptions("", "", "", false, true);
       else
         P = None;
   }
-  PassBuilder PB(TM, P);
+  PassInstrumentationCallbacks PIC;
+  StandardInstrumentations SI;
+  SI.registerCallbacks(PIC);
+
+  PassBuilder PB(TM, P, &PIC);
   registerEPCallbacks(PB, VerifyEachPass, DebugPM);
 
   // Load requested pass plugins and let them register pass builder callbacks
   for (auto &PluginFN : PassPlugins) {
     auto PassPlugin = PassPlugin::Load(PluginFN);
     if (!PassPlugin) {
       errs() << "Failed to load passes from '" << PluginFN
              << "'. Request ignored.\n";