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