xref: /freebsd/contrib/llvm-project/llvm/tools/llvm-cov/CoverageExporterJson.cpp (revision 6966ac055c3b7a39266fb982493330df7a097997)
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 //         -- Segments: array => List of Segments contained in the file
22 //           -- Segment: dict => Describes a segment of the file with a counter
23 //         -- Expansions: array => List of expansion records
24 //           -- Expansion: dict => Object that descibes a single expansion
25 //             -- CountedRegion: dict => The region to be expanded
26 //             -- TargetRegions: array => List of Regions in the expansion
27 //               -- CountedRegion: dict => Single Region in the expansion
28 //         -- Summary: dict => Object summarizing the coverage for this file
29 //           -- LineCoverage: dict => Object summarizing line coverage
30 //           -- FunctionCoverage: dict => Object summarizing function coverage
31 //           -- RegionCoverage: dict => Object summarizing region coverage
32 //     -- Functions: array => List of objects describing coverage for functions
33 //       -- Function: dict => Coverage info for a single function
34 //         -- Filenames: array => List of filenames that the function relates to
35 //   -- Summary: dict => Object summarizing the coverage for the entire binary
36 //     -- LineCoverage: dict => Object summarizing line coverage
37 //     -- FunctionCoverage: dict => Object summarizing function coverage
38 //     -- InstantiationCoverage: dict => Object summarizing inst. coverage
39 //     -- RegionCoverage: dict => Object summarizing region coverage
40 //
41 //===----------------------------------------------------------------------===//
42 
43 #include "CoverageExporterJson.h"
44 #include "CoverageReport.h"
45 #include "llvm/ADT/Optional.h"
46 #include "llvm/ADT/StringRef.h"
47 #include "llvm/Support/JSON.h"
48 #include "llvm/Support/ThreadPool.h"
49 #include "llvm/Support/Threading.h"
50 #include <algorithm>
51 #include <mutex>
52 #include <utility>
53 
54 /// The semantic version combined as a string.
55 #define LLVM_COVERAGE_EXPORT_JSON_STR "2.0.0"
56 
57 /// Unique type identifier for JSON coverage export.
58 #define LLVM_COVERAGE_EXPORT_JSON_TYPE_STR "llvm.coverage.json.export"
59 
60 using namespace llvm;
61 
62 namespace {
63 
64 json::Array renderSegment(const coverage::CoverageSegment &Segment) {
65   return json::Array({Segment.Line, Segment.Col, int64_t(Segment.Count),
66                       Segment.HasCount, Segment.IsRegionEntry});
67 }
68 
69 json::Array renderRegion(const coverage::CountedRegion &Region) {
70   return json::Array({Region.LineStart, Region.ColumnStart, Region.LineEnd,
71                       Region.ColumnEnd, int64_t(Region.ExecutionCount),
72                       Region.FileID, Region.ExpandedFileID,
73                       int64_t(Region.Kind)});
74 }
75 
76 json::Array renderRegions(ArrayRef<coverage::CountedRegion> Regions) {
77   json::Array RegionArray;
78   for (const auto &Region : Regions)
79     RegionArray.push_back(renderRegion(Region));
80   return RegionArray;
81 }
82 
83 json::Object renderExpansion(const coverage::ExpansionRecord &Expansion) {
84   return json::Object(
85       {{"filenames", json::Array(Expansion.Function.Filenames)},
86        // Mark the beginning and end of this expansion in the source file.
87        {"source_region", renderRegion(Expansion.Region)},
88        // Enumerate the coverage information for the expansion.
89        {"target_regions", renderRegions(Expansion.Function.CountedRegions)}});
90 }
91 
92 json::Object renderSummary(const FileCoverageSummary &Summary) {
93   return json::Object(
94       {{"lines",
95         json::Object({{"count", int64_t(Summary.LineCoverage.getNumLines())},
96                       {"covered", int64_t(Summary.LineCoverage.getCovered())},
97                       {"percent", Summary.LineCoverage.getPercentCovered()}})},
98        {"functions",
99         json::Object(
100             {{"count", int64_t(Summary.FunctionCoverage.getNumFunctions())},
101              {"covered", int64_t(Summary.FunctionCoverage.getExecuted())},
102              {"percent", Summary.FunctionCoverage.getPercentCovered()}})},
103        {"instantiations",
104         json::Object(
105             {{"count",
106               int64_t(Summary.InstantiationCoverage.getNumFunctions())},
107              {"covered", int64_t(Summary.InstantiationCoverage.getExecuted())},
108              {"percent", Summary.InstantiationCoverage.getPercentCovered()}})},
109        {"regions",
110         json::Object(
111             {{"count", int64_t(Summary.RegionCoverage.getNumRegions())},
112              {"covered", int64_t(Summary.RegionCoverage.getCovered())},
113              {"notcovered", int64_t(Summary.RegionCoverage.getNumRegions() -
114                                     Summary.RegionCoverage.getCovered())},
115              {"percent", Summary.RegionCoverage.getPercentCovered()}})}});
116 }
117 
118 json::Array renderFileExpansions(const coverage::CoverageData &FileCoverage,
119                                  const FileCoverageSummary &FileReport) {
120   json::Array ExpansionArray;
121   for (const auto &Expansion : FileCoverage.getExpansions())
122     ExpansionArray.push_back(renderExpansion(Expansion));
123   return ExpansionArray;
124 }
125 
126 json::Array renderFileSegments(const coverage::CoverageData &FileCoverage,
127                                const FileCoverageSummary &FileReport) {
128   json::Array SegmentArray;
129   for (const auto &Segment : FileCoverage)
130     SegmentArray.push_back(renderSegment(Segment));
131   return SegmentArray;
132 }
133 
134 json::Object renderFile(const coverage::CoverageMapping &Coverage,
135                         const std::string &Filename,
136                         const FileCoverageSummary &FileReport,
137                         const CoverageViewOptions &Options) {
138   json::Object File({{"filename", Filename}});
139   if (!Options.ExportSummaryOnly) {
140     // Calculate and render detailed coverage information for given file.
141     auto FileCoverage = Coverage.getCoverageForFile(Filename);
142     File["segments"] = renderFileSegments(FileCoverage, FileReport);
143     if (!Options.SkipExpansions) {
144       File["expansions"] = renderFileExpansions(FileCoverage, FileReport);
145     }
146   }
147   File["summary"] = renderSummary(FileReport);
148   return File;
149 }
150 
151 json::Array renderFiles(const coverage::CoverageMapping &Coverage,
152                         ArrayRef<std::string> SourceFiles,
153                         ArrayRef<FileCoverageSummary> FileReports,
154                         const CoverageViewOptions &Options) {
155   auto NumThreads = Options.NumThreads;
156   if (NumThreads == 0) {
157     NumThreads = std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),
158                                        unsigned(SourceFiles.size())));
159   }
160   ThreadPool Pool(NumThreads);
161   json::Array FileArray;
162   std::mutex FileArrayMutex;
163 
164   for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I) {
165     auto &SourceFile = SourceFiles[I];
166     auto &FileReport = FileReports[I];
167     Pool.async([&] {
168       auto File = renderFile(Coverage, SourceFile, FileReport, Options);
169       {
170         std::lock_guard<std::mutex> Lock(FileArrayMutex);
171         FileArray.push_back(std::move(File));
172       }
173     });
174   }
175   Pool.wait();
176   return FileArray;
177 }
178 
179 json::Array renderFunctions(
180     const iterator_range<coverage::FunctionRecordIterator> &Functions) {
181   json::Array FunctionArray;
182   for (const auto &F : Functions)
183     FunctionArray.push_back(
184         json::Object({{"name", F.Name},
185                       {"count", int64_t(F.ExecutionCount)},
186                       {"regions", renderRegions(F.CountedRegions)},
187                       {"filenames", json::Array(F.Filenames)}}));
188   return FunctionArray;
189 }
190 
191 } // end anonymous namespace
192 
193 void CoverageExporterJson::renderRoot(const CoverageFilters &IgnoreFilters) {
194   std::vector<std::string> SourceFiles;
195   for (StringRef SF : Coverage.getUniqueSourceFiles()) {
196     if (!IgnoreFilters.matchesFilename(SF))
197       SourceFiles.emplace_back(SF);
198   }
199   renderRoot(SourceFiles);
200 }
201 
202 void CoverageExporterJson::renderRoot(ArrayRef<std::string> SourceFiles) {
203   FileCoverageSummary Totals = FileCoverageSummary("Totals");
204   auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
205                                                         SourceFiles, Options);
206   auto Files = renderFiles(Coverage, SourceFiles, FileReports, Options);
207   // Sort files in order of their names.
208   std::sort(Files.begin(), Files.end(),
209     [](const json::Value &A, const json::Value &B) {
210       const json::Object *ObjA = A.getAsObject();
211       const json::Object *ObjB = B.getAsObject();
212       assert(ObjA != nullptr && "Value A was not an Object");
213       assert(ObjB != nullptr && "Value B was not an Object");
214       const StringRef FilenameA = ObjA->getString("filename").getValue();
215       const StringRef FilenameB = ObjB->getString("filename").getValue();
216       return FilenameA.compare(FilenameB) < 0;
217     });
218   auto Export = json::Object(
219       {{"files", std::move(Files)}, {"totals", renderSummary(Totals)}});
220   // Skip functions-level information  if necessary.
221   if (!Options.ExportSummaryOnly && !Options.SkipFunctions)
222     Export["functions"] = renderFunctions(Coverage.getCoveredFunctions());
223 
224   auto ExportArray = json::Array({std::move(Export)});
225 
226   OS << json::Object({{"version", LLVM_COVERAGE_EXPORT_JSON_STR},
227                       {"type", LLVM_COVERAGE_EXPORT_JSON_TYPE_STR},
228                       {"data", std::move(ExportArray)}});
229 }
230