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