llvm/tools/llvm-cov/CodeCoverage.cpp

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