tools/llvm-cov/CodeCoverage.cpp

   1 //===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // The 'CodeCoverageTool' class implements a command line tool to analyze and
  11 // report coverage information using the profiling instrumentation and code
  12 // coverage mapping.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "RenderingSupport.h"
  17 #include "CoverageFilters.h"
  18 #include "CoverageReport.h"
  19 #include "CoverageViewOptions.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/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/ManagedStatic.h"
  30 #include "llvm/Support/Path.h"
  31 #include "llvm/Support/PrettyStackTrace.h"
  32 #include "llvm/Support/Process.h"
  33 #include "llvm/Support/Signals.h"
  34 #include <functional>
  35 #include <system_error>
  36
  37 using namespace llvm;
  38 using namespace coverage;
  39
  40 namespace {
  41 /// \brief The implementation of the coverage tool.
  42 class CodeCoverageTool {
  43 public:
  44   enum Command {
  45     /// \brief The show command.
  46     Show,
  47     /// \brief The report command.
  48     Report
  49   };
  50
  51   /// \brief Print the error message to the error output stream.
  52   void error(const Twine &Message, StringRef Whence = "");
  53
  54   /// \brief Return a memory buffer for the given source file.
  55   ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
  56
  57   /// \brief Create source views for the expansions of the view.
  58   void attachExpansionSubViews(SourceCoverageView &View,
  59                                ArrayRef<ExpansionRecord> Expansions,
  60                                CoverageMapping &Coverage);
  61
  62   /// \brief Create the source view of a particular function.
  63   std::unique_ptr<SourceCoverageView>
  64   createFunctionView(const FunctionRecord &Function, CoverageMapping &Coverage);
  65
  66   /// \brief Create the main source view of a particular source file.
  67   std::unique_ptr<SourceCoverageView>
  68   createSourceFileView(StringRef SourceFile, CoverageMapping &Coverage);
  69
  70   /// \brief Load the coverage mapping data. Return true if an error occured.
  71   std::unique_ptr<CoverageMapping> load();
  72
  73   int run(Command Cmd, int argc, const char **argv);
  74
  75   typedef std::function<int(int, const char **)> CommandLineParserType;
  76
  77   int show(int argc, const char **argv,
  78            CommandLineParserType commandLineParser);
  79
  80   int report(int argc, const char **argv,
  81              CommandLineParserType commandLineParser);
  82
  83   std::string ObjectFilename;
  84   CoverageViewOptions ViewOpts;
  85   std::string PGOFilename;
  86   CoverageFiltersMatchAll Filters;
  87   std::vector<std::string> SourceFiles;
  88   std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
  89       LoadedSourceFiles;
  90   bool CompareFilenamesOnly;
  91   StringMap<std::string> RemappedFilenames;
  92   std::string CoverageArch;
  93 };
  94 }
  95
  96 void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
  97   errs() << "error: ";
  98   if (!Whence.empty())
  99     errs() << Whence << ": ";
 100   errs() << Message << "\n";
 101 }
 102
 103 ErrorOr<const MemoryBuffer &>
 104 CodeCoverageTool::getSourceFile(StringRef SourceFile) {
 105   // If we've remapped filenames, look up the real location for this file.
 106   if (!RemappedFilenames.empty()) {
 107     auto Loc = RemappedFilenames.find(SourceFile);
 108     if (Loc != RemappedFilenames.end())
 109       SourceFile = Loc->second;
 110   }
 111   for (const auto &Files : LoadedSourceFiles)
 112     if (sys::fs::equivalent(SourceFile, Files.first))
 113       return *Files.second;
 114   auto Buffer = MemoryBuffer::getFile(SourceFile);
 115   if (auto EC = Buffer.getError()) {
 116     error(EC.message(), SourceFile);
 117     return EC;
 118   }
 119   LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
 120   return *LoadedSourceFiles.back().second;
 121 }
 122
 123 void
 124 CodeCoverageTool::attachExpansionSubViews(SourceCoverageView &View,
 125                                           ArrayRef<ExpansionRecord> Expansions,
 126                                           CoverageMapping &Coverage) {
 127   if (!ViewOpts.ShowExpandedRegions)
 128     return;
 129   for (const auto &Expansion : Expansions) {
 130     auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
 131     if (ExpansionCoverage.empty())
 132       continue;
 133     auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
 134     if (!SourceBuffer)
 135       continue;
 136
 137     auto SubViewExpansions = ExpansionCoverage.getExpansions();
 138     auto SubView = llvm::make_unique<SourceCoverageView>(
 139         SourceBuffer.get(), ViewOpts, std::move(ExpansionCoverage));
 140     attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
 141     View.addExpansion(Expansion.Region, std::move(SubView));
 142   }
 143 }
 144
 145 std::unique_ptr<SourceCoverageView>
 146 CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
 147                                      CoverageMapping &Coverage) {
 148   auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
 149   if (FunctionCoverage.empty())
 150     return nullptr;
 151   auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
 152   if (!SourceBuffer)
 153     return nullptr;
 154
 155   auto Expansions = FunctionCoverage.getExpansions();
 156   auto View = llvm::make_unique<SourceCoverageView>(
 157       SourceBuffer.get(), ViewOpts, std::move(FunctionCoverage));
 158   attachExpansionSubViews(*View, Expansions, Coverage);
 159
 160   return View;
 161 }
 162
 163 std::unique_ptr<SourceCoverageView>
 164 CodeCoverageTool::createSourceFileView(StringRef SourceFile,
 165                                        CoverageMapping &Coverage) {
 166   auto SourceBuffer = getSourceFile(SourceFile);
 167   if (!SourceBuffer)
 168     return nullptr;
 169   auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
 170   if (FileCoverage.empty())
 171     return nullptr;
 172
 173   auto Expansions = FileCoverage.getExpansions();
 174   auto View = llvm::make_unique<SourceCoverageView>(
 175       SourceBuffer.get(), ViewOpts, std::move(FileCoverage));
 176   attachExpansionSubViews(*View, Expansions, Coverage);
 177
 178   for (auto Function : Coverage.getInstantiations(SourceFile)) {
 179     auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
 180     auto SubViewExpansions = SubViewCoverage.getExpansions();
 181     auto SubView = llvm::make_unique<SourceCoverageView>(
 182         SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
 183     attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
 184
 185     if (SubView) {
 186       unsigned FileID = Function->CountedRegions.front().FileID;
 187       unsigned Line = 0;
 188       for (const auto &CR : Function->CountedRegions)
 189         if (CR.FileID == FileID)
 190           Line = std::max(CR.LineEnd, Line);
 191       View->addInstantiation(Function->Name, Line, std::move(SubView));
 192     }
 193   }
 194   return View;
 195 }
 196
 197 static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
 198   sys::fs::file_status Status;
 199   if (sys::fs::status(LHS, Status))
 200     return false;
 201   auto LHSTime = Status.getLastModificationTime();
 202   if (sys::fs::status(RHS, Status))
 203     return false;
 204   auto RHSTime = Status.getLastModificationTime();
 205   return LHSTime > RHSTime;
 206 }
 207
 208 std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
 209   if (modifiedTimeGT(ObjectFilename, PGOFilename))
 210     errs() << "warning: profile data may be out of date - object is newer\n";
 211   auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename,
 212                                              CoverageArch);
 213   if (std::error_code EC = CoverageOrErr.getError()) {
 214     colored_ostream(errs(), raw_ostream::RED)
 215         << "error: Failed to load coverage: " << EC.message();
 216     errs() << "\n";
 217     return nullptr;
 218   }
 219   auto Coverage = std::move(CoverageOrErr.get());
 220   unsigned Mismatched = Coverage->getMismatchedCount();
 221   if (Mismatched) {
 222     colored_ostream(errs(), raw_ostream::RED)
 223         << "warning: " << Mismatched << " functions have mismatched data. ";
 224     errs() << "\n";
 225   }
 226
 227   if (CompareFilenamesOnly) {
 228     auto CoveredFiles = Coverage.get()->getUniqueSourceFiles();
 229     for (auto &SF : SourceFiles) {
 230       StringRef SFBase = sys::path::filename(SF);
 231       for (const auto &CF : CoveredFiles)
 232         if (SFBase == sys::path::filename(CF)) {
 233           RemappedFilenames[CF] = SF;
 234           SF = CF;
 235           break;
 236         }
 237     }
 238   }
 239
 240   return Coverage;
 241 }
 242
 243 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
 244   // Print a stack trace if we signal out.
 245   sys::PrintStackTraceOnErrorSignal();
 246   PrettyStackTraceProgram X(argc, argv);
 247   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 248
 249   cl::opt<std::string, true> ObjectFilename(
 250       cl::Positional, cl::Required, cl::location(this->ObjectFilename),
 251       cl::desc("Covered executable or object file."));
 252
 253   cl::list<std::string> InputSourceFiles(
 254       cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
 255
 256   cl::opt<std::string, true> PGOFilename(
 257       "instr-profile", cl::Required, cl::location(this->PGOFilename),
 258       cl::desc(
 259           "File with the profile data obtained after an instrumented run"));
 260
 261   cl::opt<std::string> Arch(
 262       "arch", cl::desc("architecture of the coverage mapping binary"));
 263
 264   cl::opt<bool> DebugDump("dump", cl::Optional,
 265                           cl::desc("Show internal debug dump"));
 266
 267   cl::opt<bool> FilenameEquivalence(
 268       "filename-equivalence", cl::Optional,
 269       cl::desc("Treat source files as equivalent to paths in the coverage data "
 270                "when the file names match, even if the full paths do not"));
 271
 272   cl::OptionCategory FilteringCategory("Function filtering options");
 273
 274   cl::list<std::string> NameFilters(
 275       "name", cl::Optional,
 276       cl::desc("Show code coverage only for functions with the given name"),
 277       cl::ZeroOrMore, cl::cat(FilteringCategory));
 278
 279   cl::list<std::string> NameRegexFilters(
 280       "name-regex", cl::Optional,
 281       cl::desc("Show code coverage only for functions that match the given "
 282                "regular expression"),
 283       cl::ZeroOrMore, cl::cat(FilteringCategory));
 284
 285   cl::opt<double> RegionCoverageLtFilter(
 286       "region-coverage-lt", cl::Optional,
 287       cl::desc("Show code coverage only for functions with region coverage "
 288                "less than the given threshold"),
 289       cl::cat(FilteringCategory));
 290
 291   cl::opt<double> RegionCoverageGtFilter(
 292       "region-coverage-gt", cl::Optional,
 293       cl::desc("Show code coverage only for functions with region coverage "
 294                "greater than the given threshold"),
 295       cl::cat(FilteringCategory));
 296
 297   cl::opt<double> LineCoverageLtFilter(
 298       "line-coverage-lt", cl::Optional,
 299       cl::desc("Show code coverage only for functions with line coverage less "
 300                "than the given threshold"),
 301       cl::cat(FilteringCategory));
 302
 303   cl::opt<double> LineCoverageGtFilter(
 304       "line-coverage-gt", cl::Optional,
 305       cl::desc("Show code coverage only for functions with line coverage "
 306                "greater than the given threshold"),
 307       cl::cat(FilteringCategory));
 308
 309   cl::opt<cl::boolOrDefault> UseColor(
 310       "use-color", cl::desc("Emit colored output (default=autodetect)"),
 311       cl::init(cl::BOU_UNSET));
 312
 313   auto commandLineParser = [&, this](int argc, const char **argv) -> int {
 314     cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
 315     ViewOpts.Debug = DebugDump;
 316     CompareFilenamesOnly = FilenameEquivalence;
 317
 318     ViewOpts.Colors = UseColor == cl::BOU_UNSET
 319                           ? sys::Process::StandardOutHasColors()
 320                           : UseColor == cl::BOU_TRUE;
 321
 322     // Create the function filters
 323     if (!NameFilters.empty() || !NameRegexFilters.empty()) {
 324       auto NameFilterer = new CoverageFilters;
 325       for (const auto &Name : NameFilters)
 326         NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
 327       for (const auto &Regex : NameRegexFilters)
 328         NameFilterer->push_back(
 329             llvm::make_unique<NameRegexCoverageFilter>(Regex));
 330       Filters.push_back(std::unique_ptr<CoverageFilter>(NameFilterer));
 331     }
 332     if (RegionCoverageLtFilter.getNumOccurrences() ||
 333         RegionCoverageGtFilter.getNumOccurrences() ||
 334         LineCoverageLtFilter.getNumOccurrences() ||
 335         LineCoverageGtFilter.getNumOccurrences()) {
 336       auto StatFilterer = new CoverageFilters;
 337       if (RegionCoverageLtFilter.getNumOccurrences())
 338         StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
 339             RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
 340       if (RegionCoverageGtFilter.getNumOccurrences())
 341         StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
 342             RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
 343       if (LineCoverageLtFilter.getNumOccurrences())
 344         StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
 345             LineCoverageFilter::LessThan, LineCoverageLtFilter));
 346       if (LineCoverageGtFilter.getNumOccurrences())
 347         StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
 348             RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
 349       Filters.push_back(std::unique_ptr<CoverageFilter>(StatFilterer));
 350     }
 351
 352     if (!Arch.empty() &&
 353         Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
 354       errs() << "error: Unknown architecture: " << Arch << "\n";
 355       return 1;
 356     }
 357     CoverageArch = Arch;
 358
 359     for (const auto &File : InputSourceFiles) {
 360       SmallString<128> Path(File);
 361       if (!CompareFilenamesOnly)
 362         if (std::error_code EC = sys::fs::make_absolute(Path)) {
 363           errs() << "error: " << File << ": " << EC.message();
 364           return 1;
 365         }
 366       SourceFiles.push_back(Path.str());
 367     }
 368     return 0;
 369   };
 370
 371   switch (Cmd) {
 372   case Show:
 373     return show(argc, argv, commandLineParser);
 374   case Report:
 375     return report(argc, argv, commandLineParser);
 376   }
 377   return 0;
 378 }
 379
 380 int CodeCoverageTool::show(int argc, const char **argv,
 381                            CommandLineParserType commandLineParser) {
 382
 383   cl::OptionCategory ViewCategory("Viewing options");
 384
 385   cl::opt<bool> ShowLineExecutionCounts(
 386       "show-line-counts", cl::Optional,
 387       cl::desc("Show the execution counts for each line"), cl::init(true),
 388       cl::cat(ViewCategory));
 389
 390   cl::opt<bool> ShowRegions(
 391       "show-regions", cl::Optional,
 392       cl::desc("Show the execution counts for each region"),
 393       cl::cat(ViewCategory));
 394
 395   cl::opt<bool> ShowBestLineRegionsCounts(
 396       "show-line-counts-or-regions", cl::Optional,
 397       cl::desc("Show the execution counts for each line, or the execution "
 398                "counts for each region on lines that have multiple regions"),
 399       cl::cat(ViewCategory));
 400
 401   cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
 402                                cl::desc("Show expanded source regions"),
 403                                cl::cat(ViewCategory));
 404
 405   cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
 406                                    cl::desc("Show function instantiations"),
 407                                    cl::cat(ViewCategory));
 408
 409   auto Err = commandLineParser(argc, argv);
 410   if (Err)
 411     return Err;
 412
 413   ViewOpts.ShowLineNumbers = true;
 414   ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
 415                            !ShowRegions || ShowBestLineRegionsCounts;
 416   ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
 417   ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
 418   ViewOpts.ShowExpandedRegions = ShowExpansions;
 419   ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
 420
 421   auto Coverage = load();
 422   if (!Coverage)
 423     return 1;
 424
 425   if (!Filters.empty()) {
 426     // Show functions
 427     for (const auto &Function : Coverage->getCoveredFunctions()) {
 428       if (!Filters.matches(Function))
 429         continue;
 430
 431       auto mainView = createFunctionView(Function, *Coverage);
 432       if (!mainView) {
 433         ViewOpts.colored_ostream(outs(), raw_ostream::RED)
 434             << "warning: Could not read coverage for '" << Function.Name;
 435         outs() << "\n";
 436         continue;
 437       }
 438       ViewOpts.colored_ostream(outs(), raw_ostream::CYAN) << Function.Name
 439                                                           << ":";
 440       outs() << "\n";
 441       mainView->render(outs(), /*WholeFile=*/false);
 442       outs() << "\n";
 443     }
 444     return 0;
 445   }
 446
 447   // Show files
 448   bool ShowFilenames = SourceFiles.size() != 1;
 449
 450   if (SourceFiles.empty())
 451     // Get the source files from the function coverage mapping
 452     for (StringRef Filename : Coverage->getUniqueSourceFiles())
 453       SourceFiles.push_back(Filename);
 454
 455   for (const auto &SourceFile : SourceFiles) {
 456     auto mainView = createSourceFileView(SourceFile, *Coverage);
 457     if (!mainView) {
 458       ViewOpts.colored_ostream(outs(), raw_ostream::RED)
 459           << "warning: The file '" << SourceFile << "' isn't covered.";
 460       outs() << "\n";
 461       continue;
 462     }
 463
 464     if (ShowFilenames) {
 465       ViewOpts.colored_ostream(outs(), raw_ostream::CYAN) << SourceFile << ":";
 466       outs() << "\n";
 467     }
 468     mainView->render(outs(), /*Wholefile=*/true);
 469     if (SourceFiles.size() > 1)
 470       outs() << "\n";
 471   }
 472
 473   return 0;
 474 }
 475
 476 int CodeCoverageTool::report(int argc, const char **argv,
 477                              CommandLineParserType commandLineParser) {
 478   auto Err = commandLineParser(argc, argv);
 479   if (Err)
 480     return Err;
 481
 482   auto Coverage = load();
 483   if (!Coverage)
 484     return 1;
 485
 486   CoverageReport Report(ViewOpts, std::move(Coverage));
 487   if (SourceFiles.empty())
 488     Report.renderFileReports(llvm::outs());
 489   else
 490     Report.renderFunctionReports(SourceFiles, llvm::outs());
 491   return 0;
 492 }
 493
 494 int showMain(int argc, const char *argv[]) {
 495   CodeCoverageTool Tool;
 496   return Tool.run(CodeCoverageTool::Show, argc, argv);
 497 }
 498
 499 int reportMain(int argc, const char *argv[]) {
 500   CodeCoverageTool Tool;
 501   return Tool.run(CodeCoverageTool::Report, argc, argv);
 502 }