[Debugify][OriginalDIMode] Export the report into JSON file

[djtodoro]

Summary

By using the option in the combination with the llvm/utils/llvm-original-di-preservation.py it becomes very user friendly tool. An example of the HTML page with the issues related to debug info can be found at [0].

[0] https://djolertrk.github.io/di-checker-html-report-example/

[djtodoro]

• Rebase

[djtodoro]

• Rebase on top of D83391

[djtodoro]

• Rebase

[djtodoro]

• Rebasing
• Refactoring

[djtodoro]

-Rebasing

[djtodoro]

• Rebase on top of trunk

[djtodoro]

Ping :)

[StephenTozer]

The fundamentals of the patch look solid; minor point about the HTML templating, and also I think there should be a couple of tests for the llvm-original-di-preservation script - nothing too complicated, just verifying that it produces the correct HTML for a given input, as with the opt-viewer tests.

llvm/utils/llvm-original-di-preservation.py

33

For each of these blocks, instead of using repeated html_header += you could instead use triple quotes and just write out the full HTML verbatim (using formatting to insert variables as needed), as in the other HTML generating python scripts.

[djtodoro]

@StephenTozer Thanks!

In D82546#2596942, @StephenTozer wrote:

and also I think there should be a couple of tests for the llvm-original-di-preservation script - nothing too complicated, just verifying that it produces the correct HTML for a given input, as with the opt-viewer tests.

I'll check this.

llvm/utils/llvm-original-di-preservation.py

33

It makes sense.

[djtodoro]

• adding a test

[djtodoro]

• adjust the test to work on Windows as well

[djtodoro]

ping :)

[aprantl]

llvm/include/llvm/Transforms/Utils/Debugify.h

169 ↗

(On Diff #328476)

The = ""; is redundant.

llvm/docs/HowToUpdateDebugInfo.rst

 when it checks the preservation of the original/real Debug Info metadata in
 optimizations. Before a pass it collects the metadata, and after the pass it
 checks if it preserved the Debug Info metadata. It could be run as follows:
 
 .. code-block:: bash
 
   $ opt -verify-debuginfo-preserve -pass-to-test sample.ll
 
+Another useful option to use with the `original-di-check` mode is exporting
+the issues that have been found into a JSON file as follows:
+
+.. code-block:: bash
+
+  $ opt -verify-debuginfo-preserve -verify-di-preserve-export=sample.json -pass-to-test sample.ll
+
+and then use the ``llvm/utils/llvm-original-di-preservation.py`` script
+to generate an HTML page with the issues reported in a more human readable form
+as follows:
+
+.. code-block:: bash
+
+  $ llvm-original-di-preservation.py sample.json sample.html
+
 Using ``VerifyDIPreserve``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A simple way to use ``VerifyDIPreserve`` in ``debugify`` mode is as follows:
 
 .. code-block:: bash
 
   $ opt -prepare-debuginfo-for-verify -pass-to-test -check-debuginfo sample.ll

llvm/include/llvm/Transforms/Utils/VerifyDIPreserve.h

 /// \param M The module to collect debug information from.
 /// \param Functions A range of functions to collect debug information from.
 /// \param DIPreservationMap A map used to check collected the DI metadata.
 /// \param Banner A prefix string to add to debug/error messages.
 /// \param NameOfWrappedPass A name of a pass to add to debug/error messages.
 bool checkDebugInfoMetadata(Module &M,
                             iterator_range<Module::iterator> Functions,
                             DebugInfoPerPassMap &DIPreservationMap,
-                            StringRef Banner, StringRef NameOfWrappedPass);
+                            StringRef Banner, StringRef NameOfWrappedPass,
+                            StringRef OrigDIVerifyBugsReportFilePath);
 } // namespace llvm
 
 /// Used to check whether we track synthetic or original debug info.
 enum class VerifyDIPreserveMode {
   NoVerify,
   Debugify,
   OriginalDebugInfo
 };

 
 /// Map pass names to a per-pass DebugifyStatistics instance.
 using DebugifyStatsMap = llvm::MapVector<llvm::StringRef, DebugifyStatistics>;
 
 llvm::ModulePass *createCheckDIModulePass(
     bool Strip = false, llvm::StringRef NameOfWrappedPass = "",
     DebugifyStatsMap *StatsMap = nullptr,
     enum VerifyDIPreserveMode Mode = VerifyDIPreserveMode::Debugify,
-    DebugInfoPerPassMap *DIPreservationMap = nullptr);
+    DebugInfoPerPassMap *DIPreservationMap = nullptr,
+    llvm::StringRef OrigDIVerifyBugsReportFilePath = "");
 
 llvm::FunctionPass *createCheckDIFunctionPass(
     bool Strip = false, llvm::StringRef NameOfWrappedPass = "",
     DebugifyStatsMap *StatsMap = nullptr,
     enum VerifyDIPreserveMode Mode = VerifyDIPreserveMode::Debugify,
-    DebugInfoPerPassMap *DIPreservationMap = nullptr);
+    DebugInfoPerPassMap *DIPreservationMap = nullptr,
+    llvm::StringRef OrigDIVerifyBugsReportFilePath = "");
 
 struct NewPMCheckDebugifyPass
     : public llvm::PassInfoMixin<NewPMCheckDebugifyPass> {
   llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
 };
 
 namespace llvm {
 /// VerifyDIPreserveCustomPassManager wraps each pass with
 /// the verify-di-preservation passes if needed.
 /// NOTE: We support legacy custom pass manager only.
 /// TODO: Add New PM support for custom pass manager.
 class VerifyDIPreserveCustomPassManager : public legacy::PassManager {
+  StringRef OrigDIVerifyBugsReportFilePath = "";
   DebugifyStatsMap *DIStatsMap = nullptr;
   DebugInfoPerPassMap *DIPreservationMap = nullptr;
   enum VerifyDIPreserveMode Mode = VerifyDIPreserveMode::NoVerify;
 
 public:
   using super = legacy::PassManager;
 
   void add(Pass *P) override {
void add(Pass *P) override {
     StringRef Name = P->getPassName();
 
     // TODO: Implement the debug info verifiers for LoopPass.
     switch (Kind) {
     case PT_Function:
       super::add(createPrepareDIFunctionPass(Mode, Name, DIPreservationMap));
       super::add(P);
       super::add(createCheckDIFunctionPass(isDebugify(), Name, DIStatsMap, Mode,
-                                           DIPreservationMap));
+                                           DIPreservationMap,
+                                           OrigDIVerifyBugsReportFilePath));
       break;
     case PT_Module:
       super::add(createPrepareDIModulePass(Mode, Name, DIPreservationMap));
       super::add(P);
       super::add(createCheckDIModulePass(isDebugify(), Name, DIStatsMap, Mode,
-                                         DIPreservationMap));
+                                         DIPreservationMap,
+                                         OrigDIVerifyBugsReportFilePath));
       break;
     default:
       super::add(P);
       break;
     }
   }
 
   // Used within Debugify mode.
   void setDIStatsMap(DebugifyStatsMap &StatMap) {
     DIStatsMap = &StatMap;
   }
   // Used within original di preservation checking mode.
   void setDIPreservationMap(DebugInfoPerPassMap &PerPassMap) {
     DIPreservationMap = &PerPassMap;
   }
   void setVerifyDIPreserveMode(enum VerifyDIPreserveMode M) {
     Mode = M;
   }
 
+  void setOrigDIVerifyBugsReportFilePath(StringRef BugsReportFilePath) {
+    OrigDIVerifyBugsReportFilePath = BugsReportFilePath;
+  }
+  StringRef getOrigDIVerifyBugsReportFilePath() const {
+    return OrigDIVerifyBugsReportFilePath;
+  }
+
   bool isDebugify() const { return Mode == VerifyDIPreserveMode::Debugify; }
   bool isOriginalDebugInfoPreserveVerify() const {
     return Mode == VerifyDIPreserveMode::OriginalDebugInfo;
   }
 
   const DebugifyStatsMap &getDebugifyStatsMap() const { return *DIStatsMap; }
   DebugInfoPerPassMap &getDebugInfoPerPassMap() { return *DIPreservationMap; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORM_UTILS_VDIP_H

llvm/lib/Transforms/Utils/VerifyDIPreserve.cpp

 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/JSON.h"
 
 #define DEBUG_TYPE "verify-di-preserve"
 
 using namespace llvm;
 
 namespace {
 
 cl::opt<bool> Quiet("debugify-quiet",
bool llvm::collectDebugInfoMetadata(Module &M,
 
   return true;
 }
 
 // This checks the preservation of original debug info attached to functions.
 static bool checkFunctions(const DebugFnMap &DIFunctionsBefore,
                            const DebugFnMap &DIFunctionsAfter,
                            StringRef NameOfWrappedPass,
-                           StringRef FileNameFromCU) {
+                           StringRef FileNameFromCU, bool ShouldWriteIntoJSON,
+                           llvm::json::Array &Bugs) {
   bool Preserved = true;
   for (const auto &F : DIFunctionsAfter) {
     if (F.second)
       continue;
     auto SPIt = DIFunctionsBefore.find(F.first);
     if (SPIt == DIFunctionsBefore.end()) {
+      if (ShouldWriteIntoJSON)
+        Bugs.push_back(llvm::json::Object({{"metadata", "DISubprogram"},
+                                           {"name", F.first},
+                                           {"action", "not-generate"}}));
+     else
       dbg() << "ERROR: " << NameOfWrappedPass
             << " did not generate DISubprogram for " << F.first << " from "
             << FileNameFromCU << '\n';
       Preserved = false;
     } else {
       auto SP = SPIt->second;
       if (!SP)
         continue;
       // If the function had the SP attacched before the pass, consider it as
       // a debug info bug.
+      if (ShouldWriteIntoJSON)
+        Bugs.push_back(llvm::json::Object({{"metadata", "DISubprogram"},
+                                           {"name", F.first},
+                                           {"action", "drop"}}));
+      else
         dbg() << "ERROR: " << NameOfWrappedPass << " dropped DISubprogram of "
               << F.first << " from " << FileNameFromCU << '\n';
       Preserved = false;
     }
   }
 
   return Preserved;
 }
 
 // This checks the preservation of the original debug info attached to
 // instructions.
 static bool checkInstructions(const DebugInstMap &DILocsBefore,
                               const DebugInstMap &DILocsAfter,
                               StringRef NameOfWrappedPass,
-                              StringRef FileNameFromCU) {
+                              StringRef FileNameFromCU,
+                              bool ShouldWriteIntoJSON,
+                              llvm::json::Array &Bugs) {
   bool Preserved = true;
   for (const auto &L : DILocsAfter) {
     if (L.second)
       continue;
     auto Instr = L.first;
     auto FnName = Instr->getFunction()->getName();
     auto BB = Instr->getParent();
     auto BBName = BB->hasName() ? BB->getName() : "no-name";
+    auto InstName = Instruction::getOpcodeName(Instr->getOpcode());
 
     auto InstrIt = DILocsBefore.find(Instr);
     if (InstrIt == DILocsBefore.end()) {
+      if (ShouldWriteIntoJSON)
+        Bugs.push_back(llvm::json::Object({{"metadata", "DILocation"},
+                                           {"fn-name", FnName.str()},
+                                           {"bb-name", BBName.str()},
+                                           {"instr", InstName},
+                                           {"action", "not-generate"}}));
+      else
         dbg() << "WARNING: " << NameOfWrappedPass
               << " did not generate DILocation for " << *Instr
               << " (BB: " << BBName << ", Fn: " << FnName
               << ", File: " << FileNameFromCU << ")\n";
       Preserved = false;
     } else {
       auto hadLoc = InstrIt->second;
       if (!hadLoc)
         continue;
       // If the instr had the !dbg attacched before the pass, consider it as
       // a debug info issue.
+      if (ShouldWriteIntoJSON)
+        Bugs.push_back(llvm::json::Object({{"metadata", "DILocation"},
+                                           {"fn-name", FnName.str()},
+                                           {"bb-name", BBName.str()},
+                                           {"instr", InstName},
+                                           {"action", "drop"}}));
+      else
         dbg() << "WARNING: " << NameOfWrappedPass << " dropped DILocation of "
               << *Instr << " (BB: " << BBName << ", Fn: " << FnName
               << ", File: " << FileNameFromCU << ")\n";
       Preserved = false;
     }
   }
 
   return Preserved;
 }
 
+// Write the json data into the specifed file.
+static void writeJSON(StringRef OrigDIVerifyBugsReportFilePath,
+                      StringRef FileNameFromCU, StringRef NameOfWrappedPass,
+                      llvm::json::Array &Bugs) {
+  std::error_code EC;
+  raw_fd_ostream OS_FILE{OrigDIVerifyBugsReportFilePath, EC,
+                         sys::fs::OF_Append | sys::fs::OF_Text};
+  if (EC) {
+    errs() << "Could not open file: " << EC.message() << ", "
+           << OrigDIVerifyBugsReportFilePath << '\n';
+    return;
+  }
+
+  OS_FILE << "{\"file\":\"" << FileNameFromCU << "\", ";
+  OS_FILE << "\"pass\":\"" << NameOfWrappedPass << "\", ";
+
+  llvm::json::Value BugsToPrint{std::move(Bugs)};
+  OS_FILE << "\"bugs\": " << BugsToPrint;
+
+  OS_FILE << "}\n";
+}
+
 bool llvm::checkDebugInfoMetadata(Module &M,
                                   iterator_range<Module::iterator> Functions,
                                   DebugInfoPerPassMap &DIPreservationMap,
                                   StringRef Banner,
-                                  StringRef NameOfWrappedPass) {
+                                  StringRef NameOfWrappedPass,
+                                  StringRef OrigDIVerifyBugsReportFilePath) {
   LLVM_DEBUG(dbgs() << Banner << " (after) " << NameOfWrappedPass << '\n');
 
   if (!M.getNamedMetadata("llvm.dbg.cu")) {
     dbg() << Banner << " Skipping module without debug info\n";
     return false;
   }
 
   // Map the debug info holding DIs after a pass.
StringRef FileNameFromCU =
           ->getFilename();
 
   auto DIFunctionsBefore = DIPreservationMap[NameOfWrappedPass].DIFunctions;
   auto DIFunctionsAfter = DIPreservationAfter[NameOfWrappedPass].DIFunctions;
 
   auto DILocsBefore = DIPreservationMap[NameOfWrappedPass].DILocations;
   auto DILocsAfter = DIPreservationAfter[NameOfWrappedPass].DILocations;
 
-  bool Result = checkFunctions(DIFunctionsBefore, DIFunctionsAfter,
-                               NameOfWrappedPass, FileNameFromCU) &&
-                checkInstructions(DILocsBefore, DILocsAfter, NameOfWrappedPass,
-                                  FileNameFromCU);
+  bool ShouldWriteIntoJSON = !OrigDIVerifyBugsReportFilePath.empty();
+  llvm::json::Array Bugs;
+
+  bool Result =
+      checkFunctions(DIFunctionsBefore, DIFunctionsAfter, NameOfWrappedPass,
+                     FileNameFromCU, ShouldWriteIntoJSON, Bugs) &&
+                        FileNameFromCU, ShouldWriteIntoJSON, Bugs);
 
   StringRef ResultBanner = NameOfWrappedPass != "" ? NameOfWrappedPass : Banner;
+
+  if (ShouldWriteIntoJSON && !Bugs.empty())
+    writeJSON(OrigDIVerifyBugsReportFilePath, FileNameFromCU, ResultBanner,
+              Bugs);
+
   if (Result)
     dbg() << ResultBanner << ": PASS\n";
   else
     dbg() << ResultBanner << ": FAIL\n";
 
   LLVM_DEBUG(dbgs() << "\n\n");
   return Result;
 }

 struct CheckDIModulePass : public ModulePass {
   bool runOnModule(Module &M) override {
     if (Mode == VerifyDIPreserveMode::Debugify)
       return checkDebugifyMetadata(M, M.functions(), NameOfWrappedPass,
                                    "CheckModuleVerifyDIPreserve", Strip,
                                    StatsMap);
     return checkDebugInfoMetadata(
         M, M.functions(), *DIPreservationMap,
-        "CheckModuleVerifyDIPreserve(original-di-check): ", NameOfWrappedPass);
+        "CheckModuleVerifyDIPreserve(original-di-check): ", NameOfWrappedPass,
+        OrigDIVerifyBugsReportFilePath);
   }
 
   CheckDIModulePass(
       bool Strip = false, StringRef NameOfWrappedPass = "",
       DebugifyStatsMap *StatsMap = nullptr,
       enum VerifyDIPreserveMode Mode = VerifyDIPreserveMode::Debugify,
-      DebugInfoPerPassMap *DIPreservationMap = nullptr)
+      DebugInfoPerPassMap *DIPreservationMap = nullptr,
+      StringRef OrigDIVerifyBugsReportFilePath = "")
       : ModulePass(ID), NameOfWrappedPass(NameOfWrappedPass),
+        OrigDIVerifyBugsReportFilePath(OrigDIVerifyBugsReportFilePath),
         StatsMap(StatsMap), DIPreservationMap(DIPreservationMap), Mode(Mode),
         Strip(Strip) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
 
 private:
   StringRef NameOfWrappedPass;
+  StringRef OrigDIVerifyBugsReportFilePath;
   DebugifyStatsMap *StatsMap;
   DebugInfoPerPassMap *DIPreservationMap;
   enum VerifyDIPreserveMode Mode;
   bool Strip;
 };
 
 /// FunctionPass for checking debug info inserted by debugify-function, used
 /// with the legacy module pass manager. In the case of the
 /// di-preservation-verify, it just checks if a pass preserved the debug
 /// info.
 struct CheckDIFunctionPass : public FunctionPass {
   bool runOnFunction(Function &F) override {
     Module &M = *F.getParent();
     auto FuncIt = F.getIterator();
     if (Mode == VerifyDIPreserveMode::Debugify)
       return checkDebugifyMetadata(
           M, make_range(FuncIt, std::next(FuncIt)), NameOfWrappedPass,
           "CheckFunctionVerifyDIPreserve", Strip, StatsMap);
     return checkDebugInfoMetadata(
         M, make_range(FuncIt, std::next(FuncIt)), *DIPreservationMap,
         "CheckFunctionVerifyDIPreserve(original-di-check): ",
-        NameOfWrappedPass);
+        NameOfWrappedPass, OrigDIVerifyBugsReportFilePath);
   }
 
   CheckDIFunctionPass(
       bool Strip = false, StringRef NameOfWrappedPass = "",
       DebugifyStatsMap *StatsMap = nullptr,
       enum VerifyDIPreserveMode Mode = VerifyDIPreserveMode::Debugify,
-      DebugInfoPerPassMap *DIPreservationMap = nullptr)
+      DebugInfoPerPassMap *DIPreservationMap = nullptr,
+      StringRef OrigDIVerifyBugsReportFilePath = "")
       : FunctionPass(ID), NameOfWrappedPass(NameOfWrappedPass),
+        OrigDIVerifyBugsReportFilePath(OrigDIVerifyBugsReportFilePath),
         StatsMap(StatsMap), DIPreservationMap(DIPreservationMap), Mode(Mode),
         Strip(Strip) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   static char ID; // Pass identification.
 
 private:
   StringRef NameOfWrappedPass;
+  StringRef OrigDIVerifyBugsReportFilePath;
   DebugifyStatsMap *StatsMap;
   DebugInfoPerPassMap *DIPreservationMap;
   enum VerifyDIPreserveMode Mode;
   bool Strip;
 };
 
 } // end anonymous namespace
 
PreservedAnalyses NewPMDebugifyPass::run(Module &M, ModuleAnalysisManager &) {
   applyDebugifyMetadata(M, M.functions(),
                         "ModuleVerifyDIPreserve: ", /*ApplyToMF*/ nullptr);
   return PreservedAnalyses::all();
 }
 
 ModulePass *createCheckDIModulePass(bool Strip, StringRef NameOfWrappedPass,
                                     DebugifyStatsMap *StatsMap,
                                     enum VerifyDIPreserveMode Mode,
-                                    DebugInfoPerPassMap *DIPreservationMap) {
+                                    DebugInfoPerPassMap *DIPreservationMap,
+                                    StringRef OrigDIVerifyBugsReportFilePath) {
   if (Mode == VerifyDIPreserveMode::Debugify)
     return new CheckDIModulePass(Strip, NameOfWrappedPass, StatsMap);
   assert(Mode == VerifyDIPreserveMode::OriginalDebugInfo &&
          "Must be original-di-check mode");
   return new CheckDIModulePass(false, NameOfWrappedPass, nullptr, Mode,
-                               DIPreservationMap);
+                               DIPreservationMap,
+                               OrigDIVerifyBugsReportFilePath);
 }
 
 FunctionPass *createCheckDIFunctionPass(
     bool Strip, StringRef NameOfWrappedPass, DebugifyStatsMap *StatsMap,
-    enum VerifyDIPreserveMode Mode, DebugInfoPerPassMap *DIPreservationMap) {
+    enum VerifyDIPreserveMode Mode, DebugInfoPerPassMap *DIPreservationMap,
+    StringRef OrigDIVerifyBugsReportFilePath) {
   if (Mode == VerifyDIPreserveMode::Debugify)
     return new CheckDIFunctionPass(Strip, NameOfWrappedPass, StatsMap);
   assert(Mode == VerifyDIPreserveMode::OriginalDebugInfo &&
          "Must be original-di-check mode");
   return new CheckDIFunctionPass(false, NameOfWrappedPass, nullptr, Mode,
-                                 DIPreservationMap);
+                                 DIPreservationMap,
+                                 OrigDIVerifyBugsReportFilePath);
 }
 
 PreservedAnalyses NewPMCheckDebugifyPass::run(Module &M,
                                               ModuleAnalysisManager &) {
   checkDebugifyMetadata(M, M.functions(), "", "CheckModuleVerifyDIPreserve",
                         false, nullptr);
   return PreservedAnalyses::all();
 }

llvm/test/DebugInfo/orig-di-preserve-verify-each-dbginfo.ll

 ; Check the preservation of original debug info.
 
 ; RUN: opt -O2 -verify-each-debuginfo-preserve -S -o - < %s 2>&1 | FileCheck %s
 
+; RUN: rm -rf %t.json
+; RUN: opt -O2 -verify-each-debuginfo-preserve -verify-di-preserve-export=%t.json -S -o - < %s
+; RUN: cat %t.json | FileCheck %s -check-prefix=CHECK-JSON
+
 ; CHECK: WARNING: Combine redundant instructions {{.*}}
 ; CHECK-NEXT: Combine redundant instructions: FAIL
 
+; CHECK-JSON: {"file":"simple.c", "pass":"Combine redundant instructions", "bugs": {{.*}}
+
 ; ModuleID = 'simple.c'
 source_filename = "simple.c"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define dso_local i32 @fn1(i32 %arg1) !dbg !12 {
 entry:

llvm/tools/opt/opt.cpp

static cl::opt<bool> DebugifyEach(
     cl::desc("Start each pass with debugify and end it with check-debugify."));
 
 static cl::opt<bool> VerifyEachDebugInfoPreserve(
     "verify-each-debuginfo-preserve",
     cl::desc("Start each pass with collecting and end it with checking of "
              "debug info preservation."));
 
 static cl::opt<std::string>
+    VerifyDIPreserveExport("verify-di-preserve-export",
+                   cl::desc("Export debug info preservation failures into "
+                            "specified (JSON) file (should be abs path as we use"
+                            " append mode to insert new JSON objects)"),
+                   cl::value_desc("filename"), cl::init(""));
+
+static cl::opt<std::string>
     DebugifyExport("debugify-export",
                    cl::desc("Export per-pass debugify (in synthetic mode) "
                             "statistics to this file"),
                    cl::value_desc("filename"), cl::init(""));
 
 static cl::opt<bool>
 PrintBreakpoints("print-breakpoints-for-testing",
                  cl::desc("Print select breakpoints location for testing"));
#endif
   DebugifyStatsMap DIStatsMap;
   DebugInfoPerPassMap DIPreservationMap;
   if (DebugifyEach) {
     Passes.setVerifyDIPreserveMode(VerifyDIPreserveMode::Debugify);
     Passes.setDIStatsMap(DIStatsMap);
   } else if (VerifyEachDebugInfoPreserve) {
     Passes.setVerifyDIPreserveMode(VerifyDIPreserveMode::OriginalDebugInfo);
     Passes.setDIPreservationMap(DIPreservationMap);
+    if (!VerifyDIPreserveExport.empty())
+      Passes.setOrigDIVerifyBugsReportFilePath(VerifyDIPreserveExport);
   }
 
   bool AddOneTimeDebugifyPasses =
       (EnableDebugify && !DebugifyEach) ||
       (VerifyDebugInfoPreserve && !VerifyEachDebugInfoPreserve);
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfoImpl TLII(ModuleTriple);

llvm/utils/llvm-original-di-preservation.py

+#!/usr/bin/env python
+#
+# Debugify summary for the original debug info testing.
+#
+
+from __future__ import print_function
+import argparse
+import os
+import sys
+from json import loads
+from collections import defaultdict
+from collections import OrderedDict
+
+class DILocBug:
+  def __init__(self, action, bb_name, fn_name, instr):
+    self.action = action
+    self.bb_name = bb_name
+    self.fn_name = fn_name
+    self.instr = instr
+
+class DISPBug:
+  def __init__(self, action, fn_name):
+    self.action = action
+    self.fn_name = fn_name
+
+# Report the bugs in form of html.
+def generate_html_report(di_location_bugs, di_subprogram_bugs, \
+                         di_location_bugs_summary, di_sp_bugs_summary, \
+                         html_file):
+  fileout = open(html_file, "w")
+
+  html_header = "<html>\n"
+  html_header += "<head>\n"
+  html_header += "<style>\n"
+  html_header += "table, th, td {\n"
+  html_header += "  border: 1px solid black;\n"
+  html_header += "}\n"
+  html_header += "table.center {\n"
+  html_header += "  margin-left: auto;\n"
+  html_header += "  margin-right: auto;\n"
+  html_header += "}\n"
+  html_header += "</style>\n"
+  html_header += "</head>\n"
+  html_header += "<body>\n"
+
+  # Create the table for Location bugs.
+  table_di_loc = "<table>\n"
+
+  # Create the table's column headers.
+  table_title_di_loc = "Location Bugs found by the LLVM DI Checker"
+  table_di_loc += "<caption><b>"
+  table_di_loc += table_title_di_loc
+  table_di_loc += "</b></caption>\n"
+
+  header_di_loc = ["File", "LLVM Pass Name", "LLVM IR Instruction", \
+                   "Function Name", "Basic Block Name", "Action"]
+  table_di_loc += "  <tr>\n"
+
+  for column in header_di_loc:
+    table_di_loc += "    <th>{0}</th>\n".format(column.strip())
+  table_di_loc += "  </tr>\n"
+
+  at_least_one_bug_found = False
+
+  # Handle loction bugs.
+  for file, per_file_bugs in di_location_bugs.items():
+    for llvm_pass, per_pass_bugs in per_file_bugs.items():
+      # No location bugs for the pass.
+      if len(per_pass_bugs) == 0:
+        continue
+      at_least_one_bug_found = True
+      row = []
+      table_di_loc += "  </tr>\n"
+      # Get the bugs info.
+      for x in per_pass_bugs:
+        row.append("    <tr>\n")
+        row.append(file)
+        row.append(llvm_pass)
+        row.append(x.instr)
+        row.append(x.fn_name)
+        row.append(x.bb_name)
+        row.append(x.action)
+        row.append("    </tr>\n")
+      # Dump the bugs info into the table.
+      for column in row:
+        # The same file-pass pair can have multiple bugs.
+        if (column == "    <tr>\n" or column == "    </tr>\n"):
+          table_di_loc += column
+          continue
+        table_di_loc += "    <td>{0}</td>\n".format(column.strip())
+      table_di_loc += "  <tr>\n"
+
+  if not at_least_one_bug_found:
+    table_di_loc += "  <tr>\n"
+    table_di_loc += "    <td colspan='7'> No bugs found </td>\n"
+    table_di_loc += "  </tr>\n"
+
+  table_di_loc += "</table>\n"
+
+  # Create the summary table for the loc bugs.
+  table_di_loc_sum = "<table>\n"
+
+  # Create the table's column headers.
+  table_title_di_loc_sum = "DI Checker Summary of Location Bugs"
+  table_di_loc_sum += "<caption><b>"
+  table_di_loc_sum += table_title_di_loc_sum
+  table_di_loc_sum += "</b></caption>\n"
+
+  header_di_loc_sum = ["LLVM Pass Name", "Number of bugs"]
+  table_di_loc_sum += "  <tr>\n"
+
+  for column in header_di_loc_sum:
+    table_di_loc_sum += "    <th>{0}</th>\n".format(column.strip())
+  table_di_loc_sum += "  </tr>\n"
+
+  # Print the summary.
+  row = []
+  for llvm_pass, num in sorted(di_location_bugs_summary.items()):
+    row.append("    <tr>\n")
+    row.append(llvm_pass)
+    row.append(str(num))
+    row.append("    </tr>\n")
+  for column in row:
+    if (column == "    <tr>\n" or column == "    </tr>\n"):
+      table_di_loc_sum += column
+      continue
+    table_di_loc_sum += "    <td>{0}</td>\n".format(column.strip())
+  table_di_loc_sum += "  <tr>\n"
+
+  if not at_least_one_bug_found:
+    table_di_loc_sum += "  <tr>\n"
+    table_di_loc_sum += "    <td colspan='2'> No bugs found </td>\n"
+    table_di_loc_sum += "  </tr>\n"
+  table_di_loc_sum += "</table>\n"
+
+  # Create the table for SP bugs.
+  table_di_sp = "<table>\n"
+
+  # Create the table's column headers.
+  table_title_di_sp = "SP Bugs found by the LLVM DI Checker"
+  table_di_sp += "<caption><b>"
+  table_di_sp += table_title_di_sp
+  table_di_sp += "</b></caption>\n"
+
+  header_di_sp = ["File", "LLVM Pass Name", "Function Name", "Action"]
+  table_di_sp += "  <tr>\n"
+
+  for column in header_di_sp:
+    table_di_sp += "    <th>{0}</th>\n".format(column.strip())
+  table_di_sp += "  </tr>\n"
+
+  at_least_one_bug_found = False
+
+  # Handle loction bugs.
+  for file, per_file_bugs in di_subprogram_bugs.items():
+    for llvm_pass, per_pass_bugs in per_file_bugs.items():
+      # No SP bugs for the pass.
+      if len(per_pass_bugs) == 0:
+        continue
+      at_least_one_bug_found = True
+      row = []
+      table_di_sp += "  </tr>\n"
+      # Get the bugs info.
+      for x in per_pass_bugs:
+        row.append("    <tr>\n")
+        row.append(file)
+        row.append(llvm_pass)
+        row.append(x.fn_name)
+        row.append(x.action)
+        row.append("    </tr>\n")
+      # Dump the bugs info into the table.
+      for column in row:
+        # The same file-pass pair can have multiple bugs.
+        if (column == "    <tr>\n" or column == "    </tr>\n"):
+          table_di_sp += column
+          continue
+        table_di_sp += "    <td>{0}</td>\n".format(column.strip())
+      table_di_sp += "  <tr>\n"
+
+  if not at_least_one_bug_found:
+    table_di_sp += "  <tr>\n"
+    table_di_sp += "    <td colspan='4'> No bugs found </td>\n"
+    table_di_sp += "  </tr>\n"
+
+  table_di_sp += "</table>\n"
+
+  # Create the summary table for the sp bugs.
+  table_di_sp_sum = "<table>\n"
+
+  # Create the table's column headers.
+  table_title_di_sp_sum = "DI Checker Summary of SP Bugs"
+  table_di_sp_sum += "<caption><b>"
+  table_di_sp_sum += table_title_di_sp_sum
+  table_di_sp_sum += "</b></caption>\n"
+
+  header_di_sp_sum = ["LLVM Pass Name", "Number of bugs"]
+  table_di_sp_sum += "  <tr>\n"
+
+  for column in header_di_sp_sum:
+    table_di_sp_sum += "    <th>{0}</th>\n".format(column.strip())
+  table_di_sp_sum += "  </tr>\n"
+
+  # Print the summary.
+  row = []
+  for llvm_pass, num in sorted(di_sp_bugs_summary.items()):
+    row.append("    <tr>\n")
+    row.append(llvm_pass)
+    row.append(str(num))
+    row.append("    </tr>\n")
+  for column in row:
+    if (column == "    <tr>\n" or column == "    </tr>\n"):
+      table_di_sp_sum += column
+      continue
+    table_di_sp_sum += "    <td>{0}</td>\n".format(column.strip())
+  table_di_sp_sum += "  <tr>\n"
+
+  if not at_least_one_bug_found:
+    table_di_sp_sum += "  <tr>\n"
+    table_di_sp_sum += "    <td colspan='2'> No bugs found </td>\n"
+    table_di_sp_sum += "  </tr>\n"
+  table_di_sp_sum += "</table>\n"
+
+
+  # Finish the html page.
+  html_footer = "</body>\n"
+  html_footer += "</html>\n"
+  new_line = "<br>\n"
+
+  fileout.writelines(html_header)
+  fileout.writelines(table_di_loc)
+  fileout.writelines(new_line)
+  fileout.writelines(table_di_loc_sum)
+  fileout.writelines(new_line)
+  fileout.writelines(new_line)
+  fileout.writelines(table_di_sp)
+  fileout.writelines(new_line)
+  fileout.writelines(table_di_sp_sum)
+  fileout.writelines(html_footer)
+  fileout.close()
+
+  print("The " + html_file + " generated.")
+
+# Read the JSON file.
+def get_json(file):
+  json_parsed = None
+  di_checker_data = []
+
+  # The file contains json object per line.
+  # An example of the line (formatted json):
+  # {
+  #  "file": "simple.c",
+  #  "pass": "Deduce function attributes in RPO",
+  #  "bugs": [
+  #    [
+  #      {
+  #        "action": "drop",
+  #        "metadata": "DISubprogram",
+  #        "name": "fn2"
+  #      },
+  #      {
+  #        "action": "drop",
+  #        "metadata": "DISubprogram",
+  #        "name": "fn1"
+  #      }
+  #    ]
+  #  ]
+  #}
+  with open(file) as json_objects_file:
+    for json_object_line in json_objects_file:
+      try:
+        json_object = loads(json_object_line)
+      except:
+        print ("error: No valid di-checker data found.")
+        sys.exit(1)
+      di_checker_data.append(json_object)
+
+  return di_checker_data
+
+# Parse the program arguments.
+def parse_program_args(parser):
+  parser.add_argument("file_name", type=str, help="json file to process")
+  parser.add_argument("html_file", type=str, help="html file to output data")
+
+  return parser.parse_args()
+
+def Main():
+  parser = argparse.ArgumentParser()
+  opts = parse_program_args(parser)
+
+  if not opts.html_file.endswith('.html'):
+    print ("error: The output file must be '.html'.")
+    sys.exit(1)
+
+  debug_info_bugs = get_json(opts.file_name)
+
+  # Use the defaultdict in order to make multidim dicts.
+  di_location_bugs = defaultdict(lambda: defaultdict(dict))
+  di_subprogram_bugs = defaultdict(lambda: defaultdict(dict))
+
+  # Use the ordered dict to make a summary.
+  di_location_bugs_summary = OrderedDict()
+  di_sp_bugs_summary = OrderedDict()
+
+  # Map the bugs into the file-pass pairs.
+  for bugs_per_pass in debug_info_bugs:
+    bugs_file = bugs_per_pass["file"]
+    bugs_pass = bugs_per_pass["pass"]
+
+    bugs = bugs_per_pass["bugs"][0]
+
+    di_loc_bugs = []
+    di_sp_bugs = []
+    for bug in bugs:
+      bugs_metadata = bug["metadata"]
+      if bugs_metadata == "DILocation":
+        action = bug["action"]
+        bb_name = bug["bb-name"]
+        fn_name = bug["fn-name"]
+        instr = bug["instr"]
+        di_loc_bugs.append(DILocBug(action, bb_name, fn_name, instr))
+
+        # Fill the summary dict.
+        if bugs_pass in di_location_bugs_summary:
+          di_location_bugs_summary[bugs_pass] += 1
+        else:
+          di_location_bugs_summary[bugs_pass] = 1
+      elif bugs_metadata == "DISubprogram":
+        action = bug["action"]
+        name = bug["name"]
+        di_sp_bugs.append(DISPBug(action, name))
+
+        # Fill the summary dict.
+        if bugs_pass in di_sp_bugs_summary:
+          di_sp_bugs_summary[bugs_pass] += 1
+        else:
+          di_sp_bugs_summary[bugs_pass] = 1
+      else:
+        print ("error: Only DILocation and DISubprogram are supported.")
+        sys.exit(1)
+
+    di_location_bugs[bugs_file][bugs_pass] = di_loc_bugs
+    di_subprogram_bugs[bugs_file][bugs_pass] = di_sp_bugs
+
+  generate_html_report(di_location_bugs, di_subprogram_bugs, \
+                       di_location_bugs_summary, di_sp_bugs_summary, \
+                       opts.html_file)
+
+if __name__ == "__main__":
+  Main()
+  sys.exit(0)