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