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