1 //===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // The 'CodeCoverageTool' class implements a command line tool to analyze and
11 // report coverage information using the profiling instrumentation and code
12 // coverage mapping.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "CoverageFilters.h"
17 #include "CoverageReport.h"
18 #include "CoverageViewOptions.h"
19 #include "RenderingSupport.h"
20 #include "SourceCoverageView.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
25 #include "llvm/ProfileData/InstrProfReader.h"
26 #include "llvm/Support/CommandLine.h"
27 #include "llvm/Support/FileSystem.h"
28 #include "llvm/Support/Format.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/Process.h"
31 #include "llvm/Support/ThreadPool.h"
32 #include <functional>
33 #include <system_error>
34
35 using namespace llvm;
36 using namespace coverage;
37
38 namespace {
39 /// \brief The implementation of the coverage tool.
40 class CodeCoverageTool {
41 public:
42 enum Command {
43 /// \brief The show command.
44 Show,
45 /// \brief The report command.
46 Report
47 };
48
49 /// \brief Print the error message to the error output stream.
50 void error(const Twine &Message, StringRef Whence = "");
51
52 /// \brief Record (but do not print) an error message in a thread-safe way.
53 void deferError(const Twine &Message, StringRef Whence = "");
54
55 /// \brief Record (but do not print) a warning message in a thread-safe way.
56 void deferWarning(const Twine &Message, StringRef Whence = "");
57
58 /// \brief Print (and then clear) all deferred error and warning messages.
59 void consumeDeferredMessages();
60
61 /// \brief Append a reference to a private copy of \p Path into SourceFiles.
62 void addCollectedPath(const std::string &Path);
63
64 /// \brief Return a memory buffer for the given source file.
65 ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
66
67 /// \brief Create source views for the expansions of the view.
68 void attachExpansionSubViews(SourceCoverageView &View,
69 ArrayRef<ExpansionRecord> Expansions,
70 CoverageMapping &Coverage);
71
72 /// \brief Create the source view of a particular function.
73 std::unique_ptr<SourceCoverageView>
74 createFunctionView(const FunctionRecord &Function, CoverageMapping &Coverage);
75
76 /// \brief Create the main source view of a particular source file.
77 std::unique_ptr<SourceCoverageView>
78 createSourceFileView(StringRef SourceFile, CoverageMapping &Coverage);
79
80 /// \brief Load the coverage mapping data. Return true if an error occured.
81 std::unique_ptr<CoverageMapping> load();
82
83 int run(Command Cmd, int argc, const char **argv);
84
85 typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
86
87 int show(int argc, const char **argv,
88 CommandLineParserType commandLineParser);
89
90 int report(int argc, const char **argv,
91 CommandLineParserType commandLineParser);
92
93 std::string ObjectFilename;
94 CoverageViewOptions ViewOpts;
95 std::string PGOFilename;
96 CoverageFiltersMatchAll Filters;
97 std::vector<StringRef> SourceFiles;
98 bool CompareFilenamesOnly;
99 StringMap<std::string> RemappedFilenames;
100 std::string CoverageArch;
101
102 private:
103 std::vector<std::string> CollectedPaths;
104
105 std::mutex DeferredMessagesLock;
106 std::vector<std::string> DeferredMessages;
107
108 std::mutex LoadedSourceFilesLock;
109 std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
110 LoadedSourceFiles;
111 };
112 }
113
getErrorString(const Twine & Message,StringRef Whence,bool Warning)114 static std::string getErrorString(const Twine &Message, StringRef Whence,
115 bool Warning) {
116 std::string Str = (Warning ? "warning" : "error");
117 Str += ": ";
118 if (!Whence.empty())
119 Str += Whence;
120 Str += Message.str() + "\n";
121 return Str;
122 }
123
error(const Twine & Message,StringRef Whence)124 void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
125 errs() << getErrorString(Message, Whence, false);
126 }
127
deferError(const Twine & Message,StringRef Whence)128 void CodeCoverageTool::deferError(const Twine &Message, StringRef Whence) {
129 std::unique_lock<std::mutex> Guard{DeferredMessagesLock};
130 DeferredMessages.emplace_back(getErrorString(Message, Whence, false));
131 }
132
deferWarning(const Twine & Message,StringRef Whence)133 void CodeCoverageTool::deferWarning(const Twine &Message, StringRef Whence) {
134 std::unique_lock<std::mutex> Guard{DeferredMessagesLock};
135 DeferredMessages.emplace_back(getErrorString(Message, Whence, true));
136 }
137
consumeDeferredMessages()138 void CodeCoverageTool::consumeDeferredMessages() {
139 std::unique_lock<std::mutex> Guard{DeferredMessagesLock};
140 for (const std::string &Message : DeferredMessages)
141 ViewOpts.colored_ostream(errs(), raw_ostream::RED) << Message;
142 DeferredMessages.clear();
143 }
144
addCollectedPath(const std::string & Path)145 void CodeCoverageTool::addCollectedPath(const std::string &Path) {
146 CollectedPaths.push_back(Path);
147 SourceFiles.emplace_back(CollectedPaths.back());
148 }
149
150 ErrorOr<const MemoryBuffer &>
getSourceFile(StringRef SourceFile)151 CodeCoverageTool::getSourceFile(StringRef SourceFile) {
152 // If we've remapped filenames, look up the real location for this file.
153 if (!RemappedFilenames.empty()) {
154 auto Loc = RemappedFilenames.find(SourceFile);
155 if (Loc != RemappedFilenames.end())
156 SourceFile = Loc->second;
157 }
158 for (const auto &Files : LoadedSourceFiles)
159 if (sys::fs::equivalent(SourceFile, Files.first))
160 return *Files.second;
161 auto Buffer = MemoryBuffer::getFile(SourceFile);
162 if (auto EC = Buffer.getError()) {
163 deferError(EC.message(), SourceFile);
164 return EC;
165 }
166 std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
167 LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
168 return *LoadedSourceFiles.back().second;
169 }
170
171 void
attachExpansionSubViews(SourceCoverageView & View,ArrayRef<ExpansionRecord> Expansions,CoverageMapping & Coverage)172 CodeCoverageTool::attachExpansionSubViews(SourceCoverageView &View,
173 ArrayRef<ExpansionRecord> Expansions,
174 CoverageMapping &Coverage) {
175 if (!ViewOpts.ShowExpandedRegions)
176 return;
177 for (const auto &Expansion : Expansions) {
178 auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
179 if (ExpansionCoverage.empty())
180 continue;
181 auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
182 if (!SourceBuffer)
183 continue;
184
185 auto SubViewExpansions = ExpansionCoverage.getExpansions();
186 auto SubView =
187 SourceCoverageView::create(Expansion.Function.Name, SourceBuffer.get(),
188 ViewOpts, std::move(ExpansionCoverage));
189 attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
190 View.addExpansion(Expansion.Region, std::move(SubView));
191 }
192 }
193
194 std::unique_ptr<SourceCoverageView>
createFunctionView(const FunctionRecord & Function,CoverageMapping & Coverage)195 CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
196 CoverageMapping &Coverage) {
197 auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
198 if (FunctionCoverage.empty())
199 return nullptr;
200 auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
201 if (!SourceBuffer)
202 return nullptr;
203
204 auto Expansions = FunctionCoverage.getExpansions();
205 auto View = SourceCoverageView::create(Function.Name, SourceBuffer.get(),
206 ViewOpts, std::move(FunctionCoverage));
207 attachExpansionSubViews(*View, Expansions, Coverage);
208
209 return View;
210 }
211
212 std::unique_ptr<SourceCoverageView>
createSourceFileView(StringRef SourceFile,CoverageMapping & Coverage)213 CodeCoverageTool::createSourceFileView(StringRef SourceFile,
214 CoverageMapping &Coverage) {
215 auto SourceBuffer = getSourceFile(SourceFile);
216 if (!SourceBuffer)
217 return nullptr;
218 auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
219 if (FileCoverage.empty())
220 return nullptr;
221
222 auto Expansions = FileCoverage.getExpansions();
223 auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
224 ViewOpts, std::move(FileCoverage));
225 attachExpansionSubViews(*View, Expansions, Coverage);
226
227 for (auto Function : Coverage.getInstantiations(SourceFile)) {
228 auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
229 auto SubViewExpansions = SubViewCoverage.getExpansions();
230 auto SubView =
231 SourceCoverageView::create(Function->Name, SourceBuffer.get(), ViewOpts,
232 std::move(SubViewCoverage));
233 attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
234
235 if (SubView) {
236 unsigned FileID = Function->CountedRegions.front().FileID;
237 unsigned Line = 0;
238 for (const auto &CR : Function->CountedRegions)
239 if (CR.FileID == FileID)
240 Line = std::max(CR.LineEnd, Line);
241 View->addInstantiation(Function->Name, Line, std::move(SubView));
242 }
243 }
244 return View;
245 }
246
modifiedTimeGT(StringRef LHS,StringRef RHS)247 static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
248 sys::fs::file_status Status;
249 if (sys::fs::status(LHS, Status))
250 return false;
251 auto LHSTime = Status.getLastModificationTime();
252 if (sys::fs::status(RHS, Status))
253 return false;
254 auto RHSTime = Status.getLastModificationTime();
255 return LHSTime > RHSTime;
256 }
257
load()258 std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
259 if (modifiedTimeGT(ObjectFilename, PGOFilename))
260 errs() << "warning: profile data may be out of date - object is newer\n";
261 auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename,
262 CoverageArch);
263 if (Error E = CoverageOrErr.takeError()) {
264 colored_ostream(errs(), raw_ostream::RED)
265 << "error: Failed to load coverage: " << toString(std::move(E)) << "\n";
266 return nullptr;
267 }
268 auto Coverage = std::move(CoverageOrErr.get());
269 unsigned Mismatched = Coverage->getMismatchedCount();
270 if (Mismatched) {
271 colored_ostream(errs(), raw_ostream::RED)
272 << "warning: " << Mismatched << " functions have mismatched data. ";
273 errs() << "\n";
274 }
275
276 if (CompareFilenamesOnly) {
277 auto CoveredFiles = Coverage.get()->getUniqueSourceFiles();
278 for (auto &SF : SourceFiles) {
279 StringRef SFBase = sys::path::filename(SF);
280 for (const auto &CF : CoveredFiles)
281 if (SFBase == sys::path::filename(CF)) {
282 RemappedFilenames[CF] = SF;
283 SF = CF;
284 break;
285 }
286 }
287 }
288
289 return Coverage;
290 }
291
run(Command Cmd,int argc,const char ** argv)292 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
293 cl::opt<std::string, true> ObjectFilename(
294 cl::Positional, cl::Required, cl::location(this->ObjectFilename),
295 cl::desc("Covered executable or object file."));
296
297 cl::list<std::string> InputSourceFiles(
298 cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
299
300 cl::opt<std::string, true> PGOFilename(
301 "instr-profile", cl::Required, cl::location(this->PGOFilename),
302 cl::desc(
303 "File with the profile data obtained after an instrumented run"));
304
305 cl::opt<std::string> Arch(
306 "arch", cl::desc("architecture of the coverage mapping binary"));
307
308 cl::opt<bool> DebugDump("dump", cl::Optional,
309 cl::desc("Show internal debug dump"));
310
311 cl::opt<CoverageViewOptions::OutputFormat> Format(
312 "format", cl::desc("Output format for line-based coverage reports"),
313 cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",
314 "Text output"),
315 clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
316 "HTML output"),
317 clEnumValEnd),
318 cl::init(CoverageViewOptions::OutputFormat::Text));
319
320 cl::opt<bool> FilenameEquivalence(
321 "filename-equivalence", cl::Optional,
322 cl::desc("Treat source files as equivalent to paths in the coverage data "
323 "when the file names match, even if the full paths do not"));
324
325 cl::OptionCategory FilteringCategory("Function filtering options");
326
327 cl::list<std::string> NameFilters(
328 "name", cl::Optional,
329 cl::desc("Show code coverage only for functions with the given name"),
330 cl::ZeroOrMore, cl::cat(FilteringCategory));
331
332 cl::list<std::string> NameRegexFilters(
333 "name-regex", cl::Optional,
334 cl::desc("Show code coverage only for functions that match the given "
335 "regular expression"),
336 cl::ZeroOrMore, cl::cat(FilteringCategory));
337
338 cl::opt<double> RegionCoverageLtFilter(
339 "region-coverage-lt", cl::Optional,
340 cl::desc("Show code coverage only for functions with region coverage "
341 "less than the given threshold"),
342 cl::cat(FilteringCategory));
343
344 cl::opt<double> RegionCoverageGtFilter(
345 "region-coverage-gt", cl::Optional,
346 cl::desc("Show code coverage only for functions with region coverage "
347 "greater than the given threshold"),
348 cl::cat(FilteringCategory));
349
350 cl::opt<double> LineCoverageLtFilter(
351 "line-coverage-lt", cl::Optional,
352 cl::desc("Show code coverage only for functions with line coverage less "
353 "than the given threshold"),
354 cl::cat(FilteringCategory));
355
356 cl::opt<double> LineCoverageGtFilter(
357 "line-coverage-gt", cl::Optional,
358 cl::desc("Show code coverage only for functions with line coverage "
359 "greater than the given threshold"),
360 cl::cat(FilteringCategory));
361
362 cl::opt<cl::boolOrDefault> UseColor(
363 "use-color", cl::desc("Emit colored output (default=autodetect)"),
364 cl::init(cl::BOU_UNSET));
365
366 auto commandLineParser = [&, this](int argc, const char **argv) -> int {
367 cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
368 ViewOpts.Debug = DebugDump;
369 CompareFilenamesOnly = FilenameEquivalence;
370
371 ViewOpts.Format = Format;
372 switch (ViewOpts.Format) {
373 case CoverageViewOptions::OutputFormat::Text:
374 ViewOpts.Colors = UseColor == cl::BOU_UNSET
375 ? sys::Process::StandardOutHasColors()
376 : UseColor == cl::BOU_TRUE;
377 break;
378 case CoverageViewOptions::OutputFormat::HTML:
379 if (UseColor == cl::BOU_FALSE)
380 error("Color output cannot be disabled when generating html.");
381 ViewOpts.Colors = true;
382 break;
383 }
384
385 // Create the function filters
386 if (!NameFilters.empty() || !NameRegexFilters.empty()) {
387 auto NameFilterer = new CoverageFilters;
388 for (const auto &Name : NameFilters)
389 NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
390 for (const auto &Regex : NameRegexFilters)
391 NameFilterer->push_back(
392 llvm::make_unique<NameRegexCoverageFilter>(Regex));
393 Filters.push_back(std::unique_ptr<CoverageFilter>(NameFilterer));
394 }
395 if (RegionCoverageLtFilter.getNumOccurrences() ||
396 RegionCoverageGtFilter.getNumOccurrences() ||
397 LineCoverageLtFilter.getNumOccurrences() ||
398 LineCoverageGtFilter.getNumOccurrences()) {
399 auto StatFilterer = new CoverageFilters;
400 if (RegionCoverageLtFilter.getNumOccurrences())
401 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
402 RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
403 if (RegionCoverageGtFilter.getNumOccurrences())
404 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
405 RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
406 if (LineCoverageLtFilter.getNumOccurrences())
407 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
408 LineCoverageFilter::LessThan, LineCoverageLtFilter));
409 if (LineCoverageGtFilter.getNumOccurrences())
410 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
411 RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
412 Filters.push_back(std::unique_ptr<CoverageFilter>(StatFilterer));
413 }
414
415 if (!Arch.empty() &&
416 Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
417 errs() << "error: Unknown architecture: " << Arch << "\n";
418 return 1;
419 }
420 CoverageArch = Arch;
421
422 for (const auto &File : InputSourceFiles) {
423 SmallString<128> Path(File);
424 if (!CompareFilenamesOnly)
425 if (std::error_code EC = sys::fs::make_absolute(Path)) {
426 errs() << "error: " << File << ": " << EC.message();
427 return 1;
428 }
429 addCollectedPath(Path.str());
430 }
431 return 0;
432 };
433
434 switch (Cmd) {
435 case Show:
436 return show(argc, argv, commandLineParser);
437 case Report:
438 return report(argc, argv, commandLineParser);
439 }
440 return 0;
441 }
442
show(int argc,const char ** argv,CommandLineParserType commandLineParser)443 int CodeCoverageTool::show(int argc, const char **argv,
444 CommandLineParserType commandLineParser) {
445
446 cl::OptionCategory ViewCategory("Viewing options");
447
448 cl::opt<bool> ShowLineExecutionCounts(
449 "show-line-counts", cl::Optional,
450 cl::desc("Show the execution counts for each line"), cl::init(true),
451 cl::cat(ViewCategory));
452
453 cl::opt<bool> ShowRegions(
454 "show-regions", cl::Optional,
455 cl::desc("Show the execution counts for each region"),
456 cl::cat(ViewCategory));
457
458 cl::opt<bool> ShowBestLineRegionsCounts(
459 "show-line-counts-or-regions", cl::Optional,
460 cl::desc("Show the execution counts for each line, or the execution "
461 "counts for each region on lines that have multiple regions"),
462 cl::cat(ViewCategory));
463
464 cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
465 cl::desc("Show expanded source regions"),
466 cl::cat(ViewCategory));
467
468 cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
469 cl::desc("Show function instantiations"),
470 cl::cat(ViewCategory));
471
472 cl::opt<std::string> ShowOutputDirectory(
473 "output-dir", cl::init(""),
474 cl::desc("Directory in which coverage information is written out"));
475 cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
476 cl::aliasopt(ShowOutputDirectory));
477
478 auto Err = commandLineParser(argc, argv);
479 if (Err)
480 return Err;
481
482 ViewOpts.ShowLineNumbers = true;
483 ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
484 !ShowRegions || ShowBestLineRegionsCounts;
485 ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
486 ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
487 ViewOpts.ShowExpandedRegions = ShowExpansions;
488 ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
489 ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
490
491 if (ViewOpts.hasOutputDirectory()) {
492 if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
493 error("Could not create output directory!", E.message());
494 return 1;
495 }
496 }
497
498 auto Coverage = load();
499 if (!Coverage)
500 return 1;
501
502 auto Printer = CoveragePrinter::create(ViewOpts);
503
504 if (!Filters.empty()) {
505 auto OSOrErr = Printer->createViewFile("functions", /*InToplevel=*/true);
506 if (Error E = OSOrErr.takeError()) {
507 error(toString(std::move(E)));
508 return 1;
509 }
510 auto OS = std::move(OSOrErr.get());
511
512 // Show functions.
513 for (const auto &Function : Coverage->getCoveredFunctions()) {
514 if (!Filters.matches(Function))
515 continue;
516
517 auto mainView = createFunctionView(Function, *Coverage);
518 if (!mainView) {
519 ViewOpts.colored_ostream(errs(), raw_ostream::RED)
520 << "warning: Could not read coverage for '" << Function.Name << "'."
521 << "\n";
522 continue;
523 }
524
525 mainView->print(*OS.get(), /*WholeFile=*/false, /*ShowSourceName=*/true);
526 }
527
528 Printer->closeViewFile(std::move(OS));
529 return 0;
530 }
531
532 // Show files
533 bool ShowFilenames = SourceFiles.size() != 1;
534
535 if (SourceFiles.empty())
536 // Get the source files from the function coverage mapping.
537 for (StringRef Filename : Coverage->getUniqueSourceFiles())
538 SourceFiles.push_back(Filename);
539
540 // Create an index out of the source files.
541 if (ViewOpts.hasOutputDirectory()) {
542 if (Error E = Printer->createIndexFile(SourceFiles)) {
543 error(toString(std::move(E)));
544 return 1;
545 }
546 }
547
548 // In -output-dir mode, it's safe to use multiple threads to print files.
549 unsigned ThreadCount = 1;
550 if (ViewOpts.hasOutputDirectory())
551 ThreadCount = std::thread::hardware_concurrency();
552 ThreadPool Pool(ThreadCount);
553
554 for (StringRef &SourceFile : SourceFiles) {
555 Pool.async([this, &SourceFile, &Coverage, &Printer, ShowFilenames] {
556 auto View = createSourceFileView(SourceFile, *Coverage);
557 if (!View) {
558 deferWarning("The file '" + SourceFile.str() + "' isn't covered.");
559 return;
560 }
561
562 auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
563 if (Error E = OSOrErr.takeError()) {
564 deferError(toString(std::move(E)));
565 return;
566 }
567 auto OS = std::move(OSOrErr.get());
568
569 View->print(*OS.get(), /*Wholefile=*/true,
570 /*ShowSourceName=*/ShowFilenames);
571 Printer->closeViewFile(std::move(OS));
572 });
573 }
574
575 Pool.wait();
576
577 consumeDeferredMessages();
578
579 return 0;
580 }
581
report(int argc,const char ** argv,CommandLineParserType commandLineParser)582 int CodeCoverageTool::report(int argc, const char **argv,
583 CommandLineParserType commandLineParser) {
584 auto Err = commandLineParser(argc, argv);
585 if (Err)
586 return Err;
587
588 if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML)
589 error("HTML output for summary reports is not yet supported.");
590
591 auto Coverage = load();
592 if (!Coverage)
593 return 1;
594
595 CoverageReport Report(ViewOpts, std::move(Coverage));
596 if (SourceFiles.empty())
597 Report.renderFileReports(llvm::outs());
598 else
599 Report.renderFunctionReports(SourceFiles, llvm::outs());
600 return 0;
601 }
602
showMain(int argc,const char * argv[])603 int showMain(int argc, const char *argv[]) {
604 CodeCoverageTool Tool;
605 return Tool.run(CodeCoverageTool::Show, argc, argv);
606 }
607
reportMain(int argc,const char * argv[])608 int reportMain(int argc, const char *argv[]) {
609 CodeCoverageTool Tool;
610 return Tool.run(CodeCoverageTool::Report, argc, argv);
611 }
612