llvm/tools/llvm-cov/CoverageExporterJson.cpp

   1 //===- CoverageExporterJson.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 JSON.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 //===----------------------------------------------------------------------===//
  14 //
  15 // The json code coverage export follows the following format
  16 // Root: dict => Root Element containing metadata
  17 // -- Data: array => Homogeneous array of one or more export objects
  18 //   -- Export: dict => Json representation of one CoverageMapping
  19 //     -- Files: array => List of objects describing coverage for files
  20 //       -- File: dict => Coverage for a single file
  21 //         -- Branches: array => List of Branches in the file
  22 //           -- Branch: dict => Describes a branch of the file with counters
  23 //         -- MCDC Records: array => List of MCDC records in the file
  24 //           -- MCDC Values: array => List of T/F covered condition values
  25 //         -- Segments: array => List of Segments contained in the file
  26 //           -- Segment: dict => Describes a segment of the file with a counter
  27 //         -- Expansions: array => List of expansion records
  28 //           -- Expansion: dict => Object that descibes a single expansion
  29 //             -- CountedRegion: dict => The region to be expanded
  30 //             -- TargetRegions: array => List of Regions in the expansion
  31 //               -- CountedRegion: dict => Single Region in the expansion
  32 //             -- Branches: array => List of Branches in the expansion
  33 //               -- Branch: dict => Describes a branch in expansion and counters
  34 //         -- Summary: dict => Object summarizing the coverage for this file
  35 //           -- LineCoverage: dict => Object summarizing line coverage
  36 //           -- FunctionCoverage: dict => Object summarizing function coverage
  37 //           -- RegionCoverage: dict => Object summarizing region coverage
  38 //           -- BranchCoverage: dict => Object summarizing branch coverage
  39 //           -- MCDCCoverage: dict => Object summarizing MC/DC coverage
  40 //     -- Functions: array => List of objects describing coverage for functions
  41 //       -- Function: dict => Coverage info for a single function
  42 //         -- Filenames: array => List of filenames that the function relates to
  43 //   -- Summary: dict => Object summarizing the coverage for the entire binary
  44 //     -- LineCoverage: dict => Object summarizing line coverage
  45 //     -- FunctionCoverage: dict => Object summarizing function coverage
  46 //     -- InstantiationCoverage: dict => Object summarizing inst. coverage
  47 //     -- RegionCoverage: dict => Object summarizing region coverage
  48 //     -- BranchCoverage: dict => Object summarizing branch coverage
  49 //     -- MCDCCoverage: dict => Object summarizing MC/DC coverage
  50 //
  51 //===----------------------------------------------------------------------===//
  52
  53 #include "CoverageExporterJson.h"
  54 #include "CoverageReport.h"
  55 #include "llvm/ADT/StringRef.h"
  56 #include "llvm/Support/JSON.h"
  57 #include "llvm/Support/ThreadPool.h"
  58 #include "llvm/Support/Threading.h"
  59 #include <algorithm>
  60 #include <limits>
  61 #include <mutex>
  62 #include <utility>
  63
  64 /// The semantic version combined as a string.
  65 #define LLVM_COVERAGE_EXPORT_JSON_STR "2.0.1"
  66
  67 /// Unique type identifier for JSON coverage export.
  68 #define LLVM_COVERAGE_EXPORT_JSON_TYPE_STR "llvm.coverage.json.export"
  69
  70 using namespace llvm;
  71
  72 namespace {
  73
  74 // The JSON library accepts int64_t, but profiling counts are stored as uint64_t.
  75 // Therefore we need to explicitly convert from unsigned to signed, since a naive
  76 // cast is implementation-defined behavior when the unsigned value cannot be
  77 // represented as a signed value. We choose to clamp the values to preserve the
  78 // invariant that counts are always >= 0.
  79 int64_t clamp_uint64_to_int64(uint64_t u) {
  80   return std::min(u, static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
  81 }
  82
  83 json::Array renderSegment(const coverage::CoverageSegment &Segment) {
  84   return json::Array({Segment.Line, Segment.Col,
  85                       clamp_uint64_to_int64(Segment.Count), Segment.HasCount,
  86                       Segment.IsRegionEntry, Segment.IsGapRegion});
  87 }
  88
  89 json::Array renderRegion(const coverage::CountedRegion &Region) {
  90   return json::Array({Region.LineStart, Region.ColumnStart, Region.LineEnd,
  91                       Region.ColumnEnd, clamp_uint64_to_int64(Region.ExecutionCount),
  92                       Region.FileID, Region.ExpandedFileID,
  93                       int64_t(Region.Kind)});
  94 }
  95
  96 json::Array renderBranch(const coverage::CountedRegion &Region) {
  97   return json::Array(
  98       {Region.LineStart, Region.ColumnStart, Region.LineEnd, Region.ColumnEnd,
  99        clamp_uint64_to_int64(Region.ExecutionCount),
 100        clamp_uint64_to_int64(Region.FalseExecutionCount), Region.FileID,
 101        Region.ExpandedFileID, int64_t(Region.Kind)});
 102 }
 103
 104 json::Array gatherConditions(const coverage::MCDCRecord &Record) {
 105   json::Array Conditions;
 106   for (unsigned c = 0; c < Record.getNumConditions(); c++)
 107     Conditions.push_back(Record.isConditionIndependencePairCovered(c));
 108   return Conditions;
 109 }
 110
 111 json::Array renderMCDCRecord(const coverage::MCDCRecord &Record) {
 112   const llvm::coverage::CounterMappingRegion &CMR = Record.getDecisionRegion();
 113   return json::Array({CMR.LineStart, CMR.ColumnStart, CMR.LineEnd,
 114                       CMR.ColumnEnd, CMR.ExpandedFileID, int64_t(CMR.Kind),
 115                       gatherConditions(Record)});
 116 }
 117
 118 json::Array renderRegions(ArrayRef<coverage::CountedRegion> Regions) {
 119   json::Array RegionArray;
 120   for (const auto &Region : Regions)
 121     RegionArray.push_back(renderRegion(Region));
 122   return RegionArray;
 123 }
 124
 125 json::Array renderBranchRegions(ArrayRef<coverage::CountedRegion> Regions) {
 126   json::Array RegionArray;
 127   for (const auto &Region : Regions)
 128     if (!Region.TrueFolded || !Region.FalseFolded)
 129       RegionArray.push_back(renderBranch(Region));
 130   return RegionArray;
 131 }
 132
 133 json::Array renderMCDCRecords(ArrayRef<coverage::MCDCRecord> Records) {
 134   json::Array RecordArray;
 135   for (auto &Record : Records)
 136     RecordArray.push_back(renderMCDCRecord(Record));
 137   return RecordArray;
 138 }
 139
 140 std::vector<llvm::coverage::CountedRegion>
 141 collectNestedBranches(const coverage::CoverageMapping &Coverage,
 142                       ArrayRef<llvm::coverage::ExpansionRecord> Expansions) {
 143   std::vector<llvm::coverage::CountedRegion> Branches;
 144   for (const auto &Expansion : Expansions) {
 145     auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
 146
 147     // Recursively collect branches from nested expansions.
 148     auto NestedExpansions = ExpansionCoverage.getExpansions();
 149     auto NestedExBranches = collectNestedBranches(Coverage, NestedExpansions);
 150     append_range(Branches, NestedExBranches);
 151
 152     // Add branches from this level of expansion.
 153     auto ExBranches = ExpansionCoverage.getBranches();
 154     for (auto B : ExBranches)
 155       if (B.FileID == Expansion.FileID)
 156         Branches.push_back(B);
 157   }
 158
 159   return Branches;
 160 }
 161
 162 json::Object renderExpansion(const coverage::CoverageMapping &Coverage,
 163                              const coverage::ExpansionRecord &Expansion) {
 164   std::vector<llvm::coverage::ExpansionRecord> Expansions = {Expansion};
 165   return json::Object(
 166       {{"filenames", json::Array(Expansion.Function.Filenames)},
 167        // Mark the beginning and end of this expansion in the source file.
 168        {"source_region", renderRegion(Expansion.Region)},
 169        // Enumerate the coverage information for the expansion.
 170        {"target_regions", renderRegions(Expansion.Function.CountedRegions)},
 171        // Enumerate the branch coverage information for the expansion.
 172        {"branches",
 173         renderBranchRegions(collectNestedBranches(Coverage, Expansions))}});
 174 }
 175
 176 json::Object renderSummary(const FileCoverageSummary &Summary) {
 177   return json::Object(
 178       {{"lines",
 179         json::Object({{"count", int64_t(Summary.LineCoverage.getNumLines())},
 180                       {"covered", int64_t(Summary.LineCoverage.getCovered())},
 181                       {"percent", Summary.LineCoverage.getPercentCovered()}})},
 182        {"functions",
 183         json::Object(
 184             {{"count", int64_t(Summary.FunctionCoverage.getNumFunctions())},
 185              {"covered", int64_t(Summary.FunctionCoverage.getExecuted())},
 186              {"percent", Summary.FunctionCoverage.getPercentCovered()}})},
 187        {"instantiations",
 188         json::Object(
 189             {{"count",
 190               int64_t(Summary.InstantiationCoverage.getNumFunctions())},
 191              {"covered", int64_t(Summary.InstantiationCoverage.getExecuted())},
 192              {"percent", Summary.InstantiationCoverage.getPercentCovered()}})},
 193        {"regions",
 194         json::Object(
 195             {{"count", int64_t(Summary.RegionCoverage.getNumRegions())},
 196              {"covered", int64_t(Summary.RegionCoverage.getCovered())},
 197              {"notcovered", int64_t(Summary.RegionCoverage.getNumRegions() -
 198                                     Summary.RegionCoverage.getCovered())},
 199              {"percent", Summary.RegionCoverage.getPercentCovered()}})},
 200        {"branches",
 201         json::Object(
 202             {{"count", int64_t(Summary.BranchCoverage.getNumBranches())},
 203              {"covered", int64_t(Summary.BranchCoverage.getCovered())},
 204              {"notcovered", int64_t(Summary.BranchCoverage.getNumBranches() -
 205                                     Summary.BranchCoverage.getCovered())},
 206              {"percent", Summary.BranchCoverage.getPercentCovered()}})},
 207        {"mcdc",
 208         json::Object(
 209             {{"count", int64_t(Summary.MCDCCoverage.getNumPairs())},
 210              {"covered", int64_t(Summary.MCDCCoverage.getCoveredPairs())},
 211              {"notcovered", int64_t(Summary.MCDCCoverage.getNumPairs() -
 212                                     Summary.MCDCCoverage.getCoveredPairs())},
 213              {"percent", Summary.MCDCCoverage.getPercentCovered()}})}});
 214 }
 215
 216 json::Array renderFileExpansions(const coverage::CoverageMapping &Coverage,
 217                                  const coverage::CoverageData &FileCoverage,
 218                                  const FileCoverageSummary &FileReport) {
 219   json::Array ExpansionArray;
 220   for (const auto &Expansion : FileCoverage.getExpansions())
 221     ExpansionArray.push_back(renderExpansion(Coverage, Expansion));
 222   return ExpansionArray;
 223 }
 224
 225 json::Array renderFileSegments(const coverage::CoverageData &FileCoverage,
 226                                const FileCoverageSummary &FileReport) {
 227   json::Array SegmentArray;
 228   for (const auto &Segment : FileCoverage)
 229     SegmentArray.push_back(renderSegment(Segment));
 230   return SegmentArray;
 231 }
 232
 233 json::Array renderFileBranches(const coverage::CoverageData &FileCoverage,
 234                                const FileCoverageSummary &FileReport) {
 235   json::Array BranchArray;
 236   for (const auto &Branch : FileCoverage.getBranches())
 237     BranchArray.push_back(renderBranch(Branch));
 238   return BranchArray;
 239 }
 240
 241 json::Array renderFileMCDC(const coverage::CoverageData &FileCoverage,
 242                            const FileCoverageSummary &FileReport) {
 243   json::Array MCDCRecordArray;
 244   for (const auto &Record : FileCoverage.getMCDCRecords())
 245     MCDCRecordArray.push_back(renderMCDCRecord(Record));
 246   return MCDCRecordArray;
 247 }
 248
 249 json::Object renderFile(const coverage::CoverageMapping &Coverage,
 250                         const std::string &Filename,
 251                         const FileCoverageSummary &FileReport,
 252                         const CoverageViewOptions &Options) {
 253   json::Object File({{"filename", Filename}});
 254   if (!Options.ExportSummaryOnly) {
 255     // Calculate and render detailed coverage information for given file.
 256     auto FileCoverage = Coverage.getCoverageForFile(Filename);
 257     File["segments"] = renderFileSegments(FileCoverage, FileReport);
 258     File["branches"] = renderFileBranches(FileCoverage, FileReport);
 259     File["mcdc_records"] = renderFileMCDC(FileCoverage, FileReport);
 260     if (!Options.SkipExpansions) {
 261       File["expansions"] =
 262           renderFileExpansions(Coverage, FileCoverage, FileReport);
 263     }
 264   }
 265   File["summary"] = renderSummary(FileReport);
 266   return File;
 267 }
 268
 269 json::Array renderFiles(const coverage::CoverageMapping &Coverage,
 270                         ArrayRef<std::string> SourceFiles,
 271                         ArrayRef<FileCoverageSummary> FileReports,
 272                         const CoverageViewOptions &Options) {
 273   ThreadPoolStrategy S = hardware_concurrency(Options.NumThreads);
 274   if (Options.NumThreads == 0) {
 275     // If NumThreads is not specified, create one thread for each input, up to
 276     // the number of hardware cores.
 277     S = heavyweight_hardware_concurrency(SourceFiles.size());
 278     S.Limit = true;
 279   }
 280   DefaultThreadPool Pool(S);
 281   json::Array FileArray;
 282   std::mutex FileArrayMutex;
 283
 284   for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I) {
 285     auto &SourceFile = SourceFiles[I];
 286     auto &FileReport = FileReports[I];
 287     Pool.async([&] {
 288       auto File = renderFile(Coverage, SourceFile, FileReport, Options);
 289       {
 290         std::lock_guard<std::mutex> Lock(FileArrayMutex);
 291         FileArray.push_back(std::move(File));
 292       }
 293     });
 294   }
 295   Pool.wait();
 296   return FileArray;
 297 }
 298
 299 json::Array renderFunctions(
 300     const iterator_range<coverage::FunctionRecordIterator> &Functions) {
 301   json::Array FunctionArray;
 302   for (const auto &F : Functions)
 303     FunctionArray.push_back(
 304         json::Object({{"name", F.Name},
 305                       {"count", clamp_uint64_to_int64(F.ExecutionCount)},
 306                       {"regions", renderRegions(F.CountedRegions)},
 307                       {"branches", renderBranchRegions(F.CountedBranchRegions)},
 308                       {"mcdc_records", renderMCDCRecords(F.MCDCRecords)},
 309                       {"filenames", json::Array(F.Filenames)}}));
 310   return FunctionArray;
 311 }
 312
 313 } // end anonymous namespace
 314
 315 void CoverageExporterJson::renderRoot(const CoverageFilters &IgnoreFilters) {
 316   std::vector<std::string> SourceFiles;
 317   for (StringRef SF : Coverage.getUniqueSourceFiles()) {
 318     if (!IgnoreFilters.matchesFilename(SF))
 319       SourceFiles.emplace_back(SF);
 320   }
 321   renderRoot(SourceFiles);
 322 }
 323
 324 void CoverageExporterJson::renderRoot(ArrayRef<std::string> SourceFiles) {
 325   FileCoverageSummary Totals = FileCoverageSummary("Totals");
 326   auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
 327                                                         SourceFiles, Options);
 328   auto Files = renderFiles(Coverage, SourceFiles, FileReports, Options);
 329   // Sort files in order of their names.
 330   llvm::sort(Files, [](const json::Value &A, const json::Value &B) {
 331     const json::Object *ObjA = A.getAsObject();
 332     const json::Object *ObjB = B.getAsObject();
 333     assert(ObjA != nullptr && "Value A was not an Object");
 334     assert(ObjB != nullptr && "Value B was not an Object");
 335     const StringRef FilenameA = *ObjA->getString("filename");
 336     const StringRef FilenameB = *ObjB->getString("filename");
 337     return FilenameA.compare(FilenameB) < 0;
 338   });
 339   auto Export = json::Object(
 340       {{"files", std::move(Files)}, {"totals", renderSummary(Totals)}});
 341   // Skip functions-level information  if necessary.
 342   if (!Options.ExportSummaryOnly && !Options.SkipFunctions)
 343     Export["functions"] = renderFunctions(Coverage.getCoveredFunctions());
 344
 345   auto ExportArray = json::Array({std::move(Export)});
 346
 347   OS << json::Object({{"version", LLVM_COVERAGE_EXPORT_JSON_STR},
 348                       {"type", LLVM_COVERAGE_EXPORT_JSON_TYPE_STR},
 349                       {"data", std::move(ExportArray)}});
 350 }