1 //===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // The 'CodeCoverageTool' class implements a command line tool to analyze and
11 // report coverage information using the profiling instrumentation and code
14 //===----------------------------------------------------------------------===//
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"
36 #include <system_error>
39 using namespace coverage;
42 /// \brief The implementation of the coverage tool.
43 class CodeCoverageTool {
46 /// \brief The show command.
48 /// \brief The report command.
52 /// \brief Print the error message to the error output stream.
53 void error(const Twine &Message, StringRef Whence = "");
55 /// \brief Return a memory buffer for the given source file.
56 ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
58 /// \brief Create source views for the expansions of the view.
59 void attachExpansionSubViews(SourceCoverageView &View,
60 ArrayRef<ExpansionRecord> Expansions,
61 CoverageMapping &Coverage);
63 /// \brief Create the source view of a particular function.
64 std::unique_ptr<SourceCoverageView>
65 createFunctionView(const FunctionRecord &Function, CoverageMapping &Coverage);
67 /// \brief Create the main source view of a particular source file.
68 std::unique_ptr<SourceCoverageView>
69 createSourceFileView(StringRef SourceFile, CoverageMapping &Coverage);
71 /// \brief Load the coverage mapping data. Return true if an error occured.
72 std::unique_ptr<CoverageMapping> load();
74 int run(Command Cmd, int argc, const char **argv);
76 typedef std::function<int(int, const char **)> CommandLineParserType;
78 int show(int argc, const char **argv,
79 CommandLineParserType commandLineParser);
81 int report(int argc, const char **argv,
82 CommandLineParserType commandLineParser);
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>>>
91 bool CompareFilenamesOnly;
92 StringMap<std::string> RemappedFilenames;
96 void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
99 errs() << Whence << ": ";
100 errs() << Message << "\n";
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;
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);
119 LoadedSourceFiles.push_back(
120 std::make_pair(SourceFile, std::move(Buffer.get())));
121 return *LoadedSourceFiles.back().second;
125 CodeCoverageTool::attachExpansionSubViews(SourceCoverageView &View,
126 ArrayRef<ExpansionRecord> Expansions,
127 CoverageMapping &Coverage) {
128 if (!ViewOpts.ShowExpandedRegions)
130 for (const auto &Expansion : Expansions) {
131 auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
132 if (ExpansionCoverage.empty())
134 auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
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));
146 std::unique_ptr<SourceCoverageView>
147 CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
148 CoverageMapping &Coverage) {
149 auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
150 if (FunctionCoverage.empty())
152 auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
156 auto Expansions = FunctionCoverage.getExpansions();
157 auto View = llvm::make_unique<SourceCoverageView>(
158 SourceBuffer.get(), ViewOpts, std::move(FunctionCoverage));
159 attachExpansionSubViews(*View, Expansions, Coverage);
164 std::unique_ptr<SourceCoverageView>
165 CodeCoverageTool::createSourceFileView(StringRef SourceFile,
166 CoverageMapping &Coverage) {
167 auto SourceBuffer = getSourceFile(SourceFile);
170 auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
171 if (FileCoverage.empty())
174 auto Expansions = FileCoverage.getExpansions();
175 auto View = llvm::make_unique<SourceCoverageView>(
176 SourceBuffer.get(), ViewOpts, std::move(FileCoverage));
177 attachExpansionSubViews(*View, Expansions, Coverage);
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);
187 unsigned FileID = Function->CountedRegions.front().FileID;
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));
198 std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
199 auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename);
200 if (std::error_code EC = CoverageOrErr.getError()) {
201 colored_ostream(errs(), raw_ostream::RED)
202 << "error: Failed to load coverage: " << EC.message();
206 auto Coverage = std::move(CoverageOrErr.get());
207 unsigned Mismatched = Coverage->getMismatchedCount();
209 colored_ostream(errs(), raw_ostream::RED)
210 << "warning: " << Mismatched << " functions have mismatched data. ";
214 if (CompareFilenamesOnly) {
215 auto CoveredFiles = Coverage.get()->getUniqueSourceFiles();
216 for (auto &SF : SourceFiles) {
217 StringRef SFBase = sys::path::filename(SF);
218 for (const auto &CF : CoveredFiles)
219 if (SFBase == sys::path::filename(CF)) {
220 RemappedFilenames[CF] = SF;
230 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
231 // Print a stack trace if we signal out.
232 sys::PrintStackTraceOnErrorSignal();
233 PrettyStackTraceProgram X(argc, argv);
234 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
236 cl::list<std::string> InputSourceFiles(
237 cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
239 cl::opt<std::string, true> PGOFilename(
240 "instr-profile", cl::Required, cl::location(this->PGOFilename),
242 "File with the profile data obtained after an instrumented run"));
244 cl::opt<bool> DebugDump("dump", cl::Optional,
245 cl::desc("Show internal debug dump"));
247 cl::opt<bool> FilenameEquivalence(
248 "filename-equivalence", cl::Optional,
249 cl::desc("Treat source files as equivalent to paths in the coverage data "
250 "when the file names match, even if the full paths do not"));
252 cl::OptionCategory FilteringCategory("Function filtering options");
254 cl::list<std::string> NameFilters(
255 "name", cl::Optional,
256 cl::desc("Show code coverage only for functions with the given name"),
257 cl::ZeroOrMore, cl::cat(FilteringCategory));
259 cl::list<std::string> NameRegexFilters(
260 "name-regex", cl::Optional,
261 cl::desc("Show code coverage only for functions that match the given "
262 "regular expression"),
263 cl::ZeroOrMore, cl::cat(FilteringCategory));
265 cl::opt<double> RegionCoverageLtFilter(
266 "region-coverage-lt", cl::Optional,
267 cl::desc("Show code coverage only for functions with region coverage "
268 "less than the given threshold"),
269 cl::cat(FilteringCategory));
271 cl::opt<double> RegionCoverageGtFilter(
272 "region-coverage-gt", cl::Optional,
273 cl::desc("Show code coverage only for functions with region coverage "
274 "greater than the given threshold"),
275 cl::cat(FilteringCategory));
277 cl::opt<double> LineCoverageLtFilter(
278 "line-coverage-lt", cl::Optional,
279 cl::desc("Show code coverage only for functions with line coverage less "
280 "than the given threshold"),
281 cl::cat(FilteringCategory));
283 cl::opt<double> LineCoverageGtFilter(
284 "line-coverage-gt", cl::Optional,
285 cl::desc("Show code coverage only for functions with line coverage "
286 "greater than the given threshold"),
287 cl::cat(FilteringCategory));
289 auto commandLineParser = [&, this](int argc, const char **argv) -> int {
290 cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
291 ViewOpts.Debug = DebugDump;
292 CompareFilenamesOnly = FilenameEquivalence;
294 // Create the function filters
295 if (!NameFilters.empty() || !NameRegexFilters.empty()) {
296 auto NameFilterer = new CoverageFilters;
297 for (const auto &Name : NameFilters)
298 NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
299 for (const auto &Regex : NameRegexFilters)
300 NameFilterer->push_back(
301 llvm::make_unique<NameRegexCoverageFilter>(Regex));
302 Filters.push_back(std::unique_ptr<CoverageFilter>(NameFilterer));
304 if (RegionCoverageLtFilter.getNumOccurrences() ||
305 RegionCoverageGtFilter.getNumOccurrences() ||
306 LineCoverageLtFilter.getNumOccurrences() ||
307 LineCoverageGtFilter.getNumOccurrences()) {
308 auto StatFilterer = new CoverageFilters;
309 if (RegionCoverageLtFilter.getNumOccurrences())
310 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
311 RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
312 if (RegionCoverageGtFilter.getNumOccurrences())
313 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
314 RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
315 if (LineCoverageLtFilter.getNumOccurrences())
316 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
317 LineCoverageFilter::LessThan, LineCoverageLtFilter));
318 if (LineCoverageGtFilter.getNumOccurrences())
319 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
320 RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
321 Filters.push_back(std::unique_ptr<CoverageFilter>(StatFilterer));
324 for (const auto &File : InputSourceFiles) {
325 SmallString<128> Path(File);
326 if (std::error_code EC = sys::fs::make_absolute(Path)) {
327 errs() << "error: " << File << ": " << EC.message();
330 SourceFiles.push_back(Path.str());
335 // Parse the object filename
337 StringRef Arg(argv[1]);
338 if (Arg.equals_lower("-help") || Arg.equals_lower("-version")) {
339 cl::ParseCommandLineOptions(2, argv, "LLVM code coverage tool\n");
342 ObjectFilename = Arg;
348 errs() << sys::path::filename(argv[0]) << ": No executable file given!\n";
354 return show(argc, argv, commandLineParser);
356 return report(argc, argv, commandLineParser);
361 int CodeCoverageTool::show(int argc, const char **argv,
362 CommandLineParserType commandLineParser) {
364 cl::OptionCategory ViewCategory("Viewing options");
366 cl::opt<bool> ShowLineExecutionCounts(
367 "show-line-counts", cl::Optional,
368 cl::desc("Show the execution counts for each line"), cl::init(true),
369 cl::cat(ViewCategory));
371 cl::opt<bool> ShowRegions(
372 "show-regions", cl::Optional,
373 cl::desc("Show the execution counts for each region"),
374 cl::cat(ViewCategory));
376 cl::opt<bool> ShowBestLineRegionsCounts(
377 "show-line-counts-or-regions", cl::Optional,
378 cl::desc("Show the execution counts for each line, or the execution "
379 "counts for each region on lines that have multiple regions"),
380 cl::cat(ViewCategory));
382 cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
383 cl::desc("Show expanded source regions"),
384 cl::cat(ViewCategory));
386 cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
387 cl::desc("Show function instantiations"),
388 cl::cat(ViewCategory));
390 cl::opt<bool> NoColors("no-colors", cl::Optional,
391 cl::desc("Don't show text colors"), cl::init(false),
392 cl::cat(ViewCategory));
394 auto Err = commandLineParser(argc, argv);
398 ViewOpts.Colors = !NoColors;
399 ViewOpts.ShowLineNumbers = true;
400 ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
401 !ShowRegions || ShowBestLineRegionsCounts;
402 ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
403 ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
404 ViewOpts.ShowExpandedRegions = ShowExpansions;
405 ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
407 auto Coverage = load();
411 if (!Filters.empty()) {
413 for (const auto &Function : Coverage->getCoveredFunctions()) {
414 if (!Filters.matches(Function))
417 auto mainView = createFunctionView(Function, *Coverage);
419 ViewOpts.colored_ostream(outs(), raw_ostream::RED)
420 << "warning: Could not read coverage for '" << Function.Name;
424 ViewOpts.colored_ostream(outs(), raw_ostream::CYAN) << Function.Name
427 mainView->render(outs(), /*WholeFile=*/false);
434 bool ShowFilenames = SourceFiles.size() != 1;
436 if (SourceFiles.empty())
437 // Get the source files from the function coverage mapping
438 for (StringRef Filename : Coverage->getUniqueSourceFiles())
439 SourceFiles.push_back(Filename);
441 for (const auto &SourceFile : SourceFiles) {
442 auto mainView = createSourceFileView(SourceFile, *Coverage);
444 ViewOpts.colored_ostream(outs(), raw_ostream::RED)
445 << "warning: The file '" << SourceFile << "' isn't covered.";
451 ViewOpts.colored_ostream(outs(), raw_ostream::CYAN) << SourceFile << ":";
454 mainView->render(outs(), /*Wholefile=*/true);
455 if (SourceFiles.size() > 1)
462 int CodeCoverageTool::report(int argc, const char **argv,
463 CommandLineParserType commandLineParser) {
464 cl::opt<bool> NoColors("no-colors", cl::Optional,
465 cl::desc("Don't show text colors"), cl::init(false));
467 auto Err = commandLineParser(argc, argv);
471 ViewOpts.Colors = !NoColors;
473 auto Coverage = load();
477 CoverageSummary Summarizer;
478 Summarizer.createSummaries(Coverage->getCoveredFunctions());
479 CoverageReport Report(ViewOpts, Summarizer);
480 if (SourceFiles.empty() && Filters.empty()) {
481 Report.renderFileReports(llvm::outs());
485 Report.renderFunctionReports(llvm::outs());
489 int show_main(int argc, const char **argv) {
490 CodeCoverageTool Tool;
491 return Tool.run(CodeCoverageTool::Show, argc, argv);
494 int report_main(int argc, const char **argv) {
495 CodeCoverageTool Tool;
496 return Tool.run(CodeCoverageTool::Report, argc, argv);