1 //===- CoverageExporterJson.cpp - Code coverage export --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements export of code coverage data to JSON.
12 //===----------------------------------------------------------------------===//
14 //===----------------------------------------------------------------------===//
16 // The json code coverage export follows the following format
17 // Root: dict => Root Element containing metadata
18 // -- Data: array => Homogeneous array of one or more export objects
19 // ---- Export: dict => Json representation of one CoverageMapping
20 // ------ Files: array => List of objects describing coverage for files
21 // -------- File: dict => Coverage for a single file
22 // ---------- Segments: array => List of Segments contained in the file
23 // ------------ Segment: dict => Describes a segment of the file with a counter
24 // ---------- Expansions: array => List of expansion records
25 // ------------ Expansion: dict => Object that descibes a single expansion
26 // -------------- CountedRegion: dict => The region to be expanded
27 // -------------- TargetRegions: array => List of Regions in the expansion
28 // ---------------- CountedRegion: dict => Single Region in the expansion
29 // ---------- Summary: dict => Object summarizing the coverage for this file
30 // ------------ LineCoverage: dict => Object summarizing line coverage
31 // ------------ FunctionCoverage: dict => Object summarizing function coverage
32 // ------------ RegionCoverage: dict => Object summarizing region coverage
33 // ------ Functions: array => List of objects describing coverage for functions
34 // -------- Function: dict => Coverage info for a single function
35 // ---------- Filenames: array => List of filenames that the function relates to
36 // ---- Summary: dict => Object summarizing the coverage for the entire binary
37 // ------ LineCoverage: dict => Object summarizing line coverage
38 // ------ FunctionCoverage: dict => Object summarizing function coverage
39 // ------ InstantiationCoverage: dict => Object summarizing inst. coverage
40 // ------ RegionCoverage: dict => Object summarizing region coverage
42 //===----------------------------------------------------------------------===//
44 #include "CoverageExporterJson.h"
45 #include "CoverageReport.h"
47 /// The semantic version combined as a string.
48 #define LLVM_COVERAGE_EXPORT_JSON_STR "2.0.0"
50 /// Unique type identifier for JSON coverage export.
51 #define LLVM_COVERAGE_EXPORT_JSON_TYPE_STR "llvm.coverage.json.export"
55 CoverageExporterJson::CoverageExporterJson(
56 const coverage::CoverageMapping &CoverageMapping,
57 const CoverageViewOptions &Options, raw_ostream &OS)
58 : CoverageExporter(CoverageMapping, Options, OS) {
59 State.push(JsonState::None);
62 void CoverageExporterJson::emitSerialized(const int64_t Value) { OS << Value; }
64 void CoverageExporterJson::emitSerialized(const std::string &Value) {
66 for (char C : Value) {
75 void CoverageExporterJson::emitComma() {
76 if (State.top() == JsonState::NonEmptyElement) {
78 } else if (State.top() == JsonState::EmptyElement) {
80 assert((State.size() >= 1) && "Closed too many JSON elements");
81 State.push(JsonState::NonEmptyElement);
85 void CoverageExporterJson::emitDictStart() {
87 State.push(JsonState::EmptyElement);
91 void CoverageExporterJson::emitDictKey(const std::string &Key) {
96 assert((State.size() >= 1) && "Closed too many JSON elements");
98 // We do not want to emit a comma after this key.
99 State.push(JsonState::EmptyElement);
102 void CoverageExporterJson::emitDictEnd() {
104 assert((State.size() >= 1) && "Closed too many JSON elements");
108 void CoverageExporterJson::emitArrayStart() {
110 State.push(JsonState::EmptyElement);
114 void CoverageExporterJson::emitArrayEnd() {
116 assert((State.size() >= 1) && "Closed too many JSON elements");
120 void CoverageExporterJson::renderRoot(
121 const CoverageFilters &IgnoreFilenameFilters) {
122 std::vector<std::string> SourceFiles;
123 for (StringRef SF : Coverage.getUniqueSourceFiles()) {
124 if (!IgnoreFilenameFilters.matchesFilename(SF))
125 SourceFiles.emplace_back(SF);
127 renderRoot(SourceFiles);
130 void CoverageExporterJson::renderRoot(
131 const std::vector<std::string> &SourceFiles) {
132 // Start Root of JSON object.
135 emitDictElement("version", LLVM_COVERAGE_EXPORT_JSON_STR);
136 emitDictElement("type", LLVM_COVERAGE_EXPORT_JSON_TYPE_STR);
139 // Start List of Exports.
145 emitDictKey("files");
147 FileCoverageSummary Totals = FileCoverageSummary("Totals");
148 auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
149 SourceFiles, Options);
150 renderFiles(SourceFiles, FileReports);
152 // Skip functions-level information for summary-only export mode.
153 if (!Options.ExportSummaryOnly) {
154 emitDictKey("functions");
155 renderFunctions(Coverage.getCoveredFunctions());
158 emitDictKey("totals");
159 renderSummary(Totals);
164 // End List of Exports.
167 // End Root of JSON Object.
170 assert((State.top() == JsonState::None) &&
171 "All Elements In JSON were Closed");
174 void CoverageExporterJson::renderFunctions(
175 const iterator_range<coverage::FunctionRecordIterator> &Functions) {
176 // Start List of Functions.
179 for (const auto &Function : Functions) {
183 emitDictElement("name", Function.Name);
184 emitDictElement("count", Function.ExecutionCount);
185 emitDictKey("regions");
187 renderRegions(Function.CountedRegions);
189 emitDictKey("filenames");
191 // Start Filenames for Function.
194 for (const auto &FileName : Function.Filenames)
195 emitArrayElement(FileName);
197 // End Filenames for Function.
204 // End List of Functions.
208 void CoverageExporterJson::renderFiles(
209 ArrayRef<std::string> SourceFiles,
210 ArrayRef<FileCoverageSummary> FileReports) {
211 // Start List of Files.
214 for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I) {
215 renderFile(SourceFiles[I], FileReports[I]);
218 // End List of Files.
222 void CoverageExporterJson::renderFile(const std::string &Filename,
223 const FileCoverageSummary &FileReport) {
227 emitDictElement("filename", Filename);
229 if (!Options.ExportSummaryOnly) {
230 // Calculate and render detailed coverage information for given file.
231 auto FileCoverage = Coverage.getCoverageForFile(Filename);
232 renderFileCoverage(FileCoverage, FileReport);
235 emitDictKey("summary");
236 renderSummary(FileReport);
243 void CoverageExporterJson::renderFileCoverage(
244 const coverage::CoverageData &FileCoverage,
245 const FileCoverageSummary &FileReport) {
246 emitDictKey("segments");
248 // Start List of Segments.
251 for (const auto &Segment : FileCoverage)
252 renderSegment(Segment);
254 // End List of Segments.
257 emitDictKey("expansions");
259 // Start List of Expansions.
262 for (const auto &Expansion : FileCoverage.getExpansions())
263 renderExpansion(Expansion);
265 // End List of Expansions.
269 void CoverageExporterJson::renderSegment(
270 const coverage::CoverageSegment &Segment) {
274 emitArrayElement(Segment.Line);
275 emitArrayElement(Segment.Col);
276 emitArrayElement(Segment.Count);
277 emitArrayElement(Segment.HasCount);
278 emitArrayElement(Segment.IsRegionEntry);
284 void CoverageExporterJson::renderExpansion(
285 const coverage::ExpansionRecord &Expansion) {
289 // Mark the beginning and end of this expansion in the source file.
290 emitDictKey("source_region");
291 renderRegion(Expansion.Region);
293 // Enumerate the coverage information for the expansion.
294 emitDictKey("target_regions");
295 renderRegions(Expansion.Function.CountedRegions);
297 emitDictKey("filenames");
298 // Start List of Filenames to map the fileIDs.
300 for (const auto &Filename : Expansion.Function.Filenames)
301 emitArrayElement(Filename);
302 // End List of Filenames.
309 void CoverageExporterJson::renderRegions(
310 ArrayRef<coverage::CountedRegion> Regions) {
311 // Start List of Regions.
314 for (const auto &Region : Regions)
315 renderRegion(Region);
317 // End List of Regions.
321 void CoverageExporterJson::renderRegion(const coverage::CountedRegion &Region) {
322 // Start CountedRegion.
325 emitArrayElement(Region.LineStart);
326 emitArrayElement(Region.ColumnStart);
327 emitArrayElement(Region.LineEnd);
328 emitArrayElement(Region.ColumnEnd);
329 emitArrayElement(Region.ExecutionCount);
330 emitArrayElement(Region.FileID);
331 emitArrayElement(Region.ExpandedFileID);
332 emitArrayElement(Region.Kind);
334 // End CountedRegion.
338 void CoverageExporterJson::renderSummary(const FileCoverageSummary &Summary) {
339 // Start Summary for the file.
342 emitDictKey("lines");
344 // Start Line Coverage Summary.
346 emitDictElement("count", Summary.LineCoverage.getNumLines());
347 emitDictElement("covered", Summary.LineCoverage.getCovered());
348 emitDictElement("percent", Summary.LineCoverage.getPercentCovered());
349 // End Line Coverage Summary.
352 emitDictKey("functions");
354 // Start Function Coverage Summary.
356 emitDictElement("count", Summary.FunctionCoverage.getNumFunctions());
357 emitDictElement("covered", Summary.FunctionCoverage.getExecuted());
358 emitDictElement("percent", Summary.FunctionCoverage.getPercentCovered());
359 // End Function Coverage Summary.
362 emitDictKey("instantiations");
364 // Start Instantiation Coverage Summary.
366 emitDictElement("count", Summary.InstantiationCoverage.getNumFunctions());
367 emitDictElement("covered", Summary.InstantiationCoverage.getExecuted());
368 emitDictElement("percent", Summary.InstantiationCoverage.getPercentCovered());
369 // End Function Coverage Summary.
372 emitDictKey("regions");
374 // Start Region Coverage Summary.
376 emitDictElement("count", Summary.RegionCoverage.getNumRegions());
377 emitDictElement("covered", Summary.RegionCoverage.getCovered());
378 emitDictElement("notcovered", Summary.RegionCoverage.getNumRegions() -
379 Summary.RegionCoverage.getCovered());
380 emitDictElement("percent", Summary.RegionCoverage.getPercentCovered());
381 // End Region Coverage Summary.
384 // End Summary for the file.