diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index c2c6800..2fdab3a 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -479,7 +479,8 @@
   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>;
diff --git a/include/llvm/Analysis/LoopInfoImpl.h b/include/llvm/Analysis/LoopInfoImpl.h
index ca44d03..2cc9afb 100644
--- a/include/llvm/Analysis/LoopInfoImpl.h
+++ b/include/llvm/Analysis/LoopInfoImpl.h
@@ -381,8 +381,8 @@
 }
 
 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 ";
@@ -407,10 +407,13 @@
     if (Verbose)
       BB->print(OS);
   }
-  OS << "\n";
 
-  for (iterator I = begin(), E = end(); I != E; ++I)
-    (*I)->print(OS, Depth + 2);
+  if (PrintNested) {
+    OS << "\n";
+
+    for (iterator I = begin(), E = end(); I != E; ++I)
+      (*I)->print(OS, /*Verbose*/ false, PrintNested, Depth + 2);
+  }
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index 93a0021..adb2bdb 100644
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -662,7 +662,7 @@
 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
 
diff --git a/lib/Passes/StandardInstrumentations.cpp b/lib/Passes/StandardInstrumentations.cpp
index 557b099..0494cb3 100644
--- a/lib/Passes/StandardInstrumentations.cpp
+++ b/lib/Passes/StandardInstrumentations.cpp
@@ -193,20 +193,18 @@
   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) {
+/// Extract Module out of \p IR unit. May return nullptr if \p IR does not match
+/// certain global filters. Will never return nullptr if \p Force is true.
+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)) {
@@ -214,130 +212,156 @@
     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;
+    assert(!Force && "Expected a module");
+    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");
@@ -406,18 +430,8 @@
 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)
@@ -485,17 +499,17 @@
 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,
+           /*ShouldPreserveUseListOrder=*/true);
 }
 
 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);
 }
 
@@ -508,14 +522,14 @@
 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() {}
@@ -529,49 +543,27 @@
 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) {
@@ -723,11 +715,8 @@
 
 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
@@ -752,8 +741,12 @@
   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) {
@@ -763,11 +756,20 @@
   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");
+  }
 
-  SmallString<20> Banner = formatv("*** IR Dump After {0} ***", PassID);
-  unwrapAndPrint(dbgs(), IR, Banner, forcePrintModuleIR());
+  if (!shouldPrintIR(IR))
+    return;
+
+  dbgs() << "*** IR Dump After " << PassID << " on " << getIRName(IR)
+         << " ***\n";
+  unwrapAndPrint(dbgs(), IR);
 }
 
 void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
@@ -779,17 +781,19 @@
     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) {
@@ -852,39 +856,12 @@
   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));
   });
 }
 
@@ -902,8 +879,8 @@
         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(
@@ -911,13 +888,11 @@
         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";
   });
 }
 
@@ -1163,10 +1138,8 @@
 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);
diff --git a/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp b/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp
index b9a8c6b..56befe4 100644
--- a/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp
+++ b/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp
@@ -171,7 +171,7 @@
   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());
     }
   }
 
diff --git a/test/Other/ChangePrinters/print-changed-diff.ll b/test/Other/ChangePrinters/print-changed-diff.ll
index b5d408f..bbfd793 100644
--- a/test/Other/ChangePrinters/print-changed-diff.ll
+++ b/test/Other/ChangePrinters/print-changed-diff.ll
@@ -138,126 +138,126 @@
   ret i32 %a
 }
 
-; CHECK-DIFF-SIMPLE: *** IR Dump At Start: ***
+; CHECK-DIFF-SIMPLE: *** IR Dump At Start ***
 ; CHECK-DIFF-SIMPLE: ModuleID = {{.+}}
-; CHECK-DIFF-SIMPLE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-DIFF-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-DIFF-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-DIFF-SIMPLE: entry:
 ; CHECK-DIFF-SIMPLE-NEXT:-  %a = add i32 2, 3
 ; CHECK-DIFF-SIMPLE-NEXT:-  ret i32 %a
 ; CHECK-DIFF-SIMPLE-NEXT:+  ret i32 5
-; CHECK-DIFF-SIMPLE: *** IR Pass PassManager{{.*}} (function: g) ignored ***
-; CHECK-DIFF-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-SIMPLE: *** IR Pass PassManager{{.*}} on g ignored ***
+; CHECK-DIFF-SIMPLE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-DIFF-SIMPLE: entry:
 ; CHECK-DIFF-SIMPLE-NEXT:-  %a = add i32 2, 3
 ; CHECK-DIFF-SIMPLE-NEXT:-  ret i32 %a
 ; CHECK-DIFF-SIMPLE-NEXT:+  ret i32 5
-; CHECK-DIFF-SIMPLE: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-DIFF-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-DIFF-SIMPLE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-DIFF-SIMPLE: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-DIFF-SIMPLE: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-DIFF-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-DIFF-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-DIFF-SIMPLE: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-DIFF-FUNC-FILTER: *** IR Dump At Start: ***
+; CHECK-DIFF-FUNC-FILTER: *** IR Dump At Start ***
 ; CHECK-DIFF-FUNC-FILTER-NEXT: ; ModuleID = {{.+}}
-; CHECK-DIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-DIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-DIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-FUNC-FILTER-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-FUNC-FILTER: entry:
 ; CHECK-DIFF-FUNC-FILTER:-  %a = add i32 2, 3
 ; CHECK-DIFF-FUNC-FILTER:-  ret i32 %a
 ; CHECK-DIFF-FUNC-FILTER:+  ret i32 5
-; CHECK-DIFF-FUNC-FILTER: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-DIFF-FUNC-FILTER: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-DIFF-FUNC-FILTER: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-DIFF-FUNC-FILTER: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-DIFF-FUNC-FILTER: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-DIFF-FUNC-FILTER: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-DIFF-FUNC-FILTER: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-DIFF-FUNC-FILTER: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump At Start: ***
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump At Start ***
 ; CHECK-DIFF-PRINT-MOD-SCOPE: ModuleID = {{.+}}
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-PRINT-MOD-SCOPE: entry:
 ; CHECK-DIFF-PRINT-MOD-SCOPE:-  %a = add i32 2, 3
 ; CHECK-DIFF-PRINT-MOD-SCOPE:-  ret i32 %a
 ; CHECK-DIFF-PRINT-MOD-SCOPE:+  ret i32 5
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-PRINT-MOD-SCOPE: entry:
 ; CHECK-DIFF-PRINT-MOD-SCOPE:-  %a = add i32 2, 3
 ; CHECK-DIFF-PRINT-MOD-SCOPE:-  ret i32 %a
 ; CHECK-DIFF-PRINT-MOD-SCOPE:+  ret i32 5
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-DIFF-PRINT-MOD-SCOPE: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump At Start: ***
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump At Start ***
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-FILTER-MULT-FUNC: entry:
 ; CHECK-DIFF-FILTER-MULT-FUNC:-  %a = add i32 2, 3
 ; CHECK-DIFF-FILTER-MULT-FUNC:-  ret i32 %a
 ; CHECK-DIFF-FILTER-MULT-FUNC:+  ret i32 5
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-FILTER-MULT-FUNC: entry:
 ; CHECK-DIFF-FILTER-MULT-FUNC:-  %a = add i32 2, 3
 ; CHECK-DIFF-FILTER-MULT-FUNC:-  ret i32 %a
 ; CHECK-DIFF-FILTER-MULT-FUNC:+  ret i32 5
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-DIFF-FILTER-MULT-FUNC: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-DIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-DIFF-FILTER-PASSES: *** IR Dump At Start: *** (function: g)
-; CHECK-DIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass (function: g) omitted because no change ***
-; CHECK-DIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass (function: f) filtered out ***
-; CHECK-DIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-DIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-DIFF-FILTER-PASSES: *** IR Dump At Start ***
+; CHECK-DIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass on g omitted because no change ***
+; CHECK-DIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass on f filtered out ***
+; CHECK-DIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump At Start: *** (function: g)
-; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump At Start ***
+; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-FILTER-MULT-PASSES: entry:
 ; CHECK-DIFF-FILTER-MULT-PASSES:-  %a = add i32 2, 3
 ; CHECK-DIFF-FILTER-MULT-PASSES:-  ret i32 %a
 ; CHECK-DIFF-FILTER-MULT-PASSES:+  ret i32 5
-; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass (function: g) omitted because no change ***
-; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass on g omitted because no change ***
+; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-FILTER-MULT-PASSES: entry:
 ; CHECK-DIFF-FILTER-MULT-PASSES:-  %a = add i32 2, 3
 ; CHECK-DIFF-FILTER-MULT-PASSES:-  ret i32 %a
 ; CHECK-DIFF-FILTER-MULT-PASSES:+  ret i32 5
-; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-DIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass (function: g) filtered out ***
-; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump At Start: *** (function: f)
-; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass on g filtered out ***
+; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump At Start ***
+; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-FILTER-FUNC-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-FILTER-FUNC-PASSES: entry:
 ; CHECK-DIFF-FILTER-FUNC-PASSES:-  %a = add i32 2, 3
 ; CHECK-DIFF-FILTER-FUNC-PASSES:-  ret i32 %a
 ; CHECK-DIFF-FILTER-FUNC-PASSES:+  ret i32 5
-; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-DIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump At Start: ***
-; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump At Start ***
+; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-MULT-PASSES-FILTER-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: entry:
 ; CHECK-DIFF-MULT-PASSES-FILTER-FUNC:-  %a = add i32 2, 3
 ; CHECK-DIFF-MULT-PASSES-FILTER-FUNC:-  ret i32 %a
 ; CHECK-DIFF-MULT-PASSES-FILTER-FUNC:+  ret i32 5
-; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: f) omitted because no change ***
+; CHECK-DIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f omitted because no change ***
 
-; CHECK-DIFF-QUIET-SIMPLE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-QUIET-SIMPLE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-QUIET-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-DIFF-QUIET-SIMPLE: entry:
@@ -265,7 +265,7 @@
 ; CHECK-DIFF-QUIET-SIMPLE-NEXT:-  ret i32 %a
 ; CHECK-DIFF-QUIET-SIMPLE-NEXT:+  ret i32 5
 ; CHECK-DIFF-QUIET-SIMPLE-EMPTY:
-; CHECK-DIFF-QUIET-SIMPLE-NEXT: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-SIMPLE-NEXT: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-DIFF-QUIET-SIMPLE: entry:
@@ -274,8 +274,8 @@
 ; CHECK-DIFF-QUIET-SIMPLE-NEXT:+  ret i32 5
 ; CHECK-DIFF-QUIET-SIMPLE-NOT: *** IR{{.*}}
 
-; CHECK-DIFF-QUIET-FUNC-FILTER-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-FUNC-FILTER: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-FUNC-FILTER-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-FUNC-FILTER: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-FUNC-FILTER-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-FUNC-FILTER: entry:
 ; CHECK-DIFF-QUIET-FUNC-FILTER:-  %a = add i32 2, 3
@@ -283,15 +283,15 @@
 ; CHECK-DIFF-QUIET-FUNC-FILTER:+  ret i32 5
 ; CHECK-DIFF-QUIET-FUNC-FILTER-NOT: *** IR{{.*}}
 
-; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE: entry:
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE:-  %a = add i32 2, 3
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE:-  ret i32 %a
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE:+  ret i32 5
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-EMPTY:
-; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NEXT: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NEXT: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE: entry:
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE:-  %a = add i32 2, 3
@@ -299,15 +299,15 @@
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE:+  ret i32 5
 ; CHECK-DIFF-QUIET-PRINT-MOD-SCOPE-NOT: *** IR{{.*}}
 
-; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC: entry:
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC:-  %a = add i32 2, 3
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC:-  ret i32 %a
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC:+  ret i32 5
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-EMPTY:
-; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-NEXT: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-NEXT: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC: entry:
 ; CHECK-DIFF-QUIET-FILTER-MULT-FUNC:-  %a = add i32 2, 3
@@ -317,15 +317,15 @@
 
 ; CHECK-DIFF-QUIET-FILTER-PASSES-NONE-NOT: *** IR
 
-; CHECK-DIFF-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-DIFF-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES: entry:
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES:-  %a = add i32 2, 3
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES:-  ret i32 %a
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES:+  ret i32 5
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES-EMPTY:
-; CHECK-DIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES: entry:
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES:-  %a = add i32 2, 3
@@ -333,8 +333,8 @@
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES:+  ret i32 5
 ; CHECK-DIFF-QUIET-FILTER-MULT-PASSES-NOT: *** IR
 
-; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES: entry:
 ; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES:-  %a = add i32 2, 3
@@ -342,8 +342,8 @@
 ; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES:+  ret i32 5
 ; CHECK-DIFF-QUIET-FILTER-FUNC-PASSES-NOT: *** IR
 
-; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC: entry:
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC:-  %a = add i32 2, 3
@@ -351,126 +351,126 @@
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC:+  ret i32 5
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR
 
-; CHECK-CDIFF-SIMPLE: *** IR Dump At Start: ***
+; CHECK-CDIFF-SIMPLE: *** IR Dump At Start ***
 ; CHECK-CDIFF-SIMPLE: ModuleID = {{.+}}
-; CHECK-CDIFF-SIMPLE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-CDIFF-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-CDIFF-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-CDIFF-SIMPLE: entry:
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-SIMPLE: *** IR Pass PassManager{{.*}} (function: g) ignored ***
-; CHECK-CDIFF-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-SIMPLE: *** IR Pass PassManager{{.*}} on g ignored ***
+; CHECK-CDIFF-SIMPLE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-CDIFF-SIMPLE: entry:
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-SIMPLE: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-CDIFF-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-CDIFF-SIMPLE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-CDIFF-SIMPLE: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-CDIFF-SIMPLE: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-CDIFF-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-CDIFF-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-CDIFF-SIMPLE: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-CDIFF-FUNC-FILTER: *** IR Dump At Start: ***
+; CHECK-CDIFF-FUNC-FILTER: *** IR Dump At Start ***
 ; CHECK-CDIFF-FUNC-FILTER-NEXT: ; ModuleID = {{.+}}
-; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-FUNC-FILTER-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-FUNC-FILTER: entry:
 ; CHECK-CDIFF-FUNC-FILTER:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-FUNC-FILTER:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-FUNC-FILTER:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-FUNC-FILTER: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-CDIFF-FUNC-FILTER: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-CDIFF-FUNC-FILTER: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-CDIFF-FUNC-FILTER: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-CDIFF-FUNC-FILTER: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump At Start: ***
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump At Start ***
 ; CHECK-CDIFF-PRINT-MOD-SCOPE: ModuleID = {{.+}}
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-PRINT-MOD-SCOPE: entry:
 ; CHECK-CDIFF-PRINT-MOD-SCOPE:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-PRINT-MOD-SCOPE:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-PRINT-MOD-SCOPE:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-PRINT-MOD-SCOPE: entry:
 ; CHECK-CDIFF-PRINT-MOD-SCOPE:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-PRINT-MOD-SCOPE:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-PRINT-MOD-SCOPE:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-CDIFF-PRINT-MOD-SCOPE: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump At Start: ***
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump At Start ***
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-FILTER-MULT-FUNC: entry:
 ; CHECK-CDIFF-FILTER-MULT-FUNC:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-FUNC:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-FUNC:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-FILTER-MULT-FUNC: entry:
 ; CHECK-CDIFF-FILTER-MULT-FUNC:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-FUNC:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-FUNC:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Pass PassManager{{.*}} (function: f) ignored ***
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Pass ModuleToFunctionPassAdaptor (module) ignored ***
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After VerifierPass (module) omitted because no change ***
-; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After PrintModulePass (module) omitted because no change ***
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Pass PassManager{{.*}} on f ignored ***
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-CDIFF-FILTER-MULT-FUNC: *** IR Dump After PrintModulePass on [module] omitted because no change ***
 
-; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-CDIFF-FILTER-PASSES: *** IR Dump At Start: *** (function: g)
-; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass (function: g) omitted because no change ***
-; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass (function: f) filtered out ***
-; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-CDIFF-FILTER-PASSES: *** IR Dump At Start ***
+; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass on g omitted because no change ***
+; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After InstSimplifyPass on f filtered out ***
+; CHECK-CDIFF-FILTER-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump At Start: *** (function: g)
-; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump At Start ***
+; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-FILTER-MULT-PASSES: entry:
 ; CHECK-CDIFF-FILTER-MULT-PASSES:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-PASSES:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-PASSES:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass (function: g) omitted because no change ***
-; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass on g omitted because no change ***
+; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-FILTER-MULT-PASSES: entry:
 ; CHECK-CDIFF-FILTER-MULT-PASSES:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-PASSES:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-FILTER-MULT-PASSES:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-CDIFF-FILTER-MULT-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass (function: g) filtered out ***
-; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump At Start: *** (function: f)
-; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass on g filtered out ***
+; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump At Start ***
+; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-FILTER-FUNC-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-FILTER-FUNC-PASSES: entry:
 ; CHECK-CDIFF-FILTER-FUNC-PASSES:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-FILTER-FUNC-PASSES:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-FILTER-FUNC-PASSES:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass (function: f) omitted because no change ***
+; CHECK-CDIFF-FILTER-FUNC-PASSES: *** IR Dump After NoOpFunctionPass on f omitted because no change ***
 
-; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump At Start: ***
-; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: g) filtered out ***
-; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump At Start ***
+; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
+; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: entry:
 ; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC:{{.\[32m\+}}  ret i32 5{{.\[0m}}
-; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass (function: f) omitted because no change ***
+; CHECK-CDIFF-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f omitted because no change ***
 
-; CHECK-CDIFF-QUIET-SIMPLE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-QUIET-SIMPLE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-QUIET-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-CDIFF-QUIET-SIMPLE: entry:
@@ -478,7 +478,7 @@
 ; CHECK-CDIFF-QUIET-SIMPLE-NEXT:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-QUIET-SIMPLE-NEXT:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-SIMPLE-EMPTY:
-; CHECK-CDIFF-QUIET-SIMPLE-NEXT: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-SIMPLE-NEXT: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-CDIFF-QUIET-SIMPLE: entry:
@@ -487,8 +487,8 @@
 ; CHECK-CDIFF-QUIET-SIMPLE-NEXT:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-SIMPLE-NOT: *** IR{{.*}}
 
-; CHECK-CDIFF-QUIET-FUNC-FILTER-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-FUNC-FILTER: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-FUNC-FILTER-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-FUNC-FILTER: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-FUNC-FILTER-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-FUNC-FILTER: entry:
 ; CHECK-CDIFF-QUIET-FUNC-FILTER:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
@@ -496,15 +496,15 @@
 ; CHECK-CDIFF-QUIET-FUNC-FILTER:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FUNC-FILTER-NOT: *** IR{{.*}}
 
-; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE: entry:
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-EMPTY:
-; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NEXT: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NEXT: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE: entry:
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
@@ -512,15 +512,15 @@
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-PRINT-MOD-SCOPE-NOT: *** IR{{.*}}
 
-; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC: entry:
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-EMPTY:
-; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-NEXT: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-NEXT: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC: entry:
 ; CHECK-CDIFF-QUIET-FILTER-MULT-FUNC:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
@@ -530,15 +530,15 @@
 
 ; CHECK-CDIFF-QUIET-FILTER-PASSES-NONE-NOT: *** IR
 
-; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: g)
+; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES: entry:
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES-EMPTY:
-; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES: entry:
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
@@ -546,8 +546,8 @@
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-MULT-PASSES-NOT: *** IR
 
-; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES: entry:
 ; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
@@ -555,8 +555,8 @@
 ; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-QUIET-FILTER-FUNC-PASSES-NOT: *** IR
 
-; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR Dump {{.*(At Start:|no change|ignored|filtered out)}} ***
-; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass *** (function: f)
+; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR Dump {{.*(At Start|no change|ignored|filtered out)}} ***
+; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC: entry:
 ; CHECK-CDIFF-QUIET-MULT-PASSES-FILTER-FUNC:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
diff --git a/test/Other/change-printer.ll b/test/Other/change-printer.ll
index dff2ef4..3bd2ccf 100644
--- a/test/Other/change-printer.ll
+++ b/test/Other/change-printer.ll
@@ -107,220 +107,220 @@
   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 on [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 Pass PassManager{{.*}} on g ignored ***
+; 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 PassManager{{.*}} on f ignored ***
+; CHECK-SIMPLE-BEFORE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
+; CHECK-SIMPLE-BEFORE: *** IR Dump After VerifierPass on [module] omitted because no change ***
+; CHECK-SIMPLE-BEFORE: *** IR Dump After PrintModulePass on [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
diff --git a/test/Other/loop-deletion-printer.ll b/test/Other/loop-deletion-printer.ll
index 6cb29ae..53971b8 100644
--- a/test/Other/loop-deletion-printer.ll
+++ b/test/Other/loop-deletion-printer.ll
@@ -11,7 +11,7 @@
 ; 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() {
diff --git a/test/Other/loop-pass-printer.ll b/test/Other/loop-pass-printer.ll
index de2cf3d..10870cc 100644
--- a/test/Other/loop-pass-printer.ll
+++ b/test/Other/loop-pass-printer.ll
@@ -46,8 +46,7 @@
 ; 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
diff --git a/test/Other/module-pass-printer.ll b/test/Other/module-pass-printer.ll
index 931d646..b43ef7d 100644
--- a/test/Other/module-pass-printer.ll
+++ b/test/Other/module-pass-printer.ll
@@ -8,9 +8,10 @@
 ; 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
@@ -32,6 +33,7 @@
 ; 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 =
diff --git a/test/Other/opt-bisect-new-pass-manager.ll b/test/Other/opt-bisect-new-pass-manager.ll
index 9ed5edb..98080dc 100644
--- a/test/Other/opt-bisect-new-pass-manager.ll
+++ b/test/Other/opt-bisect-new-pass-manager.ll
@@ -11,19 +11,19 @@
 ; 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
 
@@ -32,67 +32,67 @@
 ; 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()
diff --git a/test/Other/print-module-scope.ll b/test/Other/print-module-scope.ll
index 08d6bbb..805297d 100644
--- a/test/Other/print-module-scope.ll
+++ b/test/Other/print-module-scope.ll
@@ -16,22 +16,18 @@
 ; 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
diff --git a/test/Other/scc-deleted-printer.ll b/test/Other/scc-deleted-printer.ll
index f7b97c3..05b2f45 100644
--- a/test/Other/scc-deleted-printer.ll
+++ b/test/Other/scc-deleted-printer.ll
@@ -3,15 +3,15 @@
 ; 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 {
diff --git a/test/Other/scc-pass-printer.ll b/test/Other/scc-pass-printer.ll
index 8bf3d88..453fbeb 100644
--- a/test/Other/scc-pass-printer.ll
+++ b/test/Other/scc-pass-printer.ll
@@ -20,12 +20,12 @@
 ; 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()
 
@@ -35,7 +35,7 @@
 ; 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()
@@ -44,7 +44,7 @@
 ; 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()
diff --git a/test/ThinLTO/X86/printer.ll b/test/ThinLTO/X86/printer.ll
index 79f4f56..3ba8189 100644
--- a/test/ThinLTO/X86/printer.ll
+++ b/test/ThinLTO/X86/printer.ll
@@ -1,8 +1,8 @@
 ; 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"