[llvm-cov] Allow hiding instantiation/region coverage from summary tables

[efriedma]

Summary

Region coverage is difficult to explain without going deep into how coverage is implemented. Instantiation coverage is easier to explain, but probably not useful in most cases (templates don't exist in C, and most C++ code contains relatively few templates).

This patch adds the options "-show-region-summary" and "-show-instantiation-summary" to allow hiding those columns. "-show-instantiation-summary" is turned off by default.

[vsk]

I think it makes sense to hide instantiation coverage by default. Unless you're specifically looking for unused specializations (perhaps not the common case), it can be overwhelming.

I'd prefer to keep region coverage visible by default. It requires some additional effort up-front to understand, but is the most granular metric we currently report. IMO it's a good deal more informative than line coverage.

[efriedma]

Updated to turn "-show-region-summary" on by default.

[vsk]

Thanks!

[efriedma]

https://reviews.llvm.org/rL312969

test/tools/llvm-cov/hideUnexecutedSubviews.test

 RUN: llvm-profdata merge %S/Inputs/hideUnexecutedSubviews.proftext -o %t.profdata
 
-RUN: llvm-cov show %S/Inputs/templateInstantiations.covmapping -instr-profile %t.profdata -path-equivalence=/tmp,%S %S/showTemplateInstantiations.cpp | FileCheck -check-prefix=FILE %s
+RUN: llvm-cov show %S/Inputs/templateInstantiations.covmapping -instr-profile %t.profdata -show-region-summary -show-instantiation-summary -path-equivalence=/tmp,%S %S/showTemplateInstantiations.cpp | FileCheck -check-prefix=FILE %s
 
-RUN: llvm-cov show %S/Inputs/templateInstantiations.covmapping -instr-profile %t.profdata -format html -o %t.html.dir -path-equivalence=/tmp,%S %S/showTemplateInstantiations.cpp
+RUN: llvm-cov show %S/Inputs/templateInstantiations.covmapping -instr-profile %t.profdata -format html -show-region-summary -show-instantiation-summary -o %t.html.dir -path-equivalence=/tmp,%S %S/showTemplateInstantiations.cpp
 RUN: FileCheck -check-prefix=FILE %s -input-file %t.html.dir/coverage/tmp/showTemplateInstantiations.cpp.html
 
 FILE: Unexecuted instantiation: _Z4funcIbEiT_
 FILE: Unexecuted instantiation: _Z4funcIiEiT_
 FILE-NOT: Unexecuted instantiation
 
 RUN: FileCheck -check-prefix=INDEX %s -input-file %t.html.dir/index.html
 

test/tools/llvm-cov/report.cpp

-// RUN: llvm-cov report %S/Inputs/report.covmapping -instr-profile %S/Inputs/report.profdata -path-equivalence=,%S 2>&1 | FileCheck %s
+// RUN: llvm-cov report %S/Inputs/report.covmapping -instr-profile %S/Inputs/report.profdata -path-equivalence=,%S 2>&1 -show-region-summary -show-instantiation-summary | FileCheck %s
 // RUN: llvm-cov report -show-functions %S/Inputs/report.covmapping -instr-profile %S/Inputs/report.profdata -path-equivalence=,%S %s 2>&1 | FileCheck -check-prefix=FILT %s
 // RUN: llvm-cov report -show-functions %S/Inputs/report.covmapping -instr-profile %S/Inputs/report.profdata -path-equivalence=,%S %s does-not-exist.cpp 2>&1 | FileCheck -check-prefix=FILT %s
 
 // CHECK: Regions    Missed Regions     Cover   Functions  Missed Functions  Executed  Instantiations   Missed Insts.  Executed       Lines      Missed Lines     Cover
 // CHECK-NEXT: ---
 // CHECK-NEXT: report.cpp                          5                 2    60.00%           4                 1    75.00%               4               1    75.00%          13                 4    69.23%
 // CHECK-NEXT: ---
 // CHECK-NEXT: TOTAL                               5                 2    60.00%           4                 1    75.00%               4               1    75.00%          13                 4    69.23%

test/tools/llvm-cov/showLineExecutionCounts.cpp

 // TEXT-INDEX: Filename
 // TEXT-INDEX-NEXT: ---
 // TEXT-INDEX-NEXT: {{.*}}showLineExecutionCounts.cpp
 //
 // RUN: FileCheck -check-prefix HTML-INDEX -input-file %t.html.dir/index.html %s
 // HTML-INDEX-LABEL: <table>
 // HTML-INDEX: <td class='column-entry-left'>Filename</td>
 // HTML-INDEX: <td class='column-entry'>Function Coverage</td>
-// HTML-INDEX: <td class='column-entry'>Instantiation Coverage</td>
 // HTML-INDEX: <td class='column-entry'>Line Coverage</td>
 // HTML-INDEX: <td class='column-entry'>Region Coverage</td>
 // HTML-INDEX: <a href='coverage{{.*}}showLineExecutionCounts.cpp.html'{{.*}}showLineExecutionCounts.cpp</a>
 // HTML-INDEX: <td class='column-entry-green'>
 // HTML-INDEX: 100.00% (1/1)
-// HTML-INDEX: <td class='column-entry-green'>
-// HTML-INDEX: 100.00% (1/1)
 // HTML-INDEX: <td class='column-entry-yellow'>
 // HTML-INDEX: 80.00% (16/20)
 // HTML-INDEX: <td class='column-entry-red'>
 // HTML-INDEX: 70.00% (7/10)
 // HTML-INDEX: TOTALS

tools/llvm-cov/CodeCoverage.cpp

int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
 
   cl::opt<cl::boolOrDefault> UseColor(
       "use-color", cl::desc("Emit colored output (default=autodetect)"),
       cl::init(cl::BOU_UNSET));
 
   cl::list<std::string> DemanglerOpts(
       "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
 
+  cl::opt<bool> RegionSummary(
+      "show-region-summary", cl::Optional,
+      cl::desc("Show region statistics in summary table"),
+      cl::init(true));
+
+  cl::opt<bool> InstantiationSummary(
+      "show-instantiation-summary", cl::Optional,
+      cl::desc("Show instantiation statistics in summary table"));
+
   auto commandLineParser = [&, this](int argc, const char **argv) -> int {
     cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
     ViewOpts.Debug = DebugDump;
 
     if (!CovFilename.empty())
       ObjectFilenames.emplace_back(CovFilename);
     for (const std::string &Filename : CovFilenames)
       ObjectFilenames.emplace_back(Filename);
for (const std::string &File : InputSourceFiles)
       collectPaths(File);
 
     if (DebugDumpCollectedPaths) {
       for (const std::string &SF : SourceFiles)
         outs() << SF << '\n';
       ::exit(0);
     }
 
+    ViewOpts.ShowRegionSummary = RegionSummary;
+    ViewOpts.ShowInstantiationSummary = InstantiationSummary;
+
     return 0;
   };
 
   switch (Cmd) {
   case Show:
     return show(argc, argv, commandLineParser);
   case Report:
     return report(argc, argv, commandLineParser);

tools/llvm-cov/CoverageReport.cpp

void CoverageReport::render(const FileCoverageSummary &File,
   auto FuncCoverageColor =
       determineCoveragePercentageColor(File.FunctionCoverage);
   auto InstantiationCoverageColor =
       determineCoveragePercentageColor(File.InstantiationCoverage);
   auto LineCoverageColor = determineCoveragePercentageColor(File.LineCoverage);
   SmallString<256> FileName = File.Name;
   sys::path::remove_dots(FileName, /*remove_dot_dots=*/true);
   sys::path::native(FileName);
-  OS << column(FileName, FileReportColumns[0], Column::NoTrim)
-     << format("%*u", FileReportColumns[1],
+  OS << column(FileName, FileReportColumns[0], Column::NoTrim);
+
+  if (Options.ShowRegionSummary) {
+    OS << format("%*u", FileReportColumns[1],
                  (unsigned)File.RegionCoverage.NumRegions);
     Options.colored_ostream(OS, FileCoverageColor) << format(
         "%*u", FileReportColumns[2], (unsigned)File.RegionCoverage.NotCovered);
     if (File.RegionCoverage.NumRegions)
       Options.colored_ostream(OS, FileCoverageColor)
           << format("%*.2f", FileReportColumns[3] - 1,
                     File.RegionCoverage.getPercentCovered())
           << '%';
     else
       OS << column("-", FileReportColumns[3], Column::RightAlignment);
+  }
+
   OS << format("%*u", FileReportColumns[4],
                (unsigned)File.FunctionCoverage.NumFunctions);
   OS << format("%*u", FileReportColumns[5],
                (unsigned)(File.FunctionCoverage.NumFunctions -
                           File.FunctionCoverage.Executed));
   if (File.FunctionCoverage.NumFunctions)
     Options.colored_ostream(OS, FuncCoverageColor)
         << format("%*.2f", FileReportColumns[6] - 1,
                   File.FunctionCoverage.getPercentCovered())
         << '%';
   else
     OS << column("-", FileReportColumns[6], Column::RightAlignment);
+
+  if (Options.ShowInstantiationSummary) {
     OS << format("%*u", FileReportColumns[7],
                  (unsigned)File.InstantiationCoverage.NumFunctions);
     OS << format("%*u", FileReportColumns[8],
                  (unsigned)(File.InstantiationCoverage.NumFunctions -
                             File.InstantiationCoverage.Executed));
     if (File.InstantiationCoverage.NumFunctions)
       Options.colored_ostream(OS, InstantiationCoverageColor)
           << format("%*.2f", FileReportColumns[9] - 1,
                     File.InstantiationCoverage.getPercentCovered())
           << '%';
     else
       OS << column("-", FileReportColumns[9], Column::RightAlignment);
+  }
+
   OS << format("%*u", FileReportColumns[10],
                (unsigned)File.LineCoverage.NumLines);
   Options.colored_ostream(OS, LineCoverageColor) << format(
       "%*u", FileReportColumns[11], (unsigned)File.LineCoverage.NotCovered);
   if (File.LineCoverage.NumLines)
     Options.colored_ostream(OS, LineCoverageColor)
         << format("%*.2f", FileReportColumns[12] - 1,
                   File.LineCoverage.getPercentCovered())
void CoverageReport::renderFileReports(raw_ostream &OS,
   FileCoverageSummary Totals("TOTAL");
   auto FileReports = prepareFileReports(Coverage, Totals, Files);
 
   std::vector<StringRef> Filenames;
   for (const FileCoverageSummary &FCS : FileReports)
     Filenames.emplace_back(FCS.Name);
   adjustColumnWidths(Filenames, {});
 
-  OS << column("Filename", FileReportColumns[0])
-     << column("Regions", FileReportColumns[1], Column::RightAlignment)
+  OS << column("Filename", FileReportColumns[0]);
+  if (Options.ShowRegionSummary)
+    OS << column("Regions", FileReportColumns[1], Column::RightAlignment)
        << column("Missed Regions", FileReportColumns[2], Column::RightAlignment)
-     << column("Cover", FileReportColumns[3], Column::RightAlignment)
-     << column("Functions", FileReportColumns[4], Column::RightAlignment)
+       << column("Cover", FileReportColumns[3], Column::RightAlignment);
+  OS << column("Functions", FileReportColumns[4], Column::RightAlignment)
      << column("Missed Functions", FileReportColumns[5], Column::RightAlignment)
-     << column("Executed", FileReportColumns[6], Column::RightAlignment)
-     << column("Instantiations", FileReportColumns[7], Column::RightAlignment)
+     << column("Executed", FileReportColumns[6], Column::RightAlignment);
+  if (Options.ShowInstantiationSummary)
+    OS << column("Instantiations", FileReportColumns[7], Column::RightAlignment)
        << column("Missed Insts.", FileReportColumns[8], Column::RightAlignment)
-     << column("Executed", FileReportColumns[9], Column::RightAlignment)
-     << column("Lines", FileReportColumns[10], Column::RightAlignment)
+       << column("Executed", FileReportColumns[9], Column::RightAlignment);
+  OS << column("Lines", FileReportColumns[10], Column::RightAlignment)
      << column("Missed Lines", FileReportColumns[11], Column::RightAlignment)
      << column("Cover", FileReportColumns[12], Column::RightAlignment) << "\n";
   renderDivider(FileReportColumns, OS);
   OS << "\n";
 
   bool EmptyFiles = false;
   for (const FileCoverageSummary &FCS : FileReports) {
     if (FCS.FunctionCoverage.NumFunctions)

tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   bool Colors;
   bool ShowLineNumbers;
   bool ShowLineStats;
   bool ShowRegionMarkers;
   bool ShowLineStatsOrRegionMarkers;
   bool ShowExpandedRegions;
   bool ShowFunctionInstantiations;
   bool ShowFullFilenames;
+  bool ShowRegionSummary;
+  bool ShowInstantiationSummary;
   OutputFormat Format;
   std::string ShowOutputDirectory;
   std::vector<std::string> DemanglerOpts;
   uint32_t TabSize;
   std::string ProjectTitle;
   std::string CreatedTimeStr;
 
   /// \brief Change the output's stream color if the colors are enabled.

tools/llvm-cov/SourceCoverageViewHTML.cpp

CoveragePrinterHTML::createViewFile(StringRef Path, bool InToplevel) {
   return std::move(OS);
 }
 
 void CoveragePrinterHTML::closeViewFile(OwnedStream OS) {
   emitEpilog(*OS.get());
 }
 
 /// Emit column labels for the table in the index.
-static void emitColumnLabelsForIndex(raw_ostream &OS) {
+static void emitColumnLabelsForIndex(raw_ostream &OS,
+                                     const CoverageViewOptions &Opts) {
   SmallVector<std::string, 4> Columns;
   Columns.emplace_back(tag("td", "Filename", "column-entry-left"));
-  for (const char *Label : {"Function Coverage", "Instantiation Coverage",
-                            "Line Coverage", "Region Coverage"})
-    Columns.emplace_back(tag("td", Label, "column-entry"));
+  Columns.emplace_back(tag("td", "Function Coverage", "column-entry"));
+  if (Opts.ShowInstantiationSummary)
+    Columns.emplace_back(tag("td", "Instantiation Coverage", "column-entry"));
+  Columns.emplace_back(tag("td", "Line Coverage", "column-entry"));
+  if (Opts.ShowRegionSummary)
+    Columns.emplace_back(tag("td", "Region Coverage", "column-entry"));
   OS << tag("tr", join(Columns.begin(), Columns.end(), ""));
 }
 
 std::string
 CoveragePrinterHTML::buildLinkToFile(StringRef SF,
                                      const FileCoverageSummary &FCS) const {
   SmallString<128> LinkTextStr(sys::path::relative_path(FCS.Name));
   sys::path::remove_dots(LinkTextStr, /*remove_dot_dots=*/true);
void CoveragePrinterHTML::emitFileSummary(raw_ostream &OS, StringRef SF,
   } else {
     Filename = buildLinkToFile(SF, FCS);
   }
 
   Columns.emplace_back(tag("td", tag("pre", Filename)));
   AddCoverageTripleToColumn(FCS.FunctionCoverage.Executed,
                             FCS.FunctionCoverage.NumFunctions,
                             FCS.FunctionCoverage.getPercentCovered());
+  if (Opts.ShowInstantiationSummary)
     AddCoverageTripleToColumn(FCS.InstantiationCoverage.Executed,
                               FCS.InstantiationCoverage.NumFunctions,
                               FCS.InstantiationCoverage.getPercentCovered());
   AddCoverageTripleToColumn(FCS.LineCoverage.Covered, FCS.LineCoverage.NumLines,
                             FCS.LineCoverage.getPercentCovered());
+  if (Opts.ShowRegionSummary)
     AddCoverageTripleToColumn(FCS.RegionCoverage.Covered,
                               FCS.RegionCoverage.NumRegions,
                               FCS.RegionCoverage.getPercentCovered());
 
   OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
 }
 
 Error CoveragePrinterHTML::createIndexFile(
     ArrayRef<std::string> SourceFiles,
     const coverage::CoverageMapping &Coverage) {
   // Emit the default stylesheet.
OSRef << tag("p", "Click " +
                         a("http://clang.llvm.org/docs/"
                           "SourceBasedCodeCoverage.html#interpreting-reports",
                           "here") +
                         " for information about interpreting this report.");
 
   // Emit a table containing links to reports for each file in the covmapping.
   // Exclude files which don't contain any regions.
   OSRef << BeginCenteredDiv << BeginTable;
-  emitColumnLabelsForIndex(OSRef);
+  emitColumnLabelsForIndex(OSRef, Opts);
   FileCoverageSummary Totals("TOTALS");
   auto FileReports =
       CoverageReport::prepareFileReports(Coverage, Totals, SourceFiles);
   bool EmptyFiles = false;
   for (unsigned I = 0, E = FileReports.size(); I < E; ++I) {
     if (FileReports[I].FunctionCoverage.NumFunctions)
       emitFileSummary(OSRef, SourceFiles[I], FileReports[I]);
     else