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