handling invalidated passes in change printers

[jamieschmeiser]

Summary

The various change printers do not handle invalidated passes, even though
significant changes may be made to the IR by a pass that invalidates itself.
The reason was that the IR, being invalidated, was not available after the
pass.

Handle this by saving the module and a list of the functions in the module, on
the IR stack used by the print-changed functions, along with representations of
the functions. When a pass is invalidated, start with the saved module and create
the after representations of the now existing functions, matching and comparing them
with the saved before functions.

[jamieschmeiser]

ping

[jamieschmeiser]

ping

[jamieschmeiser]

ping

llvm/include/llvm/Passes/StandardInstrumentations.h

#ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
   SmallVector<StringRef, 8> PassStack;
 #endif
 
   static cl::opt<bool> VerifyPreservedCFG;
   void registerCallbacks(PassInstrumentationCallbacks &PIC,
                          FunctionAnalysisManager &FAM);
 };
 
+// Class that holds information for reconstructing essential parts of an IR
+// when a pass is invalidated.  The IR is not provided in the callback
+// when a pass is invalidated because the IR may have been deleted.  This
+// class holds on to the module and the function names so that a representation
+// can be built up for comparison purposes.
+class DataForInvalidatedIR {
+public:
+  DataForInvalidatedIR() {}
+
+  //  const Module *getModule() const { return SavedModule; }
+  const std::string getName() const { return Name; }
+
+  // call HandleFunc on each of the saved functions to create the comparable
+  // after data when a pass has been invalidated.
+  void generateInvalidatedIRRep(
+      std::function<void(const Function *F)> HandleFunc) const;
+
+  bool haveMultipleFunctionNames() const {
+    return SavedFunctionNames.size() > 1;
+  }
+
+  // Build up the data needed to create a representation when a pass
+  // gets invalidated.
+  void saveRepForInvalidated(Any IR);
+
+  // Is the data valid?
+  bool haveValidData() const { return SavedModule; }
+
+protected:
+  const Module *SavedModule = nullptr;
+  std::string Name;
+  SmallVector<std::string> SavedFunctionNames;
+};
+
+// Class that holds the string representation of the IR and the
+// data needed when the IR is invalidated.
+class StringIR : public DataForInvalidatedIR {
+public:
+  StringIR() {}
+
+  bool operator==(const StringIR &that) const { return Str == that.str(); }
+
+  // Accessors for the represenation of the IR.
+  std::string &str() { return Str; }
+  const std::string &str() const { return Str; }
+
+protected:
+  std::string Str;
+};
+
+inline raw_ostream &operator<<(raw_ostream &Out, const StringIR &S) {
+  Out << S.str();
+  return Out;
+}
+
 // Base class for classes that report changes to the IR.
 // It presents an interface for such classes and provides calls
 // on various events as the new pass manager transforms the IR.
 // It also provides filtering of information based on hidden options
 // specifying which functions are interesting.
 // Calls are made for the following events/queries:
 // 1.  The initial IR processed.
 // 2.  To get the representation of the IR (of type \p T).
public:
   virtual ~ChangeReporter();
 
   // Determine if this pass/IR is interesting and if so, save the IR
   // otherwise it is left on the stack without data.
   void saveIRBeforePass(Any IR, StringRef PassID, StringRef PassName);
   // Compare the IR from before the pass after the pass.
   void handleIRAfterPass(Any IR, StringRef PassID, StringRef PassName);
   // Handle the situation where a pass is invalidated.
-  void handleInvalidatedPass(StringRef PassID);
+  void handleInvalidatedPass(StringRef PassID, StringRef PassName);
 
 protected:
   // Register required callbacks.
   void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC);
 
   // Called on the first IR processed.
   virtual void handleInitialIR(Any IR) = 0;
   // Called before and after a pass to get the representation of the IR.
-  virtual void generateIRRepresentation(Any IR, StringRef PassID,
-                                        IRUnitT &Output) = 0;
+  virtual void generateIRRepresentation(Any IR, IRUnitT &Output) = 0;
   // Called when the pass is not iteresting.
   virtual void omitAfter(StringRef PassID, std::string &Name) = 0;
   // Called when an interesting IR has changed.
-  virtual void handleAfter(StringRef PassID, std::string &Name,
+  virtual void handleAfter(StringRef PassID, const std::string &Name,
                            const IRUnitT &Before, const IRUnitT &After,
-                           Any) = 0;
-  // Called when an interesting pass is invalidated.
-  virtual void handleInvalidated(StringRef PassID) = 0;
+                           bool compareMultiple) = 0;
+  // Called when an interesting pass is invalidated but no IR available.
+  virtual void handleInvalidatedUnavailableBanner(StringRef PassID) = 0;
   // Called when the IR or pass is not interesting.
   virtual void handleFiltered(StringRef PassID, std::string &Name) = 0;
   // Called when an ignored pass is encountered.
   virtual void handleIgnored(StringRef PassID, std::string &Name) = 0;
 
   // Stack of IRs before passes.
   std::vector<IRUnitT> BeforeStack;
   // Is this the first IR seen?

 class TextChangeReporter : public ChangeReporter<IRUnitT> {
 protected:
   TextChangeReporter(bool Verbose);
 
   // Print a module dump of the first IR that is changed.
   void handleInitialIR(Any IR) override;
   // Report that the IR was omitted because it did not change.
   void omitAfter(StringRef PassID, std::string &Name) override;
-  // Report that the pass was invalidated.
-  void handleInvalidated(StringRef PassID) override;
+  // Called when an interesting pass is invalidated but no IR available.
+  void handleInvalidatedUnavailableBanner(StringRef PassID) override;
   // Report that the IR was filtered out.
   void handleFiltered(StringRef PassID, std::string &Name) override;
   // Report that the pass was ignored.
   void handleIgnored(StringRef PassID, std::string &Name) override;
   // Make substitutions in \p S suitable for reporting changes
   // after the pass and then print it.
 
   raw_ostream &Out;
 };
 
 // A change printer based on the string representation of the IR as created
 // by unwrapAndPrint.  The string representation is stored in a std::string
 // to preserve it as the IR changes in each pass.  Note that the banner is
 // included in this representation but it is massaged before reporting.
-class IRChangedPrinter : public TextChangeReporter<std::string> {
+class IRChangedPrinter : public TextChangeReporter<StringIR> {
 public:
   IRChangedPrinter(bool VerboseMode)
-      : TextChangeReporter<std::string>(VerboseMode) {}
+      : TextChangeReporter<StringIR>(VerboseMode) {}
   ~IRChangedPrinter() override;
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 protected:
   // Called before and after a pass to get the representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
-                                std::string &Output) override;
+  void generateIRRepresentation(Any IR, StringIR &Output) override;
   // Called when an interesting IR has changed.
-  void handleAfter(StringRef PassID, std::string &Name,
-                   const std::string &Before, const std::string &After,
-                   Any) override;
+  void handleAfter(StringRef PassID, const std::string &Name,
+                   const StringIR &Before, const StringIR &After,
+                   bool compareMultiple) override;
 };
 
 // Information that needs to be saved for a basic block in order to compare
 // before and after the pass to determine if it was changed by a pass.
 template <typename T> class BlockDataT {
 public:
   BlockDataT(const BasicBlock &B) : Label(B.getName().str()), Data(B) {
     raw_string_ostream SS(Body);
public:
   std::string getEntryBlockName() const { return EntryBlockName; }
 
 protected:
   std::string EntryBlockName;
 };
 
 // The data saved for comparing IRs.
 template <typename T>
-class IRDataT : public OrderedChangedData<FuncDataT<T>> {};
+class IRDataT : public DataForInvalidatedIR,
+                public OrderedChangedData<FuncDataT<T>> {};
 
 // Abstract template base class for a class that compares two IRs.  The
 // class is created with the 2 IRs to compare and then compare is called.
 // The static function analyzeIR is used to build up the IR representation.
 template <typename T> class IRComparer {
 public:
   IRComparer(const IRDataT<T> &Before, const IRDataT<T> &After)
       : Before(Before), After(After) {}
 
   // Compare the 2 IRs. \p handleFunctionCompare is called to handle the
   // compare of a function. When \p InModule is set,
   // this function is being handled as part of comparing a module.
   void compare(
-      bool CompareModule,
+      bool CompareMultiple,
       std::function<void(bool InModule, unsigned Minor,
                          const FuncDataT<T> &Before, const FuncDataT<T> &After)>
           CompareFunc);
 
   // Analyze \p IR and build the IR representation in \p Data.
   static void analyzeIR(Any IR, IRDataT<T> &Data);
 
 protected:
public:
   InLineChangePrinter(bool VerboseMode, bool ColourMode)
       : TextChangeReporter<IRDataT<EmptyData>>(VerboseMode),
         UseColour(ColourMode) {}
   ~InLineChangePrinter() override;
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 protected:
   // Create a representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
+  virtual void generateIRRepresentation(Any IR,
                                         IRDataT<EmptyData> &Output) override;
 
   // Called when an interesting IR has changed.
-  void handleAfter(StringRef PassID, std::string &Name,
+  virtual void handleAfter(StringRef PassID, const std::string &Name,
                            const IRDataT<EmptyData> &Before,
-                   const IRDataT<EmptyData> &After, Any) override;
+                           const IRDataT<EmptyData> &After,
+                           bool compareMultiple) override;
 
   void handleFunctionCompare(StringRef Name, StringRef Prefix, StringRef PassID,
                              StringRef Divider, bool InModule, unsigned Minor,
                              const FuncDataT<EmptyData> &Before,
                              const FuncDataT<EmptyData> &After);
 
   bool UseColour;
 };

 
 protected:
   // Initialize the HTML file and output the header.
   bool initializeHTML();
 
   // Called on the first IR processed.
   void handleInitialIR(Any IR) override;
   // Called before and after a pass to get the representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
-                                IRDataT<DCData> &Output) override;
+  void generateIRRepresentation(Any IR, IRDataT<DCData> &Output) override;
   // Called when the pass is not iteresting.
   void omitAfter(StringRef PassID, std::string &Name) override;
   // Called when an interesting IR has changed.
-  void handleAfter(StringRef PassID, std::string &Name,
+  void handleAfter(StringRef PassID, const std::string &Name,
                    const IRDataT<DCData> &Before, const IRDataT<DCData> &After,
-                   Any) override;
-  // Called when an interesting pass is invalidated.
-  void handleInvalidated(StringRef PassID) override;
+                   bool compareMultiple) override;
+  // Called when an interesting pass is invalidated but no IR available.
+  void handleInvalidatedUnavailableBanner(StringRef PassID) override;
   // Called when the IR or pass is not interesting.
   void handleFiltered(StringRef PassID, std::string &Name) override;
   // Called when an ignored pass is encountered.
   void handleIgnored(StringRef PassID, std::string &Name) override;
 
   // Generate the pdf file into \p Dir / \p PDFFileName using \p DotFile as
   // input and return the html <a> tag with \Text as the content.
   static std::string genHTML(StringRef Text, StringRef DotFile,
public:
   // Register all the standard instrumentation callbacks. If \p FAM is nullptr
   // then PreservedCFGChecker is not enabled.
   void registerCallbacks(PassInstrumentationCallbacks &PIC,
                          FunctionAnalysisManager *FAM = nullptr);
 
   TimePassesHandler &getTimePasses() { return TimePasses; }
 };
 
-extern template class ChangeReporter<std::string>;
-extern template class TextChangeReporter<std::string>;
+extern template class ChangeReporter<StringIR>;
+extern template class TextChangeReporter<StringIR>;
 
 extern template class BlockDataT<EmptyData>;
 extern template class FuncDataT<EmptyData>;
 extern template class IRDataT<EmptyData>;
 extern template class ChangeReporter<IRDataT<EmptyData>>;
 extern template class TextChangeReporter<IRDataT<EmptyData>>;
 extern template class IRComparer<EmptyData>;
 
 } // namespace llvm
 
 #endif

llvm/lib/Passes/StandardInstrumentations.cpp

 
 cl::opt<bool> PreservedCFGCheckerInstrumentation::VerifyPreservedCFG(
     "verify-cfg-preserved", cl::Hidden,
 #ifdef NDEBUG
     cl::init(false)
 #else
     cl::init(true)
 #endif
-    );
 
 // An option that supports the -print-changed option.  See
 // the description for -print-changed for an explanation of the use
 // of this option.  Note that this option has no effect without -print-changed.
 static cl::opt<bool>
     PrintChangedBefore("print-before-changed",
                        cl::desc("Print before passes that change them"),
                        cl::init(false), cl::Hidden);
void ChangeReporter<T>::saveIRBeforePass(Any IR, StringRef PassID,
   if (InitialIR) {
     InitialIR = false;
     if (VerboseMode)
       handleInitialIR(IR);
   }
 
   // Save the IR representation on the stack.
   T &Data = BeforeStack.back();
-  generateIRRepresentation(IR, PassID, Data);
+  generateIRRepresentation(IR, Data);
+  Data.saveRepForInvalidated(IR);
+}
+
+void DataForInvalidatedIR::generateInvalidatedIRRep(
+    std::function<void(const Function *F)> HandleFunc) const {
+  assert(haveValidData() && "Expected valid data");
+  for (auto S : SavedFunctionNames)
+    if (const Function *F = SavedModule->getFunction(S)) {
+      assert(isInterestingFunction(*F) && "Expecting non-filtered function");
+      HandleFunc(F);
+    }
+}
+
+void DataForInvalidatedIR::saveRepForInvalidated(Any IR) {
+  if (any_isa<const Module *>(IR)) {
+    // Do not save module since we should not produce anything when
+    // a module becomes invalidated.
+    return;
+  }
+
+  // Save the name for printing in banners
+  Name = getIRName(IR);
+
+  auto saveModuleData = [&](const Module *M) {
+    if (forcePrintModuleIR()) {
+      SavedModule = M;
+      for (auto &F : *M)
+        // filtering
+        if (isInterestingFunction(F))
+          SavedFunctionNames.emplace_back(F.getName().str());
+      return true;
+    }
+    return false;
+  };
+
+  if (any_isa<const Function *>(IR)) {
+    // Save the function
+    const Function &F = *any_cast<const Function *>(IR);
+    if (!saveModuleData(F.getParent()))
+      // filtering
+      if (isInterestingFunction(F)) {
+        SavedModule = F.getParent();
+        SavedFunctionNames.emplace_back(F.getName().str());
+      }
+    return;
+  }
+
+  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
+    // Save all functions in SCC
+    const LazyCallGraph::SCC &C = *any_cast<const LazyCallGraph::SCC *>(IR);
+    if (!saveModuleData(C.begin()->getFunction().getParent()))
+      for (const LazyCallGraph::Node &N : C) {
+        const Function &F = N.getFunction();
+        // filtering
+        if (!F.isDeclaration() && isInterestingFunction(F)) {
+          SavedModule = F.getParent();
+          SavedFunctionNames.emplace_back(F.getName().str());
+        }
+      }
+    return;
+  }
+
+  if (any_isa<const Loop *>(IR)) {
+    // Save function containing loop
+    const Loop &L = *any_cast<const Loop *>(IR);
+    const Function &F = *L.getHeader()->getParent();
+    if (!saveModuleData(F.getParent()))
+      // filtering
+      if (isInterestingFunction(F)) {
+        SavedModule = F.getParent();
+        SavedFunctionNames.emplace_back(F.getName().str());
+      }
+    return;
+  }
+
+  llvm_unreachable("Unknown IR unit");
 }
 
 template <typename T>
 void ChangeReporter<T>::handleIRAfterPass(Any IR, StringRef PassID,
                                           StringRef PassName) {
   assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
 
   std::string Name = getIRName(IR);
 
   if (isIgnored(PassID)) {
     if (VerboseMode)
       handleIgnored(PassID, Name);
   } else if (!isInteresting(IR, PassID, PassName)) {
     if (VerboseMode)
       handleFiltered(PassID, Name);
   } else {
     // Get the before rep from the stack
     T &Before = BeforeStack.back();
     // Create the after rep
     T After;
-    generateIRRepresentation(IR, PassID, After);
+    generateIRRepresentation(IR, After);
 
     // Was there a change in IR?
     if (Before == After) {
       if (VerboseMode)
         omitAfter(PassID, Name);
     } else
-      handleAfter(PassID, Name, Before, After, IR);
+      handleAfter(PassID, Name, Before, After, getModuleForComparison(IR));
   }
   BeforeStack.pop_back();
 }
 
 template <typename T>
-void ChangeReporter<T>::handleInvalidatedPass(StringRef PassID) {
+void ChangeReporter<T>::handleInvalidatedPass(StringRef PassID,
+                                              StringRef PassName) {
   assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
 
-  // Always flag it as invalidated as we cannot determine when
-  // a pass for a filtered function is invalidated since we do not
-  // get the IR in the call.  Also, the output is just alternate
-  // forms of the banner anyway.
-  if (VerboseMode)
-    handleInvalidated(PassID);
+  SmallString<60> IPassID = formatv("Invalidated {0}", PassID);
+  if (isIgnored(PassID)) {
+    if (VerboseMode) {
+      std::string Name = "unknown IR";
+      handleIgnored(IPassID, Name);
+    }
+  } else if (!isInteresting(Any(), PassID, PassName)) {
+    if (VerboseMode) {
+      std::string Name = "unknown IR";
+      handleFiltered(IPassID, Name);
+    }
+  } else {
+    T &Before = BeforeStack.back();
+    if (!Before.haveValidData())
+      handleInvalidatedUnavailableBanner(IPassID);
+    else {
+      // Create a representation from the saved before data to compare against.
+      T After;
+      auto Func = [&](const Function *F) {
+        generateIRRepresentation(Any(F), After);
+      };
+      Before.generateInvalidatedIRRep(Func);
+      handleAfter(IPassID, Before.getName(), Before, After,
+                  Before.haveMultipleFunctionNames());
+    }
+  }
   BeforeStack.pop_back();
 }
 
 template <typename T>
 void ChangeReporter<T>::registerRequiredCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerBeforeNonSkippedPassCallback([&PIC, this](StringRef P, Any IR) {
     saveIRBeforePass(IR, P, PIC.getPassNameForClassName(P));
   });
 
   PIC.registerAfterPassCallback(
       [&PIC, this](StringRef P, Any IR, const PreservedAnalyses &) {
         handleIRAfterPass(IR, P, PIC.getPassNameForClassName(P));
       });
   PIC.registerAfterPassInvalidatedCallback(
-      [this](StringRef P, const PreservedAnalyses &) {
-        handleInvalidatedPass(P);
+      [&PIC, this](StringRef P, const PreservedAnalyses &) {
+        handleInvalidatedPass(P, PIC.getPassNameForClassName(P));
       });
 }
 
 template <typename T>
 TextChangeReporter<T>::TextChangeReporter(bool Verbose)
     : ChangeReporter<T>(Verbose), Out(dbgs()) {}
 
 template <typename T> void TextChangeReporter<T>::handleInitialIR(Any IR) {
   // Always print the module.
   // Unwrap and print directly to avoid filtering problems in general routines.
   auto *M = unwrapModule(IR, /*Force=*/true);
   assert(M && "Expected module to be unwrapped when forced.");
   Out << "*** IR Dump At Start ***\n";
   M->print(Out, nullptr);
 }
 
 template <typename T>
 void TextChangeReporter<T>::omitAfter(StringRef PassID, std::string &Name) {
   Out << formatv("*** IR Dump After {0} on {1} omitted because no change ***\n",
                  PassID, Name);
 }
 
-template <typename T>
-void TextChangeReporter<T>::handleInvalidated(StringRef PassID) {
-  Out << formatv("*** IR Pass {0} invalidated ***\n", PassID);
+template <typename IRUnitT>
+void TextChangeReporter<IRUnitT>::handleInvalidatedUnavailableBanner(
+    StringRef PassID) {
+  Out << formatv(
+      "*** IR Dump After {0} but IR unavailable or filtered out ***\n", PassID);
 }
 
 template <typename T>
 void TextChangeReporter<T>::handleFiltered(StringRef PassID,
                                            std::string &Name) {
   SmallString<20> Banner =
       formatv("*** IR Dump After {0} on {1} filtered out ***\n", PassID, Name);
   Out << Banner;
 }
 
 template <typename T>
 void TextChangeReporter<T>::handleIgnored(StringRef PassID, std::string &Name) {
   Out << formatv("*** IR Pass {0} on {1} ignored ***\n", PassID, Name);
 }
 
 IRChangedPrinter::~IRChangedPrinter() = default;
 
 void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::Verbose ||
       PrintChanged == ChangePrinter::Quiet)
-    TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
+    TextChangeReporter<StringIR>::registerRequiredCallbacks(PIC);
 }
 
-void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
-                                                std::string &Output) {
-  raw_string_ostream OS(Output);
+void IRChangedPrinter::generateIRRepresentation(Any IR, StringIR &Output) {
+  raw_string_ostream OS(Output.str());
   unwrapAndPrint(OS, IR);
   OS.str();
 }
 
-void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
-                                   const std::string &Before,
-                                   const std::string &After, Any) {
+void IRChangedPrinter::handleAfter(StringRef PassID, const std::string &Name,
+                                   const StringIR &Before,
+                                   const StringIR &After,
+                                   bool compareMultiple) {
   // 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()) {
+  if (After.str().empty()) {
     Out << "*** IR Deleted After " << PassID << " on " << Name << " ***\n";
     return;
   }
 
   Out << "*** IR Dump After " << PassID << " on " << Name << " ***\n" << After;
 }
 
 template <typename T>
while (BI != BE) {
     ++BI;
   }
 
   HandleNewData(NewDataQueue);
 }
 
 template <typename T>
 void IRComparer<T>::compare(
-    bool CompareModule,
+    bool CompareMultiple,
     std::function<void(bool InModule, unsigned Minor,
                        const FuncDataT<T> &Before, const FuncDataT<T> &After)>
         CompareFunc) {
-  if (!CompareModule) {
+  if (!CompareMultiple) {
+    if (!Before.getData().size()) {
+      assert(!After.getData().size() && "Inconsistent filtering of functions");
+      // Function was filtered out
+      return;
+    }
+
     // Just handle the single function.
     assert(Before.getData().size() == 1 && After.getData().size() == 1 &&
            "Expected only one function.");
     CompareFunc(false, 0, Before.getData().begin()->getValue(),
                 After.getData().begin()->getValue());
     return;
   }
 
PIC.registerAfterPassCallback(
           if (verifyModule(*M, &errs()))
             report_fatal_error("Broken module found, compilation aborted!");
         }
       });
 }
 
 InLineChangePrinter::~InLineChangePrinter() = default;
 
-void InLineChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
+void InLineChangePrinter::generateIRRepresentation(Any IR,
                                                    IRDataT<EmptyData> &D) {
   IRComparer<EmptyData>::analyzeIR(IR, D);
 }
 
-void InLineChangePrinter::handleAfter(StringRef PassID, std::string &Name,
+void InLineChangePrinter::handleAfter(StringRef PassID, const std::string &Name,
                                       const IRDataT<EmptyData> &Before,
-                                      const IRDataT<EmptyData> &After, Any IR) {
+                                      const IRDataT<EmptyData> &After,
+                                      bool compareMultiple) {
   SmallString<20> Banner =
       formatv("*** IR Dump After {0} on {1} ***\n", PassID, Name);
   Out << Banner;
   IRComparer<EmptyData>(Before, After)
-      .compare(getModuleForComparison(IR),
+      .compare(compareMultiple,
                [&](bool InModule, unsigned Minor,
                    const FuncDataT<EmptyData> &Before,
                    const FuncDataT<EmptyData> &After) -> void {
                  handleFunctionCompare(Name, "", PassID, " on ", InModule,
                                        Minor, Before, After);
                });
   Out << "\n";
 }
void DotCfgChangeReporter::handleFunctionCompare(
   SmallVector<char, 128> SV;
   sys::fs::createUniquePath("cfgdot-%%%%%%.dot", SV, true);
   std::string DotFile = Twine(SV).str();
 
   SmallString<20> PDFFileName = formatv("diff_{0}.pdf", Extender);
   SmallString<200> Text;
 
   Text = formatv("{0}.{1}{2}{3}{4}", Number, Prefix, makeHTMLReady(PassID),
-                 Divider, Name);
+                 Divider, makeHTMLReady(Name));
 
   DotCfgDiff Diff(Text, Before, After);
   std::string EntryBlockName = After.getEntryBlockName();
   // Use the before entry block if the after entry block was removed.
   if (EntryBlockName == "")
     EntryBlockName = Before.getEntryBlockName();
   assert(EntryBlockName != "" && "Expected to find entry block");
 

 }
 
 void DotCfgChangeReporter::handleInitialIR(Any IR) {
   assert(HTML && "Expected outstream to be set");
   *HTML << "<button type=\"button\" class=\"collapsible\">0. "
         << "Initial IR (by function)</button>\n"
         << "<div class=\"content\">\n"
         << "  <p>\n";
-  // Create representation of IR
+  // Create representation of full IR
   IRDataT<DCData> Data;
-  IRComparer<DCData>::analyzeIR(IR, Data);
+  auto *M = unwrapModule(IR, /*Force=*/true);
+  assert(M && "Expected module to be unwrapped when forced.");
+  IRComparer<DCData>::analyzeIR(M, Data);
   // Now compare it against itself, which will have everything the
   // same and will generate the files.
   IRComparer<DCData>(Data, Data)
-      .compare(getModuleForComparison(IR),
+      .compare(true,
                [&](bool InModule, unsigned Minor,
                    const FuncDataT<DCData> &Before,
                    const FuncDataT<DCData> &After) -> void {
                  handleFunctionCompare("", " ", "Initial IR", "", InModule,
                                        Minor, Before, After);
                });
   *HTML << "  </p>\n"
         << "</div><br/>\n";
   ++N;
 }
 
-void DotCfgChangeReporter::generateIRRepresentation(Any IR, StringRef PassID,
+void DotCfgChangeReporter::generateIRRepresentation(Any IR,
                                                     IRDataT<DCData> &Data) {
   IRComparer<DCData>::analyzeIR(IR, Data);
 }
 
 void DotCfgChangeReporter::omitAfter(StringRef PassID, std::string &Name) {
   assert(HTML && "Expected outstream to be set");
   SmallString<20> Banner =
       formatv("  <a>{0}. Pass {1} on {2} omitted because no change</a><br/>\n",
               N, makeHTMLReady(PassID), Name);
   *HTML << Banner;
   ++N;
 }
 
-void DotCfgChangeReporter::handleAfter(StringRef PassID, std::string &Name,
+void DotCfgChangeReporter::handleAfter(StringRef PassID,
+                                       const std::string &Name,
                                        const IRDataT<DCData> &Before,
-                                       const IRDataT<DCData> &After, Any IR) {
+                                       const IRDataT<DCData> &After,
+                                       bool compareMultiple) {
   assert(HTML && "Expected outstream to be set");
   IRComparer<DCData>(Before, After)
-      .compare(getModuleForComparison(IR),
+      .compare(compareMultiple,
                [&](bool InModule, unsigned Minor,
                    const FuncDataT<DCData> &Before,
                    const FuncDataT<DCData> &After) -> void {
                  handleFunctionCompare(Name, " Pass ", PassID, " on ", InModule,
                                        Minor, Before, After);
                });
   *HTML << "    </p></div>\n";
   ++N;
 }
 
-void DotCfgChangeReporter::handleInvalidated(StringRef PassID) {
+void DotCfgChangeReporter::handleInvalidatedUnavailableBanner(
+    StringRef PassID) {
   assert(HTML && "Expected outstream to be set");
-  SmallString<20> Banner =
-      formatv("  <a>{0}. {1} invalidated</a><br/>\n", N, makeHTMLReady(PassID));
-  *HTML << Banner;
+  *HTML << formatv(
+      "  <a>{0}. {1} but IR unavailable or filtered out</a><br/>\n", N,
+      makeHTMLReady(PassID));
   ++N;
 }
 
 void DotCfgChangeReporter::handleFiltered(StringRef PassID, std::string &Name) {
   assert(HTML && "Expected outstream to be set");
   SmallString<20> Banner =
       formatv("  <a>{0}. Pass {1} on {2} filtered out</a><br/>\n", N,
               makeHTMLReady(PassID), Name);
*HTML
       << "</html>\n";
   HTML->flush();
   HTML->close();
 }
 
 void DotCfgChangeReporter::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::DotCfgVerbose ||
-       PrintChanged == ChangePrinter::DotCfgQuiet) {
     SmallString<128> OutputDir;
     sys::fs::expand_tilde(DotCfgDir, OutputDir);
     sys::fs::make_absolute(OutputDir);
     assert(!OutputDir.empty() && "expected output dir to be non-empty");
     DotCfgDir = OutputDir.c_str();
     if (initializeHTML()) {
       ChangeReporter<IRDataT<DCData>>::registerRequiredCallbacks(PIC);
       return;
void StandardInstrumentations::registerCallbacks(
   PseudoProbeVerification.registerCallbacks(PIC);
   if (VerifyEach)
     Verify.registerCallbacks(PIC);
   PrintChangedDiff.registerCallbacks(PIC);
   WebsiteChangeReporter.registerCallbacks(PIC);
   PrintCrashIR.registerCallbacks(PIC);
 }
 
-template class ChangeReporter<std::string>;
-template class TextChangeReporter<std::string>;
+template class ChangeReporter<StringIR>;
+template class TextChangeReporter<StringIR>;
 
 template class BlockDataT<EmptyData>;
 template class FuncDataT<EmptyData>;
 template class IRDataT<EmptyData>;
 template class ChangeReporter<IRDataT<EmptyData>>;
 template class TextChangeReporter<IRDataT<EmptyData>>;
 template class IRComparer<EmptyData>;
 
 } // namespace llvm

llvm/test/Other/ChangePrinters/DotCfg/print-changed-dot-cfg-invalidated.ll

+; Deleting a loop invalidates the pass; test reporting of changes.
+;
+; Note that (mostly) only the banners are checked.
+;
+; Basic functionality
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=loop-deletion -dot-cfg-dir=%t < %s -o /dev/null
+; RUN: ls %t/*.pdf %t/passes.html | count 4
+; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-INVALIDATE
+;
+; CHECK-DOT-CFG-INVALIDATE-FILES: passes.html diff_0_0.pdf diff_4.pdf
+; CHECK-DOT-CFG-INVALIDATE:   <a href="diff_4.pdf" target="_blank">4. Pass Invalidated LoopDeletionPass on loop</a><br/>
+; CHECK-DOT-CFG-INVALIDATE-NEXT:     </p></div>
+; CHECK-DOT-CFG-INVALIDATE-NEXT:   <a>5. Invalidated PassManager{{.*}} on unknown IR ignored</a><br/>
+
+; module scope
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: opt -disable-verify -S -print-changed=dot-cfg -print-module-scope -passes=loop-deletion -dot-cfg-dir=%t < %s -o /dev/null
+; RUN: ls %t/*.pdf %t/passes.html | count 5
+; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-INVALIDATE-MOD
+;
+; CHECK-DOT-CFG-INVALIDATE-MOD-FILES: passes.html diff_0.pdf diff_4_0.pdf diff_4_1.pdf
+; CHECK-DOT-CFG-INVALIDATE-MOD:   <a href="diff_4_0.pdf" target="_blank">4.0. Pass Invalidated LoopDeletionPass on loop</a><br/>
+; CHECK-DOT-CFG-INVALIDATE-MOD:   <a href="diff_4_1.pdf" target="_blank">4.1. Pass Invalidated LoopDeletionPass on loop</a><br/>
+; CHECK-DOT-CFG-INVALIDATE-MOD-NEXT:     </p></div>
+; CHECK-DOT-CFG-INVALIDATE-MOD-NEXT:   <a>5. Invalidated PassManager{{.*}} on unknown IR ignored</a><br/>
+
+;
+; Filter out passes
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=loop-deletion -dot-cfg-dir=%t -filter-passes="notThisPass" < %s -o /dev/null
+; RUN: ls %t | count 1
+;
+; Filter in passes
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=loop-deletion -dot-cfg-dir=%t -filter-passes="loop-deletion" < %s -o /dev/null
+; RUN: ls %t | count 4
+;
+; Filter out functions
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=loop-deletion -dot-cfg-dir=%t -filter-print-funcs="notThisFunc" < %s -o /dev/null
+; RUN: ls %t | count 1
+;
+; Filter in functions
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=loop-deletion -dot-cfg-dir=%t -filter-print-funcs="deleteme" < %s -o /dev/null
+; RUN: ls %t | count 3
+;
+
+define void @deleteme() {
+entry:
+  br label %loop
+loop:
+  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
+  %iv.next = add i32 %iv, 1
+  %check = icmp ult i32 %iv.next, 3
+  br i1 %check, label %loop, label %exit
+exit:
+  ret void
+}
+
+define void @f() {
+entry:
+  ret void
+}

llvm/test/Other/ChangePrinters/DotCfg/print-changed-dot-cfg.ll

 ; Simple checks of -print-changed=dot-cfg
 ;
 ; Note that (mostly) only the banners are checked.
 ;
 ; Simple functionality check.
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=instsimplify -dot-cfg-dir=%t < %s -o /dev/null
-; RUN: ls %t/*.pdf %t/passes.html | count 4
+; RUN: ls %t/*.pdf %t/passes.html | count 5
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-SIMPLE
 ;
 ; Check that only the passes that change the IR are printed and that the
 ; others (including g) are filtered out.
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=instsimplify -filter-print-funcs=f  -dot-cfg-dir=%t < %s -o /dev/null
 ; RUN: ls %t/*.pdf %t/passes.html | count 3
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-FUNC-FILTER
 ;
 ; Check that the reporting of IRs respects is not affected by
 ; -print-module-scope
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=instsimplify -print-module-scope -dot-cfg-dir=%t < %s -o /dev/null
-; RUN: ls %t/*.pdf %t/passes.html | count 4
+; RUN: ls %t/*.pdf %t/passes.html | count 5
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-PRINT-MOD-SCOPE
 ;
 ; Check that reporting of multiple functions happens
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes=instsimplify -filter-print-funcs="f,g" -dot-cfg-dir=%t < %s -o /dev/null
-; RUN: ls %t/*.pdf %t/passes.html | count 4
+; RUN: ls %t/*.pdf %t/passes.html | count 5
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-FILTER-MULT-FUNC
 ;
 ; Check that the reporting of IRs respects -filter-passes
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes="instsimplify,no-op-function" -filter-passes="no-op-function" -dot-cfg-dir=%t < %s -o /dev/null
-; RUN: ls %t/*.pdf %t/passes.html | count 2
+; RUN: ls %t/*.pdf %t/passes.html | count 3
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-FILTER-PASSES
 ;
 ; Check that the reporting of IRs respects -filter-passes with multiple passes
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes="instsimplify,no-op-function" -filter-passes="no-op-function,instsimplify" -dot-cfg-dir=%t < %s -o /dev/null
-; RUN: ls %t/*.pdf %t/passes.html | count 4
+; RUN: ls %t/*.pdf %t/passes.html | count 5
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-FILTER-MULT-PASSES
 ;
 ; Check that the reporting of IRs respects both -filter-passes and -filter-print-funcs
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: opt -disable-verify -S -print-changed=dot-cfg -passes="instsimplify,no-op-function" -filter-passes="no-op-function,instsimplify" -filter-print-funcs=f -dot-cfg-dir=%t < %s -o /dev/null
 ; RUN: ls %t/*.pdf %t/passes.html | count 3
 ; RUN: FileCheck %s -input-file=%t/passes.html --check-prefix=CHECK-DOT-CFG-FILTER-FUNC-PASSES
 ;

 }
 
 define i32 @f() {
 entry:
   %a = add i32 2, 3
   ret i32 %a
 }
 
-; CHECK-DOT-CFG-SIMPLE-FILES: passes.html diff_0.pdf diff_1.pdf diff_3.pdf
+; CHECK-DOT-CFG-SIMPLE-FILES: passes.html diff_0_0.pdf diff_0_1.pdf diff_1.pdf diff_3.pdf
 ; CHECK-DOT-CFG-SIMPLE: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-SIMPLE-NEXT: <body><button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-SIMPLE-NEXT: <div class="content">
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <p>
-; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_0.pdf" target="_blank">0. Initial IR</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_0_0.pdf" target="_blank">0.0. Initial IR</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_0_1.pdf" target="_blank">0.1. Initial IR</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   </p>
 ; CHECK-DOT-CFG-SIMPLE-NEXT: </div><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_1.pdf" target="_blank">1. Pass InstSimplifyPass on g</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:     </p></div>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>2. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_3.pdf" target="_blank">3. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:     </p></div>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>4. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>5. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>6. Pass PrintModulePass on [module] omitted because no change</a><br/>
 ; CHECK-DOT-CFG-SIMPLE-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 ; CHECK-DOT-CFG-FUNC-FILTER: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT: <body>  <a>0. Pass InstSimplifyPass on g filtered out</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>1. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT: <button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT: <div class="content">
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <p>
-; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a href="diff_2.pdf" target="_blank">2. Initial IR</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a href="diff_2_0.pdf" target="_blank">2.0. Initial IR</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   </p>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT: </div><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a href="diff_3.pdf" target="_blank">3. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:     </p></div>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>4. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>5. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>6. Pass PrintModulePass on [module] omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FUNC-FILTER-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT: <body><button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT: <div class="content">
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <p>
-; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_0.pdf" target="_blank">0. Initial IR</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_0_0.pdf" target="_blank">0.0. Initial IR</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_0_1.pdf" target="_blank">0.1. Initial IR</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   </p>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT: </div><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_1.pdf" target="_blank">1. Pass InstSimplifyPass on g</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:     </p></div>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>2. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_3.pdf" target="_blank">3. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:     </p></div>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>4. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>5. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>6. Pass PrintModulePass on [module] omitted because no change</a><br/>
 ; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT: <body><button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT: <div class="content">
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <p>
-; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_0.pdf" target="_blank">0. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_0_0.pdf" target="_blank">0.0. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_0_1.pdf" target="_blank">0.1. Initial IR</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   </p>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT: </div><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_1.pdf" target="_blank">1. Pass InstSimplifyPass on g</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:     </p></div>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>2. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_3.pdf" target="_blank">3. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:     </p></div>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>4. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>5. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>6. Pass PrintModulePass on [module] omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 ; CHECK-DOT-CFG-FILTER-PASSES: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT: <body>  <a>0. Pass InstSimplifyPass on g filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT: <button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT: <div class="content">
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <p>
-; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a href="diff_1.pdf" target="_blank">1. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a href="diff_1_0.pdf" target="_blank">1.0. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a href="diff_1_1.pdf" target="_blank">1.1. Initial IR</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   </p>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT: </div><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>2. Pass NoOpFunctionPass on g omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>3. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>4. Pass InstSimplifyPass on f filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>5. Pass NoOpFunctionPass on f omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>6. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>7. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>8. Pass PrintModulePass on [module] filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-PASSES-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 
 
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT: <button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT: <div class="content">
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <p>
-; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a href="diff_0.pdf" target="_blank">0. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a href="diff_0_0.pdf" target="_blank">0.0. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a href="diff_0_1.pdf" target="_blank">0.1. Initial IR</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   </p>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT: </div><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a href="diff_1.pdf" target="_blank">1. Pass InstSimplifyPass on g</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:     </p></div>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>2. Pass NoOpFunctionPass on g omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>3. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a href="diff_4.pdf" target="_blank">4. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:     </p></div>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>5. Pass NoOpFunctionPass on f omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>6. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>7. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>8. Pass PrintModulePass on [module] filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT: <body>  <a>0. Pass InstSimplifyPass on g filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>1. Pass NoOpFunctionPass on g filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>2. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT: <button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT: <div class="content">
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <p>
-; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a href="diff_3.pdf" target="_blank">3. Initial IR</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a href="diff_3_0.pdf" target="_blank">3.0. Initial IR</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   </p>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT: </div><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a href="diff_4.pdf" target="_blank">4. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:     </p></div>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>5. Pass NoOpFunctionPass on f omitted because no change</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>6. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>7. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>8. Pass PrintModulePass on [module] filtered out</a><br/>
 ; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT: <script>var coll = document.getElementsByClassName("collapsible");var i;for (i = 0; i < coll.length; i++) {coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block"){ content.style.display = "none"; } else { content.style.display= "block"; } }); }</script></body></html>
 
 
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC: <!doctype html><html><head><style>.collapsible { background-color: #777; color: white; cursor: pointer; padding: 18px; width: 100%; border: none; text-align: left; outline: none; font-size: 15px;} .active, .collapsible:hover { background-color: #555;} .content { padding: 0 18px; display: none; overflow: hidden; background-color: #f1f1f1;}</style><title>passes.html</title></head>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT: <body>  <a>0. Pass InstSimplifyPass on g filtered out</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>1. Pass InstSimplifyPass on g filtered out</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>2. PassManager{{.*}} on g ignored</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT: <button type="button" class="collapsible">0. Initial IR (by function)</button>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT: <div class="content">
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <p>
-; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a href="diff_3.pdf" target="_blank">3. Initial IR</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a href="diff_3_0.pdf" target="_blank">3.0. Initial IR</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   </p>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT: </div><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a href="diff_4.pdf" target="_blank">4. Pass InstSimplifyPass on f</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:     </p></div>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>5. Pass InstSimplifyPass on f omitted because no change</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>6. PassManager{{.*}} on f ignored</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>7. ModuleToFunctionPassAdaptor on [module] ignored</a><br/>
 ; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>8. Pass PrintModulePass on [module] omitted because no change</a><br/>

llvm/test/Other/ChangePrinters/print-changed-invalidated.ll

+; Deleting a loop invalidates the pass; test reporting of changes.
+;
+; Basic functionality of print-changed=diff
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=diff 2>&1 | FileCheck %s -check-prefix=DIFF
+;
+; DIFF-LABEL: entry:
+; DIFF-LABEL: loop:
+; DIFF-LABEL: exit:
+; DIFF-LABEL: entry:
+; DIFF: IR Dump After Invalidated LoopDeletionPass on loop
+; DIFF-LABEL: entry:
+; DIFF-NEXT: -  br label %loop
+; DIFF-NEXT: +  br label %exit
+; DIFF-LABEL: -loop:                                             ; preds = %loop, %entry
+; DIFF-NEXT: -  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
+; DIFF-NEXT: -  %iv.next = add i32 %iv, 1
+; DIFF-NEXT: -  %check = icmp ult i32 %iv.next, 3
+; DIFF-NEXT: -  br i1 %check, label %loop, label %exit
+; DIFF-LABEL: -exit:
+; DIFF-LABEL: +exit:
+; DIFF-NEXT: ret
+; DIFF-NOT: IR DUMP
+; DIFF: IR Pass Invalidated {{.*}} on unknown IR ignored
+;
+; module scope
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=diff -print-module-scope 2>&1 | FileCheck %s -check-prefix=DIFF-MOD
+;
+; DIFF-MOD-LABEL: entry:
+; DIFF-MOD-LABEL: loop:
+; DIFF-MOD-LABEL: exit:
+; DIFF-MOD-LABEL: entry:
+; DIFF-MOD: IR Dump After Invalidated LoopDeletionPass on loop
+; DIFF-MOD: IR for function {{.*}}
+; DIFF-MOD-LABEL: entry:
+; DIFF-MOD-NEXT: -  br label %loop
+; DIFF-MOD-NEXT: +  br label %exit
+; DIFF-MOD-LABEL: -loop:                                             ; preds = %loop, %entry
+; DIFF-MOD-NEXT: -  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
+; DIFF-MOD-NEXT: -  %iv.next = add i32 %iv, 1
+; DIFF-MOD-NEXT: -  %check = icmp ult i32 %iv.next, 3
+; DIFF-MOD-NEXT: -  br i1 %check, label %loop, label %exit
+; DIFF-MOD-LABEL: -exit:
+; DIFF-MOD-LABEL: +exit:
+; DIFF-MOD-NEXT: ret
+; DIFF-MOD-NOT: IR DUMP
+; DIFF-MOD: IR for function {{.*}}
+; DIFF-MOD-LABEL: entry:
+; DIFF-MOD-NOT: IR DUMP
+; DIFF-MOD: IR Pass Invalidated {{.*}} on unknown IR ignored
+;
+; Filter out passes
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=diff -filter-passes="notThisPass" 2>&1 | FileCheck %s -check-prefix=DIFF-FILTER-PASS-OUT
+;
+; DIFF-FILTER-PASS-OUT: IR Dump After Invalidated LoopDeletionPass on unknown IR filtered out
+;
+; Filter in passes
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=diff-quiet -filter-passes="loop-deletion" 2>&1 | FileCheck %s -check-prefix=DIFF-FILTER-PASS-IN
+;
+; DIFF-FILTER-PASS-IN: IR Dump After Invalidated LoopDeletionPass on loop
+; DIFF-FILTER-PASS-IN-LABEL: entry:
+;
+; Filter out functions
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=diff -filter-print-funcs=notThisFunc 2>&1 | FileCheck %s -check-prefix=DIFF-FILTER-FUNC-OUT
+;
+; DIFF-FILTER-FUNC-OUT: IR Dump After Invalidated LoopDeletionPass but IR unavailable or filtered out
+;
+; Filter in functions
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=diff-quiet -filter-print-funcs=deleteme 2>&1 | FileCheck %s -check-prefix=DIFF-FILTER-FUNC-IN
+;
+; DIFF-FILTER-FUNC-IN: IR Dump After Invalidated LoopDeletionPass on loop
+; DIFF-FILTER-FUNC-IN-LABEL: entry:
+;
+
+; Basic functionality of print-changed=cdiff
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=cdiff 2>&1 | FileCheck %s -check-prefix=CDIFF
+;
+; CDIFF-LABEL: entry:
+; CDIFF-LABEL: loop:
+; CDIFF-LABEL: exit:
+; CDIFF-LABEL: entry:
+; CDIFF: IR Dump After Invalidated LoopDeletionPass on loop
+; CDIFF-LABEL: entry:
+; CDIFF-NEXT:{{.\[31m-}}  br label %loop{{.\[0m}}
+; CDIFF-NEXT:{{.\[32m\+}}  br label %exit{{.\[0m}}
+; CDIFF-LABEL:{{.\[31m-}}loop:                                             ; preds = %loop, %entry{{.\[0m}}
+; CDIFF-NEXT:{{.\[31m-}}  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]{{.\[0m}}
+; CDIFF-NEXT:{{.\[31m-}}  %iv.next = add i32 %iv, 1{{.\[0m}}
+; CDIFF-NEXT:{{.\[31m-}}  %check = icmp ult i32 %iv.next, 3{{.\[0m}}
+; CDIFF-NEXT:{{.\[31m-}}  br i1 %check, label %loop, label %exit{{.\[0m}}
+; CDIFF-LABEL:{{.\[31m-}}exit:                                             ; preds = %loop{{.\[0m}}
+; CDIFF-LABEL:{{.\[32m\+}}exit:                                             ; preds = %entry{{.\[0m}}
+; CDIFF-NEXT: ret
+; CDIFF-NOT: IR DUMP
+; CDIFF: IR Pass Invalidated {{.*}} on unknown IR ignored
+;
+; module scope
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=cdiff -print-module-scope 2>&1 | FileCheck %s -check-prefix=CDIFF-MOD
+;
+; CDIFF-MOD-LABEL: entry:
+; CDIFF-MOD-LABEL: loop:
+; CDIFF-MOD-LABEL: exit:
+; CDIFF-MOD-LABEL: entry:
+; CDIFF-MOD: IR Dump After Invalidated LoopDeletionPass on loop
+; CDIFF-MOD: IR for function {{.*}}
+; CDIFF-MOD-LABEL: entry:
+; CDIFF-MOD-NEXT:{{.\[31m-}}  br label %loop{{.\[0m}}
+; CDIFF-MOD-NEXT:{{.\[32m\+}}  br label %exit{{.\[0m}}
+; CDIFF-MOD:{{.\[31m-}}loop:                                             ; preds = %loop, %entry{{.\[0m}}
+; CDIFF-MOD-NEXT:{{.\[31m-}}  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]{{.\[0m}}
+; CDIFF-MOD-NEXT:{{.\[31m-}}  %iv.next = add i32 %iv, 1{{.\[0m}}
+; CDIFF-MOD-NEXT:{{.\[31m-}}  %check = icmp ult i32 %iv.next, 3{{.\[0m}}
+; CDIFF-MOD-NEXT:{{.\[31m-}}  br i1 %check, label %loop, label %exit{{.\[0m}}
+; CDIFF-MOD:{{.\[31m-}}exit:                                             ; preds = %loop{{.\[0m}}
+; CDIFF-MOD:{{.\[32m\+}}exit:                                             ; preds = %entry{{.\[0m}}
+; CDIFF-MOD-NEXT: ret
+; CDIFF-MOD-NOT: IR DUMP
+; CDIFF-MOD: IR for function {{.*}}
+; CDIFF-MOD-LABEL: entry:
+; CDIFF-MOD-NOT: IR DUMP
+; CDIFF-MOD: IR Pass Invalidated {{.*}} on unknown IR ignored
+;
+; Filter out passes
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=cdiff -filter-passes="notThisPass" 2>&1 | FileCheck %s -check-prefix=CDIFF-FILTER-PASS-OUT
+;
+; CDIFF-FILTER-PASS-OUT: IR Dump After Invalidated LoopDeletionPass on unknown IR filtered out
+;
+; Filter in passes
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=cdiff-quiet -filter-passes="loop-deletion" 2>&1 | FileCheck %s -check-prefix=CDIFF-FILTER-PASS-IN
+;
+; CDIFF-FILTER-PASS-IN: IR Dump After Invalidated LoopDeletionPass on loop
+; CDIFF-FILTER-PASS-IN-LABEL: entry:
+;
+; Filter out functions
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=cdiff -filter-print-funcs=notThisFunc 2>&1 | FileCheck %s -check-prefix=CDIFF-FILTER-FUNC-OUT
+;
+; CDIFF-FILTER-FUNC-OUT: IR Dump After Invalidated LoopDeletionPass but IR unavailable or filtered out
+;
+; Filter in functions
+; RUN: opt < %s -disable-output -passes=loop-deletion -print-changed=cdiff-quiet -filter-print-funcs=deleteme 2>&1 | FileCheck %s -check-prefix=CDIFF-FILTER-FUNC-IN
+;
+; CDIFF-FILTER-FUNC-IN: IR Dump After Invalidated LoopDeletionPass on loop
+; CDIFF-FILTER-FUNC-IN-LABEL: entry:
+;
+
+define void @deleteme() {
+entry:
+  br label %loop
+loop:
+  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
+  %iv.next = add i32 %iv, 1
+  %check = icmp ult i32 %iv.next, 3
+  br i1 %check, label %loop, label %exit
+exit:
+  ret void
+}
+
+define void @f() {
+entry:
+  ret void
+}

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

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