1 | //===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===// |
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 | // The 'CodeCoverageTool' class implements a command line tool to analyze and |
10 | // report coverage information using the profiling instrumentation and code |
11 | // coverage mapping. |
12 | // |
13 | //===----------------------------------------------------------------------===// |
14 | |
15 | #include "CoverageExporterJson.h" |
16 | #include "CoverageExporterLcov.h" |
17 | #include "CoverageFilters.h" |
18 | #include "CoverageReport.h" |
19 | #include "CoverageSummaryInfo.h" |
20 | #include "CoverageViewOptions.h" |
21 | #include "RenderingSupport.h" |
22 | #include "SourceCoverageView.h" |
23 | #include "llvm/ADT/SmallString.h" |
24 | #include "llvm/ADT/StringRef.h" |
25 | #include "llvm/Debuginfod/BuildIDFetcher.h" |
26 | #include "llvm/Debuginfod/Debuginfod.h" |
27 | #include "llvm/Debuginfod/HTTPClient.h" |
28 | #include "llvm/Object/BuildID.h" |
29 | #include "llvm/ProfileData/Coverage/CoverageMapping.h" |
30 | #include "llvm/ProfileData/InstrProfReader.h" |
31 | #include "llvm/Support/CommandLine.h" |
32 | #include "llvm/Support/FileSystem.h" |
33 | #include "llvm/Support/Format.h" |
34 | #include "llvm/Support/MemoryBuffer.h" |
35 | #include "llvm/Support/Path.h" |
36 | #include "llvm/Support/Process.h" |
37 | #include "llvm/Support/Program.h" |
38 | #include "llvm/Support/ScopedPrinter.h" |
39 | #include "llvm/Support/SpecialCaseList.h" |
40 | #include "llvm/Support/ThreadPool.h" |
41 | #include "llvm/Support/Threading.h" |
42 | #include "llvm/Support/ToolOutputFile.h" |
43 | #include "llvm/Support/VirtualFileSystem.h" |
44 | #include "llvm/TargetParser/Triple.h" |
45 | |
46 | #include <functional> |
47 | #include <map> |
48 | #include <optional> |
49 | #include <system_error> |
50 | |
51 | using namespace llvm; |
52 | using namespace coverage; |
53 | |
54 | void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping, |
55 | const CoverageViewOptions &Options, |
56 | raw_ostream &OS); |
57 | |
58 | namespace { |
59 | /// The implementation of the coverage tool. |
60 | class CodeCoverageTool { |
61 | public: |
62 | enum Command { |
63 | /// The show command. |
64 | Show, |
65 | /// The report command. |
66 | Report, |
67 | /// The export command. |
68 | Export |
69 | }; |
70 | |
71 | int run(Command Cmd, int argc, const char **argv); |
72 | |
73 | private: |
74 | /// Print the error message to the error output stream. |
75 | void error(const Twine &Message, StringRef Whence = "" ); |
76 | |
77 | /// Print the warning message to the error output stream. |
78 | void warning(const Twine &Message, StringRef Whence = "" ); |
79 | |
80 | /// Convert \p Path into an absolute path and append it to the list |
81 | /// of collected paths. |
82 | void addCollectedPath(const std::string &Path); |
83 | |
84 | /// If \p Path is a regular file, collect the path. If it's a |
85 | /// directory, recursively collect all of the paths within the directory. |
86 | void collectPaths(const std::string &Path); |
87 | |
88 | /// Check if the two given files are the same file. |
89 | bool isEquivalentFile(StringRef FilePath1, StringRef FilePath2); |
90 | |
91 | /// Retrieve a file status with a cache. |
92 | std::optional<sys::fs::file_status> getFileStatus(StringRef FilePath); |
93 | |
94 | /// Return a memory buffer for the given source file. |
95 | ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile); |
96 | |
97 | /// Create source views for the expansions of the view. |
98 | void attachExpansionSubViews(SourceCoverageView &View, |
99 | ArrayRef<ExpansionRecord> Expansions, |
100 | const CoverageMapping &Coverage); |
101 | |
102 | /// Create source views for the branches of the view. |
103 | void attachBranchSubViews(SourceCoverageView &View, StringRef SourceName, |
104 | ArrayRef<CountedRegion> Branches, |
105 | const MemoryBuffer &File, |
106 | CoverageData &CoverageInfo); |
107 | |
108 | /// Create source views for the MCDC records. |
109 | void attachMCDCSubViews(SourceCoverageView &View, StringRef SourceName, |
110 | ArrayRef<MCDCRecord> MCDCRecords, |
111 | const MemoryBuffer &File, CoverageData &CoverageInfo); |
112 | |
113 | /// Create the source view of a particular function. |
114 | std::unique_ptr<SourceCoverageView> |
115 | createFunctionView(const FunctionRecord &Function, |
116 | const CoverageMapping &Coverage); |
117 | |
118 | /// Create the main source view of a particular source file. |
119 | std::unique_ptr<SourceCoverageView> |
120 | createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage); |
121 | |
122 | /// Load the coverage mapping data. Return nullptr if an error occurred. |
123 | std::unique_ptr<CoverageMapping> load(); |
124 | |
125 | /// Create a mapping from files in the Coverage data to local copies |
126 | /// (path-equivalence). |
127 | void remapPathNames(const CoverageMapping &Coverage); |
128 | |
129 | /// Remove input source files which aren't mapped by \p Coverage. |
130 | void removeUnmappedInputs(const CoverageMapping &Coverage); |
131 | |
132 | /// If a demangler is available, demangle all symbol names. |
133 | void demangleSymbols(const CoverageMapping &Coverage); |
134 | |
135 | /// Write out a source file view to the filesystem. |
136 | void writeSourceFileView(StringRef SourceFile, CoverageMapping *Coverage, |
137 | CoveragePrinter *Printer, bool ShowFilenames); |
138 | |
139 | typedef llvm::function_ref<int(int, const char **)> CommandLineParserType; |
140 | |
141 | int doShow(int argc, const char **argv, |
142 | CommandLineParserType commandLineParser); |
143 | |
144 | int doReport(int argc, const char **argv, |
145 | CommandLineParserType commandLineParser); |
146 | |
147 | int doExport(int argc, const char **argv, |
148 | CommandLineParserType commandLineParser); |
149 | |
150 | std::vector<StringRef> ObjectFilenames; |
151 | CoverageViewOptions ViewOpts; |
152 | CoverageFiltersMatchAll Filters; |
153 | CoverageFilters IgnoreFilenameFilters; |
154 | |
155 | /// True if InputSourceFiles are provided. |
156 | bool HadSourceFiles = false; |
157 | |
158 | /// The path to the indexed profile. |
159 | std::string PGOFilename; |
160 | |
161 | /// A list of input source files. |
162 | std::vector<std::string> SourceFiles; |
163 | |
164 | /// In -path-equivalence mode, this maps the absolute paths from the coverage |
165 | /// mapping data to the input source files. |
166 | StringMap<std::string> RemappedFilenames; |
167 | |
168 | /// The coverage data path to be remapped from, and the source path to be |
169 | /// remapped to, when using -path-equivalence. |
170 | std::optional<std::vector<std::pair<std::string, std::string>>> |
171 | PathRemappings; |
172 | |
173 | /// File status cache used when finding the same file. |
174 | StringMap<std::optional<sys::fs::file_status>> FileStatusCache; |
175 | |
176 | /// The architecture the coverage mapping data targets. |
177 | std::vector<StringRef> CoverageArches; |
178 | |
179 | /// A cache for demangled symbols. |
180 | DemangleCache DC; |
181 | |
182 | /// A lock which guards printing to stderr. |
183 | std::mutex ErrsLock; |
184 | |
185 | /// A container for input source file buffers. |
186 | std::mutex LoadedSourceFilesLock; |
187 | std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>> |
188 | LoadedSourceFiles; |
189 | |
190 | /// Allowlist from -name-allowlist to be used for filtering. |
191 | std::unique_ptr<SpecialCaseList> NameAllowlist; |
192 | |
193 | std::unique_ptr<object::BuildIDFetcher> BIDFetcher; |
194 | |
195 | bool CheckBinaryIDs; |
196 | }; |
197 | } |
198 | |
199 | static std::string getErrorString(const Twine &Message, StringRef Whence, |
200 | bool Warning) { |
201 | std::string Str = (Warning ? "warning" : "error" ); |
202 | Str += ": " ; |
203 | if (!Whence.empty()) |
204 | Str += Whence.str() + ": " ; |
205 | Str += Message.str() + "\n" ; |
206 | return Str; |
207 | } |
208 | |
209 | void CodeCoverageTool::error(const Twine &Message, StringRef Whence) { |
210 | std::unique_lock<std::mutex> Guard{ErrsLock}; |
211 | ViewOpts.colored_ostream(OS&: errs(), Color: raw_ostream::RED) |
212 | << getErrorString(Message, Whence, Warning: false); |
213 | } |
214 | |
215 | void CodeCoverageTool::warning(const Twine &Message, StringRef Whence) { |
216 | std::unique_lock<std::mutex> Guard{ErrsLock}; |
217 | ViewOpts.colored_ostream(OS&: errs(), Color: raw_ostream::RED) |
218 | << getErrorString(Message, Whence, Warning: true); |
219 | } |
220 | |
221 | void CodeCoverageTool::addCollectedPath(const std::string &Path) { |
222 | SmallString<128> EffectivePath(Path); |
223 | if (std::error_code EC = sys::fs::make_absolute(path&: EffectivePath)) { |
224 | error(Message: EC.message(), Whence: Path); |
225 | return; |
226 | } |
227 | sys::path::remove_dots(path&: EffectivePath, /*remove_dot_dot=*/true); |
228 | if (!IgnoreFilenameFilters.matchesFilename(Filename: EffectivePath)) |
229 | SourceFiles.emplace_back(args: EffectivePath.str()); |
230 | HadSourceFiles = !SourceFiles.empty(); |
231 | } |
232 | |
233 | void CodeCoverageTool::collectPaths(const std::string &Path) { |
234 | llvm::sys::fs::file_status Status; |
235 | llvm::sys::fs::status(path: Path, result&: Status); |
236 | if (!llvm::sys::fs::exists(status: Status)) { |
237 | if (PathRemappings) |
238 | addCollectedPath(Path); |
239 | else |
240 | warning(Message: "Source file doesn't exist, proceeded by ignoring it." , Whence: Path); |
241 | return; |
242 | } |
243 | |
244 | if (llvm::sys::fs::is_regular_file(status: Status)) { |
245 | addCollectedPath(Path); |
246 | return; |
247 | } |
248 | |
249 | if (llvm::sys::fs::is_directory(status: Status)) { |
250 | std::error_code EC; |
251 | for (llvm::sys::fs::recursive_directory_iterator F(Path, EC), E; |
252 | F != E; F.increment(ec&: EC)) { |
253 | |
254 | auto Status = F->status(); |
255 | if (!Status) { |
256 | warning(Message: Status.getError().message(), Whence: F->path()); |
257 | continue; |
258 | } |
259 | |
260 | if (Status->type() == llvm::sys::fs::file_type::regular_file) |
261 | addCollectedPath(Path: F->path()); |
262 | } |
263 | } |
264 | } |
265 | |
266 | std::optional<sys::fs::file_status> |
267 | CodeCoverageTool::getFileStatus(StringRef FilePath) { |
268 | auto It = FileStatusCache.try_emplace(Key: FilePath); |
269 | auto &CachedStatus = It.first->getValue(); |
270 | if (!It.second) |
271 | return CachedStatus; |
272 | |
273 | sys::fs::file_status Status; |
274 | if (!sys::fs::status(path: FilePath, result&: Status)) |
275 | CachedStatus = Status; |
276 | return CachedStatus; |
277 | } |
278 | |
279 | bool CodeCoverageTool::isEquivalentFile(StringRef FilePath1, |
280 | StringRef FilePath2) { |
281 | auto Status1 = getFileStatus(FilePath: FilePath1); |
282 | auto Status2 = getFileStatus(FilePath: FilePath2); |
283 | return Status1 && Status2 && sys::fs::equivalent(A: *Status1, B: *Status2); |
284 | } |
285 | |
286 | ErrorOr<const MemoryBuffer &> |
287 | CodeCoverageTool::getSourceFile(StringRef SourceFile) { |
288 | // If we've remapped filenames, look up the real location for this file. |
289 | std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock}; |
290 | if (!RemappedFilenames.empty()) { |
291 | auto Loc = RemappedFilenames.find(Key: SourceFile); |
292 | if (Loc != RemappedFilenames.end()) |
293 | SourceFile = Loc->second; |
294 | } |
295 | for (const auto &Files : LoadedSourceFiles) |
296 | if (isEquivalentFile(FilePath1: SourceFile, FilePath2: Files.first)) |
297 | return *Files.second; |
298 | auto Buffer = MemoryBuffer::getFile(Filename: SourceFile); |
299 | if (auto EC = Buffer.getError()) { |
300 | error(Message: EC.message(), Whence: SourceFile); |
301 | return EC; |
302 | } |
303 | LoadedSourceFiles.emplace_back(args: std::string(SourceFile), |
304 | args: std::move(Buffer.get())); |
305 | return *LoadedSourceFiles.back().second; |
306 | } |
307 | |
308 | void CodeCoverageTool::attachExpansionSubViews( |
309 | SourceCoverageView &View, ArrayRef<ExpansionRecord> Expansions, |
310 | const CoverageMapping &Coverage) { |
311 | if (!ViewOpts.ShowExpandedRegions) |
312 | return; |
313 | for (const auto &Expansion : Expansions) { |
314 | auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion); |
315 | if (ExpansionCoverage.empty()) |
316 | continue; |
317 | auto SourceBuffer = getSourceFile(SourceFile: ExpansionCoverage.getFilename()); |
318 | if (!SourceBuffer) |
319 | continue; |
320 | |
321 | auto SubViewBranches = ExpansionCoverage.getBranches(); |
322 | auto SubViewExpansions = ExpansionCoverage.getExpansions(); |
323 | auto SubView = |
324 | SourceCoverageView::create(SourceName: Expansion.Function.Name, File: SourceBuffer.get(), |
325 | Options: ViewOpts, CoverageInfo: std::move(ExpansionCoverage)); |
326 | attachExpansionSubViews(View&: *SubView, Expansions: SubViewExpansions, Coverage); |
327 | attachBranchSubViews(View&: *SubView, SourceName: Expansion.Function.Name, Branches: SubViewBranches, |
328 | File: SourceBuffer.get(), CoverageInfo&: ExpansionCoverage); |
329 | View.addExpansion(Region: Expansion.Region, View: std::move(SubView)); |
330 | } |
331 | } |
332 | |
333 | void CodeCoverageTool::attachBranchSubViews(SourceCoverageView &View, |
334 | StringRef SourceName, |
335 | ArrayRef<CountedRegion> Branches, |
336 | const MemoryBuffer &File, |
337 | CoverageData &CoverageInfo) { |
338 | if (!ViewOpts.ShowBranchCounts && !ViewOpts.ShowBranchPercents) |
339 | return; |
340 | |
341 | const auto *NextBranch = Branches.begin(); |
342 | const auto *EndBranch = Branches.end(); |
343 | |
344 | // Group branches that have the same line number into the same subview. |
345 | while (NextBranch != EndBranch) { |
346 | SmallVector<CountedRegion, 0> ViewBranches; |
347 | unsigned CurrentLine = NextBranch->LineStart; |
348 | while (NextBranch != EndBranch && CurrentLine == NextBranch->LineStart) |
349 | ViewBranches.push_back(Elt: *NextBranch++); |
350 | |
351 | View.addBranch(Line: CurrentLine, Regions: std::move(ViewBranches), |
352 | View: SourceCoverageView::create(SourceName, File, Options: ViewOpts, |
353 | CoverageInfo: std::move(CoverageInfo))); |
354 | } |
355 | } |
356 | |
357 | void CodeCoverageTool::attachMCDCSubViews(SourceCoverageView &View, |
358 | StringRef SourceName, |
359 | ArrayRef<MCDCRecord> MCDCRecords, |
360 | const MemoryBuffer &File, |
361 | CoverageData &CoverageInfo) { |
362 | if (!ViewOpts.ShowMCDC) |
363 | return; |
364 | |
365 | const auto *NextRecord = MCDCRecords.begin(); |
366 | const auto *EndRecord = MCDCRecords.end(); |
367 | |
368 | // Group and process MCDC records that have the same line number into the |
369 | // same subview. |
370 | while (NextRecord != EndRecord) { |
371 | SmallVector<MCDCRecord, 0> ViewMCDCRecords; |
372 | unsigned CurrentLine = NextRecord->getDecisionRegion().LineEnd; |
373 | while (NextRecord != EndRecord && |
374 | CurrentLine == NextRecord->getDecisionRegion().LineEnd) |
375 | ViewMCDCRecords.push_back(Elt: *NextRecord++); |
376 | |
377 | View.addMCDCRecord(Line: CurrentLine, Records: std::move(ViewMCDCRecords), |
378 | View: SourceCoverageView::create(SourceName, File, Options: ViewOpts, |
379 | CoverageInfo: std::move(CoverageInfo))); |
380 | } |
381 | } |
382 | |
383 | std::unique_ptr<SourceCoverageView> |
384 | CodeCoverageTool::createFunctionView(const FunctionRecord &Function, |
385 | const CoverageMapping &Coverage) { |
386 | auto FunctionCoverage = Coverage.getCoverageForFunction(Function); |
387 | if (FunctionCoverage.empty()) |
388 | return nullptr; |
389 | auto SourceBuffer = getSourceFile(SourceFile: FunctionCoverage.getFilename()); |
390 | if (!SourceBuffer) |
391 | return nullptr; |
392 | |
393 | auto Branches = FunctionCoverage.getBranches(); |
394 | auto Expansions = FunctionCoverage.getExpansions(); |
395 | auto MCDCRecords = FunctionCoverage.getMCDCRecords(); |
396 | auto View = SourceCoverageView::create(SourceName: DC.demangle(Sym: Function.Name), |
397 | File: SourceBuffer.get(), Options: ViewOpts, |
398 | CoverageInfo: std::move(FunctionCoverage)); |
399 | attachExpansionSubViews(View&: *View, Expansions, Coverage); |
400 | attachBranchSubViews(View&: *View, SourceName: DC.demangle(Sym: Function.Name), Branches, |
401 | File: SourceBuffer.get(), CoverageInfo&: FunctionCoverage); |
402 | attachMCDCSubViews(View&: *View, SourceName: DC.demangle(Sym: Function.Name), MCDCRecords, |
403 | File: SourceBuffer.get(), CoverageInfo&: FunctionCoverage); |
404 | |
405 | return View; |
406 | } |
407 | |
408 | std::unique_ptr<SourceCoverageView> |
409 | CodeCoverageTool::createSourceFileView(StringRef SourceFile, |
410 | const CoverageMapping &Coverage) { |
411 | auto SourceBuffer = getSourceFile(SourceFile); |
412 | if (!SourceBuffer) |
413 | return nullptr; |
414 | auto FileCoverage = Coverage.getCoverageForFile(Filename: SourceFile); |
415 | if (FileCoverage.empty()) |
416 | return nullptr; |
417 | |
418 | auto Branches = FileCoverage.getBranches(); |
419 | auto Expansions = FileCoverage.getExpansions(); |
420 | auto MCDCRecords = FileCoverage.getMCDCRecords(); |
421 | auto View = SourceCoverageView::create(SourceName: SourceFile, File: SourceBuffer.get(), |
422 | Options: ViewOpts, CoverageInfo: std::move(FileCoverage)); |
423 | attachExpansionSubViews(View&: *View, Expansions, Coverage); |
424 | attachBranchSubViews(View&: *View, SourceName: SourceFile, Branches, File: SourceBuffer.get(), |
425 | CoverageInfo&: FileCoverage); |
426 | attachMCDCSubViews(View&: *View, SourceName: SourceFile, MCDCRecords, File: SourceBuffer.get(), |
427 | CoverageInfo&: FileCoverage); |
428 | if (!ViewOpts.ShowFunctionInstantiations) |
429 | return View; |
430 | |
431 | for (const auto &Group : Coverage.getInstantiationGroups(Filename: SourceFile)) { |
432 | // Skip functions which have a single instantiation. |
433 | if (Group.size() < 2) |
434 | continue; |
435 | |
436 | for (const FunctionRecord *Function : Group.getInstantiations()) { |
437 | std::unique_ptr<SourceCoverageView> SubView{nullptr}; |
438 | |
439 | StringRef Funcname = DC.demangle(Sym: Function->Name); |
440 | |
441 | if (Function->ExecutionCount > 0) { |
442 | auto SubViewCoverage = Coverage.getCoverageForFunction(Function: *Function); |
443 | auto SubViewExpansions = SubViewCoverage.getExpansions(); |
444 | auto SubViewBranches = SubViewCoverage.getBranches(); |
445 | auto SubViewMCDCRecords = SubViewCoverage.getMCDCRecords(); |
446 | SubView = SourceCoverageView::create( |
447 | SourceName: Funcname, File: SourceBuffer.get(), Options: ViewOpts, CoverageInfo: std::move(SubViewCoverage)); |
448 | attachExpansionSubViews(View&: *SubView, Expansions: SubViewExpansions, Coverage); |
449 | attachBranchSubViews(View&: *SubView, SourceName: SourceFile, Branches: SubViewBranches, |
450 | File: SourceBuffer.get(), CoverageInfo&: SubViewCoverage); |
451 | attachMCDCSubViews(View&: *SubView, SourceName: SourceFile, MCDCRecords: SubViewMCDCRecords, |
452 | File: SourceBuffer.get(), CoverageInfo&: SubViewCoverage); |
453 | } |
454 | |
455 | unsigned FileID = Function->CountedRegions.front().FileID; |
456 | unsigned Line = 0; |
457 | for (const auto &CR : Function->CountedRegions) |
458 | if (CR.FileID == FileID) |
459 | Line = std::max(a: CR.LineEnd, b: Line); |
460 | View->addInstantiation(FunctionName: Funcname, Line, View: std::move(SubView)); |
461 | } |
462 | } |
463 | return View; |
464 | } |
465 | |
466 | static bool modifiedTimeGT(StringRef LHS, StringRef RHS) { |
467 | sys::fs::file_status Status; |
468 | if (sys::fs::status(path: LHS, result&: Status)) |
469 | return false; |
470 | auto LHSTime = Status.getLastModificationTime(); |
471 | if (sys::fs::status(path: RHS, result&: Status)) |
472 | return false; |
473 | auto RHSTime = Status.getLastModificationTime(); |
474 | return LHSTime > RHSTime; |
475 | } |
476 | |
477 | std::unique_ptr<CoverageMapping> CodeCoverageTool::load() { |
478 | for (StringRef ObjectFilename : ObjectFilenames) |
479 | if (modifiedTimeGT(LHS: ObjectFilename, RHS: PGOFilename)) |
480 | warning(Message: "profile data may be out of date - object is newer" , |
481 | Whence: ObjectFilename); |
482 | auto FS = vfs::getRealFileSystem(); |
483 | auto CoverageOrErr = CoverageMapping::load( |
484 | ObjectFilenames, ProfileFilename: PGOFilename, FS&: *FS, Arches: CoverageArches, |
485 | CompilationDir: ViewOpts.CompilationDirectory, BIDFetcher: BIDFetcher.get(), CheckBinaryIDs); |
486 | if (Error E = CoverageOrErr.takeError()) { |
487 | error(Message: "failed to load coverage: " + toString(E: std::move(E))); |
488 | return nullptr; |
489 | } |
490 | auto Coverage = std::move(CoverageOrErr.get()); |
491 | unsigned Mismatched = Coverage->getMismatchedCount(); |
492 | if (Mismatched) { |
493 | warning(Message: Twine(Mismatched) + " functions have mismatched data" ); |
494 | |
495 | if (ViewOpts.Debug) { |
496 | for (const auto &HashMismatch : Coverage->getHashMismatches()) |
497 | errs() << "hash-mismatch: " |
498 | << "No profile record found for '" << HashMismatch.first << "'" |
499 | << " with hash = 0x" << Twine::utohexstr(Val: HashMismatch.second) |
500 | << '\n'; |
501 | } |
502 | } |
503 | |
504 | remapPathNames(Coverage: *Coverage); |
505 | |
506 | if (!SourceFiles.empty()) |
507 | removeUnmappedInputs(Coverage: *Coverage); |
508 | |
509 | demangleSymbols(Coverage: *Coverage); |
510 | |
511 | return Coverage; |
512 | } |
513 | |
514 | void CodeCoverageTool::remapPathNames(const CoverageMapping &Coverage) { |
515 | if (!PathRemappings) |
516 | return; |
517 | |
518 | // Convert remapping paths to native paths with trailing seperators. |
519 | auto nativeWithTrailing = [](StringRef Path) -> std::string { |
520 | if (Path.empty()) |
521 | return "" ; |
522 | SmallString<128> NativePath; |
523 | sys::path::native(path: Path, result&: NativePath); |
524 | sys::path::remove_dots(path&: NativePath, remove_dot_dot: true); |
525 | if (!NativePath.empty() && !sys::path::is_separator(value: NativePath.back())) |
526 | NativePath += sys::path::get_separator(); |
527 | return NativePath.c_str(); |
528 | }; |
529 | |
530 | for (std::pair<std::string, std::string> &PathRemapping : *PathRemappings) { |
531 | std::string RemapFrom = nativeWithTrailing(PathRemapping.first); |
532 | std::string RemapTo = nativeWithTrailing(PathRemapping.second); |
533 | |
534 | // Create a mapping from coverage data file paths to local paths. |
535 | for (StringRef Filename : Coverage.getUniqueSourceFiles()) { |
536 | if (RemappedFilenames.count(Key: Filename) == 1) |
537 | continue; |
538 | |
539 | SmallString<128> NativeFilename; |
540 | sys::path::native(path: Filename, result&: NativeFilename); |
541 | sys::path::remove_dots(path&: NativeFilename, remove_dot_dot: true); |
542 | if (NativeFilename.starts_with(Prefix: RemapFrom)) { |
543 | RemappedFilenames[Filename] = |
544 | RemapTo + NativeFilename.substr(Start: RemapFrom.size()).str(); |
545 | } |
546 | } |
547 | } |
548 | |
549 | // Convert input files from local paths to coverage data file paths. |
550 | StringMap<std::string> InvRemappedFilenames; |
551 | for (const auto &RemappedFilename : RemappedFilenames) |
552 | InvRemappedFilenames[RemappedFilename.getValue()] = |
553 | std::string(RemappedFilename.getKey()); |
554 | |
555 | for (std::string &Filename : SourceFiles) { |
556 | SmallString<128> NativeFilename; |
557 | sys::path::native(path: Filename, result&: NativeFilename); |
558 | auto CovFileName = InvRemappedFilenames.find(Key: NativeFilename); |
559 | if (CovFileName != InvRemappedFilenames.end()) |
560 | Filename = CovFileName->second; |
561 | } |
562 | } |
563 | |
564 | void CodeCoverageTool::removeUnmappedInputs(const CoverageMapping &Coverage) { |
565 | std::vector<StringRef> CoveredFiles = Coverage.getUniqueSourceFiles(); |
566 | |
567 | // The user may have specified source files which aren't in the coverage |
568 | // mapping. Filter these files away. |
569 | llvm::erase_if(C&: SourceFiles, P: [&](const std::string &SF) { |
570 | return !std::binary_search(first: CoveredFiles.begin(), last: CoveredFiles.end(), val: SF); |
571 | }); |
572 | } |
573 | |
574 | void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) { |
575 | if (!ViewOpts.hasDemangler()) |
576 | return; |
577 | |
578 | // Pass function names to the demangler in a temporary file. |
579 | int InputFD; |
580 | SmallString<256> InputPath; |
581 | std::error_code EC = |
582 | sys::fs::createTemporaryFile(Prefix: "demangle-in" , Suffix: "list" , ResultFD&: InputFD, ResultPath&: InputPath); |
583 | if (EC) { |
584 | error(Message: InputPath, Whence: EC.message()); |
585 | return; |
586 | } |
587 | ToolOutputFile InputTOF{InputPath, InputFD}; |
588 | |
589 | unsigned NumSymbols = 0; |
590 | for (const auto &Function : Coverage.getCoveredFunctions()) { |
591 | InputTOF.os() << Function.Name << '\n'; |
592 | ++NumSymbols; |
593 | } |
594 | InputTOF.os().close(); |
595 | |
596 | // Use another temporary file to store the demangler's output. |
597 | int OutputFD; |
598 | SmallString<256> OutputPath; |
599 | EC = sys::fs::createTemporaryFile(Prefix: "demangle-out" , Suffix: "list" , ResultFD&: OutputFD, |
600 | ResultPath&: OutputPath); |
601 | if (EC) { |
602 | error(Message: OutputPath, Whence: EC.message()); |
603 | return; |
604 | } |
605 | ToolOutputFile OutputTOF{OutputPath, OutputFD}; |
606 | OutputTOF.os().close(); |
607 | |
608 | // Invoke the demangler. |
609 | std::vector<StringRef> ArgsV; |
610 | ArgsV.reserve(n: ViewOpts.DemanglerOpts.size()); |
611 | for (StringRef Arg : ViewOpts.DemanglerOpts) |
612 | ArgsV.push_back(x: Arg); |
613 | std::optional<StringRef> Redirects[] = { |
614 | InputPath.str(), OutputPath.str(), {"" }}; |
615 | std::string ErrMsg; |
616 | int RC = |
617 | sys::ExecuteAndWait(Program: ViewOpts.DemanglerOpts[0], Args: ArgsV, |
618 | /*env=*/Env: std::nullopt, Redirects, /*secondsToWait=*/SecondsToWait: 0, |
619 | /*memoryLimit=*/MemoryLimit: 0, ErrMsg: &ErrMsg); |
620 | if (RC) { |
621 | error(Message: ErrMsg, Whence: ViewOpts.DemanglerOpts[0]); |
622 | return; |
623 | } |
624 | |
625 | // Parse the demangler's output. |
626 | auto BufOrError = MemoryBuffer::getFile(Filename: OutputPath); |
627 | if (!BufOrError) { |
628 | error(Message: OutputPath, Whence: BufOrError.getError().message()); |
629 | return; |
630 | } |
631 | |
632 | std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError); |
633 | |
634 | SmallVector<StringRef, 8> Symbols; |
635 | StringRef DemanglerData = DemanglerBuf->getBuffer(); |
636 | DemanglerData.split(A&: Symbols, Separator: '\n', /*MaxSplit=*/NumSymbols, |
637 | /*KeepEmpty=*/false); |
638 | if (Symbols.size() != NumSymbols) { |
639 | error(Message: "demangler did not provide expected number of symbols" ); |
640 | return; |
641 | } |
642 | |
643 | // Cache the demangled names. |
644 | unsigned I = 0; |
645 | for (const auto &Function : Coverage.getCoveredFunctions()) |
646 | // On Windows, lines in the demangler's output file end with "\r\n". |
647 | // Splitting by '\n' keeps '\r's, so cut them now. |
648 | DC.DemangledNames[Function.Name] = std::string(Symbols[I++].rtrim()); |
649 | } |
650 | |
651 | void CodeCoverageTool::writeSourceFileView(StringRef SourceFile, |
652 | CoverageMapping *Coverage, |
653 | CoveragePrinter *Printer, |
654 | bool ShowFilenames) { |
655 | auto View = createSourceFileView(SourceFile, Coverage: *Coverage); |
656 | if (!View) { |
657 | warning(Message: "The file '" + SourceFile + "' isn't covered." ); |
658 | return; |
659 | } |
660 | |
661 | auto OSOrErr = Printer->createViewFile(Path: SourceFile, /*InToplevel=*/false); |
662 | if (Error E = OSOrErr.takeError()) { |
663 | error(Message: "could not create view file!" , Whence: toString(E: std::move(E))); |
664 | return; |
665 | } |
666 | auto OS = std::move(OSOrErr.get()); |
667 | |
668 | View->print(OS&: *OS.get(), /*Wholefile=*/WholeFile: true, |
669 | /*ShowSourceName=*/ShowFilenames, |
670 | /*ShowTitle=*/ViewOpts.hasOutputDirectory()); |
671 | Printer->closeViewFile(OS: std::move(OS)); |
672 | } |
673 | |
674 | int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) { |
675 | cl::opt<std::string> CovFilename( |
676 | cl::Positional, cl::desc("Covered executable or object file." )); |
677 | |
678 | cl::list<std::string> CovFilenames( |
679 | "object" , cl::desc("Coverage executable or object file" )); |
680 | |
681 | cl::opt<bool> DebugDumpCollectedObjects( |
682 | "dump-collected-objects" , cl::Optional, cl::Hidden, |
683 | cl::desc("Show the collected coverage object files" )); |
684 | |
685 | cl::list<std::string> InputSourceFiles("sources" , cl::Positional, |
686 | cl::desc("<Source files>" )); |
687 | |
688 | cl::opt<bool> DebugDumpCollectedPaths( |
689 | "dump-collected-paths" , cl::Optional, cl::Hidden, |
690 | cl::desc("Show the collected paths to source files" )); |
691 | |
692 | cl::opt<std::string, true> PGOFilename( |
693 | "instr-profile" , cl::Required, cl::location(L&: this->PGOFilename), |
694 | cl::desc( |
695 | "File with the profile data obtained after an instrumented run" )); |
696 | |
697 | cl::list<std::string> Arches( |
698 | "arch" , cl::desc("architectures of the coverage mapping binaries" )); |
699 | |
700 | cl::opt<bool> DebugDump("dump" , cl::Optional, |
701 | cl::desc("Show internal debug dump" )); |
702 | |
703 | cl::list<std::string> DebugFileDirectory( |
704 | "debug-file-directory" , |
705 | cl::desc("Directories to search for object files by build ID" )); |
706 | cl::opt<bool> Debuginfod( |
707 | "debuginfod" , cl::ZeroOrMore, |
708 | cl::desc("Use debuginfod to look up object files from profile" ), |
709 | cl::init(Val: canUseDebuginfod())); |
710 | |
711 | cl::opt<CoverageViewOptions::OutputFormat> Format( |
712 | "format" , cl::desc("Output format for line-based coverage reports" ), |
713 | cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text" , |
714 | "Text output" ), |
715 | clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html" , |
716 | "HTML output" ), |
717 | clEnumValN(CoverageViewOptions::OutputFormat::Lcov, "lcov" , |
718 | "lcov tracefile output" )), |
719 | cl::init(Val: CoverageViewOptions::OutputFormat::Text)); |
720 | |
721 | cl::list<std::string> PathRemaps( |
722 | "path-equivalence" , cl::Optional, |
723 | cl::desc("<from>,<to> Map coverage data paths to local source file " |
724 | "paths" )); |
725 | |
726 | cl::OptionCategory FilteringCategory("Function filtering options" ); |
727 | |
728 | cl::list<std::string> NameFilters( |
729 | "name" , cl::Optional, |
730 | cl::desc("Show code coverage only for functions with the given name" ), |
731 | cl::cat(FilteringCategory)); |
732 | |
733 | cl::list<std::string> NameFilterFiles( |
734 | "name-allowlist" , cl::Optional, |
735 | cl::desc("Show code coverage only for functions listed in the given " |
736 | "file" ), |
737 | cl::cat(FilteringCategory)); |
738 | |
739 | cl::list<std::string> NameRegexFilters( |
740 | "name-regex" , cl::Optional, |
741 | cl::desc("Show code coverage only for functions that match the given " |
742 | "regular expression" ), |
743 | cl::cat(FilteringCategory)); |
744 | |
745 | cl::list<std::string> IgnoreFilenameRegexFilters( |
746 | "ignore-filename-regex" , cl::Optional, |
747 | cl::desc("Skip source code files with file paths that match the given " |
748 | "regular expression" ), |
749 | cl::cat(FilteringCategory)); |
750 | |
751 | cl::opt<double> RegionCoverageLtFilter( |
752 | "region-coverage-lt" , cl::Optional, |
753 | cl::desc("Show code coverage only for functions with region coverage " |
754 | "less than the given threshold" ), |
755 | cl::cat(FilteringCategory)); |
756 | |
757 | cl::opt<double> RegionCoverageGtFilter( |
758 | "region-coverage-gt" , cl::Optional, |
759 | cl::desc("Show code coverage only for functions with region coverage " |
760 | "greater than the given threshold" ), |
761 | cl::cat(FilteringCategory)); |
762 | |
763 | cl::opt<double> LineCoverageLtFilter( |
764 | "line-coverage-lt" , cl::Optional, |
765 | cl::desc("Show code coverage only for functions with line coverage less " |
766 | "than the given threshold" ), |
767 | cl::cat(FilteringCategory)); |
768 | |
769 | cl::opt<double> LineCoverageGtFilter( |
770 | "line-coverage-gt" , cl::Optional, |
771 | cl::desc("Show code coverage only for functions with line coverage " |
772 | "greater than the given threshold" ), |
773 | cl::cat(FilteringCategory)); |
774 | |
775 | cl::opt<cl::boolOrDefault> UseColor( |
776 | "use-color" , cl::desc("Emit colored output (default=autodetect)" ), |
777 | cl::init(Val: cl::BOU_UNSET)); |
778 | |
779 | cl::list<std::string> DemanglerOpts( |
780 | "Xdemangler" , cl::desc("<demangler-path>|<demangler-option>" )); |
781 | |
782 | cl::opt<bool> RegionSummary( |
783 | "show-region-summary" , cl::Optional, |
784 | cl::desc("Show region statistics in summary table" ), |
785 | cl::init(Val: true)); |
786 | |
787 | cl::opt<bool> BranchSummary( |
788 | "show-branch-summary" , cl::Optional, |
789 | cl::desc("Show branch condition statistics in summary table" ), |
790 | cl::init(Val: true)); |
791 | |
792 | cl::opt<bool> MCDCSummary("show-mcdc-summary" , cl::Optional, |
793 | cl::desc("Show MCDC statistics in summary table" ), |
794 | cl::init(Val: false)); |
795 | |
796 | cl::opt<bool> InstantiationSummary( |
797 | "show-instantiation-summary" , cl::Optional, |
798 | cl::desc("Show instantiation statistics in summary table" )); |
799 | |
800 | cl::opt<bool> SummaryOnly( |
801 | "summary-only" , cl::Optional, |
802 | cl::desc("Export only summary information for each source file" )); |
803 | |
804 | cl::opt<unsigned> NumThreads( |
805 | "num-threads" , cl::init(Val: 0), |
806 | cl::desc("Number of merge threads to use (default: autodetect)" )); |
807 | cl::alias NumThreadsA("j" , cl::desc("Alias for --num-threads" ), |
808 | cl::aliasopt(NumThreads)); |
809 | |
810 | cl::opt<std::string> CompilationDirectory( |
811 | "compilation-dir" , cl::init(Val: "" ), |
812 | cl::desc("Directory used as a base for relative coverage mapping paths" )); |
813 | |
814 | cl::opt<bool> CheckBinaryIDs( |
815 | "check-binary-ids" , cl::desc("Fail if an object couldn't be found for a " |
816 | "binary ID in the profile" )); |
817 | |
818 | auto commandLineParser = [&, this](int argc, const char **argv) -> int { |
819 | cl::ParseCommandLineOptions(argc, argv, Overview: "LLVM code coverage tool\n" ); |
820 | ViewOpts.Debug = DebugDump; |
821 | if (Debuginfod) { |
822 | HTTPClient::initialize(); |
823 | BIDFetcher = std::make_unique<DebuginfodFetcher>(args&: DebugFileDirectory); |
824 | } else { |
825 | BIDFetcher = std::make_unique<object::BuildIDFetcher>(args&: DebugFileDirectory); |
826 | } |
827 | this->CheckBinaryIDs = CheckBinaryIDs; |
828 | |
829 | if (!CovFilename.empty()) |
830 | ObjectFilenames.emplace_back(args&: CovFilename); |
831 | for (const std::string &Filename : CovFilenames) |
832 | ObjectFilenames.emplace_back(args: Filename); |
833 | if (ObjectFilenames.empty() && !Debuginfod && DebugFileDirectory.empty()) { |
834 | errs() << "No filenames specified!\n" ; |
835 | ::exit(status: 1); |
836 | } |
837 | |
838 | if (DebugDumpCollectedObjects) { |
839 | for (StringRef OF : ObjectFilenames) |
840 | outs() << OF << '\n'; |
841 | ::exit(status: 0); |
842 | } |
843 | |
844 | ViewOpts.Format = Format; |
845 | switch (ViewOpts.Format) { |
846 | case CoverageViewOptions::OutputFormat::Text: |
847 | ViewOpts.Colors = UseColor == cl::BOU_UNSET |
848 | ? sys::Process::StandardOutHasColors() |
849 | : UseColor == cl::BOU_TRUE; |
850 | break; |
851 | case CoverageViewOptions::OutputFormat::HTML: |
852 | if (UseColor == cl::BOU_FALSE) |
853 | errs() << "Color output cannot be disabled when generating html.\n" ; |
854 | ViewOpts.Colors = true; |
855 | break; |
856 | case CoverageViewOptions::OutputFormat::Lcov: |
857 | if (UseColor == cl::BOU_TRUE) |
858 | errs() << "Color output cannot be enabled when generating lcov.\n" ; |
859 | ViewOpts.Colors = false; |
860 | break; |
861 | } |
862 | |
863 | if (!PathRemaps.empty()) { |
864 | std::vector<std::pair<std::string, std::string>> Remappings; |
865 | |
866 | for (const std::string &PathRemap : PathRemaps) { |
867 | auto EquivPair = StringRef(PathRemap).split(Separator: ','); |
868 | if (EquivPair.first.empty() || EquivPair.second.empty()) { |
869 | error(Message: "invalid argument '" + PathRemap + |
870 | "', must be in format 'from,to'" , |
871 | Whence: "-path-equivalence" ); |
872 | return 1; |
873 | } |
874 | |
875 | Remappings.push_back( |
876 | x: {std::string(EquivPair.first), std::string(EquivPair.second)}); |
877 | } |
878 | |
879 | PathRemappings = Remappings; |
880 | } |
881 | |
882 | // If a demangler is supplied, check if it exists and register it. |
883 | if (!DemanglerOpts.empty()) { |
884 | auto DemanglerPathOrErr = sys::findProgramByName(Name: DemanglerOpts[0]); |
885 | if (!DemanglerPathOrErr) { |
886 | error(Message: "could not find the demangler!" , |
887 | Whence: DemanglerPathOrErr.getError().message()); |
888 | return 1; |
889 | } |
890 | DemanglerOpts[0] = *DemanglerPathOrErr; |
891 | ViewOpts.DemanglerOpts.swap(x&: DemanglerOpts); |
892 | } |
893 | |
894 | // Read in -name-allowlist files. |
895 | if (!NameFilterFiles.empty()) { |
896 | std::string SpecialCaseListErr; |
897 | NameAllowlist = SpecialCaseList::create( |
898 | Paths: NameFilterFiles, FS&: *vfs::getRealFileSystem(), Error&: SpecialCaseListErr); |
899 | if (!NameAllowlist) |
900 | error(Message: SpecialCaseListErr); |
901 | } |
902 | |
903 | // Create the function filters |
904 | if (!NameFilters.empty() || NameAllowlist || !NameRegexFilters.empty()) { |
905 | auto NameFilterer = std::make_unique<CoverageFilters>(); |
906 | for (const auto &Name : NameFilters) |
907 | NameFilterer->push_back(Filter: std::make_unique<NameCoverageFilter>(args: Name)); |
908 | if (NameAllowlist && !NameFilterFiles.empty()) |
909 | NameFilterer->push_back( |
910 | Filter: std::make_unique<NameAllowlistCoverageFilter>(args&: *NameAllowlist)); |
911 | for (const auto &Regex : NameRegexFilters) |
912 | NameFilterer->push_back( |
913 | Filter: std::make_unique<NameRegexCoverageFilter>(args: Regex)); |
914 | Filters.push_back(Filter: std::move(NameFilterer)); |
915 | } |
916 | |
917 | if (RegionCoverageLtFilter.getNumOccurrences() || |
918 | RegionCoverageGtFilter.getNumOccurrences() || |
919 | LineCoverageLtFilter.getNumOccurrences() || |
920 | LineCoverageGtFilter.getNumOccurrences()) { |
921 | auto StatFilterer = std::make_unique<CoverageFilters>(); |
922 | if (RegionCoverageLtFilter.getNumOccurrences()) |
923 | StatFilterer->push_back(Filter: std::make_unique<RegionCoverageFilter>( |
924 | args: RegionCoverageFilter::LessThan, args&: RegionCoverageLtFilter)); |
925 | if (RegionCoverageGtFilter.getNumOccurrences()) |
926 | StatFilterer->push_back(Filter: std::make_unique<RegionCoverageFilter>( |
927 | args: RegionCoverageFilter::GreaterThan, args&: RegionCoverageGtFilter)); |
928 | if (LineCoverageLtFilter.getNumOccurrences()) |
929 | StatFilterer->push_back(Filter: std::make_unique<LineCoverageFilter>( |
930 | args: LineCoverageFilter::LessThan, args&: LineCoverageLtFilter)); |
931 | if (LineCoverageGtFilter.getNumOccurrences()) |
932 | StatFilterer->push_back(Filter: std::make_unique<LineCoverageFilter>( |
933 | args: RegionCoverageFilter::GreaterThan, args&: LineCoverageGtFilter)); |
934 | Filters.push_back(Filter: std::move(StatFilterer)); |
935 | } |
936 | |
937 | // Create the ignore filename filters. |
938 | for (const auto &RE : IgnoreFilenameRegexFilters) |
939 | IgnoreFilenameFilters.push_back( |
940 | Filter: std::make_unique<NameRegexCoverageFilter>(args: RE)); |
941 | |
942 | if (!Arches.empty()) { |
943 | for (const std::string &Arch : Arches) { |
944 | if (Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) { |
945 | error(Message: "unknown architecture: " + Arch); |
946 | return 1; |
947 | } |
948 | CoverageArches.emplace_back(args: Arch); |
949 | } |
950 | if (CoverageArches.size() != 1 && |
951 | CoverageArches.size() != ObjectFilenames.size()) { |
952 | error(Message: "number of architectures doesn't match the number of objects" ); |
953 | return 1; |
954 | } |
955 | } |
956 | |
957 | // IgnoreFilenameFilters are applied even when InputSourceFiles specified. |
958 | for (const std::string &File : InputSourceFiles) |
959 | collectPaths(Path: File); |
960 | |
961 | if (DebugDumpCollectedPaths) { |
962 | for (const std::string &SF : SourceFiles) |
963 | outs() << SF << '\n'; |
964 | ::exit(status: 0); |
965 | } |
966 | |
967 | ViewOpts.ShowMCDCSummary = MCDCSummary; |
968 | ViewOpts.ShowBranchSummary = BranchSummary; |
969 | ViewOpts.ShowRegionSummary = RegionSummary; |
970 | ViewOpts.ShowInstantiationSummary = InstantiationSummary; |
971 | ViewOpts.ExportSummaryOnly = SummaryOnly; |
972 | ViewOpts.NumThreads = NumThreads; |
973 | ViewOpts.CompilationDirectory = CompilationDirectory; |
974 | |
975 | return 0; |
976 | }; |
977 | |
978 | switch (Cmd) { |
979 | case Show: |
980 | return doShow(argc, argv, commandLineParser); |
981 | case Report: |
982 | return doReport(argc, argv, commandLineParser); |
983 | case Export: |
984 | return doExport(argc, argv, commandLineParser); |
985 | } |
986 | return 0; |
987 | } |
988 | |
989 | int CodeCoverageTool::doShow(int argc, const char **argv, |
990 | CommandLineParserType commandLineParser) { |
991 | |
992 | cl::OptionCategory ViewCategory("Viewing options" ); |
993 | |
994 | cl::opt<bool> ShowLineExecutionCounts( |
995 | "show-line-counts" , cl::Optional, |
996 | cl::desc("Show the execution counts for each line" ), cl::init(Val: true), |
997 | cl::cat(ViewCategory)); |
998 | |
999 | cl::opt<bool> ShowRegions( |
1000 | "show-regions" , cl::Optional, |
1001 | cl::desc("Show the execution counts for each region" ), |
1002 | cl::cat(ViewCategory)); |
1003 | |
1004 | cl::opt<CoverageViewOptions::BranchOutputType> ShowBranches( |
1005 | "show-branches" , cl::Optional, |
1006 | cl::desc("Show coverage for branch conditions" ), cl::cat(ViewCategory), |
1007 | cl::values(clEnumValN(CoverageViewOptions::BranchOutputType::Count, |
1008 | "count" , "Show True/False counts" ), |
1009 | clEnumValN(CoverageViewOptions::BranchOutputType::Percent, |
1010 | "percent" , "Show True/False percent" )), |
1011 | cl::init(Val: CoverageViewOptions::BranchOutputType::Off)); |
1012 | |
1013 | cl::opt<bool> ShowMCDC( |
1014 | "show-mcdc" , cl::Optional, |
1015 | cl::desc("Show the MCDC Coverage for each applicable boolean expression" ), |
1016 | cl::cat(ViewCategory)); |
1017 | |
1018 | cl::opt<bool> ShowBestLineRegionsCounts( |
1019 | "show-line-counts-or-regions" , cl::Optional, |
1020 | cl::desc("Show the execution counts for each line, or the execution " |
1021 | "counts for each region on lines that have multiple regions" ), |
1022 | cl::cat(ViewCategory)); |
1023 | |
1024 | cl::opt<bool> ShowExpansions("show-expansions" , cl::Optional, |
1025 | cl::desc("Show expanded source regions" ), |
1026 | cl::cat(ViewCategory)); |
1027 | |
1028 | cl::opt<bool> ShowInstantiations("show-instantiations" , cl::Optional, |
1029 | cl::desc("Show function instantiations" ), |
1030 | cl::init(Val: true), cl::cat(ViewCategory)); |
1031 | |
1032 | cl::opt<bool> ShowDirectoryCoverage("show-directory-coverage" , cl::Optional, |
1033 | cl::desc("Show directory coverage" ), |
1034 | cl::cat(ViewCategory)); |
1035 | |
1036 | cl::opt<std::string> ShowOutputDirectory( |
1037 | "output-dir" , cl::init(Val: "" ), |
1038 | cl::desc("Directory in which coverage information is written out" )); |
1039 | cl::alias ShowOutputDirectoryA("o" , cl::desc("Alias for --output-dir" ), |
1040 | cl::aliasopt(ShowOutputDirectory)); |
1041 | |
1042 | cl::opt<uint32_t> TabSize( |
1043 | "tab-size" , cl::init(Val: 2), |
1044 | cl::desc( |
1045 | "Set tab expansion size for html coverage reports (default = 2)" )); |
1046 | |
1047 | cl::opt<std::string> ProjectTitle( |
1048 | "project-title" , cl::Optional, |
1049 | cl::desc("Set project title for the coverage report" )); |
1050 | |
1051 | cl::opt<std::string> CovWatermark( |
1052 | "coverage-watermark" , cl::Optional, |
1053 | cl::desc("<high>,<low> value indicate thresholds for high and low" |
1054 | "coverage watermark" )); |
1055 | |
1056 | auto Err = commandLineParser(argc, argv); |
1057 | if (Err) |
1058 | return Err; |
1059 | |
1060 | if (ViewOpts.Format == CoverageViewOptions::OutputFormat::Lcov) { |
1061 | error(Message: "lcov format should be used with 'llvm-cov export'." ); |
1062 | return 1; |
1063 | } |
1064 | |
1065 | ViewOpts.HighCovWatermark = 100.0; |
1066 | ViewOpts.LowCovWatermark = 80.0; |
1067 | if (!CovWatermark.empty()) { |
1068 | auto WaterMarkPair = StringRef(CovWatermark).split(Separator: ','); |
1069 | if (WaterMarkPair.first.empty() || WaterMarkPair.second.empty()) { |
1070 | error(Message: "invalid argument '" + CovWatermark + |
1071 | "', must be in format 'high,low'" , |
1072 | Whence: "-coverage-watermark" ); |
1073 | return 1; |
1074 | } |
1075 | |
1076 | char *EndPointer = nullptr; |
1077 | ViewOpts.HighCovWatermark = |
1078 | strtod(nptr: WaterMarkPair.first.begin(), endptr: &EndPointer); |
1079 | if (EndPointer != WaterMarkPair.first.end()) { |
1080 | error(Message: "invalid number '" + WaterMarkPair.first + |
1081 | "', invalid value for 'high'" , |
1082 | Whence: "-coverage-watermark" ); |
1083 | return 1; |
1084 | } |
1085 | |
1086 | ViewOpts.LowCovWatermark = |
1087 | strtod(nptr: WaterMarkPair.second.begin(), endptr: &EndPointer); |
1088 | if (EndPointer != WaterMarkPair.second.end()) { |
1089 | error(Message: "invalid number '" + WaterMarkPair.second + |
1090 | "', invalid value for 'low'" , |
1091 | Whence: "-coverage-watermark" ); |
1092 | return 1; |
1093 | } |
1094 | |
1095 | if (ViewOpts.HighCovWatermark > 100 || ViewOpts.LowCovWatermark < 0 || |
1096 | ViewOpts.HighCovWatermark <= ViewOpts.LowCovWatermark) { |
1097 | error( |
1098 | Message: "invalid number range '" + CovWatermark + |
1099 | "', must be both high and low should be between 0-100, and high " |
1100 | "> low" , |
1101 | Whence: "-coverage-watermark" ); |
1102 | return 1; |
1103 | } |
1104 | } |
1105 | |
1106 | ViewOpts.ShowLineNumbers = true; |
1107 | ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 || |
1108 | !ShowRegions || ShowBestLineRegionsCounts; |
1109 | ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts; |
1110 | ViewOpts.ShowExpandedRegions = ShowExpansions; |
1111 | ViewOpts.ShowBranchCounts = |
1112 | ShowBranches == CoverageViewOptions::BranchOutputType::Count; |
1113 | ViewOpts.ShowMCDC = ShowMCDC; |
1114 | ViewOpts.ShowBranchPercents = |
1115 | ShowBranches == CoverageViewOptions::BranchOutputType::Percent; |
1116 | ViewOpts.ShowFunctionInstantiations = ShowInstantiations; |
1117 | ViewOpts.ShowDirectoryCoverage = ShowDirectoryCoverage; |
1118 | ViewOpts.ShowOutputDirectory = ShowOutputDirectory; |
1119 | ViewOpts.TabSize = TabSize; |
1120 | ViewOpts.ProjectTitle = ProjectTitle; |
1121 | |
1122 | if (ViewOpts.hasOutputDirectory()) { |
1123 | if (auto E = sys::fs::create_directories(path: ViewOpts.ShowOutputDirectory)) { |
1124 | error(Message: "could not create output directory!" , Whence: E.message()); |
1125 | return 1; |
1126 | } |
1127 | } |
1128 | |
1129 | sys::fs::file_status Status; |
1130 | if (std::error_code EC = sys::fs::status(path: PGOFilename, result&: Status)) { |
1131 | error(Message: "could not read profile data!" + EC.message(), Whence: PGOFilename); |
1132 | return 1; |
1133 | } |
1134 | |
1135 | auto ModifiedTime = Status.getLastModificationTime(); |
1136 | std::string ModifiedTimeStr = to_string(Value: ModifiedTime); |
1137 | size_t found = ModifiedTimeStr.rfind(c: ':'); |
1138 | ViewOpts.CreatedTimeStr = (found != std::string::npos) |
1139 | ? "Created: " + ModifiedTimeStr.substr(pos: 0, n: found) |
1140 | : "Created: " + ModifiedTimeStr; |
1141 | |
1142 | auto Coverage = load(); |
1143 | if (!Coverage) |
1144 | return 1; |
1145 | |
1146 | auto Printer = CoveragePrinter::create(Opts: ViewOpts); |
1147 | |
1148 | if (SourceFiles.empty() && !HadSourceFiles) |
1149 | // Get the source files from the function coverage mapping. |
1150 | for (StringRef Filename : Coverage->getUniqueSourceFiles()) { |
1151 | if (!IgnoreFilenameFilters.matchesFilename(Filename)) |
1152 | SourceFiles.push_back(x: std::string(Filename)); |
1153 | } |
1154 | |
1155 | // Create an index out of the source files. |
1156 | if (ViewOpts.hasOutputDirectory()) { |
1157 | if (Error E = Printer->createIndexFile(SourceFiles, Coverage: *Coverage, Filters)) { |
1158 | error(Message: "could not create index file!" , Whence: toString(E: std::move(E))); |
1159 | return 1; |
1160 | } |
1161 | } |
1162 | |
1163 | if (!Filters.empty()) { |
1164 | // Build the map of filenames to functions. |
1165 | std::map<llvm::StringRef, std::vector<const FunctionRecord *>> |
1166 | FilenameFunctionMap; |
1167 | for (const auto &SourceFile : SourceFiles) |
1168 | for (const auto &Function : Coverage->getCoveredFunctions(Filename: SourceFile)) |
1169 | if (Filters.matches(CM: *Coverage, Function)) |
1170 | FilenameFunctionMap[SourceFile].push_back(x: &Function); |
1171 | |
1172 | // Only print filter matching functions for each file. |
1173 | for (const auto &FileFunc : FilenameFunctionMap) { |
1174 | StringRef File = FileFunc.first; |
1175 | const auto &Functions = FileFunc.second; |
1176 | |
1177 | auto OSOrErr = Printer->createViewFile(Path: File, /*InToplevel=*/false); |
1178 | if (Error E = OSOrErr.takeError()) { |
1179 | error(Message: "could not create view file!" , Whence: toString(E: std::move(E))); |
1180 | return 1; |
1181 | } |
1182 | auto OS = std::move(OSOrErr.get()); |
1183 | |
1184 | bool ShowTitle = ViewOpts.hasOutputDirectory(); |
1185 | for (const auto *Function : Functions) { |
1186 | auto FunctionView = createFunctionView(Function: *Function, Coverage: *Coverage); |
1187 | if (!FunctionView) { |
1188 | warning(Message: "Could not read coverage for '" + Function->Name + "'." ); |
1189 | continue; |
1190 | } |
1191 | FunctionView->print(OS&: *OS.get(), /*WholeFile=*/false, |
1192 | /*ShowSourceName=*/true, ShowTitle); |
1193 | ShowTitle = false; |
1194 | } |
1195 | |
1196 | Printer->closeViewFile(OS: std::move(OS)); |
1197 | } |
1198 | return 0; |
1199 | } |
1200 | |
1201 | // Show files |
1202 | bool ShowFilenames = |
1203 | (SourceFiles.size() != 1) || ViewOpts.hasOutputDirectory() || |
1204 | (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML); |
1205 | |
1206 | ThreadPoolStrategy S = hardware_concurrency(ThreadCount: ViewOpts.NumThreads); |
1207 | if (ViewOpts.NumThreads == 0) { |
1208 | // If NumThreads is not specified, create one thread for each input, up to |
1209 | // the number of hardware cores. |
1210 | S = heavyweight_hardware_concurrency(ThreadCount: SourceFiles.size()); |
1211 | S.Limit = true; |
1212 | } |
1213 | |
1214 | if (!ViewOpts.hasOutputDirectory() || S.ThreadsRequested == 1) { |
1215 | for (const std::string &SourceFile : SourceFiles) |
1216 | writeSourceFileView(SourceFile, Coverage: Coverage.get(), Printer: Printer.get(), |
1217 | ShowFilenames); |
1218 | } else { |
1219 | // In -output-dir mode, it's safe to use multiple threads to print files. |
1220 | DefaultThreadPool Pool(S); |
1221 | for (const std::string &SourceFile : SourceFiles) |
1222 | Pool.async(F: &CodeCoverageTool::writeSourceFileView, ArgList: this, ArgList: SourceFile, |
1223 | ArgList: Coverage.get(), ArgList: Printer.get(), ArgList&: ShowFilenames); |
1224 | Pool.wait(); |
1225 | } |
1226 | |
1227 | return 0; |
1228 | } |
1229 | |
1230 | int CodeCoverageTool::doReport(int argc, const char **argv, |
1231 | CommandLineParserType commandLineParser) { |
1232 | cl::opt<bool> ShowFunctionSummaries( |
1233 | "show-functions" , cl::Optional, cl::init(Val: false), |
1234 | cl::desc("Show coverage summaries for each function" )); |
1235 | |
1236 | auto Err = commandLineParser(argc, argv); |
1237 | if (Err) |
1238 | return Err; |
1239 | |
1240 | if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML) { |
1241 | error(Message: "HTML output for summary reports is not yet supported." ); |
1242 | return 1; |
1243 | } else if (ViewOpts.Format == CoverageViewOptions::OutputFormat::Lcov) { |
1244 | error(Message: "lcov format should be used with 'llvm-cov export'." ); |
1245 | return 1; |
1246 | } |
1247 | |
1248 | sys::fs::file_status Status; |
1249 | if (std::error_code EC = sys::fs::status(path: PGOFilename, result&: Status)) { |
1250 | error(Message: "could not read profile data!" + EC.message(), Whence: PGOFilename); |
1251 | return 1; |
1252 | } |
1253 | |
1254 | auto Coverage = load(); |
1255 | if (!Coverage) |
1256 | return 1; |
1257 | |
1258 | CoverageReport Report(ViewOpts, *Coverage); |
1259 | if (!ShowFunctionSummaries) { |
1260 | if (SourceFiles.empty()) |
1261 | Report.renderFileReports(OS&: llvm::outs(), IgnoreFilenameFilters); |
1262 | else |
1263 | Report.renderFileReports(OS&: llvm::outs(), Files: SourceFiles); |
1264 | } else { |
1265 | if (SourceFiles.empty()) { |
1266 | error(Message: "source files must be specified when -show-functions=true is " |
1267 | "specified" ); |
1268 | return 1; |
1269 | } |
1270 | |
1271 | Report.renderFunctionReports(Files: SourceFiles, DC, OS&: llvm::outs()); |
1272 | } |
1273 | return 0; |
1274 | } |
1275 | |
1276 | int CodeCoverageTool::doExport(int argc, const char **argv, |
1277 | CommandLineParserType commandLineParser) { |
1278 | |
1279 | cl::OptionCategory ExportCategory("Exporting options" ); |
1280 | |
1281 | cl::opt<bool> SkipExpansions("skip-expansions" , cl::Optional, |
1282 | cl::desc("Don't export expanded source regions" ), |
1283 | cl::cat(ExportCategory)); |
1284 | |
1285 | cl::opt<bool> SkipFunctions("skip-functions" , cl::Optional, |
1286 | cl::desc("Don't export per-function data" ), |
1287 | cl::cat(ExportCategory)); |
1288 | |
1289 | cl::opt<bool> SkipBranches("skip-branches" , cl::Optional, |
1290 | cl::desc("Don't export branch data (LCOV)" ), |
1291 | cl::cat(ExportCategory)); |
1292 | |
1293 | auto Err = commandLineParser(argc, argv); |
1294 | if (Err) |
1295 | return Err; |
1296 | |
1297 | ViewOpts.SkipExpansions = SkipExpansions; |
1298 | ViewOpts.SkipFunctions = SkipFunctions; |
1299 | ViewOpts.SkipBranches = SkipBranches; |
1300 | |
1301 | if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text && |
1302 | ViewOpts.Format != CoverageViewOptions::OutputFormat::Lcov) { |
1303 | error(Message: "coverage data can only be exported as textual JSON or an " |
1304 | "lcov tracefile." ); |
1305 | return 1; |
1306 | } |
1307 | |
1308 | sys::fs::file_status Status; |
1309 | if (std::error_code EC = sys::fs::status(path: PGOFilename, result&: Status)) { |
1310 | error(Message: "could not read profile data!" + EC.message(), Whence: PGOFilename); |
1311 | return 1; |
1312 | } |
1313 | |
1314 | auto Coverage = load(); |
1315 | if (!Coverage) { |
1316 | error(Message: "could not load coverage information" ); |
1317 | return 1; |
1318 | } |
1319 | |
1320 | std::unique_ptr<CoverageExporter> Exporter; |
1321 | |
1322 | switch (ViewOpts.Format) { |
1323 | case CoverageViewOptions::OutputFormat::Text: |
1324 | Exporter = |
1325 | std::make_unique<CoverageExporterJson>(args&: *Coverage, args&: ViewOpts, args&: outs()); |
1326 | break; |
1327 | case CoverageViewOptions::OutputFormat::HTML: |
1328 | // Unreachable because we should have gracefully terminated with an error |
1329 | // above. |
1330 | llvm_unreachable("Export in HTML is not supported!" ); |
1331 | case CoverageViewOptions::OutputFormat::Lcov: |
1332 | Exporter = |
1333 | std::make_unique<CoverageExporterLcov>(args&: *Coverage, args&: ViewOpts, args&: outs()); |
1334 | break; |
1335 | } |
1336 | |
1337 | if (SourceFiles.empty()) |
1338 | Exporter->renderRoot(IgnoreFilters: IgnoreFilenameFilters); |
1339 | else |
1340 | Exporter->renderRoot(SourceFiles); |
1341 | |
1342 | return 0; |
1343 | } |
1344 | |
1345 | int showMain(int argc, const char *argv[]) { |
1346 | CodeCoverageTool Tool; |
1347 | return Tool.run(Cmd: CodeCoverageTool::Show, argc, argv); |
1348 | } |
1349 | |
1350 | int reportMain(int argc, const char *argv[]) { |
1351 | CodeCoverageTool Tool; |
1352 | return Tool.run(Cmd: CodeCoverageTool::Report, argc, argv); |
1353 | } |
1354 | |
1355 | int exportMain(int argc, const char *argv[]) { |
1356 | CodeCoverageTool Tool; |
1357 | return Tool.run(Cmd: CodeCoverageTool::Export, argc, argv); |
1358 | } |
1359 | |