tools/llvm-cov/CodeCoverage.cpp

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