llvm/tools/llvm-cov/CoverageExporterLcov.cpp

   1 //===- CoverageExporterLcov.cpp - Code coverage export --------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements export of code coverage data to lcov trace file format.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 //===----------------------------------------------------------------------===//
  14 //
  15 // The trace file code coverage export follows the following format (see also
  16 // https://linux.die.net/man/1/geninfo). Each quoted string appears on its own
  17 // line; the indentation shown here is only for documentation purposes.
  18 //
  19 // - for each source file:
  20 //   - "SF:<absolute path to source file>"
  21 //   - for each function:
  22 //     - "FN:<line number of function start>,<function name>"
  23 //   - for each function:
  24 //     - "FNDA:<execution count>,<function name>"
  25 //   - "FNF:<number of functions found>"
  26 //   - "FNH:<number of functions hit>"
  27 //   - for each instrumented line:
  28 //     - "DA:<line number>,<execution count>[,<checksum>]
  29 //   - for each branch:
  30 //     - "BRDA:<line number>,<branch pair id>,<branch id>,<count>"
  31 //   - "BRF:<number of branches found>"
  32 //   - "BRH:<number of branches hit>"
  33 //   - "LH:<number of lines with non-zero execution count>"
  34 //   - "LF:<number of instrumented lines>"
  35 //   - "end_of_record"
  36 //
  37 // If the user is exporting summary information only, then the FN, FNDA, and DA
  38 // lines will not be present.
  39 //
  40 //===----------------------------------------------------------------------===//
  41
  42 #include "CoverageExporterLcov.h"
  43 #include "CoverageReport.h"
  44
  45 using namespace llvm;
  46
  47 namespace {
  48
  49 void renderFunctionSummary(raw_ostream &OS,
  50                            const FileCoverageSummary &Summary) {
  51   OS << "FNF:" << Summary.FunctionCoverage.getNumFunctions() << '\n'
  52      << "FNH:" << Summary.FunctionCoverage.getExecuted() << '\n';
  53 }
  54
  55 void renderFunctions(
  56     raw_ostream &OS,
  57     const iterator_range<coverage::FunctionRecordIterator> &Functions) {
  58   for (const auto &F : Functions) {
  59     auto StartLine = F.CountedRegions.front().LineStart;
  60     OS << "FN:" << StartLine << ',' << F.Name << '\n';
  61   }
  62   for (const auto &F : Functions)
  63     OS << "FNDA:" << F.ExecutionCount << ',' << F.Name << '\n';
  64 }
  65
  66 void renderLineExecutionCounts(raw_ostream &OS,
  67                                const coverage::CoverageData &FileCoverage) {
  68   coverage::LineCoverageIterator LCI{FileCoverage, 1};
  69   coverage::LineCoverageIterator LCIEnd = LCI.getEnd();
  70   for (; LCI != LCIEnd; ++LCI) {
  71     const coverage::LineCoverageStats &LCS = *LCI;
  72     if (LCS.isMapped()) {
  73       OS << "DA:" << LCS.getLine() << ',' << LCS.getExecutionCount() << '\n';
  74     }
  75   }
  76 }
  77
  78 std::vector<llvm::coverage::CountedRegion>
  79 collectNestedBranches(const coverage::CoverageMapping &Coverage,
  80                       ArrayRef<llvm::coverage::ExpansionRecord> Expansions,
  81                       int ViewDepth = 0, int SrcLine = 0) {
  82   std::vector<llvm::coverage::CountedRegion> Branches;
  83   for (const auto &Expansion : Expansions) {
  84     auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
  85
  86     // If we're at the top level, set the corresponding source line.
  87     if (ViewDepth == 0)
  88       SrcLine = Expansion.Region.LineStart;
  89
  90     // Recursively collect branches from nested expansions.
  91     auto NestedExpansions = ExpansionCoverage.getExpansions();
  92     auto NestedExBranches = collectNestedBranches(Coverage, NestedExpansions,
  93                                                   ViewDepth + 1, SrcLine);
  94     append_range(Branches, NestedExBranches);
  95
  96     // Add branches from this level of expansion.
  97     auto ExBranches = ExpansionCoverage.getBranches();
  98     for (auto B : ExBranches)
  99       if (B.FileID == Expansion.FileID) {
 100         B.LineStart = SrcLine;
 101         Branches.push_back(B);
 102       }
 103   }
 104
 105   return Branches;
 106 }
 107
 108 bool sortLine(llvm::coverage::CountedRegion I,
 109               llvm::coverage::CountedRegion J) {
 110   return (I.LineStart < J.LineStart) ||
 111          ((I.LineStart == J.LineStart) && (I.ColumnStart < J.ColumnStart));
 112 }
 113
 114 void renderBranchExecutionCounts(raw_ostream &OS,
 115                                  const coverage::CoverageMapping &Coverage,
 116                                  const coverage::CoverageData &FileCoverage) {
 117   std::vector<llvm::coverage::CountedRegion> Branches =
 118       FileCoverage.getBranches();
 119
 120   // Recursively collect branches for all file expansions.
 121   std::vector<llvm::coverage::CountedRegion> ExBranches =
 122       collectNestedBranches(Coverage, FileCoverage.getExpansions());
 123
 124   // Append Expansion Branches to Source Branches.
 125   append_range(Branches, ExBranches);
 126
 127   // Sort branches based on line number to ensure branches corresponding to the
 128   // same source line are counted together.
 129   llvm::sort(Branches, sortLine);
 130
 131   auto NextBranch = Branches.begin();
 132   auto EndBranch = Branches.end();
 133
 134   // Branches with the same source line are enumerated individually
 135   // (BranchIndex) as well as based on True/False pairs (PairIndex).
 136   while (NextBranch != EndBranch) {
 137     unsigned CurrentLine = NextBranch->LineStart;
 138     unsigned PairIndex = 0;
 139     unsigned BranchIndex = 0;
 140
 141     while (NextBranch != EndBranch && CurrentLine == NextBranch->LineStart) {
 142       if (!NextBranch->Folded) {
 143         unsigned BC1 = NextBranch->ExecutionCount;
 144         unsigned BC2 = NextBranch->FalseExecutionCount;
 145         bool BranchNotExecuted = (BC1 == 0 && BC2 == 0);
 146
 147         for (int I = 0; I < 2; I++, BranchIndex++) {
 148           OS << "BRDA:" << CurrentLine << ',' << PairIndex << ','
 149              << BranchIndex;
 150           if (BranchNotExecuted)
 151             OS << ',' << '-' << '\n';
 152           else
 153             OS << ',' << (I == 0 ? BC1 : BC2) << '\n';
 154         }
 155
 156         PairIndex++;
 157       }
 158       NextBranch++;
 159     }
 160   }
 161 }
 162
 163 void renderLineSummary(raw_ostream &OS, const FileCoverageSummary &Summary) {
 164   OS << "LF:" << Summary.LineCoverage.getNumLines() << '\n'
 165      << "LH:" << Summary.LineCoverage.getCovered() << '\n';
 166 }
 167
 168 void renderBranchSummary(raw_ostream &OS, const FileCoverageSummary &Summary) {
 169   OS << "BRF:" << Summary.BranchCoverage.getNumBranches() << '\n'
 170      << "BRH:" << Summary.BranchCoverage.getCovered() << '\n';
 171 }
 172
 173 void renderFile(raw_ostream &OS, const coverage::CoverageMapping &Coverage,
 174                 const std::string &Filename,
 175                 const FileCoverageSummary &FileReport, bool ExportSummaryOnly,
 176                 bool SkipFunctions, bool SkipBranches) {
 177   OS << "SF:" << Filename << '\n';
 178
 179   if (!ExportSummaryOnly && !SkipFunctions) {
 180     renderFunctions(OS, Coverage.getCoveredFunctions(Filename));
 181   }
 182   renderFunctionSummary(OS, FileReport);
 183
 184   if (!ExportSummaryOnly) {
 185     // Calculate and render detailed coverage information for given file.
 186     auto FileCoverage = Coverage.getCoverageForFile(Filename);
 187     renderLineExecutionCounts(OS, FileCoverage);
 188     if (!SkipBranches)
 189       renderBranchExecutionCounts(OS, Coverage, FileCoverage);
 190   }
 191   if (!SkipBranches)
 192     renderBranchSummary(OS, FileReport);
 193   renderLineSummary(OS, FileReport);
 194
 195   OS << "end_of_record\n";
 196 }
 197
 198 void renderFiles(raw_ostream &OS, const coverage::CoverageMapping &Coverage,
 199                  ArrayRef<std::string> SourceFiles,
 200                  ArrayRef<FileCoverageSummary> FileReports,
 201                  bool ExportSummaryOnly, bool SkipFunctions,
 202                  bool SkipBranches) {
 203   for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I)
 204     renderFile(OS, Coverage, SourceFiles[I], FileReports[I], ExportSummaryOnly,
 205                SkipFunctions, SkipBranches);
 206 }
 207
 208 } // end anonymous namespace
 209
 210 void CoverageExporterLcov::renderRoot(const CoverageFilters &IgnoreFilters) {
 211   std::vector<std::string> SourceFiles;
 212   for (StringRef SF : Coverage.getUniqueSourceFiles()) {
 213     if (!IgnoreFilters.matchesFilename(SF))
 214       SourceFiles.emplace_back(SF);
 215   }
 216   renderRoot(SourceFiles);
 217 }
 218
 219 void CoverageExporterLcov::renderRoot(ArrayRef<std::string> SourceFiles) {
 220   FileCoverageSummary Totals = FileCoverageSummary("Totals");
 221   auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
 222                                                         SourceFiles, Options);
 223   renderFiles(OS, Coverage, SourceFiles, FileReports, Options.ExportSummaryOnly,
 224               Options.SkipFunctions, Options.SkipBranches);
 225 }