[NewPM] Cleanup IR printing instrumentation

[aeubanks]

Summary

Being lazy with printing the banner seems hard to reason with, we should print it
unconditionally first (it could also lead to duplicate banners if we
have multiple functions in -filter-print-funcs).

The printIR() functions were doing too many things. I separated out the
call from PrintPassInstrumentation since we were essentially doing two
completely separate things in printIR() from different callers.

There were multiple ways to generate the name of some IR. That's all
been moved to getIRName(). The printing of the IR name was also
inconsistent, now it's always "IR Dump on $foo" where "$foo" is the
name. For a function, it's the function name. For a loop, it's what's
printed by Loop::print(), which is more detailed. For an SCC, it's the
list of functions in parentheses. For a module it's "[module]", to
differentiate between a possible SCC with a function called "module".

To preserve D74814, we have to check if we're going to print anything at
all first. This is unfortunate, but I would consider this a special
case that shouldn't be handled in the core logic.

[aeubanks]

rebase, major overhaul

[aeubanks]

more changes

[aeubanks]

test fixes

[jamieschmeiser]

Thanks for doing this. There are a couple of comments/asserts that were missed...The only real thing is that the functionality of unwrapping Any is repeated many times... perhaps a function taking lambdas for what to do with each type of IR would be useful, probably in the header with Any? WDYT?

llvm/lib/Passes/StandardInstrumentations.cpp

196

Remove second sentence of this comment. It is no longer valid.

218

"made a pair" => "a Module"

222

This could be changed to an assert and then the llvm_unreachable can be removed.

280

Again, assert this and remove llvm_unreachable.

323

Asert and remove llvm_unreachable.

362

Assert and remove the llvm_unreachable. The basic form of this function appears 4 or 5 times...would it make sense to have a function taking lambdas for the varying actions (in this case, calling printIR) to common up the unpacking logic associated with Any?

[aeubanks]

address comments

[aeubanks]

I'm not sure that having a helper method with 4 lambdas is any cleaner. Normal control flow in a function is easier to read and understand, and not really that much more code.

llvm/lib/Passes/StandardInstrumentations.cpp

222

I kinda prefer the symmetry.

[jamieschmeiser]

LGTM

llvm/include/llvm/Analysis/LoopInfo.h

#endif
 
   /// Returns true if the loop is annotated parallel.
   ///
   /// Derived classes can override this method using static template
   /// polymorphism.
   bool isAnnotatedParallel() const { return false; }
 
   /// Print loop with all the BBs inside it.
-  void print(raw_ostream &OS, unsigned Depth = 0, bool Verbose = false) const;
+  void print(raw_ostream &OS, bool Verbose = false, bool PrintNested = true,
+             unsigned Depth = 0) const;
 
 protected:
   friend class LoopInfoBase<BlockT, LoopT>;
 
   /// This creates an empty loop.
   LoopBase() : ParentLoop(nullptr) {}
 
   explicit LoopBase(BlockT *BB) : ParentLoop(nullptr) {

llvm/include/llvm/Analysis/LoopInfoImpl.h

void LoopBase<BlockT, LoopT>::verifyLoopNest(
   // Verify this loop.
   verifyLoop();
   // Verify the subloops.
   for (iterator I = begin(), E = end(); I != E; ++I)
     (*I)->verifyLoopNest(Loops);
 }
 
 template <class BlockT, class LoopT>
-void LoopBase<BlockT, LoopT>::print(raw_ostream &OS, unsigned Depth,
-                                    bool Verbose) const {
+void LoopBase<BlockT, LoopT>::print(raw_ostream &OS, bool Verbose,
+                                    bool PrintNested, unsigned Depth) const {
   OS.indent(Depth * 2);
   if (static_cast<const LoopT *>(this)->isAnnotatedParallel())
     OS << "Parallel ";
   OS << "Loop at depth " << getLoopDepth() << " containing: ";
 
   BlockT *H = getHeader();
   for (unsigned i = 0; i < getBlocks().size(); ++i) {
     BlockT *BB = getBlocks()[i];
     if (!Verbose) {
       if (i)
         OS << ",";
       BB->printAsOperand(OS, false);
     } else
       OS << "\n";
 
     if (BB == H)
       OS << "<header>";
     if (isLoopLatch(BB))
       OS << "<latch>";
     if (isLoopExiting(BB))
       OS << "<exiting>";
     if (Verbose)
       BB->print(OS);
   }
+
+  if (PrintNested) {
     OS << "\n";
 
     for (iterator I = begin(), E = end(); I != E; ++I)
-    (*I)->print(OS, Depth + 2);
+      (*I)->print(OS, /*Verbose*/ false, PrintNested, Depth + 2);
+  }
 }
 
 //===----------------------------------------------------------------------===//
 /// Stable LoopInfo Analysis - Build a loop tree using stable iterators so the
 /// result does / not depend on use list (block predecessor) order.
 ///
 
 /// Discover a subloop with the specified backedges such that: All blocks within

llvm/lib/Analysis/LoopInfo.cpp

Loop::LocRange Loop::getLocRange() const {
 
   return LocRange();
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Loop::dump() const { print(dbgs()); }
 
 LLVM_DUMP_METHOD void Loop::dumpVerbose() const {
-  print(dbgs(), /*Depth=*/0, /*Verbose=*/true);
+  print(dbgs(), /*Verbose=*/true);
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // UnloopUpdater implementation
 //
 
 namespace {

llvm/lib/Passes/StandardInstrumentations.cpp

std::string doSystemDiff(StringRef Before, StringRef After,
   for (unsigned I = 0; I < NumFiles; ++I) {
     std::error_code EC = sys::fs::remove(FileName[I]);
     if (EC)
       return "Unable to remove temporary file.";
   }
   return Diff;
 }
 
 /// Extracting Module out of \p IR unit. Also fills a textual description
 /// of \p IR for use in header when printing.
-Optional<std::pair<const Module *, std::string>>
-unwrapModule(Any IR, bool Force = false) {
+const Module *unwrapModule(Any IR, bool Force = false) {
   if (any_isa<const Module *>(IR))
-    return std::make_pair(any_cast<const Module *>(IR), std::string());
+    return any_cast<const Module *>(IR);
 
   if (any_isa<const Function *>(IR)) {
     const Function *F = any_cast<const Function *>(IR);
     if (!Force && !isFunctionInPrintList(F->getName()))
-      return None;
+      return nullptr;
 
-    const Module *M = F->getParent();
-    return std::make_pair(M, formatv(" (function: {0})", F->getName()).str());
+    return F->getParent();
   }
 
   if (any_isa<const LazyCallGraph::SCC *>(IR)) {
     const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
     for (const LazyCallGraph::Node &N : *C) {
       const Function &F = N.getFunction();
       if (Force || (!F.isDeclaration() && isFunctionInPrintList(F.getName()))) {
-        const Module *M = F.getParent();
-        return std::make_pair(M, formatv(" (scc: {0})", C->getName()).str());
+        return F.getParent();
       }
     }
     assert(!Force && "Expected to have made a pair when forced.");
-    return None;
+    return nullptr;
   }
 
   if (any_isa<const Loop *>(IR)) {
     const Loop *L = any_cast<const Loop *>(IR);
     const Function *F = L->getHeader()->getParent();
     if (!Force && !isFunctionInPrintList(F->getName()))
-      return None;
-    const Module *M = F->getParent();
-    std::string LoopName;
-    raw_string_ostream ss(LoopName);
-    L->getHeader()->printAsOperand(ss, false);
-    return std::make_pair(M, formatv(" (loop: {0})", ss.str()).str());
+      return nullptr;
+    return F->getParent();
   }
 
   llvm_unreachable("Unknown IR unit");
 }
 
-void printIR(raw_ostream &OS, const Function *F, StringRef Banner,
-             StringRef Extra = StringRef(), bool Brief = false) {
-  if (Brief) {
-    OS << F->getName() << '\n';
-    return;
-  }
-
+void printIR(raw_ostream &OS, const Function *F) {
   if (!isFunctionInPrintList(F->getName()))
     return;
-  OS << Banner << Extra << "\n" << static_cast<const Value &>(*F);
+  OS << *F;
 }
 
-void printIR(raw_ostream &OS, const Module *M, StringRef Banner,
-             StringRef Extra = StringRef(), bool Brief = false,
+void printIR(raw_ostream &OS, const Module *M,
              bool ShouldPreserveUseListOrder = false) {
-  if (Brief) {
-    OS << M->getName() << '\n';
-    return;
-  }
-
   if (isFunctionInPrintList("*") || forcePrintModuleIR()) {
-    OS << Banner << Extra << "\n";
     M->print(OS, nullptr, ShouldPreserveUseListOrder);
   } else {
     for (const auto &F : M->functions()) {
-      printIR(OS, &F, Banner, Extra);
+      printIR(OS, &F);
     }
   }
 }
 
-void printIR(raw_ostream &OS, const LazyCallGraph::SCC *C, StringRef Banner,
-             StringRef Extra = StringRef(), bool Brief = false) {
-  if (Brief) {
-    OS << *C << '\n';
-    return;
-  }
-
-  bool BannerPrinted = false;
+void printIR(raw_ostream &OS, const LazyCallGraph::SCC *C) {
   for (const LazyCallGraph::Node &N : *C) {
     const Function &F = N.getFunction();
     if (!F.isDeclaration() && isFunctionInPrintList(F.getName())) {
-      if (!BannerPrinted) {
-        OS << Banner << Extra << "\n";
-        BannerPrinted = true;
-      }
       F.print(OS);
     }
   }
 }
 
-void printIR(raw_ostream &OS, const Loop *L, StringRef Banner,
-             bool Brief = false) {
-  if (Brief) {
-    OS << *L;
-    return;
-  }
-
+void printIR(raw_ostream &OS, const Loop *L) {
   const Function *F = L->getHeader()->getParent();
   if (!isFunctionInPrintList(F->getName()))
     return;
-  printLoop(const_cast<Loop &>(*L), OS, std::string(Banner));
+  printLoop(const_cast<Loop &>(*L), OS);
+}
+
+std::string getIRName(Any IR) {
+  if (any_isa<const Module *>(IR))
+    return "[module]";
+
+  if (any_isa<const Function *>(IR)) {
+    const Function *F = any_cast<const Function *>(IR);
+    return F->getName().str();
+  }
+
+  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
+    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
+    return C->getName();
+  }
+
+  if (any_isa<const Loop *>(IR)) {
+    const Loop *L = any_cast<const Loop *>(IR);
+    std::string S;
+    raw_string_ostream OS(S);
+    L->print(OS, /*Verbose*/ false, /*PrintNested*/ false);
+    return OS.str();
+  }
+
+  llvm_unreachable("Unknown wrapped IR type");
+}
+
+bool moduleContainsFilterPrintFunc(const Module &M) {
+  return any_of(M.functions(),
+                [](const Function &F) {
+                  return isFunctionInPrintList(F.getName());
+                }) ||
+         isFunctionInPrintList("*");
+}
+
+bool sccContainsFilterPrintFunc(const LazyCallGraph::SCC &C) {
+  return any_of(C,
+                [](const LazyCallGraph::Node &N) {
+                  return isFunctionInPrintList(N.getName());
+                }) ||
+         isFunctionInPrintList("*");
+}
+
+bool shouldPrintIR(Any IR) {
+  if (any_isa<const Module *>(IR)) {
+    const Module *M = any_cast<const Module *>(IR);
+    return moduleContainsFilterPrintFunc(*M);
+  }
+
+  if (any_isa<const Function *>(IR)) {
+    const Function *F = any_cast<const Function *>(IR);
+    return isFunctionInPrintList(F->getName());
+  }
+
+  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
+    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
+    return sccContainsFilterPrintFunc(*C);
+  }
+
+  if (any_isa<const Loop *>(IR)) {
+    const Loop *L = any_cast<const Loop *>(IR);
+    return isFunctionInPrintList(L->getHeader()->getParent()->getName());
+  }
+  llvm_unreachable("Unknown wrapped IR type");
 }
 
 /// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
 /// llvm::Any and does actual print job.
-void unwrapAndPrint(raw_ostream &OS, Any IR, StringRef Banner,
-                    bool ForceModule = false, bool Brief = false,
+void unwrapAndPrint(raw_ostream &OS, Any IR,
                     bool ShouldPreserveUseListOrder = false) {
-  if (ForceModule) {
-    if (auto UnwrappedModule = unwrapModule(IR))
-      printIR(OS, UnwrappedModule->first, Banner, UnwrappedModule->second,
-              Brief, ShouldPreserveUseListOrder);
+  if (!shouldPrintIR(IR))
+    return;
+
+  if (forcePrintModuleIR()) {
+    auto *M = unwrapModule(IR);
+    assert(M && "should have unwrapped module");
+    printIR(OS, M, ShouldPreserveUseListOrder);
     return;
   }
 
   if (any_isa<const Module *>(IR)) {
     const Module *M = any_cast<const Module *>(IR);
-    assert(M && "module should be valid for printing");
-    printIR(OS, M, Banner, "", Brief, ShouldPreserveUseListOrder);
+    printIR(OS, M, ShouldPreserveUseListOrder);
     return;
   }
 
   if (any_isa<const Function *>(IR)) {
     const Function *F = any_cast<const Function *>(IR);
-    assert(F && "function should be valid for printing");
-    printIR(OS, F, Banner, "", Brief);
+    printIR(OS, F);
     return;
   }
 
   if (any_isa<const LazyCallGraph::SCC *>(IR)) {
     const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
-    assert(C && "scc should be valid for printing");
-    std::string Extra = std::string(formatv(" (scc: {0})", C->getName()));
-    printIR(OS, C, Banner, Extra, Brief);
+    printIR(OS, C);
     return;
   }
 
   if (any_isa<const Loop *>(IR)) {
     const Loop *L = any_cast<const Loop *>(IR);
-    assert(L && "Loop should be valid for printing");
-    printIR(OS, L, Banner, Brief);
+    printIR(OS, L);
     return;
   }
   llvm_unreachable("Unknown wrapped IR type");
 }
 
 // Return true when this is a pass for which changes should be ignored
 bool isIgnored(StringRef PassID) {
   return isSpecialPass(PassID,
void ChangeReporter<IRUnitT>::saveIRBeforePass(Any IR, StringRef PassID) {
   // Save the IR representation on the stack.
   IRUnitT &Data = BeforeStack.back();
   generateIRRepresentation(IR, PassID, Data);
 }
 
 template <typename IRUnitT>
 void ChangeReporter<IRUnitT>::handleIRAfterPass(Any IR, StringRef PassID) {
   assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
-  std::string Name;
 
-  // unwrapModule has inconsistent handling of names for function IRs.
-  if (any_isa<const Function *>(IR)) {
-    const Function *F = any_cast<const Function *>(IR);
-    Name = formatv(" (function: {0})", F->getName()).str();
-  } else {
-    if (auto UM = unwrapModule(IR))
-      Name = UM->second;
-  }
-  if (Name == "")
-    Name = " (module)";
+  std::string Name = getIRName(IR);
 
   if (isIgnored(PassID)) {
     if (VerboseMode)
       handleIgnored(PassID, Name);
   } else if (!isInteresting(IR, PassID)) {
     if (VerboseMode)
       handleFiltered(PassID, Name);
   } else {

 template <typename IRUnitT>
 TextChangeReporter<IRUnitT>::TextChangeReporter(bool Verbose)
     : ChangeReporter<IRUnitT>(Verbose), Out(dbgs()) {}
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::handleInitialIR(Any IR) {
   // Always print the module.
   // Unwrap and print directly to avoid filtering problems in general routines.
-  auto UnwrappedModule = unwrapModule(IR, /*Force=*/true);
-  assert(UnwrappedModule && "Expected module to be unwrapped when forced.");
-  Out << "*** IR Dump At Start: ***" << UnwrappedModule->second << "\n";
-  UnwrappedModule->first->print(Out, nullptr,
-                                /*ShouldPreserveUseListOrder=*/true);
+  auto *M = unwrapModule(IR, /*Force=*/true);
+  assert(M && "Expected module to be unwrapped when forced.");
+  Out << "*** IR Dump At Start ***\n";
+  M->print(Out, nullptr,
 }
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::omitAfter(StringRef PassID,
                                             std::string &Name) {
-  Out << formatv("*** IR Dump After {0}{1} omitted because no change ***\n",
+  Out << formatv("*** IR Dump After {0} on {1} omitted because no change ***\n",
                  PassID, Name);
 }
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::handleInvalidated(StringRef PassID) {
   Out << formatv("*** IR Pass {0} invalidated ***\n", PassID);
 }
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::handleFiltered(StringRef PassID,
                                                  std::string &Name) {
   SmallString<20> Banner =
-      formatv("*** IR Dump After {0}{1} filtered out ***\n", PassID, Name);
+      formatv("*** IR Dump After {0} on {1} filtered out ***\n", PassID, Name);
   Out << Banner;
 }
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::handleIgnored(StringRef PassID,
                                                 std::string &Name) {
-  Out << formatv("*** IR Pass {0}{1} ignored ***\n", PassID, Name);
+  Out << formatv("*** IR Pass {0} on {1} ignored ***\n", PassID, Name);
 }
 
 IRChangedPrinter::~IRChangedPrinter() {}
 
 void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::PrintChangedVerbose ||
       PrintChanged == ChangePrinter::PrintChangedQuiet)
     TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
 }
 
 void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
                                                 std::string &Output) {
   raw_string_ostream OS(Output);
-  // use the after banner for all cases so it will match
-  SmallString<20> Banner = formatv("*** IR Dump After {0} ***", PassID);
-  unwrapAndPrint(OS, IR, Banner, forcePrintModuleIR(),
-                 /*Brief=*/false, /*ShouldPreserveUseListOrder=*/true);
-
+  unwrapAndPrint(OS, IR,
+                 /*ShouldPreserveUseListOrder=*/true);
   OS.str();
 }
 
 void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
                                    const std::string &Before,
                                    const std::string &After, Any) {
+  // Report the IR before the changes when requested.
+  if (PrintChangedBefore)
+    Out << "*** IR Dump Before " << PassID << " on " << Name << " ***\n"
+        << Before;
+
   // We might not get anything to print if we only want to print a specific
   // function but it gets deleted.
   if (After.empty()) {
-    Out << "*** IR Deleted After " << PassID << Name << " ***\n";
+    Out << "*** IR Deleted After " << PassID << " on " << Name << " ***\n";
     return;
   }
 
-  assert(After.find("*** IR Dump") == 0 && "Unexpected banner format.");
-  StringRef AfterRef = After;
-  StringRef Banner =
-      AfterRef.take_until([](char C) -> bool { return C == '\n'; });
-
-  // Report the IR before the changes when requested.
-  if (PrintChangedBefore) {
-    Out << "*** IR Dump Before" << Banner.substr(17);
-    // LazyCallGraph::SCC already has "(scc:..." in banner so only add
-    // in the name if it isn't already there.
-    if (Name.substr(0, 6) != " (scc:" && !forcePrintModuleIR())
-      Out << Name;
-
-    StringRef BeforeRef = Before;
-    Out << BeforeRef.substr(Banner.size());
-  }
-
-  Out << Banner;
-
-  // LazyCallGraph::SCC already has "(scc:..." in banner so only add
-  // in the name if it isn't already there.
-  if (Name.substr(0, 6) != " (scc:" && !forcePrintModuleIR())
-    Out << Name;
-
-  Out << After.substr(Banner.size());
+  Out << "*** IR Dump After " << PassID << " on " << Name << " ***\n" << After;
 }
 
 bool IRChangedPrinter::same(const std::string &S1, const std::string &S2) {
   return S1 == S2;
 }
 
 template <typename IRData>
 void OrderedChangedData<IRData>::report(

 }
 
 PrintIRInstrumentation::~PrintIRInstrumentation() {
   assert(ModuleDescStack.empty() && "ModuleDescStack is not empty at exit");
 }
 
 void PrintIRInstrumentation::pushModuleDesc(StringRef PassID, Any IR) {
   assert(StoreModuleDesc);
-  const Module *M = nullptr;
-  std::string Extra;
-  if (auto UnwrappedModule = unwrapModule(IR))
-    std::tie(M, Extra) = UnwrappedModule.getValue();
-  ModuleDescStack.emplace_back(M, Extra, PassID);
+  const Module *M = unwrapModule(IR);
+  ModuleDescStack.emplace_back(M, getIRName(IR), PassID);
 }
 
 PrintIRInstrumentation::PrintModuleDesc
 PrintIRInstrumentation::popModuleDesc(StringRef PassID) {
   assert(!ModuleDescStack.empty() && "empty ModuleDescStack");
   PrintModuleDesc ModuleDesc = ModuleDescStack.pop_back_val();
   assert(std::get<2>(ModuleDesc).equals(PassID) && "malformed ModuleDescStack");
   return ModuleDesc;
 }
 
 void PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
   if (isIgnored(PassID))
     return;
 
   // Saving Module for AfterPassInvalidated operations.
   // Note: here we rely on a fact that we do not change modules while
   // traversing the pipeline, so the latest captured module is good
   // for all print operations that has not happen yet.
   if (StoreModuleDesc && shouldPrintAfterPass(PassID))
     pushModuleDesc(PassID, IR);
 
   if (!shouldPrintBeforePass(PassID))
     return;
 
-  SmallString<20> Banner = formatv("*** IR Dump Before {0} ***", PassID);
-  unwrapAndPrint(dbgs(), IR, Banner, forcePrintModuleIR());
+  if (!shouldPrintIR(IR))
+    return;
+
+  dbgs() << "*** IR Dump Before " << PassID << " on " << getIRName(IR)
+         << " ***\n";
+  unwrapAndPrint(dbgs(), IR);
 }
 
 void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
   if (isIgnored(PassID))
     return;
 
   if (!shouldPrintAfterPass(PassID))
     return;
 
-  if (StoreModuleDesc)
-    popModuleDesc(PassID);
+  if (StoreModuleDesc) {
+    const Module *M;
+    std::string IRName;
+    StringRef StoredPassID;
+    std::tie(M, IRName, StoredPassID) = popModuleDesc(PassID);
+    assert(StoredPassID == PassID && "mismatched PassID");
+  }
+
+  if (!shouldPrintIR(IR))
+    return;
 
-  SmallString<20> Banner = formatv("*** IR Dump After {0} ***", PassID);
-  unwrapAndPrint(dbgs(), IR, Banner, forcePrintModuleIR());
+  dbgs() << "*** IR Dump After " << PassID << " on " << getIRName(IR)
+         << " ***\n";
+  unwrapAndPrint(dbgs(), IR);
 }
 
 void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
   StringRef PassName = PIC->getPassNameForClassName(PassID);
   if (!StoreModuleDesc || !shouldPrintAfterPass(PassName))
     return;
 
   if (isIgnored(PassID))
     return;
 
   const Module *M;
-  std::string Extra;
+  std::string IRName;
   StringRef StoredPassID;
-  std::tie(M, Extra, StoredPassID) = popModuleDesc(PassID);
+  std::tie(M, IRName, StoredPassID) = popModuleDesc(PassID);
+  assert(StoredPassID == PassID && "mismatched PassID");
   // Additional filtering (e.g. -filter-print-func) can lead to module
   // printing being skipped.
   if (!M)
     return;
 
   SmallString<20> Banner =
-      formatv("*** IR Dump After {0} *** invalidated: ", PassID);
-  printIR(dbgs(), M, Banner, Extra);
+      formatv("*** IR Dump After {0} on {1} (invalidated) ***", PassID, IRName);
+  dbgs() << Banner << "\n";
+  printIR(dbgs(), M);
 }
 
 bool PrintIRInstrumentation::shouldPrintBeforePass(StringRef PassID) {
   if (shouldPrintBeforeAll())
     return true;
 
   StringRef PassName = PIC->getPassNameForClassName(PassID);
   return llvm::is_contained(printBeforePasses(), PassName);
bool OptNoneInstrumentation::shouldRun(StringRef PassID, Any IR) {
   bool ShouldRun = !(F && F->hasOptNone());
   if (!ShouldRun && DebugLogging) {
     errs() << "Skipping pass " << PassID << " on " << F->getName()
            << " due to optnone attribute\n";
   }
   return ShouldRun;
 }
 
-static std::string getBisectDescription(Any IR) {
-  if (any_isa<const Module *>(IR)) {
-    const Module *M = any_cast<const Module *>(IR);
-    assert(M && "module should be valid for printing");
-    return "module (" + M->getName().str() + ")";
-  }
-
-  if (any_isa<const Function *>(IR)) {
-    const Function *F = any_cast<const Function *>(IR);
-    assert(F && "function should be valid for printing");
-    return "function (" + F->getName().str() + ")";
-  }
-
-  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
-    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
-    assert(C && "scc should be valid for printing");
-    return "SCC " + C->getName();
-  }
-
-  if (any_isa<const Loop *>(IR)) {
-    return "loop";
-  }
-
-  llvm_unreachable("Unknown wrapped IR type");
-}
-
 void OptBisectInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!OptBisector->isEnabled())
     return;
   PIC.registerShouldRunOptionalPassCallback([](StringRef PassID, Any IR) {
-    return isIgnored(PassID) ||
-           OptBisector->checkPass(PassID, getBisectDescription(IR));
+    return isIgnored(PassID) || OptBisector->checkPass(PassID, getIRName(IR));
   });
 }
 
 void PrintPassInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!DebugLogging)
     return;
 
   std::vector<StringRef> SpecialPasses = {"PassManager"};
   if (!DebugPMVerbose)
     SpecialPasses.emplace_back("PassAdaptor");
 
   PIC.registerBeforeSkippedPassCallback(
       [SpecialPasses](StringRef PassID, Any IR) {
         assert(!isSpecialPass(PassID, SpecialPasses) &&
                "Unexpectedly skipping special pass");
 
-        dbgs() << "Skipping pass: " << PassID << " on ";
-        unwrapAndPrint(dbgs(), IR, "", false, true);
+        dbgs() << "Skipping pass: " << PassID << " on " << getIRName(IR)
+               << "\n";
       });
 
   PIC.registerBeforeNonSkippedPassCallback(
       [SpecialPasses](StringRef PassID, Any IR) {
         if (isSpecialPass(PassID, SpecialPasses))
           return;
 
-        dbgs() << "Running pass: " << PassID << " on ";
-        unwrapAndPrint(dbgs(), IR, "", false, true);
+        dbgs() << "Running pass: " << PassID << " on " << getIRName(IR) << "\n";
       });
 
   PIC.registerBeforeAnalysisCallback([](StringRef PassID, Any IR) {
-    dbgs() << "Running analysis: " << PassID << " on ";
-    unwrapAndPrint(dbgs(), IR, "", false, true);
+    dbgs() << "Running analysis: " << PassID << " on " << getIRName(IR) << "\n";
   });
 }
 
 PreservedCFGCheckerInstrumentation::CFG::CFG(const Function *F,
                                              bool TrackBBLifetime) {
   if (TrackBBLifetime)
     BBGuards = DenseMap<intptr_t, BBGuard>(F->size());
   for (const auto &BB : *F) {

 void InLineChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
                                                    ChangedIRData &D) {
   ChangedIRComparer::analyzeIR(IR, D);
 }
 
 void InLineChangePrinter::handleAfter(StringRef PassID, std::string &Name,
                                       const ChangedIRData &Before,
                                       const ChangedIRData &After, Any IR) {
-  if (Name == "")
-    Name = " (module)";
   SmallString<20> Banner =
-      formatv("*** IR Dump After {0} ***{1}\n", PassID, Name);
+      formatv("*** IR Dump After {0} on {1} ***\n", PassID, Name);
   Out << Banner;
   ChangedIRComparer(Out, Before, After, UseColour)
       .compare(IR, "", PassID, Name);
   Out << "\n";
 }
 
 bool InLineChangePrinter::same(const ChangedIRData &D1,
                                const ChangedIRData &D2) {

llvm/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

for (MBBVector::const_iterator iterBlk = OrderedBlks.begin(),
         dbgs() << " ";
       }
     }
   }
 
   static void PrintLoopinfo(const MachineLoopInfo &LoopInfo) {
     for (MachineLoop::iterator iter = LoopInfo.begin(),
          iterEnd = LoopInfo.end(); iter != iterEnd; ++iter) {
-      (*iter)->print(dbgs(), 0);
+      (*iter)->print(dbgs());
     }
   }
 
   // UTILITY FUNCTIONS
   int getSCCNum(MachineBasicBlock *MBB) const;
   MachineBasicBlock *getLoopLandInfo(MachineLoop *LoopRep) const;
   bool hasBackEdge(MachineBasicBlock *MBB) const;
   bool isRetiredBlock(MachineBasicBlock *MBB) const;

llvm/test/Other/change-printer.ll

 }
 
 define i32 @f() {
 entry:
   %a = add i32 2, 3
   ret i32 %a
 }
 
-; CHECK-SIMPLE: *** IR Dump At Start: ***
+; CHECK-SIMPLE: *** IR Dump At Start ***
 ; CHECK-SIMPLE-NEXT: ; ModuleID = {{.+}}
-; CHECK-SIMPLE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-SIMPLE-NEXT: define i32 @g()
-; CHECK-SIMPLE: *** IR Pass PassManager{{.*}} (function: g) ignored ***
-; CHECK-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-SIMPLE: *** IR Pass PassManager{{.*}} on g ignored ***
+; CHECK-SIMPLE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-SIMPLE-NEXT: define i32 @f()
-; CHECK-SIMPLE: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-SIMPLE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-SIMPLE: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-SIMPLE: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-SIMPLE: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 ; CHECK-SIMPLE-NOT: *** IR
 
-; CHECK-FUNC-FILTER: *** IR Dump At Start: ***
+; CHECK-FUNC-FILTER: *** IR Dump At Start ***
 ; CHECK-FUNC-FILTER-NEXT: ; ModuleID = {{.+}}
-; CHECK-FUNC-FILTER: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-FUNC-FILTER: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FUNC-FILTER: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-FUNC-FILTER: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FUNC-FILTER-NEXT: define i32 @f()
 
-; CHECK-PRINT-MOD-SCOPE: *** IR Dump At Start: ***
+; CHECK-PRINT-MOD-SCOPE: *** IR Dump At Start ***
 ; CHECK-PRINT-MOD-SCOPE-NEXT: ModuleID = {{.+}}
-; CHECK-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-PRINT-MOD-SCOPE-NEXT: ModuleID = {{.+}}
-; CHECK-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-PRINT-MOD-SCOPE-NEXT: ModuleID = {{.+}}
 
-; CHECK-FUNC-FILTER-MOD-SCOPE: *** IR Dump At Start: ***
+; CHECK-FUNC-FILTER-MOD-SCOPE: *** IR Dump At Start ***
 ; CHECK-FUNC-FILTER-MOD-SCOPE-NEXT: ; ModuleID = {{.+}}
-; CHECK-FUNC-FILTER-MOD-SCOPE: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-FUNC-FILTER-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FUNC-FILTER-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-FUNC-FILTER-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FUNC-FILTER-MOD-SCOPE-NEXT: ModuleID = {{.+}}
 
-; CHECK-FILTER-MULT-FUNC: *** IR Dump At Start: ***
+; CHECK-FILTER-MULT-FUNC: *** IR Dump At Start ***
 ; CHECK-FILTER-MULT-FUNC-NEXT: ; ModuleID = {{.+}}
-; CHECK-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-FILTER-MULT-FUNC-NEXT: define i32 @g()
-; CHECK-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FILTER-MULT-FUNC-NEXT: define i32 @f()
 
-; CHECK-FILTER-PASSES: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-FILTER-PASSES: *** IR Dump At Start: *** (function: g)
+; CHECK-FILTER-PASSES: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-FILTER-PASSES: *** IR Dump At Start ***
 ; CHECK-FILTER-PASSES-NEXT: ; ModuleID = {{.+}}
-; CHECK-FILTER-PASSES: *** IR Dump After NoOpFunctionPass (function: g) omitted because no change ***
-; CHECK-FILTER-PASSES: *** IR Dump After InstSimplifyPass (function: f) filtered out ***
-; CHECK-FILTER-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-FILTER-PASSES: *** IR Dump After NoOpFunctionPass on g omitted because no change ***
+; CHECK-FILTER-PASSES: *** IR Dump After InstSimplifyPass on f filtered out ***
+; CHECK-FILTER-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-FILTER-MULT-PASSES: *** IR Dump At Start: *** (function: g)
+; CHECK-FILTER-MULT-PASSES: *** IR Dump At Start ***
 ; CHECK-FILTER-MULT-PASSES-NEXT: ; ModuleID = {{.+}}
-; CHECK-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-FILTER-MULT-PASSES-NEXT: define i32 @g()
-; CHECK-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass (function: g) omitted because no change ***
-; CHECK-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass on g omitted because no change ***
+; CHECK-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FILTER-MULT-PASSES-NEXT: define i32 @f()
-; CHECK-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass (function: g) filtered out ***
-; CHECK-FILTER-FUNC-PASSES: *** IR Dump At Start: *** (function: f)
+; CHECK-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass on g filtered out ***
+; CHECK-FILTER-FUNC-PASSES: *** IR Dump At Start ***
 ; CHECK-FILTER-FUNC-PASSES-NEXT: ; ModuleID = {{.+}}
-; CHECK-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FILTER-FUNC-PASSES-NEXT: define i32 @f()
-; CHECK-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After NoOpFunctionPass (function: g) filtered out ***
-; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump At Start: *** (function: f)
+; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After NoOpFunctionPass on g filtered out ***
+; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump At Start ***
 ; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE-NEXT: ; ModuleID = {{.+}}
-; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE-NEXT: ModuleID = {{.+}}
-; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump At Start: ***
+; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump At Start ***
 ; CHECK-MULT-PASSES-FILTER-FUNC-NEXT: ; ModuleID = {{.+}}
-; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-MULT-PASSES-FILTER-FUNC-NEXT: define i32 @f()
-; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: f) omitted because no change ***
+; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f omitted because no change ***
 
-; CHECK-SIMPLE-BEFORE: *** IR Dump At Start: ***
+; CHECK-SIMPLE-BEFORE: *** IR Dump At Start ***
 ; CHECK-SIMPLE-BEFORE-NEXT: ; ModuleID = {{.+}}
-; CHECK-SIMPLE-BEFORE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-SIMPLE-BEFORE: *** IR Dump Before InstSimplifyPass *** (function: g)
+; CHECK-SIMPLE-BEFORE: *** IR Dump After VerifierPass [module] omitted because no change ***
+; CHECK-SIMPLE-BEFORE: *** IR Dump Before InstSimplifyPass on g ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @g()
-; CHECK-SIMPLE-BEFORE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-SIMPLE-BEFORE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @g()
 ; CHECK-SIMPLE-BEFORE: *** IR Pass PassManager{{.*}} (function: g) ignored ***
-; CHECK-SIMPLE-BEFORE: *** IR Dump Before InstSimplifyPass *** (function: f)
+; CHECK-SIMPLE-BEFORE: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @f()
-; CHECK-SIMPLE-BEFORE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-SIMPLE-BEFORE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @f()
 ; CHECK-SIMPLE-BEFORE: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-SIMPLE-BEFORE: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-SIMPLE-BEFORE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-SIMPLE-BEFORE: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-SIMPLE-BEFORE: *** IR Pass ModuleToFunctionPassAdaptor [module] ignored ***
+; CHECK-SIMPLE-BEFORE: *** IR Dump After VerifierPass [module] omitted because no change ***
+; CHECK-SIMPLE-BEFORE: *** IR Dump After PrintModulePass [module] omitted because no change ***
 ; CHECK-SIMPLE-BEFORE-NOT: *** IR
 
-; CHECK-FUNC-FILTER-BEFORE: *** IR Dump At Start: ***
+; CHECK-FUNC-FILTER-BEFORE: *** IR Dump At Start ***
 ; CHECK-FUNC-FILTER-BEFORE-NEXT: ; ModuleID = {{.+}}
-; CHECK-FUNC-FILTER-BEFORE: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-FUNC-FILTER-BEFORE: *** IR Dump Before InstSimplifyPass *** (function: f)
+; CHECK-FUNC-FILTER-BEFORE: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-FUNC-FILTER-BEFORE: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-FUNC-FILTER-BEFORE-NEXT: define i32 @f()
-; CHECK-FUNC-FILTER-BEFORE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FUNC-FILTER-BEFORE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FUNC-FILTER-BEFORE-NEXT: define i32 @f()
 
-; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump At Start: ***
+; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump At Start ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-NEXT: ModuleID = {{.+}}
-; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump Before InstSimplifyPass *** (function: g)
+; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump Before InstSimplifyPass on g ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-NEXT: ModuleID = {{.+}}
-; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-NEXT: ModuleID = {{.+}}
-; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump Before InstSimplifyPass *** (function: f)
+; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-NEXT: ModuleID = {{.+}}
-; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-PRINT-MOD-SCOPE-BEFORE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-NEXT: ModuleID = {{.+}}
 
-; CHECK-QUIET-SIMPLE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-QUIET-SIMPLE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-QUIET-SIMPLE-NEXT: define i32 @g()
 ; CHECK-QUIET-SIMPLE-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-SIMPLE-NEXT: define i32 @f()
 ; CHECK-QUIET-SIMPLE-NOT: *** IR
 
-; CHECK-QUIET-FUNC-FILTER-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FUNC-FILTER: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FUNC-FILTER-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FUNC-FILTER: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FUNC-FILTER-NEXT: define i32 @f()
 ; CHECK-QUIET-FUNC-FILTER-NOT: *** IR
 
-; CHECK-QUIET-PRINT-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-QUIET-PRINT-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-QUIET-PRINT-MOD-SCOPE-NEXT: ModuleID = {{.+}}
-; CHECK-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-PRINT-MOD-SCOPE-NEXT: ModuleID = {{.+}}
 ; CHECK-QUIET-PRINT-MOD-SCOPE-NOT: *** IR
 
-; CHECK-QUIET-FUNC-FILTER-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FUNC-FILTER-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FUNC-FILTER-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FUNC-FILTER-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FUNC-FILTER-MOD-SCOPE-NEXT: ModuleID = {{.+}}
 ; CHECK-QUIET-FUNC-FILTER-MOD-SCOPE-NOT: *** IR
 
-; CHECK-QUIET-FILTER-MULT-FUNC-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-QUIET-FILTER-MULT-FUNC-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-QUIET-FILTER-MULT-FUNC-NEXT: define i32 @g()
-; CHECK-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FILTER-MULT-FUNC-NEXT: define i32 @f()
 ; CHECK-QUIET-FILTER-MULT-FUNC-NOT: *** IR
 
 ; CHECK-QUIET-FILTER-PASSES-NONE-NOT: *** IR
 
-; CHECK-QUIET-FILTER-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-QUIET-FILTER-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-QUIET-FILTER-PASSES-NEXT: define i32 @g()
-; CHECK-QUIET-FILTER-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FILTER-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FILTER-PASSES-NEXT: define i32 @f()
 ; CHECK-QUIET-FILTER-PASSES-NOT: *** IR
 
-; CHECK-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-QUIET-FILTER-MULT-PASSES-NEXT: define i32 @g()
-; CHECK-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FILTER-MULT-PASSES-NEXT: define i32 @f()
 ; CHECK-QUIET-FILTER-MULT-PASSES-NOT: *** IR
 
-; CHECK-QUIET-FILTER-FUNC-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FILTER-FUNC-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FILTER-FUNC-PASSES-NEXT: define i32 @f()
 ; CHECK-QUIET-FILTER-FUNC-PASSES-NOT: *** IR
 
-; CHECK-QUIET-FILTER-FUNC-PASSES-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-FILTER-FUNC-PASSES-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-FILTER-FUNC-PASSES-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-FILTER-FUNC-PASSES-MOD-SCOPE-NEXT: ModuleID = {{.+}}
 ; CHECK-QUIET-FILTER-FUNC-PASSES-MOD-SCOPE-NOT: *** IR
 
-; CHECK-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-QUIET-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-QUIET-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-QUIET-MULT-PASSES-FILTER-FUNC-NEXT: define i32 @f()
 ; CHECK-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR
 
-; CHECK-SIMPLE-BEFORE-QUIET-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass *** (function: g)
+; CHECK-SIMPLE-BEFORE-QUIET-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass on g ***
 ; CHECK-SIMPLE-BEFORE-QUIET-NEXT: define i32 @g()
 ; CHECK-SIMPLE-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-SIMPLE-BEFORE-QUIET-NEXT: define i32 @g()
 ; CHECK-SIMPLE-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass *** (function: f)
+; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-SIMPLE-BEFORE-QUIET-NEXT: define i32 @f()
 ; CHECK-SIMPLE-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-SIMPLE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-SIMPLE-BEFORE-QUIET-NEXT: define i32 @f()
 ; CHECK-SIMPLE-BEFORE-QUIET-NOT: *** IR
 
-; CHECK-FUNC-FILTER-BEFORE-QUIET-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-FUNC-FILTER-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass *** (function: f)
+; CHECK-FUNC-FILTER-BEFORE-QUIET-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-FUNC-FILTER-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-FUNC-FILTER-BEFORE-QUIET-NEXT: define i32 @f()
 ; CHECK-FUNC-FILTER-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-FUNC-FILTER-BEFORE-QUIET: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-FUNC-FILTER-BEFORE-QUIET: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-FUNC-FILTER-BEFORE-QUIET-NEXT: define i32 @f()
 ; CHECK-FUNC-FILTER-BEFORE-QUIET-NOT: *** IR
 
-; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass *** (function: g)
+; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass on g ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NEXT: ModuleID = {{.+}}
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NEXT: ModuleID = {{.+}}
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass *** (function: f)
+; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NEXT: ModuleID = {{.+}}
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NOT: *** IR Dump {{.*(no change|ignored|filtered out)}} ***
-; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NEXT: ModuleID = {{.+}}
 ; CHECK-PRINT-MOD-SCOPE-BEFORE-QUIET-NOT: *** IR

llvm/test/Other/loop-deletion-printer.ll

 ; Make sure that Loop which was invalidated by loop-deletion
 ; does not lead to problems for -print-after-all and is just skipped.
 ;
 ; RUN: opt < %s -disable-output \
 ; RUN:     -passes=loop-instsimplify -print-after-all  2>&1 | FileCheck %s -check-prefix=SIMPLIFY
 ; RUN: opt < %s -disable-output \
 ; RUN:     -passes=loop-deletion,loop-instsimplify -print-after-all  2>&1 | FileCheck %s -check-prefix=DELETED
 ; RUN: opt < %s -disable-output \
 ; RUN:     -passes=loop-deletion,loop-instsimplify -print-after-all -print-module-scope  2>&1 | FileCheck %s -check-prefix=DELETED-BUT-PRINTED
 ;
 ; SIMPLIFY: IR Dump {{.*}} LoopInstSimplifyPass
 ; DELETED-NOT: IR Dump {{.*}}LoopInstSimplifyPass
 ; DELETED-NOT: IR Dump {{.*}}LoopDeletionPass
-; DELETED-BUT-PRINTED: IR Dump {{.*}}LoopDeletionPass {{.*invalidated:}}
+; DELETED-BUT-PRINTED: IR Dump {{.*}}LoopDeletionPass {{.*}}(invalidated)
 ; DELETED-BUT-PRINTED-NOT: IR Dump {{.*}}LoopInstSimplifyPass
 
 define void @deleteme() {
 entry:
   br label %loop
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
   %iv.next = add i32 %iv, 1
   %check = icmp ult i32 %iv.next, 3
   br i1 %check, label %loop, label %exit
 exit:
   ret void
 }
 

llvm/test/Other/loop-pass-printer.ll

 ; BAR-NEXT:  br label %loop
 ; BAR:      ; Loop:
 ; BAR-NEXT:  loop:
 ; BAR:      ; Exit blocks
 ; BAR:       end:
 ; BAR-OLD-NOT: IR Dump
 ; BAR-OLD-NOT:  ; Loop
 
-; FOO-MODULE: IR Dump After {{Unroll|LoopFullUnrollPass}}
-; FOO-MODULE-SAME: loop: %loop
+; FOO-MODULE: IR Dump After {{Unroll|LoopFullUnrollPass}} {{.*}}%loop
 ; FOO-MODULE-NEXT: ModuleID =
 ; FOO-MODULE: define void @foo
 ; FOO-MODULE: define void @bar
 ; FOO-MODULE-OLD-NOT: IR Dump
 
 define void @foo(){
   %idx = alloca i32, align 4
   store i32 0, i32* %idx, align 4

llvm/test/Other/module-pass-printer.ll

 ; Check pass name is only printed once.
 ; Check only one function is printed
 ; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo | FileCheck %s  -check-prefix=FOO
 ; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo | FileCheck %s  -check-prefix=FOO
 
 ; Check pass name is only printed once.
 ; Check both functions are printed
 ; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo,bar | FileCheck %s -check-prefix=BOTH
 ; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo,bar | FileCheck %s -check-prefix=BOTH
 
-; Check pass name is not printed if a module doesn't include any function specified in -filter-print-funcs.
+; Check pass name is not printed if a module/SCC doesn't include any function specified in -filter-print-funcs.
 ; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY
 ; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY
+; RUN: opt < %s 2>&1 -passes=no-op-cgscc -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY
 
 ; Check whole module is printed with user-specified wildcast switch -filter-print-funcs=* or -print-module-scope
 ; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all | FileCheck %s -check-prefix=ALL
 ; RUN: opt < %s 2>&1 -forceattrs -disable-output  -print-after-all -filter-print-funcs=* | FileCheck %s -check-prefix=ALL
 ; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo -print-module-scope | FileCheck %s -check-prefix=ALL
 ; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all | FileCheck %s -check-prefix=ALL
 ; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=* | FileCheck %s -check-prefix=ALL
 ; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo -print-module-scope | FileCheck %s -check-prefix=ALL
 
 ; FOO:      IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
 ; FOO:      define void @foo
 ; FOO-NOT:  define void @bar
 ; FOO-NOT:  IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
 
 ; BOTH:     IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
 ; BOTH:     define void @foo
 ; BOTH:     define void @bar
 ; BOTH-NOT: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
 ; BOTH-NOT: ModuleID =
 
 ; EMPTY-NOT: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
+; EMPTY-NOT: IR Dump After NoOp
 
 ; ALL:  IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
 ; ALL:  ModuleID =
 ; ALL:  define void @foo
 ; ALL:  define void @bar
 ; ALL-NOT: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
 
 define void @foo() {
   ret void
 }
 
 define void @bar() {
   ret void
 }

llvm/test/Other/opt-bisect-new-pass-manager.ll

 ; This file verifies the behavior of the OptBisect class, which is used to
 ; diagnose optimization related failures.  The tests check various
 ; invocations that result in different sets of optimization passes that
 ; are run in different ways.
 ;
 ; Because the exact set of optimizations that will be run is expected to
 ; change over time, the checks for disabling passes are written in a
 ; conservative way that avoids assumptions about which specific passes
 ; will be disabled.
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=-1 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MODULE-PASS
-; CHECK-MODULE-PASS: BISECT: running pass (1) InferFunctionAttrsPass on module
+; CHECK-MODULE-PASS: BISECT: running pass (1) InferFunctionAttrsPass on [module]
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=0 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-MODULE-PASS
-; CHECK-LIMIT-MODULE-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass on module
+; CHECK-LIMIT-MODULE-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass on [module]
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=-1 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-REQUIRED-PASS
 ; CHECK-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
 ; CHECK-REQUIRED-PASS: Running pass: VerifierPass
-; CHECK-REQUIRED-PASS: BISECT: running pass (1) InferFunctionAttrsPass on module
+; CHECK-REQUIRED-PASS: BISECT: running pass (1) InferFunctionAttrsPass on [module]
 ; CHECK-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
 ; CHECK-REQUIRED-PASS: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=0 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-REQUIRED-PASS
 ; CHECK-LIMIT-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
 ; CHECK-LIMIT-REQUIRED-PASS: Running pass: VerifierPass
-; CHECK-LIMIT-REQUIRED-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass on module
+; CHECK-LIMIT-REQUIRED-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass on [module]
 ; CHECK-LIMIT-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
 ; CHECK-LIMIT-REQUIRED-PASS: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=early-cse -opt-bisect-limit=-1 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
-; CHECK-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on function (f1)
-; CHECK-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on function (f2)
-; CHECK-FUNCTION-PASS: BISECT: running pass (3) EarlyCSEPass on function (f3)
-; CHECK-FUNCTION-PASS: BISECT: running pass (4) EarlyCSEPass on function (f4)
+; CHECK-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on f1
+; CHECK-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on f2
+; CHECK-FUNCTION-PASS: BISECT: running pass (3) EarlyCSEPass on f3
+; CHECK-FUNCTION-PASS: BISECT: running pass (4) EarlyCSEPass on f4
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=early-cse -opt-bisect-limit=2 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-FUNCTION-PASS
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on function (f1)
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on function (f2)
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (3) EarlyCSEPass on function (f3)
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (4) EarlyCSEPass on function (f4)
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on f1
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on f2
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (3) EarlyCSEPass on f3
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (4) EarlyCSEPass on f4
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=function-attrs -opt-bisect-limit=-1 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-CGSCC-PASS
-; CHECK-CGSCC-PASS: BISECT: running pass (1) PostOrderFunctionAttrsPass on SCC (f1)
-; CHECK-CGSCC-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on SCC (f2)
-; CHECK-CGSCC-PASS: BISECT: running pass (3) PostOrderFunctionAttrsPass on SCC (f3)
-; CHECK-CGSCC-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on SCC (f4)
+; CHECK-CGSCC-PASS: BISECT: running pass (1) PostOrderFunctionAttrsPass on (f1)
+; CHECK-CGSCC-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on (f2)
+; CHECK-CGSCC-PASS: BISECT: running pass (3) PostOrderFunctionAttrsPass on (f3)
+; CHECK-CGSCC-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on (f4)
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=function-attrs -opt-bisect-limit=3 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-CGSCC-PASS
-; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (1) PostOrderFunctionAttrsPass on SCC (f1)
-; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on SCC (f2)
-; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (3) PostOrderFunctionAttrsPass on SCC (f3)
-; CHECK-LIMIT-CGSCC-PASS: BISECT: NOT running pass (4) PostOrderFunctionAttrsPass on SCC (f4)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (1) PostOrderFunctionAttrsPass on (f1)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on (f2)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (3) PostOrderFunctionAttrsPass on (f3)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: NOT running pass (4) PostOrderFunctionAttrsPass on (f4)
 
 ; RUN: opt -disable-output -disable-verify -opt-bisect-limit=-1 \
 ; RUN:     -passes='inferattrs,cgscc(function-attrs,function(early-cse))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MULTI-PASS
-; CHECK-MULTI-PASS: BISECT: running pass (1) InferFunctionAttrsPass on module
-; CHECK-MULTI-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on SCC (f1)
-; CHECK-MULTI-PASS: BISECT: running pass (3) EarlyCSEPass on function (f1)
-; CHECK-MULTI-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on SCC (f2)
-; CHECK-MULTI-PASS: BISECT: running pass (5) EarlyCSEPass on function (f2)
-; CHECK-MULTI-PASS: BISECT: running pass (6) PostOrderFunctionAttrsPass on SCC (f3)
-; CHECK-MULTI-PASS: BISECT: running pass (7) EarlyCSEPass on function (f3)
-; CHECK-MULTI-PASS: BISECT: running pass (8) PostOrderFunctionAttrsPass on SCC (f4)
-; CHECK-MULTI-PASS: BISECT: running pass (9) EarlyCSEPass on function (f4)
+; CHECK-MULTI-PASS: BISECT: running pass (1) InferFunctionAttrsPass on [module]
+; CHECK-MULTI-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on (f1)
+; CHECK-MULTI-PASS: BISECT: running pass (3) EarlyCSEPass on f1
+; CHECK-MULTI-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on (f2)
+; CHECK-MULTI-PASS: BISECT: running pass (5) EarlyCSEPass on f2
+; CHECK-MULTI-PASS: BISECT: running pass (6) PostOrderFunctionAttrsPass on (f3)
+; CHECK-MULTI-PASS: BISECT: running pass (7) EarlyCSEPass on f3
+; CHECK-MULTI-PASS: BISECT: running pass (8) PostOrderFunctionAttrsPass on (f4)
+; CHECK-MULTI-PASS: BISECT: running pass (9) EarlyCSEPass on f4
 
 ; RUN: opt -disable-output -disable-verify -opt-bisect-limit=7 \
 ; RUN:     -passes='inferattrs,cgscc(function-attrs,function(early-cse))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-MULTI-PASS
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (1) InferFunctionAttrsPass on module
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on SCC (f1)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (3) EarlyCSEPass on function (f1)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on SCC (f2)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (5) EarlyCSEPass on function (f2)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (6) PostOrderFunctionAttrsPass on SCC (f3)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (7) EarlyCSEPass on function (f3)
-; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (8) PostOrderFunctionAttrsPass on SCC (f4)
-; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (9) EarlyCSEPass on function (f4)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (1) InferFunctionAttrsPass on [module]
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on (f1)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (3) EarlyCSEPass on f1
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on (f2)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (5) EarlyCSEPass on f2
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (6) PostOrderFunctionAttrsPass on (f3)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (7) EarlyCSEPass on f3
+; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (8) PostOrderFunctionAttrsPass on (f4)
+; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (9) EarlyCSEPass on f4
 
 
 declare i32 @g()
 
 define void @f1() {
 entry:
   br label %loop.0
 loop.0:

llvm/test/Other/print-module-scope.ll

 ; RUN:     | FileCheck %s -check-prefix=CFG
 ; RUN: opt -enable-new-pm=0 < %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 {{Simplify the CFG|SimplifyCFGPass}}
-; CFG-SAME:   function: foo
+; CFG:      IR Dump After {{Simplify the CFG|SimplifyCFGPass}} {{.*}}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: IR Dump After {{.*}}bar
 ; CFG-NEXT: ModuleID =
 ; CFG: define void @foo
 ; CFG: define void @bar
 ; CFG: declare void @baz
 
-; FOO:      IR Dump After {{Simplify the CFG|SimplifyCFGPass}}
-; FOO-NOT:    function: bar
-; FOO-SAME:   function: foo
+; FOO:      IR Dump After {{Simplify the CFG|SimplifyCFGPass}} {{.*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
 ; FOO: declare void @baz
 

llvm/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-all -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD
 
-; INL: IR Dump Before {{InlinerPass .*scc: .tester, foo}}
+; INL: IR Dump Before InlinerPass on (tester, foo)
 ; INL-NOT: IR Dump After {{InlinerPass}}
-; INL: IR Dump Before {{InlinerPass .*scc: .tester}}
-; INL: IR Dump After {{InlinerPass .*scc: .tester}}
+; INL: IR Dump Before InlinerPass on (tester)
+; INL: IR Dump After InlinerPass on (tester)
 
-; INL-MOD: IR Dump Before {{InlinerPass .*scc: .tester, foo}}
-; INL-MOD: IR Dump After {{InlinerPass .*invalidated: .*scc: .tester, foo}}
-; INL-MOD: IR Dump Before {{InlinerPass .*scc: .tester}}
-; INL-MOD: IR Dump After {{InlinerPass .*scc: .tester}}
+; INL-MOD: IR Dump Before InlinerPass on (tester, foo)
+; INL-MOD: IR Dump After InlinerPass on (tester, foo) (invalidated)
+; INL-MOD: IR Dump Before InlinerPass on (tester)
+; INL-MOD: IR Dump After InlinerPass on (tester)
 
 
 define void @tester() noinline {
   call void @foo()
   ret void
 }
 
 define internal void @foo() alwaysinline {
   call void @tester()
   ret void
 }

llvm/test/Other/scc-pass-printer.ll

 ; LEGACY:        define void @bar()
 ; LEGACY-NEXT:   call void @foo()
 ; LEGACY: define void @foo()
 ; LEGACY-NEXT:   call void @bar()
 ; LEGACY: IR Dump After Function Integration/Inlining
 ; LEGACY: define void @tester()
 ; LEGACY-NEXT:  call void @foo()
 
-; INL:      IR Dump After InlinerPass *** (scc: (foo, bar))
+; INL:      IR Dump After InlinerPass on (foo, bar) ***
 ; INL:      define void @foo()
 ; INL-NEXT:   call void @bar()
 ; INL:      define void @bar()
 ; INL-NEXT:   call void @foo()
-; INL:      IR Dump After InlinerPass *** (scc: (tester))
+; INL:      IR Dump After InlinerPass on (tester) ***
 ; INL:      define void @tester()
 ; INL-NEXT:   call void @foo()
 
 ; LEGACY-MOD:      IR Dump After Function Integration/Inlining
 ; LEGACY-MOD-NEXT: ModuleID =
 ; LEGACY-MOD:      define void @tester()
 ; LEGACY-MOD:      define void @foo()
 ; LEGACY-MOD:      define void @bar()
 
-; INL-MOD-LABEL:*** IR Dump After InlinerPass *** (scc: (foo, bar))
+; INL-MOD-LABEL:*** IR Dump After InlinerPass on (foo, bar) ***
 ; 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-LABEL:*** IR Dump After InlinerPass *** (scc: (tester))
+; INL-MOD-LABEL:*** IR Dump After InlinerPass on (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()

llvm/test/ThinLTO/X86/printer.ll

 ; RUN: llvm-as %s -o %t.bc
 ; RUN: llvm-lto2 run -r=%t.bc,foo,pxl -use-new-pm --print-before-all %t.bc -o %t2 2>&1 | FileCheck %s --check-prefix=CHECK-BEFORE
 ; RUN: llvm-lto2 run -r=%t.bc,foo,pxl -use-new-pm --print-after-all %t.bc -o %t3 2>&1 | FileCheck %s --check-prefix=CHECK-AFTER
-; CHECK-BEFORE: *** IR Dump Before GlobalDCEPass ***
-; CHECK-AFTER: *** IR Dump After GlobalDCEPass ***
+; CHECK-BEFORE: *** IR Dump Before GlobalDCEPass
+; CHECK-AFTER: *** IR Dump After GlobalDCEPass
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @foo() {
     ret i32 42
 }