Add dot-cfg-changes style view to the llvm-diff tool

[jamieschmeiser]

Summary

Add an option -dot-cfg=<dir> to llvm-diff so that it uses the dot-cfg-changes
graphical view, building a web-site with either the module differences or the
indicated functions.

Note that this diff builds upon https://reviews.llvm.org/D87202

[jamieschmeiser]

Note that the clang-tidy comment about the non-existent header is because this PR builds upon other PRs that have not been incorporated yet, one of which introduces the header file.

[jamieschmeiser]

This will require changes based on changes that have been made to the code it uses. The changes will be made after that code lands.

[jamieschmeiser]

This is out of date and would require reworking.

llvm/tools/llvm-diff/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  Analysis
   Core
   IRReader
+  Passes
   Support
   )
 
 add_llvm_tool(llvm-diff
   llvm-diff.cpp
   DiffConsumer.cpp
   DiffLog.cpp
   DifferenceEngine.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/tools/llvm-diff/llvm-diff.cpp

 //===-- llvm-diff.cpp - Module comparator command-line driver ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the command-line driver for the difference engine.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DiffLog.h"
 #include "DifferenceEngine.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/IR/ChangeReporters.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <utility>
 
 
 using namespace llvm;
+using namespace cr;
+
+static cl::opt<std::string> DotCfgDiff(
+    "dot-cfg",
+    cl::desc("Generate dot files into specified directory to show differences"),
+    cl::NotHidden, cl::init(""));
 
 /// Reads a module from a file.  On error, messages are written to stderr
 /// and null is returned.
 static std::unique_ptr<Module> readModule(LLVMContext &Context,
                                           StringRef Name) {
   SMDiagnostic Diag;
   std::unique_ptr<Module> M = parseIRFile(Name, Diag, Context);
   if (!M)
     Diag.print("llvm-diff", errs());
   return M;
 }
 
-static void diffGlobal(DifferenceEngine &Engine, Module &L, Module &R,
+static std::pair<Function *, Function *> getFuncs(Module &L, Module &R,
                                                   StringRef Name) {
   // Drop leading sigils from the global name.
   if (Name.startswith("@")) Name = Name.substr(1);
 
   Function *LFn = L.getFunction(Name);
   Function *RFn = R.getFunction(Name);
   if (LFn && RFn)
-    Engine.diff(LFn, RFn);
-  else if (!LFn && !RFn)
+    return {LFn, RFn};
+  if (!LFn && !RFn)
     errs() << "No function named @" << Name << " in either module\n";
   else if (!LFn)
     errs() << "No function named @" << Name << " in left module\n";
   else
     errs() << "No function named @" << Name << " in right module\n";
+  return {nullptr, nullptr};
+}
+
+static void diffGlobal(DifferenceEngine &Engine, Module &L, Module &R,
+                       StringRef Name) {
+  Function *LFn = nullptr;
+  Function *RFn = nullptr;
+  std::tie(LFn, RFn) = getFuncs(L, R, Name);
+  if (LFn && RFn)
+    Engine.diff(LFn, RFn);
 }
 
 static cl::opt<std::string> LeftFilename(cl::Positional,
                                          cl::desc("<first file>"),
                                          cl::Required);
 static cl::opt<std::string> RightFilename(cl::Positional,
                                           cl::desc("<second file>"),
                                           cl::Required);
 static cl::list<std::string> GlobalsToCompare(cl::Positional,
                                               cl::desc("<globals to compare>"));
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv);
 
   LLVMContext Context;
 
   // Load both modules.  Die if that fails.
   std::unique_ptr<Module> LModule = readModule(Context, LeftFilename);
   std::unique_ptr<Module> RModule = readModule(Context, RightFilename);
   if (!LModule || !RModule) return 1;
 
+  if (DotCfgDiff != "") {
+    std::error_code EC;
+    llvm::raw_fd_ostream HTML(DotCfgDiff + "/dot-cfg-diffs.html", EC);
+    if (EC) {
+      errs() << "Error: " << EC.message() << "\n";
+      return 1;
+    }
+
+    HTML << "<!DOCTYPE "
+         << "html><html><head><title>dot-cfg-diffs.html</title></head>\n"
+         << "<body>";
+
+    // If any global names were given, just diff those.
+    if (!GlobalsToCompare.empty()) {
+      for (unsigned I = 0, E = GlobalsToCompare.size(); I != E; ++I) {
+        Function *LFn = nullptr;
+        Function *RFn = nullptr;
+        std::tie(LFn, RFn) = getFuncs(*LModule, *RModule, GlobalsToCompare[I]);
+        if (LFn && RFn) {
+          Any LAny((const Function *)LFn);
+          BlockSuccessorsIRData Before;
+          CFGDotComparer::analyzeIR(LAny, Before);
+          Any RAny((const Function *)RFn);
+          BlockSuccessorsIRData After;
+          CFGDotComparer::analyzeIR(RAny, After);
+
+          // Create diff for function.
+          CFGDotComparer CDC(HTML, I, DotCfgDiff, Before, After);
+          CDC.compare(LAny, "", "", LFn->getName());
+        }
+      }
+    } else {
+      // Otherwise, diff everything in the module.
+      Any LAny(&(const Module &)((*LModule)));
+      BlockSuccessorsIRData Before;
+      CFGDotComparer::analyzeIR(LAny, Before);
+      Any RAny(&(const Module &)((*RModule)));
+      BlockSuccessorsIRData After;
+      CFGDotComparer::analyzeIR(RAny, After);
+
+      CFGDotComparer CDC(HTML, 0, DotCfgDiff, Before, After);
+      CDC.compare(RAny, "", "", "");
+    }
+
+    HTML << "</body></html>\n";
+    HTML.flush();
+    HTML.close();
+
+    return 0;
+  }
+
   DiffConsumer Consumer;
   DifferenceEngine Engine(Consumer);
 
   // If any global names were given, just diff those.
   if (!GlobalsToCompare.empty()) {
     for (unsigned I = 0, E = GlobalsToCompare.size(); I != E; ++I)
       diffGlobal(Engine, *LModule, *RModule, GlobalsToCompare[I]);
 
   // Otherwise, diff everything in the module.
   } else {
     Engine.diff(LModule.get(), RModule.get());
   }
 
   return Consumer.hadDifferences();
 }