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