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