Allow branch coverage to be skipped by llvm-cov when exporting for LCOV

[alanphipps]

Summary

This small patch adds a '--skip-branches' option to the llvm-cov export options. This option allows branch coverage information to be skipped from the exported LCOV directives if it's not needed. For now, this only works when exporting LCOV (which is noted in the option description), but it can be extended for JSON later if it makes sense.

Reference discussion here: https://discourse.llvm.org/t/is-it-possible-to-disable-branch-coverage-generation/62342/7

[justincady]

LGTM.

Thank you!

llvm/test/tools/llvm-cov/branch-export-lcov.test

 
 // RUN: llvm-profdata merge %S/Inputs/branch-showBranchPercentage.proftext -o %t.profdata
 // RUN: llvm-cov export --format=lcov %S/Inputs/branch-showBranchPercentage.o32l -instr-profile %t.profdata | FileCheck %s
+// RUN: llvm-cov export --format=lcov --skip-branches %S/Inputs/branch-showBranchPercentage.o32l -instr-profile %t.profdata | FileCheck %s --check-prefix=NOBRANCH
 
 // CHECK-DAG: BRDA:14,0,0,1
 // CHECK-DAG: BRDA:14,0,1,5
 // CHECK-DAG: BRDA:27,0,0,1
 // CHECK-DAG: BRDA:27,0,1,4
 // CHECK-DAG: BRDA:27,1,2,0
 // CHECK-DAG: BRDA:27,1,3,1
 // CHECK-DAG: BRDA:27,2,4,0

 // CHECK-DAG: BRDA:53,0,1,5
 // CHECK-NOT: BRDA
 // CHECK: BRF:30
 // CHECK: BRH:26
 
 // Check recursive macro-expansions.
 // RUN: llvm-profdata merge %S/Inputs/branch-macros.proftext -o %t.profdata
 // RUN: llvm-cov export --format=lcov %S/Inputs/branch-macros.o32l -instr-profile %t.profdata | FileCheck %s -check-prefix=MACROS
+// RUN: llvm-cov export --format=lcov --skip-branches %S/Inputs/branch-macros.o32l -instr-profile %t.profdata | FileCheck %s -check-prefix=NOBRANCH
 
 // MACROS-COUNT-4: BRDA:17
 // MACROS-NOT: BRDA:17
 
 // MACROS-COUNT-4: BRDA:19
 // MACROS-NOT: BRDA:19
 
 // MACROS-COUNT-4: BRDA:21

 // MACROS: BRDA:27,4,8,-
 // MACROS: BRDA:27,4,9,-
 
 // MACROS-COUNT-10: BRDA:37
 // MACROS-NOT: BRDA:37
 // MACROS-NOT: BRDA
 // MACROS: BRF:40
 // MACROS: BRH:24
+
+// NOBRANCH-NOT: BRDA
+// NOBRANCH-NOT: BRF
+// NOBRANCH-NOT: BRH
+

llvm/tools/llvm-cov/CodeCoverage.cpp

int CodeCoverageTool::doExport(int argc, const char **argv,
   cl::opt<bool> SkipExpansions("skip-expansions", cl::Optional,
                                cl::desc("Don't export expanded source regions"),
                                cl::cat(ExportCategory));
 
   cl::opt<bool> SkipFunctions("skip-functions", cl::Optional,
                               cl::desc("Don't export per-function data"),
                               cl::cat(ExportCategory));
 
+  cl::opt<bool> SkipBranches("skip-branches", cl::Optional,
+                              cl::desc("Don't export branch data (LCOV)"),
+                              cl::cat(ExportCategory));
+
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
   ViewOpts.SkipExpansions = SkipExpansions;
   ViewOpts.SkipFunctions = SkipFunctions;
+  ViewOpts.SkipBranches = SkipBranches;
 
   if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text &&
       ViewOpts.Format != CoverageViewOptions::OutputFormat::Lcov) {
     error("Coverage data can only be exported as textual JSON or an "
           "lcov tracefile.");
     return 1;
   }
 

llvm/tools/llvm-cov/CoverageExporterLcov.cpp

 void renderBranchSummary(raw_ostream &OS, const FileCoverageSummary &Summary) {
   OS << "BRF:" << Summary.BranchCoverage.getNumBranches() << '\n'
      << "BRH:" << Summary.BranchCoverage.getCovered() << '\n';
 }
 
 void renderFile(raw_ostream &OS, const coverage::CoverageMapping &Coverage,
                 const std::string &Filename,
                 const FileCoverageSummary &FileReport, bool ExportSummaryOnly,
-                bool SkipFunctions) {
+                bool SkipFunctions, bool SkipBranches) {
   OS << "SF:" << Filename << '\n';
 
   if (!ExportSummaryOnly && !SkipFunctions) {
     renderFunctions(OS, Coverage.getCoveredFunctions(Filename));
   }
   renderFunctionSummary(OS, FileReport);
 
   if (!ExportSummaryOnly) {
     // Calculate and render detailed coverage information for given file.
     auto FileCoverage = Coverage.getCoverageForFile(Filename);
     renderLineExecutionCounts(OS, FileCoverage);
+    if (!SkipBranches)
       renderBranchExecutionCounts(OS, Coverage, FileCoverage);
   }
+  if (!SkipBranches)
     renderBranchSummary(OS, FileReport);
   renderLineSummary(OS, FileReport);
 
   OS << "end_of_record\n";
 }
 
 void renderFiles(raw_ostream &OS, const coverage::CoverageMapping &Coverage,
                  ArrayRef<std::string> SourceFiles,
                  ArrayRef<FileCoverageSummary> FileReports,
-                 bool ExportSummaryOnly, bool SkipFunctions) {
+                 bool ExportSummaryOnly, bool SkipFunctions,
+                 bool SkipBranches) {
   for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I)
     renderFile(OS, Coverage, SourceFiles[I], FileReports[I], ExportSummaryOnly,
-               SkipFunctions);
+               SkipFunctions, SkipBranches);
 }
 
 } // end anonymous namespace
 
 void CoverageExporterLcov::renderRoot(const CoverageFilters &IgnoreFilters) {
   std::vector<std::string> SourceFiles;
   for (StringRef SF : Coverage.getUniqueSourceFiles()) {
     if (!IgnoreFilters.matchesFilename(SF))
       SourceFiles.emplace_back(SF);
   }
   renderRoot(SourceFiles);
 }
 
 void CoverageExporterLcov::renderRoot(ArrayRef<std::string> SourceFiles) {
   FileCoverageSummary Totals = FileCoverageSummary("Totals");
   auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
                                                         SourceFiles, Options);
   renderFiles(OS, Coverage, SourceFiles, FileReports, Options.ExportSummaryOnly,
-              Options.SkipFunctions);
+              Options.SkipFunctions, Options.SkipBranches);
 }

llvm/tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   bool ShowFunctionInstantiations;
   bool ShowFullFilenames;
   bool ShowBranchSummary;
   bool ShowRegionSummary;
   bool ShowInstantiationSummary;
   bool ExportSummaryOnly;
   bool SkipExpansions;
   bool SkipFunctions;
+  bool SkipBranches;
   OutputFormat Format;
   BranchOutputType ShowBranches;
   std::string ShowOutputDirectory;
   std::vector<std::string> DemanglerOpts;
   uint32_t TabSize;
   std::string ProjectTitle;
   std::string CreatedTimeStr;
   unsigned NumThreads;