blob: 430cb0b50c9ff785505514943a19f092f57d18b4 [file] [log] [blame]
Alex Lorenze82d89c2014-08-22 22:56:03 +00001//===- 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
Max Moroz1ef3a772018-01-04 19:33:29 +000016#include "CoverageExporterJson.h"
Alex Lorenze82d89c2014-08-22 22:56:03 +000017#include "CoverageFilters.h"
Alex Lorenze82d89c2014-08-22 22:56:03 +000018#include "CoverageReport.h"
Vedant Kumar6e28bcd2017-02-05 20:10:58 +000019#include "CoverageSummaryInfo.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000020#include "CoverageViewOptions.h"
Easwaran Ramandc707122016-04-29 18:53:05 +000021#include "RenderingSupport.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000022#include "SourceCoverageView.h"
Alex Lorenze82d89c2014-08-22 22:56:03 +000023#include "llvm/ADT/SmallString.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000024#include "llvm/ADT/StringRef.h"
Justin Bogner43795352015-03-11 02:30:51 +000025#include "llvm/ADT/Triple.h"
Easwaran Ramandc707122016-04-29 18:53:05 +000026#include "llvm/ProfileData/Coverage/CoverageMapping.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000027#include "llvm/ProfileData/InstrProfReader.h"
Alex Lorenze82d89c2014-08-22 22:56:03 +000028#include "llvm/Support/CommandLine.h"
29#include "llvm/Support/FileSystem.h"
Alex Lorenze82d89c2014-08-22 22:56:03 +000030#include "llvm/Support/Format.h"
Vedant Kumar424f51b2016-07-15 22:44:57 +000031#include "llvm/Support/MemoryBuffer.h"
Alex Lorenze82d89c2014-08-22 22:56:03 +000032#include "llvm/Support/Path.h"
Justin Bognercfb53e42015-03-19 00:02:23 +000033#include "llvm/Support/Process.h"
Vedant Kumar424f51b2016-07-15 22:44:57 +000034#include "llvm/Support/Program.h"
Pavel Labath757ca882016-10-24 10:59:17 +000035#include "llvm/Support/ScopedPrinter.h"
Vedant Kumar86b2ac632016-07-13 21:38:36 +000036#include "llvm/Support/ThreadPool.h"
Max Morozcc254ba2018-01-05 16:15:07 +000037#include "llvm/Support/Threading.h"
Vedant Kumar424f51b2016-07-15 22:44:57 +000038#include "llvm/Support/ToolOutputFile.h"
Sean Evesonfa8ef352017-09-28 10:07:30 +000039
Alex Lorenze82d89c2014-08-22 22:56:03 +000040#include <functional>
Sean Evesonfa8ef352017-09-28 10:07:30 +000041#include <map>
Justin Bognere53be062014-09-09 05:32:18 +000042#include <system_error>
Alex Lorenze82d89c2014-08-22 22:56:03 +000043
44using namespace llvm;
45using namespace coverage;
46
Vedant Kumar5c61c702016-10-25 00:08:33 +000047void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping,
Vedant Kumar72c3a112017-09-08 18:44:49 +000048 const CoverageViewOptions &Options,
Vedant Kumar7101d732016-07-26 22:50:58 +000049 raw_ostream &OS);
50
Alex Lorenze82d89c2014-08-22 22:56:03 +000051namespace {
Alex Lorenze82d89c2014-08-22 22:56:03 +000052/// \brief The implementation of the coverage tool.
53class CodeCoverageTool {
54public:
55 enum Command {
56 /// \brief The show command.
57 Show,
58 /// \brief The report command.
Vedant Kumar7101d732016-07-26 22:50:58 +000059 Report,
60 /// \brief The export command.
61 Export
Alex Lorenze82d89c2014-08-22 22:56:03 +000062 };
63
Vedant Kumar46103672016-09-22 21:49:47 +000064 int run(Command Cmd, int argc, const char **argv);
65
66private:
Alex Lorenze82d89c2014-08-22 22:56:03 +000067 /// \brief Print the error message to the error output stream.
68 void error(const Twine &Message, StringRef Whence = "");
69
Vedant Kumarb3020632016-07-18 17:53:12 +000070 /// \brief Print the warning message to the error output stream.
71 void warning(const Twine &Message, StringRef Whence = "");
Vedant Kumar86b2ac632016-07-13 21:38:36 +000072
Vedant Kumarbc647982016-09-23 18:57:32 +000073 /// \brief Convert \p Path into an absolute path and append it to the list
74 /// of collected paths.
Vedant Kumarcef440f2016-06-28 16:12:18 +000075 void addCollectedPath(const std::string &Path);
76
Vedant Kumar1ce90d82016-09-22 21:49:43 +000077 /// \brief If \p Path is a regular file, collect the path. If it's a
78 /// directory, recursively collect all of the paths within the directory.
79 void collectPaths(const std::string &Path);
80
Alex Lorenze82d89c2014-08-22 22:56:03 +000081 /// \brief Return a memory buffer for the given source file.
82 ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
83
Justin Bogner953e2402014-09-20 15:31:56 +000084 /// \brief Create source views for the expansions of the view.
85 void attachExpansionSubViews(SourceCoverageView &View,
86 ArrayRef<ExpansionRecord> Expansions,
Vedant Kumarf681e2e2016-07-15 01:19:33 +000087 const CoverageMapping &Coverage);
Alex Lorenze82d89c2014-08-22 22:56:03 +000088
Justin Bogner953e2402014-09-20 15:31:56 +000089 /// \brief Create the source view of a particular function.
Justin Bogner5a6edad2014-09-19 19:07:17 +000090 std::unique_ptr<SourceCoverageView>
Vedant Kumarf681e2e2016-07-15 01:19:33 +000091 createFunctionView(const FunctionRecord &Function,
92 const CoverageMapping &Coverage);
Alex Lorenze82d89c2014-08-22 22:56:03 +000093
94 /// \brief Create the main source view of a particular source file.
Justin Bogner5a6edad2014-09-19 19:07:17 +000095 std::unique_ptr<SourceCoverageView>
Vedant Kumarf681e2e2016-07-15 01:19:33 +000096 createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
Alex Lorenze82d89c2014-08-22 22:56:03 +000097
Simon Pilgrimdae11f72016-11-20 13:31:13 +000098 /// \brief Load the coverage mapping data. Return nullptr if an error occurred.
Justin Bogner953e2402014-09-20 15:31:56 +000099 std::unique_ptr<CoverageMapping> load();
Alex Lorenze82d89c2014-08-22 22:56:03 +0000100
Sean Eveson9edfeac2017-08-14 10:20:12 +0000101 /// \brief Create a mapping from files in the Coverage data to local copies
102 /// (path-equivalence).
103 void remapPathNames(const CoverageMapping &Coverage);
104
Vedant Kumarcab52ad2016-09-23 20:13:41 +0000105 /// \brief Remove input source files which aren't mapped by \p Coverage.
106 void removeUnmappedInputs(const CoverageMapping &Coverage);
107
Vedant Kumar424f51b2016-07-15 22:44:57 +0000108 /// \brief If a demangler is available, demangle all symbol names.
109 void demangleSymbols(const CoverageMapping &Coverage);
110
Vedant Kumar6fd94bf2016-10-19 17:55:44 +0000111 /// \brief Write out a source file view to the filesystem.
112 void writeSourceFileView(StringRef SourceFile, CoverageMapping *Coverage,
113 CoveragePrinter *Printer, bool ShowFilenames);
114
Benjamin Kramerc321e532016-06-08 19:09:22 +0000115 typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000116
Max Moroz1ef3a772018-01-04 19:33:29 +0000117 int doShow(int argc, const char **argv,
Alex Lorenze82d89c2014-08-22 22:56:03 +0000118 CommandLineParserType commandLineParser);
119
Max Moroz1ef3a772018-01-04 19:33:29 +0000120 int doReport(int argc, const char **argv,
121 CommandLineParserType commandLineParser);
122
123 int doExport(int argc, const char **argv,
124 CommandLineParserType commandLineParser);
Vedant Kumar7101d732016-07-26 22:50:58 +0000125
Vedant Kumara3661ef2016-10-25 17:40:55 +0000126 std::vector<StringRef> ObjectFilenames;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000127 CoverageViewOptions ViewOpts;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000128 CoverageFiltersMatchAll Filters;
Max Moroz4220f892018-04-09 15:20:35 +0000129 CoverageFilters IgnoreFilenameFilters;
Vedant Kumar46103672016-09-22 21:49:47 +0000130
131 /// The path to the indexed profile.
132 std::string PGOFilename;
133
134 /// A list of input source files.
Vedant Kumarbc647982016-09-23 18:57:32 +0000135 std::vector<std::string> SourceFiles;
Vedant Kumar46103672016-09-22 21:49:47 +0000136
Sean Eveson9edfeac2017-08-14 10:20:12 +0000137 /// In -path-equivalence mode, this maps the absolute paths from the coverage
138 /// mapping data to the input source files.
Justin Bogner116c1662014-09-19 08:13:12 +0000139 StringMap<std::string> RemappedFilenames;
Vedant Kumar46103672016-09-22 21:49:47 +0000140
Sean Eveson9edfeac2017-08-14 10:20:12 +0000141 /// The coverage data path to be remapped from, and the source path to be
142 /// remapped to, when using -path-equivalence.
143 Optional<std::pair<std::string, std::string>> PathRemapping;
144
Vedant Kumar46103672016-09-22 21:49:47 +0000145 /// The architecture the coverage mapping data targets.
Vedant Kumar4b102c32017-08-01 21:23:26 +0000146 std::vector<StringRef> CoverageArches;
Vedant Kumarcef440f2016-06-28 16:12:18 +0000147
Vedant Kumar6e28bcd2017-02-05 20:10:58 +0000148 /// A cache for demangled symbols.
149 DemangleCache DC;
Vedant Kumar424f51b2016-07-15 22:44:57 +0000150
Vedant Kumarb6bfd472017-02-05 20:10:55 +0000151 /// A lock which guards printing to stderr.
Vedant Kumarb3020632016-07-18 17:53:12 +0000152 std::mutex ErrsLock;
Vedant Kumar86b2ac632016-07-13 21:38:36 +0000153
Vedant Kumar6ab6b362016-07-15 22:44:54 +0000154 /// A container for input source file buffers.
Vedant Kumar86b2ac632016-07-13 21:38:36 +0000155 std::mutex LoadedSourceFilesLock;
156 std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
157 LoadedSourceFiles;
Sean Evesone15300e2017-08-31 09:11:31 +0000158
159 /// Whitelist from -name-whitelist to be used for filtering.
160 std::unique_ptr<SpecialCaseList> NameWhitelist;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000161};
162}
163
Vedant Kumar86b2ac632016-07-13 21:38:36 +0000164static std::string getErrorString(const Twine &Message, StringRef Whence,
165 bool Warning) {
166 std::string Str = (Warning ? "warning" : "error");
167 Str += ": ";
Alex Lorenze82d89c2014-08-22 22:56:03 +0000168 if (!Whence.empty())
Vedant Kumarb95dc462016-07-15 01:53:39 +0000169 Str += Whence.str() + ": ";
Vedant Kumar86b2ac632016-07-13 21:38:36 +0000170 Str += Message.str() + "\n";
171 return Str;
172}
173
174void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
Vedant Kumarb3020632016-07-18 17:53:12 +0000175 std::unique_lock<std::mutex> Guard{ErrsLock};
176 ViewOpts.colored_ostream(errs(), raw_ostream::RED)
177 << getErrorString(Message, Whence, false);
Vedant Kumar86b2ac632016-07-13 21:38:36 +0000178}
179
Vedant Kumarb3020632016-07-18 17:53:12 +0000180void CodeCoverageTool::warning(const Twine &Message, StringRef Whence) {
181 std::unique_lock<std::mutex> Guard{ErrsLock};
182 ViewOpts.colored_ostream(errs(), raw_ostream::RED)
183 << getErrorString(Message, Whence, true);
Alex Lorenze82d89c2014-08-22 22:56:03 +0000184}
185
Vedant Kumarcef440f2016-06-28 16:12:18 +0000186void CodeCoverageTool::addCollectedPath(const std::string &Path) {
Sean Eveson9edfeac2017-08-14 10:20:12 +0000187 SmallString<128> EffectivePath(Path);
188 if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
189 error(EC.message(), Path);
190 return;
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000191 }
Sean Eveson9edfeac2017-08-14 10:20:12 +0000192 sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
Max Moroz4220f892018-04-09 15:20:35 +0000193 if (!IgnoreFilenameFilters.matchesFilename(EffectivePath))
194 SourceFiles.emplace_back(EffectivePath.str());
Vedant Kumarcef440f2016-06-28 16:12:18 +0000195}
196
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000197void CodeCoverageTool::collectPaths(const std::string &Path) {
198 llvm::sys::fs::file_status Status;
199 llvm::sys::fs::status(Path, Status);
200 if (!llvm::sys::fs::exists(Status)) {
Sean Eveson9edfeac2017-08-14 10:20:12 +0000201 if (PathRemapping)
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000202 addCollectedPath(Path);
203 else
Max Moroz650fd6c2018-04-05 19:43:24 +0000204 warning("Source file doesn't exist, proceeded by ignoring it.", Path);
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000205 return;
206 }
207
208 if (llvm::sys::fs::is_regular_file(Status)) {
209 addCollectedPath(Path);
210 return;
211 }
212
213 if (llvm::sys::fs::is_directory(Status)) {
214 std::error_code EC;
215 for (llvm::sys::fs::recursive_directory_iterator F(Path, EC), E;
Max Moroz650fd6c2018-04-05 19:43:24 +0000216 F != E; F.increment(EC)) {
217
218 if (EC) {
219 warning(EC.message(), F->path());
220 continue;
221 }
222
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000223 if (llvm::sys::fs::is_regular_file(F->path()))
224 addCollectedPath(F->path());
225 }
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000226 }
227}
228
Alex Lorenze82d89c2014-08-22 22:56:03 +0000229ErrorOr<const MemoryBuffer &>
230CodeCoverageTool::getSourceFile(StringRef SourceFile) {
Justin Bogner116c1662014-09-19 08:13:12 +0000231 // If we've remapped filenames, look up the real location for this file.
Vedant Kumar615b85d2016-07-15 01:19:36 +0000232 std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
Justin Bogner116c1662014-09-19 08:13:12 +0000233 if (!RemappedFilenames.empty()) {
234 auto Loc = RemappedFilenames.find(SourceFile);
235 if (Loc != RemappedFilenames.end())
236 SourceFile = Loc->second;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000237 }
Justin Bogner116c1662014-09-19 08:13:12 +0000238 for (const auto &Files : LoadedSourceFiles)
239 if (sys::fs::equivalent(SourceFile, Files.first))
240 return *Files.second;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000241 auto Buffer = MemoryBuffer::getFile(SourceFile);
242 if (auto EC = Buffer.getError()) {
Vedant Kumarb3020632016-07-18 17:53:12 +0000243 error(EC.message(), SourceFile);
Alex Lorenze82d89c2014-08-22 22:56:03 +0000244 return EC;
245 }
Benjamin Kramerf5e2fc42015-05-29 19:43:39 +0000246 LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000247 return *LoadedSourceFiles.back().second;
248}
249
Vedant Kumarf681e2e2016-07-15 01:19:33 +0000250void CodeCoverageTool::attachExpansionSubViews(
251 SourceCoverageView &View, ArrayRef<ExpansionRecord> Expansions,
252 const CoverageMapping &Coverage) {
Alex Lorenze82d89c2014-08-22 22:56:03 +0000253 if (!ViewOpts.ShowExpandedRegions)
254 return;
Justin Bogner953e2402014-09-20 15:31:56 +0000255 for (const auto &Expansion : Expansions) {
256 auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
257 if (ExpansionCoverage.empty())
Alex Lorenze82d89c2014-08-22 22:56:03 +0000258 continue;
Justin Bogner953e2402014-09-20 15:31:56 +0000259 auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
260 if (!SourceBuffer)
Alex Lorenze82d89c2014-08-22 22:56:03 +0000261 continue;
Justin Bogner953e2402014-09-20 15:31:56 +0000262
263 auto SubViewExpansions = ExpansionCoverage.getExpansions();
Vedant Kumarf9151b92016-06-25 02:58:30 +0000264 auto SubView =
265 SourceCoverageView::create(Expansion.Function.Name, SourceBuffer.get(),
266 ViewOpts, std::move(ExpansionCoverage));
Justin Bogner953e2402014-09-20 15:31:56 +0000267 attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
268 View.addExpansion(Expansion.Region, std::move(SubView));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000269 }
270}
271
Justin Bogner5a6edad2014-09-19 19:07:17 +0000272std::unique_ptr<SourceCoverageView>
Justin Bogner953e2402014-09-20 15:31:56 +0000273CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
Vedant Kumarf681e2e2016-07-15 01:19:33 +0000274 const CoverageMapping &Coverage) {
Justin Bogner953e2402014-09-20 15:31:56 +0000275 auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
276 if (FunctionCoverage.empty())
Justin Bogner5a6edad2014-09-19 19:07:17 +0000277 return nullptr;
Justin Bogner953e2402014-09-20 15:31:56 +0000278 auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
Justin Bogner5a6edad2014-09-19 19:07:17 +0000279 if (!SourceBuffer)
280 return nullptr;
Justin Bogner953e2402014-09-20 15:31:56 +0000281
282 auto Expansions = FunctionCoverage.getExpansions();
Vedant Kumar6e28bcd2017-02-05 20:10:58 +0000283 auto View = SourceCoverageView::create(DC.demangle(Function.Name),
Vedant Kumar0053c0b2016-09-08 00:56:48 +0000284 SourceBuffer.get(), ViewOpts,
285 std::move(FunctionCoverage));
Justin Bogner953e2402014-09-20 15:31:56 +0000286 attachExpansionSubViews(*View, Expansions, Coverage);
287
288 return View;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000289}
290
Justin Bogner953e2402014-09-20 15:31:56 +0000291std::unique_ptr<SourceCoverageView>
292CodeCoverageTool::createSourceFileView(StringRef SourceFile,
Vedant Kumarf681e2e2016-07-15 01:19:33 +0000293 const CoverageMapping &Coverage) {
Justin Bogner5a6edad2014-09-19 19:07:17 +0000294 auto SourceBuffer = getSourceFile(SourceFile);
295 if (!SourceBuffer)
296 return nullptr;
Justin Bogner953e2402014-09-20 15:31:56 +0000297 auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
298 if (FileCoverage.empty())
Justin Bogner5a6edad2014-09-19 19:07:17 +0000299 return nullptr;
Justin Bogner953e2402014-09-20 15:31:56 +0000300
301 auto Expansions = FileCoverage.getExpansions();
Vedant Kumarf9151b92016-06-25 02:58:30 +0000302 auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
303 ViewOpts, std::move(FileCoverage));
Justin Bogner953e2402014-09-20 15:31:56 +0000304 attachExpansionSubViews(*View, Expansions, Coverage);
Vedant Kumar79554e42017-08-02 23:35:24 +0000305 if (!ViewOpts.ShowFunctionInstantiations)
306 return View;
Justin Bogner953e2402014-09-20 15:31:56 +0000307
Vedant Kumardde19c52017-08-02 23:35:25 +0000308 for (const auto &Group : Coverage.getInstantiationGroups(SourceFile)) {
309 // Skip functions which have a single instantiation.
310 if (Group.size() < 2)
311 continue;
Justin Bogner953e2402014-09-20 15:31:56 +0000312
Vedant Kumardde19c52017-08-02 23:35:25 +0000313 for (const FunctionRecord *Function : Group.getInstantiations()) {
314 std::unique_ptr<SourceCoverageView> SubView{nullptr};
Vedant Kumare9079772016-09-20 21:27:48 +0000315
Vedant Kumardde19c52017-08-02 23:35:25 +0000316 StringRef Funcname = DC.demangle(Function->Name);
317
318 if (Function->ExecutionCount > 0) {
319 auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
320 auto SubViewExpansions = SubViewCoverage.getExpansions();
321 SubView = SourceCoverageView::create(
322 Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
323 attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
324 }
325
326 unsigned FileID = Function->CountedRegions.front().FileID;
327 unsigned Line = 0;
328 for (const auto &CR : Function->CountedRegions)
329 if (CR.FileID == FileID)
330 Line = std::max(CR.LineEnd, Line);
331 View->addInstantiation(Funcname, Line, std::move(SubView));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000332 }
333 }
Justin Bogner5a6edad2014-09-19 19:07:17 +0000334 return View;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000335}
336
Justin Bogner65337d12015-05-04 04:09:38 +0000337static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
338 sys::fs::file_status Status;
339 if (sys::fs::status(LHS, Status))
340 return false;
341 auto LHSTime = Status.getLastModificationTime();
342 if (sys::fs::status(RHS, Status))
343 return false;
344 auto RHSTime = Status.getLastModificationTime();
345 return LHSTime > RHSTime;
346}
347
Justin Bogner953e2402014-09-20 15:31:56 +0000348std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
Vedant Kumara3661ef2016-10-25 17:40:55 +0000349 for (StringRef ObjectFilename : ObjectFilenames)
350 if (modifiedTimeGT(ObjectFilename, PGOFilename))
351 warning("profile data may be out of date - object is newer",
352 ObjectFilename);
Vedant Kumarb3020632016-07-18 17:53:12 +0000353 auto CoverageOrErr =
Vedant Kumar4b102c32017-08-01 21:23:26 +0000354 CoverageMapping::load(ObjectFilenames, PGOFilename, CoverageArches);
Vedant Kumar9152fd12016-05-19 03:54:45 +0000355 if (Error E = CoverageOrErr.takeError()) {
Vedant Kumara3661ef2016-10-25 17:40:55 +0000356 error("Failed to load coverage: " + toString(std::move(E)),
357 join(ObjectFilenames.begin(), ObjectFilenames.end(), ", "));
Justin Bogner953e2402014-09-20 15:31:56 +0000358 return nullptr;
359 }
360 auto Coverage = std::move(CoverageOrErr.get());
361 unsigned Mismatched = Coverage->getMismatchedCount();
Vedant Kumar18dd9e82017-09-21 01:11:30 +0000362 if (Mismatched) {
Benjamin Kramer3a13ed62017-12-28 16:58:54 +0000363 warning(Twine(Mismatched) + " functions have mismatched data");
Justin Bogner116c1662014-09-19 08:13:12 +0000364
Vedant Kumar18dd9e82017-09-21 01:11:30 +0000365 if (ViewOpts.Debug) {
366 for (const auto &HashMismatch : Coverage->getHashMismatches())
367 errs() << "hash-mismatch: "
368 << "No profile record found for '" << HashMismatch.first << "'"
Benjamin Kramer3a13ed62017-12-28 16:58:54 +0000369 << " with hash = 0x" << Twine::utohexstr(HashMismatch.second)
370 << '\n';
Vedant Kumar18dd9e82017-09-21 01:11:30 +0000371
372 for (const auto &CounterMismatch : Coverage->getCounterMismatches())
373 errs() << "counter-mismatch: "
374 << "Coverage mapping for " << CounterMismatch.first
375 << " only has " << CounterMismatch.second
376 << " valid counter expressions\n";
377 }
378 }
379
Sean Eveson9edfeac2017-08-14 10:20:12 +0000380 remapPathNames(*Coverage);
381
Vedant Kumarcab52ad2016-09-23 20:13:41 +0000382 if (!SourceFiles.empty())
383 removeUnmappedInputs(*Coverage);
384
385 demangleSymbols(*Coverage);
386
387 return Coverage;
388}
389
Sean Eveson9edfeac2017-08-14 10:20:12 +0000390void CodeCoverageTool::remapPathNames(const CoverageMapping &Coverage) {
391 if (!PathRemapping)
392 return;
393
394 // Convert remapping paths to native paths with trailing seperators.
395 auto nativeWithTrailing = [](StringRef Path) -> std::string {
396 if (Path.empty())
397 return "";
398 SmallString<128> NativePath;
399 sys::path::native(Path, NativePath);
400 if (!sys::path::is_separator(NativePath.back()))
401 NativePath += sys::path::get_separator();
402 return NativePath.c_str();
403 };
404 std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
405 std::string RemapTo = nativeWithTrailing(PathRemapping->second);
406
407 // Create a mapping from coverage data file paths to local paths.
408 for (StringRef Filename : Coverage.getUniqueSourceFiles()) {
409 SmallString<128> NativeFilename;
410 sys::path::native(Filename, NativeFilename);
411 if (NativeFilename.startswith(RemapFrom)) {
412 RemappedFilenames[Filename] =
413 RemapTo + NativeFilename.substr(RemapFrom.size()).str();
414 }
415 }
416
417 // Convert input files from local paths to coverage data file paths.
418 StringMap<std::string> InvRemappedFilenames;
419 for (const auto &RemappedFilename : RemappedFilenames)
420 InvRemappedFilenames[RemappedFilename.getValue()] = RemappedFilename.getKey();
421
422 for (std::string &Filename : SourceFiles) {
423 SmallString<128> NativeFilename;
424 sys::path::native(Filename, NativeFilename);
425 auto CovFileName = InvRemappedFilenames.find(NativeFilename);
426 if (CovFileName != InvRemappedFilenames.end())
427 Filename = CovFileName->second;
428 }
429}
430
Vedant Kumarcab52ad2016-09-23 20:13:41 +0000431void CodeCoverageTool::removeUnmappedInputs(const CoverageMapping &Coverage) {
432 std::vector<StringRef> CoveredFiles = Coverage.getUniqueSourceFiles();
Vedant Kumar458808802016-09-23 18:57:35 +0000433
434 auto UncoveredFilesIt = SourceFiles.end();
Sean Eveson9edfeac2017-08-14 10:20:12 +0000435 // The user may have specified source files which aren't in the coverage
436 // mapping. Filter these files away.
437 UncoveredFilesIt = std::remove_if(
438 SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
439 return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
440 SF);
441 });
Justin Bogner116c1662014-09-19 08:13:12 +0000442
Vedant Kumar458808802016-09-23 18:57:35 +0000443 SourceFiles.erase(UncoveredFilesIt, SourceFiles.end());
Alex Lorenze82d89c2014-08-22 22:56:03 +0000444}
445
Vedant Kumar424f51b2016-07-15 22:44:57 +0000446void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) {
447 if (!ViewOpts.hasDemangler())
448 return;
449
450 // Pass function names to the demangler in a temporary file.
451 int InputFD;
452 SmallString<256> InputPath;
453 std::error_code EC =
454 sys::fs::createTemporaryFile("demangle-in", "list", InputFD, InputPath);
455 if (EC) {
456 error(InputPath, EC.message());
457 return;
458 }
Reid Kleckner3fc649c2017-09-23 01:03:17 +0000459 ToolOutputFile InputTOF{InputPath, InputFD};
Vedant Kumar424f51b2016-07-15 22:44:57 +0000460
461 unsigned NumSymbols = 0;
462 for (const auto &Function : Coverage.getCoveredFunctions()) {
463 InputTOF.os() << Function.Name << '\n';
464 ++NumSymbols;
465 }
Vedant Kumar554357b2016-07-15 23:08:22 +0000466 InputTOF.os().close();
Vedant Kumar424f51b2016-07-15 22:44:57 +0000467
468 // Use another temporary file to store the demangler's output.
469 int OutputFD;
470 SmallString<256> OutputPath;
471 EC = sys::fs::createTemporaryFile("demangle-out", "list", OutputFD,
472 OutputPath);
473 if (EC) {
474 error(OutputPath, EC.message());
475 return;
476 }
Reid Kleckner3fc649c2017-09-23 01:03:17 +0000477 ToolOutputFile OutputTOF{OutputPath, OutputFD};
Vedant Kumar554357b2016-07-15 23:08:22 +0000478 OutputTOF.os().close();
Vedant Kumar424f51b2016-07-15 22:44:57 +0000479
480 // Invoke the demangler.
481 std::vector<const char *> ArgsV;
482 for (const std::string &Arg : ViewOpts.DemanglerOpts)
483 ArgsV.push_back(Arg.c_str());
484 ArgsV.push_back(nullptr);
Alexander Kornienko208eecd2017-09-13 17:03:37 +0000485 Optional<StringRef> Redirects[] = {InputPath.str(), OutputPath.str(), {""}};
Vedant Kumar424f51b2016-07-15 22:44:57 +0000486 std::string ErrMsg;
487 int RC = sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV.data(),
488 /*env=*/nullptr, Redirects, /*secondsToWait=*/0,
489 /*memoryLimit=*/0, &ErrMsg);
490 if (RC) {
491 error(ErrMsg, ViewOpts.DemanglerOpts[0]);
492 return;
493 }
494
495 // Parse the demangler's output.
496 auto BufOrError = MemoryBuffer::getFile(OutputPath);
497 if (!BufOrError) {
498 error(OutputPath, BufOrError.getError().message());
499 return;
500 }
501
502 std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);
503
504 SmallVector<StringRef, 8> Symbols;
505 StringRef DemanglerData = DemanglerBuf->getBuffer();
506 DemanglerData.split(Symbols, '\n', /*MaxSplit=*/NumSymbols,
507 /*KeepEmpty=*/false);
508 if (Symbols.size() != NumSymbols) {
509 error("Demangler did not provide expected number of symbols");
510 return;
511 }
512
513 // Cache the demangled names.
514 unsigned I = 0;
515 for (const auto &Function : Coverage.getCoveredFunctions())
Igor Kudrin9e015da2017-02-19 14:26:52 +0000516 // On Windows, lines in the demangler's output file end with "\r\n".
517 // Splitting by '\n' keeps '\r's, so cut them now.
518 DC.DemangledNames[Function.Name] = Symbols[I++].rtrim();
Vedant Kumar424f51b2016-07-15 22:44:57 +0000519}
520
Vedant Kumar6fd94bf2016-10-19 17:55:44 +0000521void CodeCoverageTool::writeSourceFileView(StringRef SourceFile,
522 CoverageMapping *Coverage,
523 CoveragePrinter *Printer,
524 bool ShowFilenames) {
525 auto View = createSourceFileView(SourceFile, *Coverage);
526 if (!View) {
527 warning("The file '" + SourceFile + "' isn't covered.");
528 return;
529 }
530
531 auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
532 if (Error E = OSOrErr.takeError()) {
533 error("Could not create view file!", toString(std::move(E)));
534 return;
535 }
536 auto OS = std::move(OSOrErr.get());
537
538 View->print(*OS.get(), /*Wholefile=*/true,
Sean Evesonfa8ef352017-09-28 10:07:30 +0000539 /*ShowSourceName=*/ShowFilenames,
540 /*ShowTitle=*/ViewOpts.hasOutputDirectory());
Vedant Kumar6fd94bf2016-10-19 17:55:44 +0000541 Printer->closeViewFile(std::move(OS));
542}
543
Alex Lorenze82d89c2014-08-22 22:56:03 +0000544int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
Vedant Kumara3661ef2016-10-25 17:40:55 +0000545 cl::opt<std::string> CovFilename(
546 cl::Positional, cl::desc("Covered executable or object file."));
547
548 cl::list<std::string> CovFilenames(
549 "object", cl::desc("Coverage executable or object file"), cl::ZeroOrMore,
550 cl::CommaSeparated);
Justin Bognerf6c50552014-10-30 20:51:24 +0000551
Alex Lorenze82d89c2014-08-22 22:56:03 +0000552 cl::list<std::string> InputSourceFiles(
553 cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
554
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000555 cl::opt<bool> DebugDumpCollectedPaths(
556 "dump-collected-paths", cl::Optional, cl::Hidden,
557 cl::desc("Show the collected paths to source files"));
558
Justin Bogner953e2402014-09-20 15:31:56 +0000559 cl::opt<std::string, true> PGOFilename(
560 "instr-profile", cl::Required, cl::location(this->PGOFilename),
Alex Lorenze82d89c2014-08-22 22:56:03 +0000561 cl::desc(
562 "File with the profile data obtained after an instrumented run"));
563
Vedant Kumar4b102c32017-08-01 21:23:26 +0000564 cl::list<std::string> Arches(
565 "arch", cl::desc("architectures of the coverage mapping binaries"));
Justin Bogner43795352015-03-11 02:30:51 +0000566
Alex Lorenze82d89c2014-08-22 22:56:03 +0000567 cl::opt<bool> DebugDump("dump", cl::Optional,
568 cl::desc("Show internal debug dump"));
569
Vedant Kumar8d74cb22016-06-29 00:38:21 +0000570 cl::opt<CoverageViewOptions::OutputFormat> Format(
571 "format", cl::desc("Output format for line-based coverage reports"),
572 cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",
573 "Text output"),
Vedant Kumar4c010922016-07-06 21:44:05 +0000574 clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
Mehdi Amini732afdd2016-10-08 19:41:06 +0000575 "HTML output")),
Vedant Kumar8d74cb22016-06-29 00:38:21 +0000576 cl::init(CoverageViewOptions::OutputFormat::Text));
577
Sean Eveson9edfeac2017-08-14 10:20:12 +0000578 cl::opt<std::string> PathRemap(
579 "path-equivalence", cl::Optional,
580 cl::desc("<from>,<to> Map coverage data paths to local source file "
581 "paths"));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000582
583 cl::OptionCategory FilteringCategory("Function filtering options");
584
585 cl::list<std::string> NameFilters(
586 "name", cl::Optional,
587 cl::desc("Show code coverage only for functions with the given name"),
588 cl::ZeroOrMore, cl::cat(FilteringCategory));
589
Sean Evesone15300e2017-08-31 09:11:31 +0000590 cl::list<std::string> NameFilterFiles(
591 "name-whitelist", cl::Optional,
592 cl::desc("Show code coverage only for functions listed in the given "
593 "file"),
594 cl::ZeroOrMore, cl::cat(FilteringCategory));
595
Alex Lorenze82d89c2014-08-22 22:56:03 +0000596 cl::list<std::string> NameRegexFilters(
597 "name-regex", cl::Optional,
598 cl::desc("Show code coverage only for functions that match the given "
599 "regular expression"),
600 cl::ZeroOrMore, cl::cat(FilteringCategory));
601
Max Moroz4220f892018-04-09 15:20:35 +0000602 cl::list<std::string> IgnoreFilenameRegexFilters(
603 "ignore-filename-regex", cl::Optional,
604 cl::desc("Skip source code files with file paths that match the given "
605 "regular expression"),
606 cl::ZeroOrMore, cl::cat(FilteringCategory));
607
Alex Lorenze82d89c2014-08-22 22:56:03 +0000608 cl::opt<double> RegionCoverageLtFilter(
609 "region-coverage-lt", cl::Optional,
610 cl::desc("Show code coverage only for functions with region coverage "
611 "less than the given threshold"),
612 cl::cat(FilteringCategory));
613
614 cl::opt<double> RegionCoverageGtFilter(
615 "region-coverage-gt", cl::Optional,
616 cl::desc("Show code coverage only for functions with region coverage "
617 "greater than the given threshold"),
618 cl::cat(FilteringCategory));
619
620 cl::opt<double> LineCoverageLtFilter(
621 "line-coverage-lt", cl::Optional,
622 cl::desc("Show code coverage only for functions with line coverage less "
623 "than the given threshold"),
624 cl::cat(FilteringCategory));
625
626 cl::opt<double> LineCoverageGtFilter(
627 "line-coverage-gt", cl::Optional,
628 cl::desc("Show code coverage only for functions with line coverage "
629 "greater than the given threshold"),
630 cl::cat(FilteringCategory));
631
Justin Bogner9deb1d42015-03-19 04:45:16 +0000632 cl::opt<cl::boolOrDefault> UseColor(
633 "use-color", cl::desc("Emit colored output (default=autodetect)"),
634 cl::init(cl::BOU_UNSET));
Justin Bognercfb53e42015-03-19 00:02:23 +0000635
Vedant Kumar424f51b2016-07-15 22:44:57 +0000636 cl::list<std::string> DemanglerOpts(
637 "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
638
Eli Friedman50479f62017-09-11 22:56:20 +0000639 cl::opt<bool> RegionSummary(
640 "show-region-summary", cl::Optional,
641 cl::desc("Show region statistics in summary table"),
642 cl::init(true));
643
644 cl::opt<bool> InstantiationSummary(
645 "show-instantiation-summary", cl::Optional,
646 cl::desc("Show instantiation statistics in summary table"));
647
Max Morozfe4d9042017-12-11 23:17:46 +0000648 cl::opt<bool> SummaryOnly(
649 "summary-only", cl::Optional,
650 cl::desc("Export only summary information for each source file"));
651
Max Morozcc254ba2018-01-05 16:15:07 +0000652 cl::opt<unsigned> NumThreads(
653 "num-threads", cl::init(0),
654 cl::desc("Number of merge threads to use (default: autodetect)"));
655 cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
656 cl::aliasopt(NumThreads));
657
Alex Lorenze82d89c2014-08-22 22:56:03 +0000658 auto commandLineParser = [&, this](int argc, const char **argv) -> int {
659 cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
660 ViewOpts.Debug = DebugDump;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000661
Vedant Kumara3661ef2016-10-25 17:40:55 +0000662 if (!CovFilename.empty())
663 ObjectFilenames.emplace_back(CovFilename);
664 for (const std::string &Filename : CovFilenames)
665 ObjectFilenames.emplace_back(Filename);
666 if (ObjectFilenames.empty()) {
Vedant Kumar22c1b7c2016-10-25 19:52:57 +0000667 errs() << "No filenames specified!\n";
Vedant Kumara3661ef2016-10-25 17:40:55 +0000668 ::exit(1);
669 }
670
Vedant Kumar8d74cb22016-06-29 00:38:21 +0000671 ViewOpts.Format = Format;
672 switch (ViewOpts.Format) {
673 case CoverageViewOptions::OutputFormat::Text:
674 ViewOpts.Colors = UseColor == cl::BOU_UNSET
675 ? sys::Process::StandardOutHasColors()
676 : UseColor == cl::BOU_TRUE;
677 break;
Vedant Kumar4c010922016-07-06 21:44:05 +0000678 case CoverageViewOptions::OutputFormat::HTML:
679 if (UseColor == cl::BOU_FALSE)
Vedant Kumar22c1b7c2016-10-25 19:52:57 +0000680 errs() << "Color output cannot be disabled when generating html.\n";
Vedant Kumar4c010922016-07-06 21:44:05 +0000681 ViewOpts.Colors = true;
682 break;
Vedant Kumar8d74cb22016-06-29 00:38:21 +0000683 }
Justin Bognercfb53e42015-03-19 00:02:23 +0000684
Sean Eveson9edfeac2017-08-14 10:20:12 +0000685 // If path-equivalence was given and is a comma seperated pair then set
686 // PathRemapping.
687 auto EquivPair = StringRef(PathRemap).split(',');
688 if (!(EquivPair.first.empty() && EquivPair.second.empty()))
689 PathRemapping = EquivPair;
690
Vedant Kumar424f51b2016-07-15 22:44:57 +0000691 // If a demangler is supplied, check if it exists and register it.
692 if (DemanglerOpts.size()) {
693 auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
694 if (!DemanglerPathOrErr) {
695 error("Could not find the demangler!",
696 DemanglerPathOrErr.getError().message());
697 return 1;
698 }
699 DemanglerOpts[0] = *DemanglerPathOrErr;
700 ViewOpts.DemanglerOpts.swap(DemanglerOpts);
701 }
702
Sean Evesone15300e2017-08-31 09:11:31 +0000703 // Read in -name-whitelist files.
704 if (!NameFilterFiles.empty()) {
705 std::string SpecialCaseListErr;
706 NameWhitelist =
707 SpecialCaseList::create(NameFilterFiles, SpecialCaseListErr);
708 if (!NameWhitelist)
709 error(SpecialCaseListErr);
710 }
711
Alex Lorenze82d89c2014-08-22 22:56:03 +0000712 // Create the function filters
Sean Evesone15300e2017-08-31 09:11:31 +0000713 if (!NameFilters.empty() || NameWhitelist || !NameRegexFilters.empty()) {
Vedant Kumar8a622382017-08-04 00:36:24 +0000714 auto NameFilterer = llvm::make_unique<CoverageFilters>();
Alex Lorenze82d89c2014-08-22 22:56:03 +0000715 for (const auto &Name : NameFilters)
716 NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
Sean Evesone15300e2017-08-31 09:11:31 +0000717 if (NameWhitelist)
718 NameFilterer->push_back(
719 llvm::make_unique<NameWhitelistCoverageFilter>(*NameWhitelist));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000720 for (const auto &Regex : NameRegexFilters)
721 NameFilterer->push_back(
722 llvm::make_unique<NameRegexCoverageFilter>(Regex));
Vedant Kumar8a622382017-08-04 00:36:24 +0000723 Filters.push_back(std::move(NameFilterer));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000724 }
Max Moroz4220f892018-04-09 15:20:35 +0000725
Alex Lorenze82d89c2014-08-22 22:56:03 +0000726 if (RegionCoverageLtFilter.getNumOccurrences() ||
727 RegionCoverageGtFilter.getNumOccurrences() ||
728 LineCoverageLtFilter.getNumOccurrences() ||
729 LineCoverageGtFilter.getNumOccurrences()) {
Vedant Kumar8a622382017-08-04 00:36:24 +0000730 auto StatFilterer = llvm::make_unique<CoverageFilters>();
Alex Lorenze82d89c2014-08-22 22:56:03 +0000731 if (RegionCoverageLtFilter.getNumOccurrences())
732 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
733 RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
734 if (RegionCoverageGtFilter.getNumOccurrences())
735 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
736 RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
737 if (LineCoverageLtFilter.getNumOccurrences())
738 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
739 LineCoverageFilter::LessThan, LineCoverageLtFilter));
740 if (LineCoverageGtFilter.getNumOccurrences())
741 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
742 RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
Vedant Kumar8a622382017-08-04 00:36:24 +0000743 Filters.push_back(std::move(StatFilterer));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000744 }
745
Max Moroz4220f892018-04-09 15:20:35 +0000746 // Create the ignore filename filters.
747 for (const auto &RE : IgnoreFilenameRegexFilters)
748 IgnoreFilenameFilters.push_back(
749 llvm::make_unique<NameRegexCoverageFilter>(RE));
750
Vedant Kumar4b102c32017-08-01 21:23:26 +0000751 if (!Arches.empty()) {
752 for (const std::string &Arch : Arches) {
753 if (Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
754 error("Unknown architecture: " + Arch);
755 return 1;
756 }
757 CoverageArches.emplace_back(Arch);
758 }
759 if (CoverageArches.size() != ObjectFilenames.size()) {
760 error("Number of architectures doesn't match the number of objects");
761 return 1;
762 }
Justin Bogner43795352015-03-11 02:30:51 +0000763 }
764
Max Moroz4220f892018-04-09 15:20:35 +0000765 // IgnoreFilenameFilters are applied even when InputSourceFiles specified.
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000766 for (const std::string &File : InputSourceFiles)
767 collectPaths(File);
768
769 if (DebugDumpCollectedPaths) {
Vedant Kumarbc647982016-09-23 18:57:32 +0000770 for (const std::string &SF : SourceFiles)
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000771 outs() << SF << '\n';
772 ::exit(0);
Justin Bogner116c1662014-09-19 08:13:12 +0000773 }
Vedant Kumar1ce90d82016-09-22 21:49:43 +0000774
Eli Friedman50479f62017-09-11 22:56:20 +0000775 ViewOpts.ShowRegionSummary = RegionSummary;
776 ViewOpts.ShowInstantiationSummary = InstantiationSummary;
Max Morozfe4d9042017-12-11 23:17:46 +0000777 ViewOpts.ExportSummaryOnly = SummaryOnly;
Max Morozcc254ba2018-01-05 16:15:07 +0000778 ViewOpts.NumThreads = NumThreads;
Eli Friedman50479f62017-09-11 22:56:20 +0000779
Alex Lorenze82d89c2014-08-22 22:56:03 +0000780 return 0;
781 };
782
Alex Lorenze82d89c2014-08-22 22:56:03 +0000783 switch (Cmd) {
784 case Show:
Max Moroz1ef3a772018-01-04 19:33:29 +0000785 return doShow(argc, argv, commandLineParser);
Alex Lorenze82d89c2014-08-22 22:56:03 +0000786 case Report:
Max Moroz1ef3a772018-01-04 19:33:29 +0000787 return doReport(argc, argv, commandLineParser);
Vedant Kumar7101d732016-07-26 22:50:58 +0000788 case Export:
Max Moroz1ef3a772018-01-04 19:33:29 +0000789 return doExport(argc, argv, commandLineParser);
Alex Lorenze82d89c2014-08-22 22:56:03 +0000790 }
791 return 0;
792}
793
Max Moroz1ef3a772018-01-04 19:33:29 +0000794int CodeCoverageTool::doShow(int argc, const char **argv,
795 CommandLineParserType commandLineParser) {
Alex Lorenze82d89c2014-08-22 22:56:03 +0000796
797 cl::OptionCategory ViewCategory("Viewing options");
798
799 cl::opt<bool> ShowLineExecutionCounts(
800 "show-line-counts", cl::Optional,
801 cl::desc("Show the execution counts for each line"), cl::init(true),
802 cl::cat(ViewCategory));
803
804 cl::opt<bool> ShowRegions(
805 "show-regions", cl::Optional,
806 cl::desc("Show the execution counts for each region"),
807 cl::cat(ViewCategory));
808
809 cl::opt<bool> ShowBestLineRegionsCounts(
810 "show-line-counts-or-regions", cl::Optional,
811 cl::desc("Show the execution counts for each line, or the execution "
812 "counts for each region on lines that have multiple regions"),
813 cl::cat(ViewCategory));
814
815 cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
816 cl::desc("Show expanded source regions"),
817 cl::cat(ViewCategory));
818
819 cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
820 cl::desc("Show function instantiations"),
Vedant Kumar79554e42017-08-02 23:35:24 +0000821 cl::init(true), cl::cat(ViewCategory));
Alex Lorenze82d89c2014-08-22 22:56:03 +0000822
Vedant Kumar7937ef32016-06-28 02:09:39 +0000823 cl::opt<std::string> ShowOutputDirectory(
824 "output-dir", cl::init(""),
825 cl::desc("Directory in which coverage information is written out"));
826 cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
827 cl::aliasopt(ShowOutputDirectory));
828
Ying Yi0ef31b72016-08-04 10:39:43 +0000829 cl::opt<uint32_t> TabSize(
Vedant Kumarad547d32016-08-04 18:00:42 +0000830 "tab-size", cl::init(2),
831 cl::desc(
832 "Set tab expansion size for html coverage reports (default = 2)"));
Ying Yi0ef31b72016-08-04 10:39:43 +0000833
Ying Yi84dc9712016-08-24 14:27:23 +0000834 cl::opt<std::string> ProjectTitle(
835 "project-title", cl::Optional,
836 cl::desc("Set project title for the coverage report"));
837
Alex Lorenze82d89c2014-08-22 22:56:03 +0000838 auto Err = commandLineParser(argc, argv);
839 if (Err)
840 return Err;
841
Alex Lorenze82d89c2014-08-22 22:56:03 +0000842 ViewOpts.ShowLineNumbers = true;
843 ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
844 !ShowRegions || ShowBestLineRegionsCounts;
845 ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
Alex Lorenze82d89c2014-08-22 22:56:03 +0000846 ViewOpts.ShowExpandedRegions = ShowExpansions;
847 ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
Vedant Kumar7937ef32016-06-28 02:09:39 +0000848 ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
Ying Yi0ef31b72016-08-04 10:39:43 +0000849 ViewOpts.TabSize = TabSize;
Ying Yi84dc9712016-08-24 14:27:23 +0000850 ViewOpts.ProjectTitle = ProjectTitle;
Vedant Kumar7937ef32016-06-28 02:09:39 +0000851
Vedant Kumar64d8a022016-06-28 16:12:20 +0000852 if (ViewOpts.hasOutputDirectory()) {
Vedant Kumar7937ef32016-06-28 02:09:39 +0000853 if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
854 error("Could not create output directory!", E.message());
855 return 1;
856 }
857 }
Alex Lorenze82d89c2014-08-22 22:56:03 +0000858
Ying Yi84dc9712016-08-24 14:27:23 +0000859 sys::fs::file_status Status;
860 if (sys::fs::status(PGOFilename, Status)) {
861 error("profdata file error: can not get the file status. \n");
862 return 1;
863 }
864
865 auto ModifiedTime = Status.getLastModificationTime();
Pavel Labath757ca882016-10-24 10:59:17 +0000866 std::string ModifiedTimeStr = to_string(ModifiedTime);
Benjamin Kramere6ba5ef2016-11-30 10:01:11 +0000867 size_t found = ModifiedTimeStr.rfind(':');
Ying Yi84dc9712016-08-24 14:27:23 +0000868 ViewOpts.CreatedTimeStr = (found != std::string::npos)
869 ? "Created: " + ModifiedTimeStr.substr(0, found)
870 : "Created: " + ModifiedTimeStr;
871
Justin Bogner953e2402014-09-20 15:31:56 +0000872 auto Coverage = load();
873 if (!Coverage)
Alex Lorenze82d89c2014-08-22 22:56:03 +0000874 return 1;
875
Vedant Kumar9cbad2c2016-06-28 16:12:24 +0000876 auto Printer = CoveragePrinter::create(ViewOpts);
877
Sean Eveson1439fa62017-09-27 16:20:07 +0000878 if (SourceFiles.empty())
879 // Get the source files from the function coverage mapping.
Max Moroz4220f892018-04-09 15:20:35 +0000880 for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
881 if (!IgnoreFilenameFilters.matchesFilename(Filename))
882 SourceFiles.push_back(Filename);
883 }
Sean Eveson1439fa62017-09-27 16:20:07 +0000884
885 // Create an index out of the source files.
886 if (ViewOpts.hasOutputDirectory()) {
Sean Evesonfa8ef352017-09-28 10:07:30 +0000887 if (Error E = Printer->createIndexFile(SourceFiles, *Coverage, Filters)) {
Sean Eveson1439fa62017-09-27 16:20:07 +0000888 error("Could not create index file!", toString(std::move(E)));
889 return 1;
890 }
891 }
892
Sean Evesonfa8ef352017-09-28 10:07:30 +0000893 if (!Filters.empty()) {
894 // Build the map of filenames to functions.
895 std::map<llvm::StringRef, std::vector<const FunctionRecord *>>
896 FilenameFunctionMap;
897 for (const auto &SourceFile : SourceFiles)
898 for (const auto &Function : Coverage->getCoveredFunctions(SourceFile))
899 if (Filters.matches(*Coverage.get(), Function))
900 FilenameFunctionMap[SourceFile].push_back(&Function);
901
902 // Only print filter matching functions for each file.
903 for (const auto &FileFunc : FilenameFunctionMap) {
904 StringRef File = FileFunc.first;
905 const auto &Functions = FileFunc.second;
906
907 auto OSOrErr = Printer->createViewFile(File, /*InToplevel=*/false);
908 if (Error E = OSOrErr.takeError()) {
909 error("Could not create view file!", toString(std::move(E)));
910 return 1;
911 }
912 auto OS = std::move(OSOrErr.get());
913
Sean Evesonea9dcee2017-10-04 08:54:37 +0000914 bool ShowTitle = ViewOpts.hasOutputDirectory();
Sean Evesonfa8ef352017-09-28 10:07:30 +0000915 for (const auto *Function : Functions) {
916 auto FunctionView = createFunctionView(*Function, *Coverage);
917 if (!FunctionView) {
918 warning("Could not read coverage for '" + Function->Name + "'.");
919 continue;
920 }
921 FunctionView->print(*OS.get(), /*WholeFile=*/false,
922 /*ShowSourceName=*/true, ShowTitle);
923 ShowTitle = false;
924 }
925
926 Printer->closeViewFile(std::move(OS));
927 }
928 return 0;
929 }
930
931 // Show files
932 bool ShowFilenames =
933 (SourceFiles.size() != 1) || ViewOpts.hasOutputDirectory() ||
934 (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML);
935
Max Morozcc254ba2018-01-05 16:15:07 +0000936 auto NumThreads = ViewOpts.NumThreads;
937
Vedant Kumar7fa75102017-07-11 01:23:29 +0000938 // If NumThreads is not specified, auto-detect a good default.
939 if (NumThreads == 0)
940 NumThreads =
941 std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),
942 unsigned(SourceFiles.size())));
943
944 if (!ViewOpts.hasOutputDirectory() || NumThreads == 1) {
Vedant Kumar6fd94bf2016-10-19 17:55:44 +0000945 for (const std::string &SourceFile : SourceFiles)
946 writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
947 ShowFilenames);
948 } else {
949 // In -output-dir mode, it's safe to use multiple threads to print files.
Vedant Kumar7fa75102017-07-11 01:23:29 +0000950 ThreadPool Pool(NumThreads);
Vedant Kumar6fd94bf2016-10-19 17:55:44 +0000951 for (const std::string &SourceFile : SourceFiles)
952 Pool.async(&CodeCoverageTool::writeSourceFileView, this, SourceFile,
953 Coverage.get(), Printer.get(), ShowFilenames);
954 Pool.wait();
Alex Lorenze82d89c2014-08-22 22:56:03 +0000955 }
956
957 return 0;
958}
959
Max Moroz1ef3a772018-01-04 19:33:29 +0000960int CodeCoverageTool::doReport(int argc, const char **argv,
961 CommandLineParserType commandLineParser) {
Vedant Kumar62eb0fd2017-02-05 20:11:08 +0000962 cl::opt<bool> ShowFunctionSummaries(
963 "show-functions", cl::Optional, cl::init(false),
964 cl::desc("Show coverage summaries for each function"));
965
Alex Lorenze82d89c2014-08-22 22:56:03 +0000966 auto Err = commandLineParser(argc, argv);
967 if (Err)
968 return Err;
969
Vedant Kumar431359a2017-02-28 16:57:28 +0000970 if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML) {
Vedant Kumar4c010922016-07-06 21:44:05 +0000971 error("HTML output for summary reports is not yet supported.");
Vedant Kumar431359a2017-02-28 16:57:28 +0000972 return 1;
973 }
Vedant Kumar4c010922016-07-06 21:44:05 +0000974
Justin Bogner953e2402014-09-20 15:31:56 +0000975 auto Coverage = load();
976 if (!Coverage)
Alex Lorenze82d89c2014-08-22 22:56:03 +0000977 return 1;
978
Vedant Kumar702bb9d2016-09-06 22:45:57 +0000979 CoverageReport Report(ViewOpts, *Coverage.get());
Vedant Kumarfeb3f522017-09-25 23:10:03 +0000980 if (!ShowFunctionSummaries) {
Max Moroz4a4bfa42017-10-13 14:44:51 +0000981 if (SourceFiles.empty())
Max Moroz4220f892018-04-09 15:20:35 +0000982 Report.renderFileReports(llvm::outs(), IgnoreFilenameFilters);
Max Moroz4a4bfa42017-10-13 14:44:51 +0000983 else
984 Report.renderFileReports(llvm::outs(), SourceFiles);
Vedant Kumarfeb3f522017-09-25 23:10:03 +0000985 } else {
986 if (SourceFiles.empty()) {
987 error("Source files must be specified when -show-functions=true is "
988 "specified");
989 return 1;
990 }
991
Vedant Kumarf2b067c2017-02-05 20:11:03 +0000992 Report.renderFunctionReports(SourceFiles, DC, llvm::outs());
Vedant Kumarfeb3f522017-09-25 23:10:03 +0000993 }
Alex Lorenze82d89c2014-08-22 22:56:03 +0000994 return 0;
995}
996
Max Moroz1ef3a772018-01-04 19:33:29 +0000997int CodeCoverageTool::doExport(int argc, const char **argv,
998 CommandLineParserType commandLineParser) {
Vedant Kumar7101d732016-07-26 22:50:58 +0000999
1000 auto Err = commandLineParser(argc, argv);
1001 if (Err)
1002 return Err;
1003
Vedant Kumar431359a2017-02-28 16:57:28 +00001004 if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text) {
1005 error("Coverage data can only be exported as textual JSON.");
1006 return 1;
1007 }
1008
Vedant Kumar7101d732016-07-26 22:50:58 +00001009 auto Coverage = load();
1010 if (!Coverage) {
1011 error("Could not load coverage information");
1012 return 1;
1013 }
1014
Max Moroz1ef3a772018-01-04 19:33:29 +00001015 auto Exporter = CoverageExporterJson(*Coverage.get(), ViewOpts, outs());
1016
1017 if (SourceFiles.empty())
Max Moroz4220f892018-04-09 15:20:35 +00001018 Exporter.renderRoot(IgnoreFilenameFilters);
Max Moroz1ef3a772018-01-04 19:33:29 +00001019 else
1020 Exporter.renderRoot(SourceFiles);
Vedant Kumar7101d732016-07-26 22:50:58 +00001021
1022 return 0;
1023}
1024
Justin Bognerd249a3b2014-10-30 20:57:49 +00001025int showMain(int argc, const char *argv[]) {
Alex Lorenze82d89c2014-08-22 22:56:03 +00001026 CodeCoverageTool Tool;
1027 return Tool.run(CodeCoverageTool::Show, argc, argv);
1028}
1029
Justin Bognerd249a3b2014-10-30 20:57:49 +00001030int reportMain(int argc, const char *argv[]) {
Alex Lorenze82d89c2014-08-22 22:56:03 +00001031 CodeCoverageTool Tool;
1032 return Tool.run(CodeCoverageTool::Report, argc, argv);
1033}
Vedant Kumar7101d732016-07-26 22:50:58 +00001034
1035int exportMain(int argc, const char *argv[]) {
1036 CodeCoverageTool Tool;
1037 return Tool.run(CodeCoverageTool::Export, argc, argv);
1038}