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 } 1038