Add new choices dot-cfg and dot-cfg-quiet to print-changed which creates a website of DOT files showing colourized changes as the IR is changed by passes in the new pass manager pipeline.

[jamieschmeiser]

Summary

Add new options -print-changed=[dot-cfg | dot-cfg-quiet] which create
a website of DOT files showing colourized changes as the IR is changed
by passes in the new pass manager pipeline.

A new change reporter is introduced that creates a website of changes made
by passes in the opt pipeline that change the IR. The hidden option
-dot-cfg-dir=<dir> specifies a directory (defaulting to "./") into which the
website will be created.

A file passes.html is created that contains a list of all the passes that
act on the IR. Those that do not change the IR are listed as omitted
because of no change, ignored or filtered out (using -filter-print-func
and -filter-passes) or not listed in quiet mode. Those that
do change the IR are listed as a link to a DOT file which contains a
CFG depiction of the IR (ala -dot-cfg) except that the instructions,
basic blocks and links that are only in the IR before the pass (ie, removed)
and those that are only in the IR after the pass (ie, added) are shown in
red and green, respectively, while the aspects of the CFG that do not change
are shown in black. Additional hidden options
-dot-cfg-before-color=<dot named color>,
-dot-cfg-after-color=<dot named color> and
-dot-cfg-common-color=<dot named color> are defined that allow the
customization of the colors used in colorizing the CFG.
-change-printer-dot-path=<path to dot exe> is also added.

This builds upon the base classes introduced in
https://reviews.llvm.org/D86360 and expanded in
https://reviews.llvm.org/D87000 and https://reviews.llvm.org/D91890. The changes to the GraphWriter in
https://reviews.llvm.org/D86362 have been incorporated into this PR as they are
difficult to understand in isolation and that PR was cancelled.

This change printer was introduced during my tuturial at the October 2020
virtual developer's meeting.

[madhur13490]

llvm/lib/IR/ChangeReporters.cpp

408 ↗

(On Diff #290122)

I can be unsigned

705 ↗

(On Diff #290122)

Doxygen comments can be on newlines.

707 ↗

(On Diff #290122)

Is it worth filing a bug report for opt bug and refer it here?

779 ↗

(On Diff #290122)

I can be unsigned.

795 ↗

(On Diff #290122)

Can use shorthand operator.

805 ↗

(On Diff #290122)

I think you can use C++ regex here. You can get rid of whole while loop and do the intended thing in one line.

830 ↗

(On Diff #290122)

Is there any reason to use series of appends than just a single concatenation?

858 ↗

(On Diff #290122)

"Before" and "After" can be more readble.

llvm/lib/Passes/StandardInstrumentations.cpp

1278

Please format the string in a readble way. Please use indentation and newlines just like you'd write in a HTML file.

[jamieschmeiser]

Changed code to only open output stream when option is specified.

[jamieschmeiser]

Change option name to dot-cfg-changed to align with existing dot-cfg pass.

[jamieschmeiser]

Change name to dot-cfg-changes as it is more similar to print-changes than to print-changed

[jamieschmeiser]

Respond to review comments: use regex, format HTML output to make it easier
to read, other changes.

Update PR based on changes to other PRs in chain, most notably: change
lambdas to virtual overrides.

[jamieschmeiser]

I will be updating this to reflect changes to PRs earlier in the chain.

[jamieschmeiser]

Update the code based on changes in the earlier PRs in the
chain. Also, the changes to the GraphWriter in
https://reviews.llvm.org/D86362 have been incorporated into this PR as they are
difficult to understand in isolation and that PR will be cancelled.

[jamieschmeiser]

ping

[jamieschmeiser]

A new quiet mode for change printers is being considered in https://reviews.llvm.org/D92589. I will likely have to change this patch based on the results of that, which would introduce a quiet mode into this change reporter also.

[MaskRay]

llvm/include/llvm/Passes/StandardInstrumentations.h

455

In header files, there is a namespace llvm {} so llvm:: can be omitted.

Can the using declarations be omitted?

llvm/include/llvm/Support/GraphWriter.h

267

Use lower case tags which are more common.

[jamieschmeiser]

Updated the code to reflect various changes made in reviews
for the other change printers that have landed. Also added
unit tests.

[aeubanks]

I'd like to try this out locally, but arc patch is complaining that this patch isn't applied directly against trunk. Could you rebase against upstream main?
And sorry for the slow reviews, I've been fairly busy. I'll try to get to this one this week.

[jamieschmeiser]

Rebase to facilitate applying patch. Also, I removed the indenting for a grouping of links as I don't think it was useful.

[jamieschmeiser]

Don't apologize for "slow reviews," I appreciate your taking the time to review all of these changes. If there is anything I can do to make it easier, please let me know.

[aeubanks]

In the description I think you meant dot-cfg-dir instead of dot-cfg-changes.

Again, lots of unnecessary llvm::.

I don't think I can really review the html generation too much, so I'll assume it's good unless somebody else wants to review it.

llvm/include/llvm/Passes/StandardInstrumentations.h

262

BlockDataBase?

551

std::unique_ptr?

llvm/include/llvm/Support/DOTGraphTraits.h

71

is this param used anywhere?

llvm/lib/Passes/StandardInstrumentations.cpp

134

should probably be more specific, like dot-cfg-before-color

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

7

all these should probably use -dot-cfg-dir in a temp directory

8

are all the 2>&1 in here necessary? and > /dev/null

8

-disable-output

8

-S shouldn't be necessary

[aeubanks]

llvm/lib/Passes/StandardInstrumentations.cpp

34

looks like llvm doesn't really use <regex> a lot, and I vaguely remember hearing bad things about it.
Does llvm/include/llvm/Support/Regex.h work?

1372

we should really get this figured out

[jamieschmeiser]

I have addressed your comments from previous reviews. Regarding the statics to avoid a crash,
I figured out that the problem was a template instantiation that was missing a const, resulting
in a copy being made, which didn't copy everything. This has been fixed. I have also
simplified the code and templates.

[jamieschmeiser]

Trying newly generated patch as last one couldn't be applied. I also added code to call expand_tilde on the -dot-cfg-dir specified directory and then make it absolute.

[jamieschmeiser]

Trying again with a newly generated patch...

[jamieschmeiser]

Removed stale parent reviews because I think they were causing problems with applying the patch

[jamieschmeiser]

Fix lit test failure: make test unsupported if /usr/bin/dot is unavailable.

[jamieschmeiser]

Fix clang tidy problems and add option to specify dot executable.

[jamieschmeiser]

The clang-tidy complaints relate to names that are required by existing code.

[jamieschmeiser]

Add // NOLINTNEXTLINE comments

[jamieschmeiser]

make clang-tidy comments specific to readability-identifier-naming

[jamieschmeiser]

I do not know what is causing the debian build to fail but I do not believe the failure is caused by my changes. I used the instructions to replicate the failure and this resulted in the same error that llgo isn't a known project. Checking out the previous commit resulted in the same error so it is a pre-existing condition and not the result of my changes.

[aeubanks]

don't worry about the presubmit
I'll try to get around to reviewing this at some point (although it might take some time since this is a very large change)

[jamieschmeiser]

Thanks. Would it help if I split it up a bit? For example, there are a lot of changes relating to making data into templates which affects the existing change printers but doesn't change their functioning. These could be split out and handled first to simplify things. Would this help?

[aeubanks]

In D87202#3028295, @jamieschmeiser wrote:

Thanks. Would it help if I split it up a bit? For example, there are a lot of changes relating to making data into templates which affects the existing change printers but doesn't change their functioning. These could be split out and handled first to simplify things. Would this help?

Yes please

[jamieschmeiser]

Created new review https://reviews.llvm.org/D110737 with non-functional background changes to simplify this review. I will update this review to reflect any changes from that review when it lands.

[jamieschmeiser]

Update after landing of D110737 which had most of the changes to existing code.

[aeubanks]

this is impossible for me to review especially since I don't really know html super well
but lgtm (with nits) I guess, I tried patching this in and running it and it does work as expected

llvm/lib/Passes/StandardInstrumentations.cpp

1239

I've barely seen this anywhere in LLVM, I don't think it's necessary

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

133 ↗

(On Diff #380724)

I'd add -disable-verify to the opt invocations to avoid these, since it'll already implicitly be off in a release build

[jamieschmeiser]

Respond to review comments, remove nolint instructions and clean
up unit tests.

[tpopp]

Hi Jamie, this code has test failures: https://reviews.llvm.org/B131761

Additionally, you're not required to fix these build issues, but other issues might appear on some platforms as you can see here: https://buildkite.com/llvm-project/upstream-bazel-rbe/builds/11083#96df16f2-6dd8-4800-a2f1-25de809a99f1

[jamieschmeiser]

Hi @tpopp, can you please explain to me the nature of these failures? The code changed here is only active under options that are not being used in those tests so I expect that the errors are unrelated. I have not received any notifications from the build-bots of a problem so far. I am also unclear as to why there are build issues on those other platforms. Are you asking me to revert this?

[tpopp]

In D87202#3103520, @jamieschmeiser wrote:

Hi @tpopp, can you please explain to me the nature of these failures? The code changed here is only active under options that are not being used in those tests so I expect that the errors are unrelated. I have not received any notifications from the build-bots of a problem so far. I am also unclear as to why there are build issues on those other platforms. Are you asking me to revert this?

Please ignore the first link. I didn't look further at the first link, so they're probably existing failures.

The second test was for a different BUILD system, so normally other people are responsible for fixing them. In this case it showed code that doesn't work on all platforms, so I made a small modification to make this work. Hopefully it's okay: https://github.com/llvm/llvm-project/commit/88fc0ab45db98f097c5ef898068081eb097cceeb

If that change is okay, nothing more needs to be done.

[jamieschmeiser]

Hi @tpopp, yes, it looks fine. Thanks!

[hvdijk]

I am seeing:

********************
FAIL: LLVM :: Other/ChangePrinters/DotCfg/print-changed-dot-cfg.ll (6061 of 45994)
******************** TEST 'LLVM :: Other/ChangePrinters/DotCfg/print-changed-dot-cfg.ll' FAILED ********************
[...]
--
Exit Code: 1

Command Output (stderr):
--
Format: "pdf" not recognized. No formats found.
Perhaps "dot -c" needs to be run (with installer's privileges) to register the plugins?
Format: "pdf" not recognized. No formats found.
Perhaps "dot -c" needs to be run (with installer's privileges) to register the plugins?
Format: "pdf" not recognized. No formats found.
Perhaps "dot -c" needs to be run (with installer's privileges) to register the plugins?
ls: cannot access '/home/harald/llvm-project/build/test/Other/ChangePrinters/DotCfg/Output/print-changed-dot-cfg.ll.tmp/*.pdf': No such file or directory
Expected 4 lines, got 1.

--

http://graphviz.org/docs/outputs/pdf/ mentions that whether PDF output is supported by dot depends on how Graphviz was configured; we cannot assume that if dot is present, it will support PDF. Is there some way to ensure that in this case, the test is skipped?

[uabelho]

llvm/lib/Passes/StandardInstrumentations.cpp

1578

gcc warns about this function being unused:

[2174/4649] Building CXX object lib/Passes/CMakeFiles/LLVMPasses.dir/StandardInstrumentations.cpp.o
../lib/Passes/StandardInstrumentations.cpp:1649:13: warning: 'std::string {anonymous}::DotCfgDiff::attribute({anonymous}::IRChangeDiffType) const' defined but not used [-Wunused-function]
 1649 | std::string DotCfgDiff::attribute(IRChangeDiffType T) const {
      |             ^~~~~~~~~~

Will it be used or should it be removed (or should it be there even if it's unused)?

[jamieschmeiser]

Hi @hvdijk, a fix for the lit-test problem is up for review in https://reviews.llvm.org/D113187

[jamieschmeiser]

Hi @uabelho, the function is unnecessary and has been removed in https://reviews.llvm.org/D113188

[uabelho]

In D87202#3108860, @jamieschmeiser wrote:

Hi @uabelho, the function is unnecessary and has been removed in https://reviews.llvm.org/D113188

Cool, thanks!

[mehdi_amini]

llvm/lib/Passes/StandardInstrumentations.cpp

1197

This seems like this global is mutable and I see a bunch of TSAN failures, can you look into this?

[aeubanks]

llvm/lib/Passes/StandardInstrumentations.cpp

1197

Yeah this should probably be a member variable.

But where are you seeing tsan failures? This is used for debugging and the in-tree tests for this should only be single threaded.

[mehdi_amini]

llvm/lib/Passes/StandardInstrumentations.cpp

1197

WARNING: ThreadSanitizer: data race (pid=45032)
  Write of size 1 at 0x000005020700 by thread T2:
    #0 memcpy <null> (llvm-lto2+0x143fb6e)
    #1 std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_assign(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) <null> (libstdc++.so.6+0x13c835)
    #2 runNewPMPasses /usr/local/google/home/aminim/projects/llvm-project/llvm/lib/LTO/LTOBackend.cpp:242:28 (llvm-lto2+0x268869a)
    #3 llvm::lto::opt(llvm::lto::Config const&, llvm::TargetMachine*, unsigned int, llvm::Module&, bool, llvm::ModuleSummaryIndex*, llvm::ModuleSummaryIndex const*, std::vector<unsigned char, std::allocator<unsigned char> > const&) /usr/local/google/home/aminim/projects/llvm-project/llvm/lib/LTO/LTOBackend.cpp:370:5 (llvm-lto2+0x268869a)

[jamieschmeiser]

llvm/lib/Passes/StandardInstrumentations.cpp

1197

This array is actually unnecessary and was only there to ease understanding of the code. I will remove it.

[jamieschmeiser]

llvm/lib/Passes/StandardInstrumentations.cpp

1197

@mehdi_amini Fix in https://reviews.llvm.org/D115175

[jrtc27]

This commit broke the non-HTML output, causing https://github.com/llvm/llvm-project/issues/52610

llvm/include/llvm/Support/GraphWriter.h

257

Surely you don't want this for HTML?

266–270

I believe this whole chunk of code is meant to be this

267

This makes no sense. It's not truncated if i != e?

269

The } was unconditional before, now it's conditional so you get mismatched }s and graphviz errors out unless you have more than 64 edge dest labels

[jamieschmeiser]

llvm/include/llvm/Support/GraphWriter.h

257

@jrtc27 This changes in this section are unnecessary because the code that uses the HTML rendering does not use edge destination labels. I will change this section back to what it was.

llvm/include/llvm/Passes/StandardInstrumentations.h

protected:
   // Called when an interesting IR has changed.
   void handleAfter(StringRef PassID, std::string &Name,
                    const std::string &Before, const std::string &After,
                    Any) override;
   // Called to compare the before and after representations of the IR.
   bool same(const std::string &Before, const std::string &After) override;
 };
 
-// The following classes hold a representation of the IR for a change
-// reporter that uses string comparisons of the basic blocks
-// that are created using print (ie, similar to dump()).
-// These classes respect the filtering of passes and functions using
-// -filter-passes and -filter-print-funcs.
-//
 // 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.
-class ChangedBlockData {
+template <typename BlockDataT> class BlockDataTemplate {
 public:
-  ChangedBlockData(const BasicBlock &B);
+  BlockDataTemplate(const BasicBlock &B) : Label(B.getName().str()), Data(B) {
+    raw_string_ostream SS(Body);
+    B.print(SS, nullptr, true, true);
+  }
 
-  bool operator==(const ChangedBlockData &That) const {
+  bool operator==(const BlockDataTemplate &That) const {
     return Body == That.Body;
   }
-  bool operator!=(const ChangedBlockData &That) const {
+  bool operator!=(const BlockDataTemplate &That) const {
     return Body != That.Body;
   }
 
   // Return the label of the represented basic block.
   StringRef getLabel() const { return Label; }
   // Return the string representation of the basic block.
   StringRef getBody() const { return Body; }
 
+  // Return the associated data
+  const BlockDataT &getData() const { return Data; }
+
 protected:
   std::string Label;
   std::string Body;
+
+  // Extra data associated with a basic block
+  BlockDataT Data;
 };
 
-template <typename IRData> class OrderedChangedData {
+template <typename IRDataT> class OrderedChangedData {
 public:
   // Return the names in the order they were saved
   std::vector<std::string> &getOrder() { return Order; }
   const std::vector<std::string> &getOrder() const { return Order; }
 
   // Return a map of names to saved representations
-  StringMap<IRData> &getData() { return Data; }
-  const StringMap<IRData> &getData() const { return Data; }
+  StringMap<IRDataT> &getData() { return Data; }
+  const StringMap<IRDataT> &getData() const { return Data; }
 
-  bool operator==(const OrderedChangedData<IRData> &That) const {
+  bool operator==(const OrderedChangedData<IRDataT> &That) const {
     return Data == That.getData();
   }
 
   // Call the lambda \p HandlePair on each corresponding pair of data from
   // \p Before and \p After.  The order is based on the order in \p After
   // with ones that are only in \p Before interspersed based on where they
   // occur in \p Before.  This is used to present the output in an order
   // based on how the data is ordered in LLVM.
   static void
   report(const OrderedChangedData &Before, const OrderedChangedData &After,
-         function_ref<void(const IRData *, const IRData *)> HandlePair);
+         function_ref<void(const IRDataT *, const IRDataT *)> HandlePair);
 
 protected:
   std::vector<std::string> Order;
-  StringMap<IRData> Data;
+  StringMap<IRDataT> Data;
+};
+
+// Do not need extra information for patch-style change reporter.
+class EmptyData {
+public:
+  EmptyData(const BasicBlock &) {}
 };
 
+// The following classes hold a representation of the IR for a change
+// reporter that uses string comparisons of the basic blocks
+// that are created using print (ie, similar to dump()).
+// These classes respect the filtering of passes and functions using
+// -filter-passes and -filter-print-funcs
+//
+// The data saved for comparing basic blocks.
+using ChangedBlockData = BlockDataTemplate<EmptyData>;
+
 // The data saved for comparing functions.
-using ChangedFuncData = OrderedChangedData<ChangedBlockData>;
+template <typename BlockDataT>
+class OrderedFuncDataTemplate : public OrderedChangedData<BlockDataT> {
+public:
+  OrderedFuncDataTemplate(std::string S) : EntryBlockName(S) {}
+
+  // Return the name of the entry block
+  std::string getEntryBlockName() const { return EntryBlockName; }
+
+protected:
+  std::string EntryBlockName;
+};
+
+using ChangedFuncData = OrderedFuncDataTemplate<ChangedBlockData>;
 
 // A map of names to the saved data.
 using ChangedIRData = OrderedChangedData<ChangedFuncData>;
 
-// A class that compares two IRs and does a diff between them.  The
-// added lines are prefixed with a '+', the removed lines are prefixed
-// with a '-' and unchanged lines are prefixed with a space (to have
-// things line up).
-class ChangedIRComparer {
+// 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 FuncDataT, typename IRDataT> class IRComparer {
+protected:
+  IRComparer(const IRDataT &Before, const IRDataT &After)
+      : Before(Before), After(After) {}
+
 public:
-  ChangedIRComparer(raw_ostream &OS, const ChangedIRData &Before,
-                    const ChangedIRData &After)
-      : Before(Before), After(After), Out(OS) {}
+  virtual ~IRComparer() {}
 
   // Compare the 2 IRs.
   void compare(Any IR, StringRef Prefix, StringRef PassID, StringRef Name);
 
   // Analyze \p IR and build the IR representation in \p Data.
-  static void analyzeIR(Any IR, ChangedIRData &Data);
+  static void analyzeIR(Any IR, IRDataT &Data);
 
 protected:
   // Return the module when that is the appropriate level of
   // comparison for \p IR.
   static const Module *getModuleForComparison(Any IR);
 
   // Generate the data for \p F into \p Data.
-  static bool generateFunctionData(ChangedIRData &Data, const Function &F);
+  static bool generateFunctionData(IRDataT &Data, const Function &F);
 
   // Called to handle the compare of a function. When \p InModule is set,
   // this function is being handled as part of comparing a module.
+  virtual void handleFunctionCompare(StringRef Name, StringRef Prefix,
+                                     StringRef PassID, bool InModule,
+                                     unsigned Minor, const FuncDataT &Before,
+                                     const FuncDataT &After) = 0;
+
+  const IRDataT &Before;
+  const IRDataT &After;
+};
+
+// A class that compares two IRs and does a diff between them.  The
+// added lines are prefixed with a '+', the removed lines are prefixed
+// with a '-' and unchanged lines are prefixed with a space (to have
+// things line up).
+class ChangedIRComparer : public IRComparer<ChangedFuncData, ChangedIRData> {
+public:
+  ChangedIRComparer(raw_ostream &OS, const ChangedIRData &Before,
+                    const ChangedIRData &After)
+      : IRComparer(Before, After), Out(OS) {}
+
+  ~ChangedIRComparer() override {}
+
+protected:
   void handleFunctionCompare(StringRef Name, StringRef Prefix, StringRef PassID,
-                             bool InModule, const ChangedFuncData &Before,
-                             const ChangedFuncData &After);
+                             bool InModule, unsigned Minor,
+                             const ChangedFuncData &Before,
+                             const ChangedFuncData &After) override;
 
-  const ChangedIRData &Before;
-  const ChangedIRData &After;
   raw_ostream &Out;
 };
 
 // A change printer that prints out in-line differences in the basic
 // blocks.  It uses an InlineComparer to do the comparison so it shows
 // the differences prefixed with '-' and '+' for code that is removed
 // and added, respectively.  Changes to the IR that do not affect basic
 // blocks are not reported as having changed the IR.  The option

 class VerifyInstrumentation {
   bool DebugLogging;
 
 public:
   VerifyInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
+// Class that holds transitions between basic blocks.  The transitions
+// are contained in a map of values to names of basic blocks.
+class BlockSuccessors {
+public:
+  // Fill the map with the transitions from basic block \p B.
+  BlockSuccessors(const BasicBlock &B);
+
+  // Return an iterator to the names of the successor blocks.
+  StringMap<std::string>::const_iterator begin() const {
+    return Successors.begin();
+  }
+  StringMap<std::string>::const_iterator end() const {
+    return Successors.end();
+  }
+
+  // Return the label of the basic block reached on a transition on \p S.
+  const StringRef getSuccessorLabel(StringRef S) const {
+    assert(Successors.count(S) == 1 && "Expected to find successor.");
+    return Successors.find(S)->getValue();
+  }
+
+protected:
+  // Add a transition to \p Succ on \p Label
+  void addSuccessorLabel(StringRef Succ, StringRef Label) {
+    std::pair<std::string, std::string> SS{Succ, Label};
+    Successors.insert(SS);
+  }
+
+  StringMap<std::string> Successors;
+};
+
+using BlockSuccessorsBlockData = BlockDataTemplate<BlockSuccessors>;
+
+using BlockSuccessorsFuncData =
+    OrderedFuncDataTemplate<BlockSuccessorsBlockData>;
+
+using BlockSuccessorsIRData = OrderedChangedData<BlockSuccessorsFuncData>;
+
+// Class that compares two IRs and creates a graphical representation of
+// the differences between the two IRs.  It produces HTML instructions for
+// a web page with links to pdf files showing the differences between
+// functions in the IRs.
+class DotCfgComparer
+    : public IRComparer<BlockSuccessorsFuncData, BlockSuccessorsIRData> {
+
+public:
+  // Output html on \p OS, storing the file in \p Directory, using a suffix
+  // of \p N in the filename.
+  DotCfgComparer(llvm::raw_fd_ostream &OS, unsigned N,
+                 llvm::StringRef Directory, const BlockSuccessorsIRData &Before,
+                 const BlockSuccessorsIRData &After);
+
+  // Replace '<' and '>' in \p SR with "&lt;" and "&gt;", respectively
+  static std::string makeHTMLReady(llvm::StringRef SR);
+
+protected:
+  void handleFunctionCompare(StringRef Name, StringRef Prefix, StringRef PassID,
+                             bool InModule, unsigned Minor,
+                             const BlockSuccessorsFuncData &Before,
+                             const BlockSuccessorsFuncData &After) 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, possibly
+  // indented, based on \p Indent.
+  static std::string genHTML(llvm::StringRef Text, llvm::StringRef DotFile,
+                             llvm::StringRef PDFFileName, llvm::StringRef Dir,
+                             bool Indent);
+
+  std::string Directory;
+  llvm::raw_fd_ostream &HTML;
+  unsigned N;
+};
+
+// A change reporter that builds a website with links to pdf files showing
+// dot control flow graphs with changed instructions shown in colour.
+class DotCfgChangeReporter : public ChangeReporter<BlockSuccessorsIRData> {
+public:
+  DotCfgChangeReporter(bool Verbose)
+      : ChangeReporter<BlockSuccessorsIRData>(Verbose) {}
+  ~DotCfgChangeReporter() override;
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+
+protected:
+  // Initialize the HTML file and output the header.
+  void initializeHTML();
+
+  // Called on the first IR processed.
+  void handleInitialIR(llvm::Any IR) override;
+  // Called before and after a pass to get the representation of the IR.
+  void generateIRRepresentation(llvm::Any IR, llvm::StringRef PassID,
+                                BlockSuccessorsIRData &Output) override;
+  // Called when the pass is not iteresting.
+  void omitAfter(llvm::StringRef PassID, std::string &Name) override;
+  // Called when an interesting IR has changed.
+  void handleAfter(llvm::StringRef PassID, std::string &Name,
+                   const BlockSuccessorsIRData &Before,
+                   const BlockSuccessorsIRData &After, llvm::Any) override;
+  // Called when an interesting pass is invalidated.
+  void handleInvalidated(llvm::StringRef PassID) override;
+  // Called when the IR or pass is not interesting.
+  void handleFiltered(llvm::StringRef PassID, std::string &Name) override;
+  // Called when an ignored pass is encountered.
+  void handleIgnored(llvm::StringRef PassID, std::string &Name) override;
+  // Called to compare the before and after representations of the IR.
+  bool same(const BlockSuccessorsIRData &Before,
+            const BlockSuccessorsIRData &After) override;
+
+  unsigned N = 0;
+  raw_fd_ostream *HTML = nullptr;
+};
+
 /// This class provides an interface to register all the standard pass
 /// instrumentations and manages their state (if any).
 class StandardInstrumentations {
   PrintIRInstrumentation PrintIR;
   PrintPassInstrumentation PrintPass;
   TimePassesHandler TimePasses;
   OptNoneInstrumentation OptNone;
   OptBisectInstrumentation OptBisect;
   PreservedCFGCheckerInstrumentation PreservedCFGChecker;
   IRChangedPrinter PrintChangedIR;
   PseudoProbeVerifier PseudoProbeVerification;
   InLineChangePrinter PrintChangedDiff;
   VerifyInstrumentation Verify;
+  DotCfgChangeReporter DotCfgChangeReporter;
 
   bool VerifyEach;
 
 public:
   StandardInstrumentations(bool DebugLogging, bool VerifyEach = false);
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
   TimePassesHandler &getTimePasses() { return TimePasses; }
 };
 
 extern template class ChangeReporter<std::string>;
 extern template class TextChangeReporter<std::string>;
 
+extern template class BlockDataTemplate<EmptyData>;
+extern template class OrderedChangedData<ChangedBlockData>;
+extern template class OrderedChangedData<ChangedFuncData>;
 extern template class ChangeReporter<ChangedIRData>;
 extern template class TextChangeReporter<ChangedIRData>;
+extern template class IRComparer<ChangedFuncData, ChangedIRData>;
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/DOTGraphTraits.h

public:
 
   /// isNodeHidden - If the function returns true, the given node is not
   /// displayed in the graph.
   template <typename GraphType>
   static bool isNodeHidden(const void *, const GraphType &) {
     return false;
   }
 
+  // renderNodeUsingHTML - If the function returns true, this node will be
+  // rendered using HTML-like labels which allows colors, etc in the node
+  // and the edge source labels.
+  static bool renderNodeUsingHTML(const void *) { return false; }
+
   /// getNodeLabel - Given a node and a pointer to the top level graph, return
   /// the label to print in the node.
   template<typename GraphType>
   std::string getNodeLabel(const void *, const GraphType &) {
     return "";
   }
 
   // getNodeIdentifierLabel - Returns a string representing the

llvm/include/llvm/Support/GraphWriter.h

class GraphWriter {
 
   // Writes the edge labels of the node to O and returns true if there are any
   // edge labels not equal to the empty string "".
   bool getEdgeSourceLabels(raw_ostream &O, NodeRef Node) {
     child_iterator EI = GTraits::child_begin(Node);
     child_iterator EE = GTraits::child_end(Node);
     bool hasEdgeSourceLabels = false;
 
+    if (DTraits.renderNodeUsingHTML(Node))
+      O << "</TR><TR>";
+
     for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i) {
       std::string label = DTraits.getEdgeSourceLabel(Node, EI);
 
       if (label.empty())
         continue;
 
       hasEdgeSourceLabels = true;
 
+      if (DTraits.renderNodeUsingHTML(Node))
+        O << "<TD COLSPAN=\"1\" PORT=\"s" << i << "\">" << label << "</TD>";
+      else {
         if (i)
           O << "|";
 
         O << "<s" << i << ">" << DOT::EscapeString(label);
       }
+    }
 
-    if (EI != EE && hasEdgeSourceLabels)
+    if (EI != EE && hasEdgeSourceLabels) {
+      if (DTraits.renderNodeUsingHTML(Node))
+        O << "<TD COLSPAN=\"1\" PORT=\"s64\">truncated...</TD>";
+      else
         O << "|<s64>truncated...";
+    }
 
     return hasEdgeSourceLabels;
   }
 
 public:
   GraphWriter(raw_ostream &o, const GraphType &g, bool SN) : O(o), G(g) {
     DTraits = DOTTraits(SN);
   }
for (const auto Node : nodes<GraphType>(G))
         writeNode(Node);
   }
 
   bool isNodeHidden(NodeRef Node) { return DTraits.isNodeHidden(Node, G); }
 
   void writeNode(NodeRef Node) {
     std::string NodeAttributes = DTraits.getNodeAttributes(Node, G);
 
-    O << "\tNode" << static_cast<const void*>(Node) << " [shape=record,";
+    O << "\tNode" << static_cast<const void *>(Node) << " [shape=";
+    if (DTraits.renderNodeUsingHTML(Node))
+      O << "none,";
+    else
+      O << "record,";
+
     if (!NodeAttributes.empty()) O << NodeAttributes << ",";
-    O << "label=\"{";
+    O << "label=";
+
+    if (DTraits.renderNodeUsingHTML(Node)) {
+      // Count the numbewr of edges out of the node to determine how
+      // many columns to span (max 64)
+      unsigned ColSpan = 0;
+      child_iterator EI = GTraits::child_begin(Node);
+      child_iterator EE = GTraits::child_end(Node);
+      for (; EI != EE && ColSpan != 64; ++EI, ++ColSpan)
+        ;
+      if (ColSpan == 0)
+        ColSpan = 1;
+      // Include truncated messages when counting.
+      if (EI != EE)
+        ++ColSpan;
+      O << "<<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\""
+        << " CELLPADDING=\"0\"><TR><TD ALIGN=\"text\" COLSPAN=\"" << ColSpan
+        << "\">";
+    } else
+      O << "\"{";
 
     if (!DTraits.renderGraphFromBottomUp()) {
+      if (DTraits.renderNodeUsingHTML(Node))
+        O << DTraits.getNodeLabel(Node, G) << "</TD>";
+      else
         O << DOT::EscapeString(DTraits.getNodeLabel(Node, G));
 
       // If we should include the address of the node in the label, do so now.
       std::string Id = DTraits.getNodeIdentifierLabel(Node, G);
       if (!Id.empty())
         O << "|" << DOT::EscapeString(Id);
 
       std::string NodeDesc = DTraits.getNodeDescription(Node, G);
       if (!NodeDesc.empty())
         O << "|" << DOT::EscapeString(NodeDesc);
     }
 
     std::string edgeSourceLabels;
     raw_string_ostream EdgeSourceLabels(edgeSourceLabels);
     bool hasEdgeSourceLabels = getEdgeSourceLabels(EdgeSourceLabels, Node);
 
     if (hasEdgeSourceLabels) {
-      if (!DTraits.renderGraphFromBottomUp()) O << "|";
+      if (!DTraits.renderGraphFromBottomUp())
+        if (!DTraits.renderNodeUsingHTML(Node))
+          O << "|";
 
+      if (DTraits.renderNodeUsingHTML(Node))
+        O << EdgeSourceLabels.str();
+      else
         O << "{" << EdgeSourceLabels.str() << "}";
 
-      if (DTraits.renderGraphFromBottomUp()) O << "|";
+      if (DTraits.renderGraphFromBottomUp())
+        if (!DTraits.renderNodeUsingHTML(Node))
+          O << "|";
     }
 
     if (DTraits.renderGraphFromBottomUp()) {
+      if (DTraits.renderNodeUsingHTML(Node))
+        O << DTraits.getNodeLabel(Node, G);
+      else
         O << DOT::EscapeString(DTraits.getNodeLabel(Node, G));
 
       // If we should include the address of the node in the label, do so now.
       std::string Id = DTraits.getNodeIdentifierLabel(Node, G);
       if (!Id.empty())
         O << "|" << DOT::EscapeString(Id);
 
       std::string NodeDesc = DTraits.getNodeDescription(Node, G);
       if (!NodeDesc.empty())
         O << "|" << DOT::EscapeString(NodeDesc);
     }
 
     if (DTraits.hasEdgeDestLabels()) {
       O << "|{";
 
       unsigned i = 0, e = DTraits.numEdgeDestLabels(Node);
       for (; i != e && i != 64; ++i) {
         if (i) O << "|";
         O << "<d" << i << ">"
           << DOT::EscapeString(DTraits.getEdgeDestLabel(Node, i));
       }
 
-      if (i != e)
-        O << "|<d64>truncated...";
-      O << "}";
+      if (DTraits.renderNodeUsingHTML(Node))
+        O << "<TD COLSPAN=\"1\">... truncated</TD>";
+      else if (i != e)
+        O << "|<d64>truncated...}";
     }
 
-    O << "}\"];\n";   // Finish printing the "node" line
+    if (DTraits.renderNodeUsingHTML(Node))
+      O << "</TR></TABLE>>";
+    else
+      O << "}\"";
+    O << "];\n"; // Finish printing the "node" line
 
     // Output all of the edges now
     child_iterator EI = GTraits::child_begin(Node);
     child_iterator EE = GTraits::child_end(Node);
     for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i)
       if (!DTraits.isNodeHidden(*EI, G))
         writeEdge(Node, i, EI);
     for (; EI != EE; ++EI)

llvm/lib/Passes/StandardInstrumentations.cpp

 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PrintPasses.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
+#include <regex>
+#include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
 
 cl::opt<bool> PreservedCFGCheckerInstrumentation::VerifyPreservedCFG(
     "verify-cfg-preserved", cl::Hidden,
 #ifdef NDEBUG
     cl::init(false));

 // insert the prefixes.  For systems that do not have the necessary
 // facilities, the error message will be shown in place of the expected output.
 //
 enum class ChangePrinter {
   NoChangePrinter,
   PrintChangedVerbose,
   PrintChangedQuiet,
   PrintChangedDiffVerbose,
-  PrintChangedDiffQuiet
+  PrintChangedDiffQuiet,
+  PrintChangedDotCfgVerbose,
+  PrintChangedDotCfgQuiet
 };
 static cl::opt<ChangePrinter> PrintChanged(
     "print-changed", cl::desc("Print changed IRs"), cl::Hidden,
     cl::ValueOptional, cl::init(ChangePrinter::NoChangePrinter),
-    cl::values(clEnumValN(ChangePrinter::PrintChangedQuiet, "quiet",
-                          "Run in quiet mode"),
-               clEnumValN(ChangePrinter::PrintChangedDiffVerbose, "diff",
-                          "Display patch-like changes"),
-               clEnumValN(ChangePrinter::PrintChangedDiffQuiet, "diff-quiet",
-                          "Display patch-like changes in quiet mode"),
-               // Sentinel value for unspecified option.
-               clEnumValN(ChangePrinter::PrintChangedVerbose, "", "")));
+    cl::values(
+        clEnumValN(ChangePrinter::PrintChangedQuiet, "quiet",
+        clEnumValN(ChangePrinter::PrintChangedDotCfgVerbose, "dot-cfg",
+                   "Create a website with graphical changes"),
+        clEnumValN(ChangePrinter::PrintChangedDotCfgQuiet, "dot-cfg-quiet",
+                   "Create a website with graphical changes in quiet mode"),
 
 // 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::list<std::string>
     PrintPassesList("filter-passes", cl::value_desc("pass names"),
                     cl::desc("Only consider IR changes for passes whose names "
                              "match for the print-changed option"),
                     cl::CommaSeparated, cl::Hidden);
 // 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);
 
 // An option for specifying the diff used by print-changed=[diff | diff-quiet]
 static cl::opt<std::string>
     DiffBinary("print-changed-diff-path", cl::Hidden, cl::init("diff"),
                cl::desc("system diff used by change reporters"));
 
+// An option that determines the colour used for elements that are only
+// in the before part.  Must be a colour named in appendix J of
+// https://graphviz.org/pdf/dotguide.pdf
+cl::opt<std::string> BeforeColour("before-color",
+                                  cl::desc("Color for before elements."),
+                                  cl::Hidden, cl::init("red"));
+// An option that determines the colour used for elements that are only
+// in the after part.  Must be a colour named in appendix J of
+// https://graphviz.org/pdf/dotguide.pdf
+cl::opt<std::string> AfterColour("after-color",
+                                 cl::desc("Color for after elements."),
+                                 cl::Hidden, cl::init("forestgreen"));
+// An option that determines the colour used for elements that are in both
+// the before and after parts.  Must be a colour named in appendix J of
+// https://graphviz.org/pdf/dotguide.pdf
+cl::opt<std::string> CommonColour("common-color",
+                                  cl::desc("Color for common elements."),
+                                  cl::Hidden, cl::init("black"));
+
+// An option that determines where the generated website file (named
+// passes.html) and the associated pdf files (named diff_*.pdf) are saved.
+static cl::opt<std::string> DotCfgDir(
+    "dot-cfg-dir",
+    cl::desc("Generate dot files into specified directory for changed IRs"),
+    cl::Hidden, cl::init("./"));
+
 namespace {
 
 // Perform a system based diff between \p Before and \p After, using
 // \p OldLineFormat, \p NewLineFormat, and \p UnchangedLineFormat
 // to control the formatting of the output.  Return an error message
 // for any failures instead of the diff.
 std::string doSystemDiff(StringRef Before, StringRef After,
                          StringRef OldLineFormat, StringRef NewLineFormat,
PIC.registerAfterPassCallback(
         handleIRAfterPass(IR, P);
       });
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &) {
         handleInvalidatedPass(P);
       });
 }
 
-ChangedBlockData::ChangedBlockData(const BasicBlock &B)
-    : Label(B.getName().str()) {
-  raw_string_ostream SS(Body);
-  B.print(SS, nullptr, true, true);
-}
-
 template <typename IRUnitT>
 TextChangeReporter<IRUnitT>::TextChangeReporter(bool Verbose)
     : ChangeReporter<IRUnitT>(Verbose), Out(dbgs()) {}
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::handleInitialIR(Any IR) {
   // Always print the module.
   // Unwrap and print directly to avoid filtering problems in general routines.
void OrderedChangedData<IRData>::report(
   while (BI != BE) {
     handlePotentiallyRemovedIRData(*BI);
     ++BI;
   }
 
   handleNewIRData(NewIRDataQueue);
 }
 
-void ChangedIRComparer::compare(Any IR, StringRef Prefix, StringRef PassID,
-                                StringRef Name) {
+template <typename FuncDataT, typename IRDataT>
+void IRComparer<FuncDataT, IRDataT>::compare(Any IR, StringRef Prefix,
+                                             StringRef PassID, StringRef Name) {
   if (!getModuleForComparison(IR)) {
     // Not a module so just handle the single function.
     assert(Before.getData().size() == 1 && "Expected only one function.");
     assert(After.getData().size() == 1 && "Expected only one function.");
-    handleFunctionCompare(Name, Prefix, PassID, false,
+    handleFunctionCompare(Name, Prefix, PassID, false, 0,
                           Before.getData().begin()->getValue(),
                           After.getData().begin()->getValue());
     return;
   }
 
-  ChangedIRData::report(
-      Before, After, [&](const ChangedFuncData *B, const ChangedFuncData *A) {
-        ChangedFuncData Missing;
-        if (!B)
-          B = &Missing;
-        else if (!A)
-          A = &Missing;
-        assert(B != &Missing && A != &Missing &&
-               "Both functions cannot be missing.");
-        handleFunctionCompare(Name, Prefix, PassID, true, *B, *A);
-      });
+  unsigned Minor = 0;
+  FuncDataT Missing("");
+  IRDataT::report(Before, After, [&](const FuncDataT *B, const FuncDataT *A) {
+    assert((B || A) && "Both functions cannot be missing.");
+    if (!A)
+    handleFunctionCompare(Name, Prefix, PassID, true, Minor++, *B, *A);
 }
 
-void ChangedIRComparer::analyzeIR(Any IR, ChangedIRData &Data) {
+template <typename FuncDataT, typename IRDataT>
+void IRComparer<FuncDataT, IRDataT>::analyzeIR(Any IR, IRDataT &Data) {
   if (const Module *M = getModuleForComparison(IR)) {
     // Create data for each existing/interesting function in the module.
     for (const Function &F : *M)
       generateFunctionData(Data, F);
     return;
   }
 
   const Function *F = nullptr;
   if (any_isa<const Function *>(IR))
     F = any_cast<const Function *>(IR);
   else {
     assert(any_isa<const Loop *>(IR) && "Unknown IR unit.");
     const Loop *L = any_cast<const Loop *>(IR);
     F = L->getHeader()->getParent();
   }
   assert(F && "Unknown IR unit.");
   generateFunctionData(Data, *F);
 }
 
-const Module *ChangedIRComparer::getModuleForComparison(Any IR) {
+template <typename FuncDataT, typename IRDataT>
+const Module *IRComparer<FuncDataT, IRDataT>::getModuleForComparison(Any IR) {
   if (any_isa<const Module *>(IR))
     return any_cast<const Module *>(IR);
   if (any_isa<const LazyCallGraph::SCC *>(IR))
     return any_cast<const LazyCallGraph::SCC *>(IR)
         ->begin()
         ->getFunction()
         .getParent();
   return nullptr;
 }
 
-bool ChangedIRComparer::generateFunctionData(ChangedIRData &Data,
+template <typename FuncDataT, typename IRDataT>
+bool IRComparer<FuncDataT, IRDataT>::generateFunctionData(IRDataT &Data,
                                                           const Function &F) {
   if (!F.isDeclaration() && isFunctionInPrintList(F.getName())) {
-    ChangedFuncData CFD;
+    FuncDataT FD(F.getEntryBlock().getName().str());
     for (const auto &B : F) {
-      CFD.getOrder().emplace_back(B.getName());
-      CFD.getData().insert({B.getName(), B});
+      FD.getOrder().emplace_back(B.getName());
+      FD.getData().insert({B.getName(), B});
     }
     Data.getOrder().emplace_back(F.getName());
-    Data.getData().insert({F.getName(), CFD});
+    Data.getData().insert({F.getName(), FD});
     return true;
   }
   return false;
 }
 
 PrintIRInstrumentation::~PrintIRInstrumentation() {
   assert(ModuleDescStack.empty() && "ModuleDescStack is not empty at exit");
 }

 
 bool InLineChangePrinter::same(const ChangedIRData &D1,
                                const ChangedIRData &D2) {
   return D1 == D2;
 }
 
 void ChangedIRComparer::handleFunctionCompare(StringRef Name, StringRef Prefix,
                                               StringRef PassID, bool InModule,
+                                              unsigned Minor,
                                               const ChangedFuncData &Before,
                                               const ChangedFuncData &After) {
   // Print a banner when this is being shown in the context of a module
   if (InModule)
     Out << "\n*** IR for function " << Name << " ***\n";
 
   ChangedFuncData::report(
       Before, After, [&](const ChangedBlockData *B, const ChangedBlockData *A) {
         StringRef BStr = B ? B->getBody() : "\n";
         StringRef AStr = A ? A->getBody() : "\n";
         const std::string Removed = "\033[31m-%l\033[0m\n";
         const std::string Added = "\033[32m+%l\033[0m\n";
         const std::string NoChange = " %l\n";
         Out << doSystemDiff(BStr, AStr, Removed, Added, NoChange);
       });
 }
 
 void InLineChangePrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::PrintChangedDiffVerbose ||
       PrintChanged == ChangePrinter::PrintChangedDiffQuiet)
     TextChangeReporter<ChangedIRData>::registerRequiredCallbacks(PIC);
 }
 
+namespace {
+
+enum IRChangeDiffType { InBefore, InAfter, IsCommon, NumIRChangeDiffTypes };
+
+// Describe where a given element exists.
+std::string Colours[NumIRChangeDiffTypes];
+
+class DisplayNode;
+class DotCfgDiffDisplayGraph;
+
+// Base class for a node or edge in the dot-cfg-changes graph.
+class DisplayElement {
+public:
+  // Is this in before, after, or both?
+  IRChangeDiffType getType() const { return Type; }
+
+protected:
+  DisplayElement(IRChangeDiffType T) : Type(T) {}
+  const IRChangeDiffType Type;
+};
+
+// An edge representing a transition between basic blocks in the
+// dot-cfg-changes graph.
+class DisplayEdge : public DisplayElement {
+public:
+  DisplayEdge(std::string V, DisplayNode &Node, IRChangeDiffType T)
+      : DisplayElement(T), Value(V), Node(Node) {}
+  // The value on which the transition is made.
+  std::string getValue() const { return Value; }
+  // The node (representing a basic block) reached by this transition.
+  const DisplayNode &getDestinationNode() const { return Node; }
+
+protected:
+  std::string Value;
+  const DisplayNode &Node;
+};
+
+// A node in the dot-cfg-changes graph which represents a basic block.
+class DisplayNode : public DisplayElement {
+public:
+  // \p C is the content for the node, \p T indicates the colour for the
+  // outline of the node
+  DisplayNode(std::string C, IRChangeDiffType T)
+      : DisplayElement(T), Content(C) {}
+
+  // Iterator to the child nodes.  Required by GraphWriter.
+  using ChildIterator = std::unordered_set<DisplayNode *>::const_iterator;
+  ChildIterator children_begin() const { return Children.cbegin(); }
+  ChildIterator children_end() const { return Children.cend(); }
+
+  // Iterator for the edges.  Required by GraphWriter.
+  using EdgeIterator = std::vector<DisplayEdge *>::const_iterator;
+  EdgeIterator edges_begin() const { return EdgePtrs.cbegin(); }
+  EdgeIterator edges_end() const { return EdgePtrs.cend(); }
+
+  // Create an edge to \p Node on value \p V, with type \p T.
+  void createEdge(StringRef V, DisplayNode &Node, IRChangeDiffType T);
+
+  // Return the content of this node.
+  std::string getContent() const { return Content; }
+
+  // Return the type of the edge to node \p S.
+  const DisplayEdge &getEdge(const DisplayNode &To) const {
+    assert(EdgeMap.find(&To) != EdgeMap.end() && "Expected to find edge.");
+    return *EdgeMap.find(&To)->second;
+  }
+
+  // Return the value for the transition to basic block \p S.
+  // Required by GraphWriter.
+  std::string getEdgeSourceLabel(const DisplayNode &Sink) const {
+    return getEdge(Sink).getValue();
+  }
+
+  void createEdgeMap();
+
+protected:
+  const std::string Content;
+
+  // Place to collect all of the edges.  Once they are all in the vector,
+  // the vector will not reallocate so then we can use pointers to them,
+  // which are required by the graph writing routines.
+  std::vector<DisplayEdge> Edges;
+
+  std::vector<DisplayEdge *> EdgePtrs;
+  std::unordered_set<DisplayNode *> Children;
+  std::unordered_map<const DisplayNode *, const DisplayEdge *> EdgeMap;
+
+  // Safeguard adding of edges.
+  bool AllEdgesCreated = false;
+};
+
+// Class representing a difference display (corresponds to a pdf file).
+class DotCfgDiffDisplayGraph {
+public:
+  DotCfgDiffDisplayGraph(std::string Name) {
+    NodeGenerationComplete = false;
+    GraphName = Name;
+    assert(Nodes.size() == 0 && "Expected Nodes to be empty.");
+    assert(NodePtrs.size() == 0 && "Expected NodePtrs to be empty.");
+    assert(EntryNode == nullptr && "Expected EntryNode to be null.");
+  }
+  ~DotCfgDiffDisplayGraph() {
+    // Due to opt bug we have static members.  Clear them out.
+    GraphName = "";
+    Nodes.clear();
+    NodePtrs.clear();
+    EntryNode = nullptr;
+  }
+
+  // Generate the file into \p DotFile.
+  void generateDotFile(StringRef DotFile);
+
+  // Iterator to the nodes.  Required by GraphWriter.
+  using NodeIterator = std::vector<DisplayNode *>::const_iterator;
+  NodeIterator nodes_begin() const {
+    assert(NodeGenerationComplete && "Unexpected children iterator creation");
+    return NodePtrs.cbegin();
+  }
+  NodeIterator nodes_end() const {
+    assert(NodeGenerationComplete && "Unexpected children iterator creation");
+    return NodePtrs.cend();
+  }
+
+  // Record the index of the entry node.  At this point, we can build up
+  // vectors of pointers that are required by the graph routines.
+  void setEntryNode(unsigned N) {
+    // At this point, there will be no new nodes.
+    assert(!NodeGenerationComplete && "Unexpected node creation");
+    NodeGenerationComplete = true;
+    for (auto &N : Nodes)
+      NodePtrs.emplace_back(&N);
+
+    EntryNode = NodePtrs[N];
+  }
+
+  // Create a node.
+  void createNode(std::string C, IRChangeDiffType T) {
+    assert(!NodeGenerationComplete && "Unexpected node creation");
+    Nodes.emplace_back(C, T);
+  }
+  // Return the node at index \p N to avoid problems with vectors reallocating.
+  DisplayNode &getNode(unsigned N) {
+    assert(N < Nodes.size() && "Node is out of bounds");
+    return Nodes[N];
+  }
+  unsigned size() const {
+    assert(NodeGenerationComplete && "Unexpected children iterator creation");
+    return Nodes.size();
+  }
+
+  // Return the name of the graph.  Required by GraphWriter.
+  std::string getGraphName() const { return GraphName; }
+
+  // Return the string representing the differences for basic block \p Node.
+  // Required by GraphWriter.
+  std::string getNodeLabel(const DisplayNode &Node) const {
+    return Node.getContent();
+  }
+
+  // Return a string with colour information for Dot.  Required by GraphWriter.
+  std::string getNodeAttributes(const DisplayNode &Node) const {
+    return attribute(Node.getType());
+  }
+
+  // Return a string with colour information for Dot.  Required by GraphWriter.
+  std::string getEdgeColorAttr(const DisplayNode &From,
+                               const DisplayNode &To) const {
+    return attribute(From.getEdge(To).getType());
+  }
+
+  // Get the starting basic block.  Required by GraphWriter.
+  DisplayNode *getEntryNode() const {
+    assert(NodeGenerationComplete && "Unexpected children iterator creation");
+    return EntryNode;
+  }
+
+protected:
+  // Return the string containing the colour to use as a Dot attribute.
+  std::string attribute(IRChangeDiffType T) const;
+
+  // There appears to be an optimization bug in the build compiler in
+  // that when begin() and end() are called from GraphWriter, the pointer to
+  // DotCfgDiff (the G member of GraphWriter) is changed to refer to the
+  // stack.  This does not happen in a non-release build and I do not see
+  // any code that should cause a copy to be made (in fact, the copy
+  // constructor and operator= are deleted).  Because of this, these members
+  // have to be static or else the program will crash.
+  // It can be shown by adding
+  // "dbgs() << __FUNCTION__ << " " << (void*)this << "\n";" into the ctor
+  // and begin/end functions.  They should match because only 1 object is
+  // created.
+  // TODO verify the bug at the proper level of build compiler and make a
+  // bug report if necessary.
+  // TODO These should be made members and workarounds removed when the
+  // bug is fixed.
+  static bool NodeGenerationComplete;
+  static std::string GraphName;
+  static std::vector<DisplayNode> Nodes;
+  static std::vector<DisplayNode *> NodePtrs;
+  static DisplayNode *EntryNode;
+};
+
+bool DotCfgDiffDisplayGraph::NodeGenerationComplete;
+std::string DotCfgDiffDisplayGraph::GraphName;
+std::vector<DisplayNode> DotCfgDiffDisplayGraph::Nodes;
+std::vector<DisplayNode *> DotCfgDiffDisplayGraph::NodePtrs;
+DisplayNode *DotCfgDiffDisplayGraph::EntryNode;
+
+void DisplayNode::createEdge(StringRef V, DisplayNode &Node,
+                             IRChangeDiffType T) {
+  assert(!AllEdgesCreated && "Expected to be able to still create edges.");
+  Edges.emplace_back(V.str(), Node, T);
+  Children.insert(&Node);
+}
+
+void DisplayNode::createEdgeMap() {
+  // No more edges will be added so we can now use pointers to the edges
+  // as the vector will not grow and reallocate.
+  AllEdgesCreated = true;
+  for (auto &E : Edges)
+    EdgeMap.insert({&E.getDestinationNode(), &E});
+}
+
+class DotCfgDiffNode;
+class DotCfgDiff;
+
+// A class representing a basic block in the Dot difference graph.
+class DotCfgDiffNode {
+public:
+  DotCfgDiffNode() = delete;
+
+  // Create a node in Dot difference graph \p G representing the basic block
+  // represented by \p BD with type \p T (where it exists).
+  DotCfgDiffNode(DotCfgDiff &G, unsigned N, const BlockSuccessorsBlockData &BD,
+                 IRChangeDiffType T)
+      : Graph(G), N(N), Data{&BD, nullptr}, Type(T) {}
+  DotCfgDiffNode(const DotCfgDiffNode &DN)
+      : Graph(DN.Graph), N(DN.N), Data{DN.Data[0], DN.Data[1]}, Type(DN.Type),
+        EdgesMap(DN.EdgesMap), Children(DN.Children), Edges(DN.Edges) {}
+
+  unsigned getIndex() const { return N; }
+
+  // The label of the basic block
+  StringRef getLabel() const {
+    assert(Data[0] && "Expected Data[0] to be set.");
+    return Data[0]->getLabel();
+  }
+  // Return where this block exists.
+  IRChangeDiffType getType() const { return Type; }
+  // Change this basic block from being only in before to being common.
+  // Save the pointer to \p Other.
+  void setCommon(const BlockSuccessorsBlockData &Other) {
+    assert(!Data[1] && "Expected only one block datum");
+    Data[1] = &Other;
+    Type = IsCommon;
+  }
+  // Add an edge to \p E of type {\p Value, \p T}.
+  void addEdge(unsigned E, StringRef Value, IRChangeDiffType T) {
+    // This is a new edge or it is an edge being made common.
+    assert((EdgesMap.count(E) == 0 || T == IsCommon) &&
+           "Unexpected edge count and type.");
+    EdgesMap[E] = {Value.str(), T};
+  }
+  // Record the children and create edges.
+  void finalize(DotCfgDiff &G);
+
+  // Return the type of the edge to node \p S.
+  std::pair<std::string, IRChangeDiffType> getEdge(const unsigned S) const {
+    assert(EdgesMap.count(S) == 1 && "Expected to find edge.");
+    return EdgesMap.at(S);
+  }
+
+  // Return the string representing the basic block.
+  std::string getBodyContent() const;
+
+  void createDisplayEdges(DotCfgDiffDisplayGraph &Graph, unsigned DisplayNode,
+                          std::map<const unsigned, unsigned> &NodeMap);
+
+protected:
+  DotCfgDiff &Graph;
+  const unsigned N;
+  const BlockSuccessorsBlockData *Data[2];
+  IRChangeDiffType Type;
+  std::map<const unsigned, std::pair<std::string, IRChangeDiffType>> EdgesMap;
+  std::vector<unsigned> Children;
+  std::vector<unsigned> Edges;
+};
+
+// Class representing the difference graph between two functions.
+class DotCfgDiff {
+public:
+  // \p Title is the title given to the graph.  \p EntryNodeName is the
+  // entry node for the function.  \p Before and \p After are the before
+  // after versions of the function, respectively.  \p Dir is the directory
+  // in which to store the results.
+  DotCfgDiff(StringRef Title, const BlockSuccessorsFuncData &Before,
+             const BlockSuccessorsFuncData &After, StringRef Dir);
+  // Only needed because of opt bug...
+  ~DotCfgDiff() {
+    // Due to opt bug we have static members.  Clear them out.
+    Nodes.clear();
+    NodePosition.clear();
+    GraphName = "";
+  }
+
+  DotCfgDiff(const DotCfgDiff &) = delete;
+  DotCfgDiff &operator=(const DotCfgDiff &) = delete;
+
+  DotCfgDiffDisplayGraph createDisplayGraph(StringRef Title,
+                                            StringRef EntryNodeName);
+
+  // Return a string consisting of the labels for the \p Source and \p Sink.
+  // The combination allows distinguishing changing transitions on the
+  // same value (ie, a transition went to X before and goes to Y after).
+  // Required by GraphWriter.
+  StringRef getEdgeSourceLabel(const unsigned &Source,
+                               const unsigned &Sink) const {
+    std::string S =
+        getNode(Source).getLabel().str() + " " + getNode(Sink).getLabel().str();
+    assert(EdgeLabels.count(S) == 1 && "Expected to find edge label.");
+    return EdgeLabels.find(S)->getValue();
+  }
+
+  // Return the number of basic blocks (nodes).  Required by GraphWriter.
+  unsigned size() const { return Nodes.size(); }
+
+  DotCfgDiffNode &getNode(unsigned N) const {
+    assert(N < Nodes.size() && "Unexpected index for node reference");
+    return Nodes[N];
+  }
+
+protected:
+  // Return the string surrounded by HTML to make it the appropriate colour.
+  std::string colourize(std::string S, IRChangeDiffType T) const;
+  // Return the string containing the colour to use as a Dot attribute.
+  std::string attribute(IRChangeDiffType T) const;
+
+  void createNode(StringRef Label, const BlockSuccessorsBlockData &BD,
+                  IRChangeDiffType T) {
+    unsigned Pos = Nodes.size();
+    Nodes.emplace_back(*this, Pos, BD, T);
+    NodePosition.insert({Label, Pos});
+  }
+
+  // There appears to be an optimization bug in the build compiler in
+  // that when begin() and end() are called from GraphWriter, the pointer to
+  // DotCfgDiff (the G member of GraphWriter) is changed to refer to the
+  // stack.  This does not happen in a non-release build and I do not see
+  // any code that should cause a copy to be made (in fact, the copy
+  // constructor and operator= are deleted).  Because of this, these members
+  // have to be static or else the program will crash.
+  // It can be shown by adding
+  // "dbgs() << __FUNCTION__ << " " << (void*)this << "\n";" into the ctor
+  // and begin/end functions.  They should match because only 1 object is
+  // created.
+  // TODO verify the bug and make a bug report.
+  static std::vector<DotCfgDiffNode> Nodes;
+  static StringMap<unsigned> NodePosition;
+  static std::string GraphName;
+
+  DotCfgDiffNode *EntryNode;
+  StringMap<std::string> EdgeLabels;
+};
+
+std::string DotCfgDiffNode::getBodyContent() const {
+  if (Type == IsCommon) {
+    assert(Data[1] && "Expected Data[1] to be set.");
+
+    StringRef SR[2];
+    for (unsigned I = 0; I < 2; ++I) {
+      SR[I] = Data[I]->getBody();
+      // drop initial '\n' if present
+      if (SR[I][0] == '\n')
+        SR[I] = SR[I].drop_front();
+      // drop predecessors as they can be big and are redundant
+      SR[I] = SR[I].drop_until([](char c) { return c == '\n'; }).drop_front();
+    }
+
+    SmallString<80> OldLineFormat = formatv(
+        "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>", Colours[InBefore]);
+    SmallString<80> NewLineFormat = formatv(
+        "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>", Colours[InAfter]);
+    SmallString<80> UnchangedLineFormat = formatv(
+        "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>", Colours[IsCommon]);
+    std::string Diff = Data[0]->getLabel().str();
+    Diff += ":\n<BR align=\"left\"/>" +
+            doSystemDiff(DotCfgComparer::makeHTMLReady(SR[0]),
+                         DotCfgComparer::makeHTMLReady(SR[1]), OldLineFormat,
+                         NewLineFormat, UnchangedLineFormat);
+
+    // Diff adds in some empty colour changes which are not valid HTML
+    // so remove them.  Colours are all lowercase alpha characters (as
+    // listed in https://graphviz.org/pdf/dotguide.pdf).
+    return std::regex_replace(Diff, std::regex("<FONT COLOR=\"\\w+\"></FONT>"),
+                              std::string(""));
+  }
+
+  // Put node out in the appropriate colour.
+  assert(!Data[1] && "Data[1] is set unexpectedly.");
+  std::string Body = DotCfgComparer::makeHTMLReady(Data[0]->getBody());
+  const StringRef BS = Body;
+  StringRef BS1 = BS;
+  // Drop leading newline, if present.
+  if (BS.front() == '\n')
+    BS1 = BS1.drop_front(1);
+  // Get label.
+  StringRef Label = BS1.take_until([](char c) { return c == ':'; });
+  // drop predecessors as they can be big and are redundant
+  BS1 = BS1.drop_until([](char c) { return c == '\n'; }).drop_front();
+
+  std::string S = "<FONT COLOR=\"" + Colours[Type] + "\">" + Label.str() + ":";
+
+  // align each line to the left.
+  while (BS1.size()) {
+    S.append("<BR align=\"left\"/>");
+    StringRef Line = BS1.take_until([](char c) { return c == '\n'; });
+    S.append(Line.str());
+    BS1 = BS1.drop_front(Line.size() + 1);
+  }
+  S.append("<BR align=\"left\"/></FONT>");
+  return S;
+}
+
+std::string DotCfgDiff::colourize(std::string S, IRChangeDiffType T) const {
+  if (S.length() == 0)
+    return S;
+  return "<FONT COLOR=\"" + Colours[T] + "\">" + S + "</FONT>";
+}
+
+std::string DotCfgDiff::attribute(IRChangeDiffType T) const {
+  return "color=" + Colours[T];
+}
+
+std::string DotCfgDiffDisplayGraph::attribute(IRChangeDiffType T) const {
+  return "color=" + Colours[T];
+}
+
+DotCfgDiff::DotCfgDiff(StringRef Title, const BlockSuccessorsFuncData &Before,
+                       const BlockSuccessorsFuncData &After, StringRef Dir) {
+  // Due to opt bug we have static members.  Ensure that they are empty.
+  assert(Nodes.empty() && "Expected Nodes to be empty.");
+  assert(NodePosition.empty() && "Expected NodePosition to be empty.");
+  assert(GraphName.size() == 0 && "Expected GraphName to be empty.");
+
+  GraphName = Title.str();
+  StringMap<IRChangeDiffType> EdgesMap;
+
+  // Handle each basic block in the before IR.
+  for (auto &B : Before.getData()) {
+    StringRef Label = B.getKey();
+    const BlockSuccessorsBlockData &BD = B.getValue();
+    createNode(Label, BD, InBefore);
+
+    // Create transitions with names made up of the from block label, the value
+    // on which the transition is made and the to block label.
+    for (StringMap<std::string>::const_iterator Sink = BD.getData().begin(),
+                                                E = BD.getData().end();
+         Sink != E; ++Sink) {
+      std::string Key = (Label + " " + Sink->getKey().str()).str() + " " +
+                        BD.getData().getSuccessorLabel(Sink->getKey()).str();
+      EdgesMap.insert({Key, InBefore});
+    }
+  }
+
+  // Handle each basic block in the after IR
+  for (auto &A : After.getData()) {
+    StringRef Label = A.getKey();
+    const BlockSuccessorsBlockData &BD = A.getValue();
+    unsigned C = NodePosition.count(Label);
+    if (C == 0)
+      // This only exists in the after IR.  Create the node.
+      createNode(Label, BD, InAfter);
+    else {
+      assert(C == 1 && "Unexpected multiple nodes.");
+      Nodes[NodePosition[Label]].setCommon(BD);
+    }
+    // Add in the edges between the nodes (as common or only in after).
+    for (StringMap<std::string>::const_iterator Sink = BD.getData().begin(),
+                                                E = BD.getData().end();
+         Sink != E; ++Sink) {
+      std::string Key = (Label + " " + Sink->getKey().str()).str() + " " +
+                        BD.getData().getSuccessorLabel(Sink->getKey()).str();
+      unsigned C = EdgesMap.count(Key);
+      if (C == 0)
+        EdgesMap.insert({Key, InAfter});
+      else {
+        EdgesMap[Key] = IsCommon;
+      }
+    }
+  }
+
+  // Now go through the map of edges and add them to the node.
+  for (auto &E : EdgesMap) {
+    // Extract the source, sink and value from the edge key.
+    StringRef S = E.getKey();
+    auto SP1 = S.rsplit(' ');
+    auto &SourceSink = SP1.first;
+    auto SP2 = SourceSink.split(' ');
+    StringRef Source = SP2.first;
+    StringRef Sink = SP2.second;
+    StringRef Value = SP1.second;
+
+    assert(NodePosition.count(Source) == 1 && "Expected to find node.");
+    DotCfgDiffNode &SourceNode = Nodes[NodePosition[Source]];
+    assert(NodePosition.count(Sink) == 1 && "Expected to find node.");
+    unsigned SinkNode = NodePosition[Sink];
+    IRChangeDiffType T = E.second;
+
+    // Look for an edge from Source to Sink
+    if (EdgeLabels.count(SourceSink) == 0)
+      EdgeLabels.insert({SourceSink, colourize(Value.str(), T)});
+    else {
+      StringRef V = EdgeLabels.find(SourceSink)->getValue();
+      std::string NV = colourize(V.str() + " " + Value.str(), T);
+      T = IsCommon;
+      EdgeLabels[SourceSink] = NV;
+    }
+    SourceNode.addEdge(SinkNode, Value, T);
+  }
+  for (auto &I : Nodes)
+    I.finalize(*this);
+}
+
+DotCfgDiffDisplayGraph DotCfgDiff::createDisplayGraph(StringRef Title,
+                                                      StringRef EntryNodeName) {
+  assert(NodePosition.count(EntryNodeName) == 1 &&
+         "Expected to find entry block in map.");
+  unsigned Entry = NodePosition[EntryNodeName];
+  assert(Entry < Nodes.size() && "Expected to find entry node");
+  DotCfgDiffDisplayGraph G(Title.str());
+
+  std::map<const unsigned, unsigned> NodeMap;
+
+  int EntryIndex = -1;
+  unsigned Index = 0;
+  for (auto &I : Nodes) {
+    if (I.getIndex() == Entry)
+      EntryIndex = Index;
+    G.createNode(I.getBodyContent(), I.getType());
+    NodeMap.insert({I.getIndex(), Index++});
+  }
+  assert(EntryIndex >= 0 && "Expected entry node index to be set.");
+  G.setEntryNode(EntryIndex);
+
+  for (auto &I : NodeMap) {
+    unsigned SourceNode = I.first;
+    unsigned DisplayNode = I.second;
+    getNode(SourceNode).createDisplayEdges(G, DisplayNode, NodeMap);
+  }
+  return G;
+}
+
+void DotCfgDiffNode::createDisplayEdges(
+    DotCfgDiffDisplayGraph &DisplayGraph, unsigned DisplayNodeIndex,
+    std::map<const unsigned, unsigned> &NodeMap) {
+
+  DisplayNode &SourceDisplayNode = DisplayGraph.getNode(DisplayNodeIndex);
+
+  for (auto I : Edges) {
+    unsigned SinkNodeIndex = I;
+    IRChangeDiffType Type = getEdge(SinkNodeIndex).second;
+    const DotCfgDiffNode *SinkNode = &Graph.getNode(SinkNodeIndex);
+
+    StringRef Label = Graph.getEdgeSourceLabel(getIndex(), SinkNodeIndex);
+    DisplayNode &SinkDisplayNode = DisplayGraph.getNode(SinkNode->getIndex());
+    SourceDisplayNode.createEdge(Label, SinkDisplayNode, Type);
+  }
+  SourceDisplayNode.createEdgeMap();
+}
+
+// TODO Nodes should probably be a StringMap<DotCfgDiffNode> after the
+// display graph is separated out, which would remove the need for NodePosition.
+std::vector<DotCfgDiffNode> DotCfgDiff::Nodes;
+StringMap<unsigned> DotCfgDiff::NodePosition;
+std::string DotCfgDiff::GraphName;
+
+void DotCfgDiffNode::finalize(DotCfgDiff &G) {
+  for (auto E : EdgesMap) {
+    Children.emplace_back(E.first);
+    Edges.emplace_back(E.first);
+  }
+}
+
+} // namespace
+
+namespace llvm {
+
+template <> struct GraphTraits<DotCfgDiffDisplayGraph *> {
+  using NodeRef = const DisplayNode *;
+  using ChildIteratorType = DisplayNode::ChildIterator;
+  using nodes_iterator = DotCfgDiffDisplayGraph::NodeIterator;
+  using EdgeRef = const DisplayEdge *;
+  using ChildEdgeIterator = DisplayNode::EdgeIterator;
+
+  static NodeRef getEntryNode(const DotCfgDiffDisplayGraph *G) {
+    return G->getEntryNode();
+  }
+  static ChildIteratorType child_begin(NodeRef N) {
+    return N->children_begin();
+  }
+  static ChildIteratorType child_end(NodeRef N) { return N->children_end(); }
+  static nodes_iterator nodes_begin(const DotCfgDiffDisplayGraph *G) {
+    return G->nodes_begin();
+  }
+  static nodes_iterator nodes_end(const DotCfgDiffDisplayGraph *G) {
+    return G->nodes_end();
+  }
+  static ChildEdgeIterator child_edge_begin(NodeRef N) {
+    return N->edges_begin();
+  }
+  static ChildEdgeIterator child_edge_end(NodeRef N) { return N->edges_end(); }
+  static NodeRef edge_dest(EdgeRef E) { return &E->getDestinationNode(); }
+  static unsigned size(const DotCfgDiffDisplayGraph *G) { return G->size(); }
+};
+
+template <>
+struct DOTGraphTraits<DotCfgDiffDisplayGraph *> : public DefaultDOTGraphTraits {
+  explicit DOTGraphTraits(bool simple = false)
+      : DefaultDOTGraphTraits(simple) {}
+
+  static bool renderNodeUsingHTML(const DisplayNode *Node) { return true; }
+  static std::string getGraphName(const DotCfgDiffDisplayGraph *DiffData) {
+    return DiffData->getGraphName();
+  }
+  static std::string
+  getGraphProperties(const DotCfgDiffDisplayGraph *DiffData) {
+    return "\tsize=\"190, 190\";\n";
+  }
+  static std::string getNodeLabel(const DisplayNode *Node,
+                                  const DotCfgDiffDisplayGraph *DiffData) {
+    return DiffData->getNodeLabel(*Node);
+  }
+  static std::string getNodeAttributes(const DisplayNode *Node,
+                                       const DotCfgDiffDisplayGraph *DiffData) {
+    return DiffData->getNodeAttributes(*Node);
+  }
+  static std::string getEdgeSourceLabel(const DisplayNode *From,
+                                        DisplayNode::ChildIterator &To) {
+    return From->getEdgeSourceLabel(**To);
+  }
+  static std::string getEdgeAttributes(const DisplayNode *From,
+                                       DisplayNode::ChildIterator &To,
+                                       const DotCfgDiffDisplayGraph *DiffData) {
+    return DiffData->getEdgeColorAttr(*From, **To);
+  }
+};
+
+} // namespace llvm
+
+namespace {
+
+void DotCfgDiffDisplayGraph::generateDotFile(StringRef DotFile) {
+  std::error_code EC;
+  llvm::raw_fd_ostream OutStream(DotFile, EC);
+  if (EC) {
+    errs() << "Error: " << EC.message() << "\n";
+    return;
+  }
+  GraphWriter<DotCfgDiffDisplayGraph *> W(OutStream, this, false);
+  W.writeGraph("");
+  OutStream.flush();
+  OutStream.close();
+}
+
+} // namespace
+
+namespace llvm {
+
+BlockSuccessors::BlockSuccessors(const BasicBlock &B) {
+  // Build up transition labels.
+  const Instruction *Term = B.getTerminator();
+  if (const BranchInst *Br = dyn_cast<const BranchInst>(Term))
+    if (Br->isUnconditional())
+      addSuccessorLabel(Br->getSuccessor(0)->getName().str(), "");
+    else {
+      addSuccessorLabel(Br->getSuccessor(0)->getName().str(), "true");
+      addSuccessorLabel(Br->getSuccessor(1)->getName().str(), "false");
+    }
+  else if (const SwitchInst *Sw = dyn_cast<const SwitchInst>(Term)) {
+    addSuccessorLabel(Sw->case_default()->getCaseSuccessor()->getName().str(),
+                      "default");
+    for (auto &C : Sw->cases()) {
+      assert(C.getCaseValue() && "Expected to find case value.");
+      SmallString<20> Value = formatv("{0}", C.getCaseValue()->getSExtValue());
+      addSuccessorLabel(C.getCaseSuccessor()->getName().str(), Value);
+    }
+  } else
+    for (const_succ_iterator I = succ_begin(&B), E = succ_end(&B); I != E; ++I)
+      addSuccessorLabel((*I)->getName().str(), "");
+}
+
+std::string DotCfgComparer::makeHTMLReady(StringRef SR) {
+  std::string S;
+  while (true) {
+    StringRef Clean =
+        SR.take_until([](char C) { return C == '<' || C == '>'; });
+    S.append(Clean.str());
+    SR = SR.drop_front(Clean.size());
+    if (SR.size() == 0)
+      return S;
+    S.append(SR[0] == '<' ? "&lt;" : "&gt;");
+    SR = SR.drop_front();
+  }
+  llvm_unreachable("problems converting string to HTML");
+}
+
+DotCfgComparer::DotCfgComparer(raw_fd_ostream &OS, unsigned N, StringRef Dir,
+                               const BlockSuccessorsIRData &Before,
+                               const BlockSuccessorsIRData &After)
+    : IRComparer(Before, After), Directory(Dir.str()), HTML(OS), N(N) {
+  // Set up the colours based on the hidden options.
+  Colours[InBefore] = BeforeColour;
+  Colours[InAfter] = AfterColour;
+  Colours[IsCommon] = CommonColour;
+}
+
+void DotCfgComparer::handleFunctionCompare(
+    StringRef Name, StringRef Prefix, StringRef PassID, bool InModule,
+    unsigned Minor, const BlockSuccessorsFuncData &Before,
+    const BlockSuccessorsFuncData &After) {
+  SmallString<8> Extender;
+  SmallString<8> Number;
+  // Handle numbering and file names.
+  if (InModule) {
+    Extender = formatv("{0}_{1}", N, Minor);
+    Number = formatv("{0}.{1}", N, Minor);
+  } else {
+    Extender = formatv("{0}", N);
+    Number = formatv("{0}", N);
+  }
+  // Create a temporary file name for the dot file.
+  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}", Number, Prefix, makeHTMLReady(PassID), Name);
+
+  DotCfgDiff Diff(Text, Before, After, Directory);
+  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");
+
+  DotCfgDiffDisplayGraph DG = Diff.createDisplayGraph(Text, EntryBlockName);
+  DG.generateDotFile(DotFile);
+
+  HTML << genHTML(Text, DotFile, PDFFileName, Directory, InModule);
+  std::error_code EC = sys::fs::remove(DotFile);
+  if (EC)
+    errs() << "Error: " << EC.message() << "\n";
+}
+
+std::string DotCfgComparer::genHTML(StringRef Text, StringRef DotFile,
+                                    StringRef PDFFileName, StringRef Directory,
+                                    bool Indent) {
+  SmallString<20> PDFFile = formatv("{0}/{1}", Directory, PDFFileName);
+  // Create the PDF file.
+  SmallString<200> Command = formatv("dot -Tpdf -o {0} {1}", PDFFile, DotFile);
+  system(Command.c_str());
+  // Create the HTML tag refering to the PDF file.
+  SmallString<200> S =
+      formatv("  <a href=\"{0}\" {2}target=\"_blank\">{1}</a><br/>\n",
+              PDFFileName, Text, Indent ? "style=\"margin-left:2em\" " : "");
+  return S.c_str();
+}
+
+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
+  BlockSuccessorsIRData Data;
+  DotCfgComparer::analyzeIR(IR, Data);
+  // Now compare it against itself, which will have everything the
+  // same and will generate the files.
+  DotCfgComparer Comparer(*HTML, N, DotCfgDir, Data, Data);
+  Comparer.compare(IR, " ", "Initial IR", "");
+  *HTML << "  </p>\n"
+        << "</div><br/>\n";
+  ++N;
+}
+
+void DotCfgChangeReporter::generateIRRepresentation(
+    Any IR, StringRef PassID, BlockSuccessorsIRData &Data) {
+  DotCfgComparer::analyzeIR(IR, Data);
+}
+
+void DotCfgChangeReporter::omitAfter(StringRef PassID, std::string &Name) {
+  assert(HTML && "Expected outstream to be set");
+  SmallString<20> Banner =
+      formatv("  <a>{0}. After {1}{2} omitted because no change</a><br/>\n", N,
+              DotCfgComparer::makeHTMLReady(PassID), Name);
+  *HTML << Banner;
+  ++N;
+}
+
+void DotCfgChangeReporter::handleAfter(StringRef PassID, std::string &Name,
+                                       const BlockSuccessorsIRData &Before,
+                                       const BlockSuccessorsIRData &After,
+                                       Any IR) {
+  assert(HTML && "Expected outstream to be set");
+  DotCfgComparer Comparer(*HTML, N, DotCfgDir, Before, After);
+  Comparer.compare(IR, " After ", PassID, Name);
+  *HTML << "    </p></div>\n";
+  ++N;
+}
+
+void DotCfgChangeReporter::handleInvalidated(StringRef PassID) {
+  assert(HTML && "Expected outstream to be set");
+  SmallString<20> Banner = formatv("  <a>{0}. {1} invalidated</a><br/>\n", N,
+                                   DotCfgComparer::makeHTMLReady(PassID));
+  *HTML << Banner;
+  ++N;
+}
+
+void DotCfgChangeReporter::handleFiltered(StringRef PassID, std::string &Name) {
+  assert(HTML && "Expected outstream to be set");
+  SmallString<20> Banner =
+      formatv("  <a>{0}. After {1}{2} filtered out</a><br/>\n", N,
+              DotCfgComparer::makeHTMLReady(PassID), Name);
+  *HTML << Banner;
+  ++N;
+}
+
+void DotCfgChangeReporter::handleIgnored(StringRef PassID, std::string &Name) {
+  assert(HTML && "Expected outstream to be set");
+  SmallString<20> Banner = formatv("  <a>{0}. {1}{2} ignored</a><br/>\n", N,
+                                   DotCfgComparer::makeHTMLReady(PassID), Name);
+  *HTML << Banner;
+  ++N;
+}
+
+bool DotCfgChangeReporter::same(const BlockSuccessorsIRData &Before,
+                                const BlockSuccessorsIRData &After) {
+  return Before == After;
+}
+
+void DotCfgChangeReporter::initializeHTML() {
+  std::error_code EC;
+  HTML = new raw_fd_ostream(DotCfgDir + "/passes.html", EC);
+  assert(!EC && "Unable to open output stream for -cfg-dot-changed");
+
+  *HTML << "<!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>\n"
+        << "<body>";
+}
+
+DotCfgChangeReporter::~DotCfgChangeReporter() {
+  if (!HTML)
+    return;
+  *HTML
+      << "<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>\n";
+  HTML->flush();
+  HTML->close();
+  delete HTML;
+}
+
+void DotCfgChangeReporter::registerCallbacks(
+    PassInstrumentationCallbacks &PIC) {
+  if (PrintChanged == ChangePrinter::PrintChangedDotCfgVerbose ||
+      PrintChanged == ChangePrinter::PrintChangedDotCfgQuiet) {
+    ChangeReporter<BlockSuccessorsIRData>::registerRequiredCallbacks(PIC);
+    initializeHTML();
+  }
+}
+
 StandardInstrumentations::StandardInstrumentations(bool DebugLogging,
                                                    bool VerifyEach)
     : PrintPass(DebugLogging), OptNone(DebugLogging),
       PrintChangedIR(PrintChanged == ChangePrinter::PrintChangedVerbose),
       PrintChangedDiff(PrintChanged == ChangePrinter::PrintChangedDiffVerbose),
-      Verify(DebugLogging), VerifyEach(VerifyEach) {}
+      Verify(DebugLogging),
+      DotCfgChangeReporter(PrintChanged ==
+                           ChangePrinter::PrintChangedDotCfgVerbose),
+      VerifyEach(VerifyEach) {}
 
 void StandardInstrumentations::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PrintIR.registerCallbacks(PIC);
   PrintPass.registerCallbacks(PIC);
   TimePasses.registerCallbacks(PIC);
   OptNone.registerCallbacks(PIC);
   OptBisect.registerCallbacks(PIC);
   PreservedCFGChecker.registerCallbacks(PIC);
   PrintChangedIR.registerCallbacks(PIC);
   PseudoProbeVerification.registerCallbacks(PIC);
   if (VerifyEach)
     Verify.registerCallbacks(PIC);
   PrintChangedDiff.registerCallbacks(PIC);
+  DotCfgChangeReporter.registerCallbacks(PIC);
 }
 
-namespace llvm {
-
 template class ChangeReporter<std::string>;
 template class TextChangeReporter<std::string>;
 
+template class BlockDataTemplate<EmptyData>;
+template class OrderedChangedData<ChangedBlockData>;
+template class OrderedChangedData<ChangedFuncData>;
 template class ChangeReporter<ChangedIRData>;
 template class TextChangeReporter<ChangedIRData>;
+template class IRComparer<ChangedFuncData, ChangedIRData>;
 
 } // namespace llvm

llvm/test/Other/ChangePrinters/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 -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes=instsimplify 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 4
+; RUN: FileCheck %s -input-file=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 -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes=instsimplify -filter-print-funcs=f  2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=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 -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes=instsimplify -print-module-scope 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 4
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-PRINT-MOD-SCOPE
+;
+; Check that reporting of multiple functions happens
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes=instsimplify -filter-print-funcs="f,g" 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 4
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-FILTER-MULT-FUNC
+;
+; Check that the reporting of IRs respects -filter-passes
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes="instsimplify,no-op-function" -filter-passes="NoOpFunctionPass" 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 1
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-FILTER-PASSES
+;
+; Check that the reporting of IRs respects -filter-passes with multiple passes
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes="instsimplify,no-op-function" -filter-passes="NoOpFunctionPass,InstSimplifyPass" 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 3
+; RUN: FileCheck %s -input-file=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 -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes="instsimplify,no-op-function" -filter-passes="NoOpFunctionPass,InstSimplifyPass" -filter-print-funcs=f 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-FILTER-FUNC-PASSES
+;
+; Check that repeated passes that change the IR are printed and that the
+; others (including g) are filtered out.  Note that only the first time
+; instsimplify is run on f will result in changes
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg -passes="instsimplify,instsimplify" -filter-print-funcs=f  2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC
+;
+; Simple checks of -print-changed=dot-cfg-quiet
+;
+; Note that (mostly) only the banners are checked.
+;
+; Simple functionality check.
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes=instsimplify 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-SIMPLE --allow-empty
+;
+; Check that only the passes that change the IR are printed and that the
+; others (including g) are filtered out.
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes=instsimplify -filter-print-funcs=f  2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 1
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-FUNC-FILTER
+;
+; Check that the reporting of IRs respects is not affected by
+; -print-module-scope
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes=instsimplify -print-module-scope 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-PRINT-MOD-SCOPE
+;
+; Check that reporting of multiple functions happens
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes=instsimplify -filter-print-funcs="f,g" 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-FILTER-MULT-FUNC
+;
+; Check that the reporting of IRs respects -filter-passes
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes="instsimplify,no-op-function" -filter-passes="NoOpFunctionPass" 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-FILTER-PASSES-NONE --allow-empty
+;
+; Check that the reporting of IRs respects -filter-passes with multiple passes
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes="instsimplify,no-op-function" -filter-passes="NoOpFunctionPass,InstSimplifyPass" 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 2
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-FILTER-MULT-PASSES
+;
+; Check that the reporting of IRs respects both -filter-passes and -filter-print-funcs
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes="instsimplify,no-op-function" -filter-passes="NoOpFunctionPass,InstSimplifyPass" -filter-print-funcs=f 2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 1
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-FILTER-FUNC-PASSES
+;
+; Check that repeated passes that change the IR are printed and that the
+; others (including g) are filtered out.  Note that only the first time
+; instsimplify is run on f will result in changes
+; RUN: rm -f diff_*.pdf
+; RUN: opt -S -print-changed=dot-cfg-quiet -passes="instsimplify,instsimplify" -filter-print-funcs=f  2>&1 -o /dev/null < %s 2>&1 > /dev/null
+; RUN: ls *.pdf | count 1
+; RUN: FileCheck %s -input-file=passes.html --check-prefix=CHECK-DOT-CFG-QUIET-MULT-PASSES-FILTER-FUNC
+
+define i32 @g() {
+entry:
+  %a = add i32 2, 3
+  ret i32 %a
+}
+
+define i32 @f() {
+entry:
+  %a = add i32 2, 3
+  ret i32 %a
+}
+
+; CHECK-DOT-CFG-SIMPLE-FILES: passes.html diff_0_0.pdf diff_0_1.pdf diff_2.pdf diff_4.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_0.pdf" style="margin-left:2em" target="_blank">0.0. Initial IR </a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_0_1.pdf" style="margin-left:2em" 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>1. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_2.pdf" target="_blank">2. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:     </p></div>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>3. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a href="diff_4.pdf" target="_blank">4. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:     </p></div>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>5. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>6. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>7. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-SIMPLE-NEXT:   <a>8. After PrintModulePass (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><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_0_0.pdf" style="margin-left:2em" target="_blank">0.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>1. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>2. After InstSimplifyPass (function: g) filtered out</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>3. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a href="diff_4.pdf" target="_blank">4. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:     </p></div>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>5. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>6. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>7. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FUNC-FILTER-NEXT:   <a>8. After PrintModulePass (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_0.pdf" style="margin-left:2em" target="_blank">0.0. Initial IR </a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_0_1.pdf" style="margin-left:2em" 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>1. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_2.pdf" target="_blank">2. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:     </p></div>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>3. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a href="diff_4.pdf" target="_blank">4. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:     </p></div>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>5. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>6. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>7. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-PRINT-MOD-SCOPE-NEXT:   <a>8. After PrintModulePass (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_0.pdf" style="margin-left:2em" target="_blank">0.0. Initial IR </a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_0_1.pdf" style="margin-left:2em" 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>1. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_2.pdf" target="_blank">2. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:     </p></div>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>3. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a href="diff_4.pdf" target="_blank">4. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:     </p></div>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>5. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>6. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>7. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-FUNC-NEXT:   <a>8. After PrintModulePass (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. After VerifierPass (module) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>1. After InstSimplifyPass (function: 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_2.pdf" target="_blank">2. 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>3. After NoOpFunctionPass (function: g) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>4. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>5. After InstSimplifyPass (function: f) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>6. After NoOpFunctionPass (function: f) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>7. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>8. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>9. After VerifierPass (module) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-PASSES-NEXT:   <a>10. After PrintModulePass (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: <body>  <a>0. After VerifierPass (module) filtered out</a><br/>
+; 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_1.pdf" target="_blank">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_2.pdf" target="_blank">2. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:     </p></div>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>3. After NoOpFunctionPass (function: g) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>4. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a href="diff_5.pdf" target="_blank">5. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:     </p></div>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>6. After NoOpFunctionPass (function: f) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>7. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>8. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>9. After VerifierPass (module) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-MULT-PASSES-NEXT:   <a>10. After PrintModulePass (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. After VerifierPass (module) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>1. After InstSimplifyPass (function: g) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>2. After NoOpFunctionPass (function: g) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>3. PassManager&lt;llvm::Function&gt; (function: 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_4.pdf" target="_blank">4. 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_5.pdf" target="_blank">5. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:     </p></div>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>6. After NoOpFunctionPass (function: f) omitted because no change</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>7. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>8. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>9. After VerifierPass (module) filtered out</a><br/>
+; CHECK-DOT-CFG-FILTER-FUNC-PASSES-NEXT:   <a>10. After PrintModulePass (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><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_0_0.pdf" style="margin-left:2em" target="_blank">0.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>1. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>2. After InstSimplifyPass (function: g) filtered out</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>3. After InstSimplifyPass (function: g) filtered out</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>4. PassManager&lt;llvm::Function&gt; (function: g) ignored</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a href="diff_5.pdf" target="_blank">5. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:     </p></div>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>6. After InstSimplifyPass (function: f) omitted because no change</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>7. PassManager&lt;llvm::Function&gt; (function: f) ignored</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>8. ModuleToFunctionPassAdaptor (module) ignored</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>9. After VerifierPass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-FUNC-NEXT:   <a>10. After PrintModulePass (module) omitted because no change</a><br/>
+; CHECK-DOT-CFG-MULT-PASSES-FILTER-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-QUIET-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-QUIET-SIMPLE-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-QUIET-SIMPLE-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-SIMPLE-NEXT:   <a href="diff_1.pdf" target="_blank">1. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-SIMPLE-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-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-QUIET-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-QUIET-FUNC-FILTER-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-FUNC-FILTER-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-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-QUIET-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-QUIET-PRINT-MOD-SCOPE-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-QUIET-PRINT-MOD-SCOPE-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-PRINT-MOD-SCOPE-NEXT:   <a href="diff_1.pdf" target="_blank">1. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-PRINT-MOD-SCOPE-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-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-QUIET-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-QUIET-FILTER-MULT-FUNC-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-QUIET-FILTER-MULT-FUNC-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-FILTER-MULT-FUNC-NEXT:   <a href="diff_1.pdf" target="_blank">1. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-FILTER-MULT-FUNC-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-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-QUIET-FILTER-PASSES-NONE: <!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-QUIET-FILTER-PASSES-NONE-NEXT: <body><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-QUIET-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-QUIET-FILTER-MULT-PASSES-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: g)</a><br/>
+; CHECK-DOT-CFG-QUIET-FILTER-MULT-PASSES-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-FILTER-MULT-PASSES-NEXT:   <a href="diff_1.pdf" target="_blank">1. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-FILTER-MULT-PASSES-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-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-QUIET-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-QUIET-FILTER-FUNC-PASSES-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-FILTER-FUNC-PASSES-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-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-QUIET-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-QUIET-MULT-PASSES-FILTER-FUNC-NEXT: <body>  <a href="diff_0.pdf" target="_blank">0. After InstSimplifyPass  (function: f)</a><br/>
+; CHECK-DOT-CFG-QUIET-MULT-PASSES-FILTER-FUNC-NEXT:     </p></div>
+; CHECK-DOT-CFG-QUIET-MULT-PASSES-FILTER-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>