Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/llvm-cov/CodeCoverage.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// The 'CodeCoverageTool' class implements a command line tool to analyze and
10
// report coverage information using the profiling instrumentation and code
11
// coverage mapping.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#include "CoverageExporterJson.h"
16
#include "CoverageExporterLcov.h"
17
#include "CoverageFilters.h"
18
#include "CoverageReport.h"
19
#include "CoverageSummaryInfo.h"
20
#include "CoverageViewOptions.h"
21
#include "RenderingSupport.h"
22
#include "SourceCoverageView.h"
23
#include "llvm/ADT/SmallString.h"
24
#include "llvm/ADT/StringRef.h"
25
#include "llvm/ADT/Triple.h"
26
#include "llvm/ProfileData/Coverage/CoverageMapping.h"
27
#include "llvm/ProfileData/InstrProfReader.h"
28
#include "llvm/Support/CommandLine.h"
29
#include "llvm/Support/FileSystem.h"
30
#include "llvm/Support/Format.h"
31
#include "llvm/Support/MemoryBuffer.h"
32
#include "llvm/Support/Path.h"
33
#include "llvm/Support/Process.h"
34
#include "llvm/Support/Program.h"
35
#include "llvm/Support/ScopedPrinter.h"
36
#include "llvm/Support/ThreadPool.h"
37
#include "llvm/Support/Threading.h"
38
#include "llvm/Support/ToolOutputFile.h"
39
40
#include <functional>
41
#include <map>
42
#include <system_error>
43
44
using namespace llvm;
45
using namespace coverage;
46
47
void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping,
48
                              const CoverageViewOptions &Options,
49
                              raw_ostream &OS);
50
51
namespace {
52
/// The implementation of the coverage tool.
53
class CodeCoverageTool {
54
public:
55
  enum Command {
56
    /// The show command.
57
    Show,
58
    /// The report command.
59
    Report,
60
    /// The export command.
61
    Export
62
  };
63
64
  int run(Command Cmd, int argc, const char **argv);
65
66
private:
67
  /// Print the error message to the error output stream.
68
  void error(const Twine &Message, StringRef Whence = "");
69
70
  /// Print the warning message to the error output stream.
71
  void warning(const Twine &Message, StringRef Whence = "");
72
73
  /// Convert \p Path into an absolute path and append it to the list
74
  /// of collected paths.
75
  void addCollectedPath(const std::string &Path);
76
77
  /// 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
81
  /// Return a memory buffer for the given source file.
82
  ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
83
84
  /// Create source views for the expansions of the view.
85
  void attachExpansionSubViews(SourceCoverageView &View,
86
                               ArrayRef<ExpansionRecord> Expansions,
87
                               const CoverageMapping &Coverage);
88
89
  /// Create the source view of a particular function.
90
  std::unique_ptr<SourceCoverageView>
91
  createFunctionView(const FunctionRecord &Function,
92
                     const CoverageMapping &Coverage);
93
94
  /// Create the main source view of a particular source file.
95
  std::unique_ptr<SourceCoverageView>
96
  createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
97
98
  /// Load the coverage mapping data. Return nullptr if an error occurred.
99
  std::unique_ptr<CoverageMapping> load();
100
101
  /// Create a mapping from files in the Coverage data to local copies
102
  /// (path-equivalence).
103
  void remapPathNames(const CoverageMapping &Coverage);
104
105
  /// Remove input source files which aren't mapped by \p Coverage.
106
  void removeUnmappedInputs(const CoverageMapping &Coverage);
107
108
  /// If a demangler is available, demangle all symbol names.
109
  void demangleSymbols(const CoverageMapping &Coverage);
110
111
  /// Write out a source file view to the filesystem.
112
  void writeSourceFileView(StringRef SourceFile, CoverageMapping *Coverage,
113
                           CoveragePrinter *Printer, bool ShowFilenames);
114
115
  typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
116
117
  int doShow(int argc, const char **argv,
118
             CommandLineParserType commandLineParser);
119
120
  int doReport(int argc, const char **argv,
121
               CommandLineParserType commandLineParser);
122
123
  int doExport(int argc, const char **argv,
124
               CommandLineParserType commandLineParser);
125
126
  std::vector<StringRef> ObjectFilenames;
127
  CoverageViewOptions ViewOpts;
128
  CoverageFiltersMatchAll Filters;
129
  CoverageFilters IgnoreFilenameFilters;
130
131
  /// The path to the indexed profile.
132
  std::string PGOFilename;
133
134
  /// A list of input source files.
135
  std::vector<std::string> SourceFiles;
136
137
  /// In -path-equivalence mode, this maps the absolute paths from the coverage
138
  /// mapping data to the input source files.
139
  StringMap<std::string> RemappedFilenames;
140
141
  /// 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
145
  /// The architecture the coverage mapping data targets.
146
  std::vector<StringRef> CoverageArches;
147
148
  /// A cache for demangled symbols.
149
  DemangleCache DC;
150
151
  /// A lock which guards printing to stderr.
152
  std::mutex ErrsLock;
153
154
  /// A container for input source file buffers.
155
  std::mutex LoadedSourceFilesLock;
156
  std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
157
      LoadedSourceFiles;
158
159
  /// Whitelist from -name-whitelist to be used for filtering.
160
  std::unique_ptr<SpecialCaseList> NameWhitelist;
161
};
162
}
163
164
static std::string getErrorString(const Twine &Message, StringRef Whence,
165
38
                                  bool Warning) {
166
38
  std::string Str = (Warning ? 
"warning"16
:
"error"22
);
167
38
  Str += ": ";
168
38
  if (!Whence.empty())
169
18
    Str += Whence.str() + ": ";
170
38
  Str += Message.str() + "\n";
171
38
  return Str;
172
38
}
173
174
22
void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
175
22
  std::unique_lock<std::mutex> Guard{ErrsLock};
176
22
  ViewOpts.colored_ostream(errs(), raw_ostream::RED)
177
22
      << getErrorString(Message, Whence, false);
178
22
}
179
180
16
void CodeCoverageTool::warning(const Twine &Message, StringRef Whence) {
181
16
  std::unique_lock<std::mutex> Guard{ErrsLock};
182
16
  ViewOpts.colored_ostream(errs(), raw_ostream::RED)
183
16
      << getErrorString(Message, Whence, true);
184
16
}
185
186
89
void CodeCoverageTool::addCollectedPath(const std::string &Path) {
187
89
  SmallString<128> EffectivePath(Path);
188
89
  if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
189
0
    error(EC.message(), Path);
190
0
    return;
191
0
  }
192
89
  sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
193
89
  if (!IgnoreFilenameFilters.matchesFilename(EffectivePath))
194
87
    SourceFiles.emplace_back(EffectivePath.str());
195
89
}
196
197
87
void CodeCoverageTool::collectPaths(const std::string &Path) {
198
87
  llvm::sys::fs::file_status Status;
199
87
  llvm::sys::fs::status(Path, Status);
200
87
  if (!llvm::sys::fs::exists(Status)) {
201
7
    if (PathRemapping)
202
7
      addCollectedPath(Path);
203
0
    else
204
0
      warning("Source file doesn't exist, proceeded by ignoring it.", Path);
205
7
    return;
206
7
  }
207
80
208
80
  if (llvm::sys::fs::is_regular_file(Status)) {
209
70
    addCollectedPath(Path);
210
70
    return;
211
70
  }
212
10
213
10
  if (llvm::sys::fs::is_directory(Status)) {
214
6
    std::error_code EC;
215
6
    for (llvm::sys::fs::recursive_directory_iterator F(Path, EC), E;
216
22
         F != E; 
F.increment(EC)16
) {
217
16
218
16
      auto Status = F->status();
219
16
      if (!Status) {
220
0
        warning(Status.getError().message(), F->path());
221
0
        continue;
222
0
      }
223
16
224
16
      if (Status->type() == llvm::sys::fs::file_type::regular_file)
225
12
        addCollectedPath(F->path());
226
16
    }
227
6
  }
228
10
}
229
230
ErrorOr<const MemoryBuffer &>
231
150
CodeCoverageTool::getSourceFile(StringRef SourceFile) {
232
150
  // If we've remapped filenames, look up the real location for this file.
233
150
  std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
234
150
  if (!RemappedFilenames.empty()) {
235
146
    auto Loc = RemappedFilenames.find(SourceFile);
236
146
    if (Loc != RemappedFilenames.end())
237
146
      SourceFile = Loc->second;
238
146
  }
239
150
  for (const auto &Files : LoadedSourceFiles)
240
190
    if (sys::fs::equivalent(SourceFile, Files.first))
241
10
      return *Files.second;
242
150
  auto Buffer = MemoryBuffer::getFile(SourceFile);
243
140
  if (auto EC = Buffer.getError()) {
244
14
    error(EC.message(), SourceFile);
245
14
    return EC;
246
14
  }
247
126
  LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
248
126
  return *LoadedSourceFiles.back().second;
249
126
}
250
251
void CodeCoverageTool::attachExpansionSubViews(
252
    SourceCoverageView &View, ArrayRef<ExpansionRecord> Expansions,
253
188
    const CoverageMapping &Coverage) {
254
188
  if (!ViewOpts.ShowExpandedRegions)
255
184
    return;
256
4
  for (const auto &Expansion : Expansions) {
257
3
    auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
258
3
    if (ExpansionCoverage.empty())
259
0
      continue;
260
3
    auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
261
3
    if (!SourceBuffer)
262
0
      continue;
263
3
264
3
    auto SubViewExpansions = ExpansionCoverage.getExpansions();
265
3
    auto SubView =
266
3
        SourceCoverageView::create(Expansion.Function.Name, SourceBuffer.get(),
267
3
                                   ViewOpts, std::move(ExpansionCoverage));
268
3
    attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
269
3
    View.addExpansion(Expansion.Region, std::move(SubView));
270
3
  }
271
4
}
272
273
std::unique_ptr<SourceCoverageView>
274
CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
275
30
                                     const CoverageMapping &Coverage) {
276
30
  auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
277
30
  if (FunctionCoverage.empty())
278
0
    return nullptr;
279
30
  auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
280
30
  if (!SourceBuffer)
281
3
    return nullptr;
282
27
283
27
  auto Expansions = FunctionCoverage.getExpansions();
284
27
  auto View = SourceCoverageView::create(DC.demangle(Function.Name),
285
27
                                         SourceBuffer.get(), ViewOpts,
286
27
                                         std::move(FunctionCoverage));
287
27
  attachExpansionSubViews(*View, Expansions, Coverage);
288
27
289
27
  return View;
290
27
}
291
292
std::unique_ptr<SourceCoverageView>
293
CodeCoverageTool::createSourceFileView(StringRef SourceFile,
294
117
                                       const CoverageMapping &Coverage) {
295
117
  auto SourceBuffer = getSourceFile(SourceFile);
296
117
  if (!SourceBuffer)
297
11
    return nullptr;
298
106
  auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
299
106
  if (FileCoverage.empty())
300
0
    return nullptr;
301
106
302
106
  auto Expansions = FileCoverage.getExpansions();
303
106
  auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
304
106
                                         ViewOpts, std::move(FileCoverage));
305
106
  attachExpansionSubViews(*View, Expansions, Coverage);
306
106
  if (!ViewOpts.ShowFunctionInstantiations)
307
1
    return View;
308
105
309
128
  
for (const auto &Group : Coverage.getInstantiationGroups(SourceFile))105
{
310
128
    // Skip functions which have a single instantiation.
311
128
    if (Group.size() < 2)
312
102
      continue;
313
26
314
60
    
for (const FunctionRecord *Function : Group.getInstantiations())26
{
315
60
      std::unique_ptr<SourceCoverageView> SubView{nullptr};
316
60
317
60
      StringRef Funcname = DC.demangle(Function->Name);
318
60
319
60
      if (Function->ExecutionCount > 0) {
320
52
        auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
321
52
        auto SubViewExpansions = SubViewCoverage.getExpansions();
322
52
        SubView = SourceCoverageView::create(
323
52
            Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
324
52
        attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
325
52
      }
326
60
327
60
      unsigned FileID = Function->CountedRegions.front().FileID;
328
60
      unsigned Line = 0;
329
60
      for (const auto &CR : Function->CountedRegions)
330
446
        if (CR.FileID == FileID)
331
446
          Line = std::max(CR.LineEnd, Line);
332
60
      View->addInstantiation(Funcname, Line, std::move(SubView));
333
60
    }
334
26
  }
335
105
  return View;
336
105
}
337
338
119
static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
339
119
  sys::fs::file_status Status;
340
119
  if (sys::fs::status(LHS, Status))
341
0
    return false;
342
119
  auto LHSTime = Status.getLastModificationTime();
343
119
  if (sys::fs::status(RHS, Status))
344
0
    return false;
345
119
  auto RHSTime = Status.getLastModificationTime();
346
119
  return LHSTime > RHSTime;
347
119
}
348
349
116
std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
350
116
  for (StringRef ObjectFilename : ObjectFilenames)
351
119
    if (modifiedTimeGT(ObjectFilename, PGOFilename))
352
1
      warning("profile data may be out of date - object is newer",
353
1
              ObjectFilename);
354
116
  auto CoverageOrErr =
355
116
      CoverageMapping::load(ObjectFilenames, PGOFilename, CoverageArches);
356
116
  if (Error E = CoverageOrErr.takeError()) {
357
2
    error("Failed to load coverage: " + toString(std::move(E)),
358
2
          join(ObjectFilenames.begin(), ObjectFilenames.end(), ", "));
359
2
    return nullptr;
360
2
  }
361
114
  auto Coverage = std::move(CoverageOrErr.get());
362
114
  unsigned Mismatched = Coverage->getMismatchedCount();
363
114
  if (Mismatched) {
364
1
    warning(Twine(Mismatched) + " functions have mismatched data");
365
1
366
1
    if (ViewOpts.Debug) {
367
1
      for (const auto &HashMismatch : Coverage->getHashMismatches())
368
1
        errs() << "hash-mismatch: "
369
1
               << "No profile record found for '" << HashMismatch.first << "'"
370
1
               << " with hash = 0x" << Twine::utohexstr(HashMismatch.second)
371
1
               << '\n';
372
1
    }
373
1
  }
374
114
375
114
  remapPathNames(*Coverage);
376
114
377
114
  if (!SourceFiles.empty())
378
67
    removeUnmappedInputs(*Coverage);
379
114
380
114
  demangleSymbols(*Coverage);
381
114
382
114
  return Coverage;
383
114
}
384
385
114
void CodeCoverageTool::remapPathNames(const CoverageMapping &Coverage) {
386
114
  if (!PathRemapping)
387
22
    return;
388
92
389
92
  // Convert remapping paths to native paths with trailing seperators.
390
184
  
auto nativeWithTrailing = [](StringRef Path) -> std::string 92
{
391
184
    if (Path.empty())
392
0
      return "";
393
184
    SmallString<128> NativePath;
394
184
    sys::path::native(Path, NativePath);
395
184
    if (!sys::path::is_separator(NativePath.back()))
396
181
      NativePath += sys::path::get_separator();
397
184
    return NativePath.c_str();
398
184
  };
399
92
  std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
400
92
  std::string RemapTo = nativeWithTrailing(PathRemapping->second);
401
92
402
92
  // Create a mapping from coverage data file paths to local paths.
403
209
  for (StringRef Filename : Coverage.getUniqueSourceFiles()) {
404
209
    SmallString<128> NativeFilename;
405
209
    sys::path::native(Filename, NativeFilename);
406
209
    if (NativeFilename.startswith(RemapFrom)) {
407
208
      RemappedFilenames[Filename] =
408
208
          RemapTo + NativeFilename.substr(RemapFrom.size()).str();
409
208
    }
410
209
  }
411
92
412
92
  // Convert input files from local paths to coverage data file paths.
413
92
  StringMap<std::string> InvRemappedFilenames;
414
92
  for (const auto &RemappedFilename : RemappedFilenames)
415
208
    InvRemappedFilenames[RemappedFilename.getValue()] = RemappedFilename.getKey();
416
92
417
92
  for (std::string &Filename : SourceFiles) {
418
72
    SmallString<128> NativeFilename;
419
72
    sys::path::native(Filename, NativeFilename);
420
72
    auto CovFileName = InvRemappedFilenames.find(NativeFilename);
421
72
    if (CovFileName != InvRemappedFilenames.end())
422
63
      Filename = CovFileName->second;
423
72
  }
424
92
}
425
426
67
void CodeCoverageTool::removeUnmappedInputs(const CoverageMapping &Coverage) {
427
67
  std::vector<StringRef> CoveredFiles = Coverage.getUniqueSourceFiles();
428
67
429
67
  auto UncoveredFilesIt = SourceFiles.end();
430
67
  // The user may have specified source files which aren't in the coverage
431
67
  // mapping. Filter these files away.
432
67
  UncoveredFilesIt = std::remove_if(
433
74
      SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
434
74
        return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
435
74
                                   SF);
436
74
      });
437
67
438
67
  SourceFiles.erase(UncoveredFilesIt, SourceFiles.end());
439
67
}
440
441
114
void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) {
442
114
  if (!ViewOpts.hasDemangler())
443
111
    return;
444
3
445
3
  // Pass function names to the demangler in a temporary file.
446
3
  int InputFD;
447
3
  SmallString<256> InputPath;
448
3
  std::error_code EC =
449
3
      sys::fs::createTemporaryFile("demangle-in", "list", InputFD, InputPath);
450
3
  if (EC) {
451
0
    error(InputPath, EC.message());
452
0
    return;
453
0
  }
454
3
  ToolOutputFile InputTOF{InputPath, InputFD};
455
3
456
3
  unsigned NumSymbols = 0;
457
9
  for (const auto &Function : Coverage.getCoveredFunctions()) {
458
9
    InputTOF.os() << Function.Name << '\n';
459
9
    ++NumSymbols;
460
9
  }
461
3
  InputTOF.os().close();
462
3
463
3
  // Use another temporary file to store the demangler's output.
464
3
  int OutputFD;
465
3
  SmallString<256> OutputPath;
466
3
  EC = sys::fs::createTemporaryFile("demangle-out", "list", OutputFD,
467
3
                                    OutputPath);
468
3
  if (EC) {
469
0
    error(OutputPath, EC.message());
470
0
    return;
471
0
  }
472
3
  ToolOutputFile OutputTOF{OutputPath, OutputFD};
473
3
  OutputTOF.os().close();
474
3
475
3
  // Invoke the demangler.
476
3
  std::vector<StringRef> ArgsV;
477
3
  for (StringRef Arg : ViewOpts.DemanglerOpts)
478
6
    ArgsV.push_back(Arg);
479
3
  Optional<StringRef> Redirects[] = {InputPath.str(), OutputPath.str(), {""}};
480
3
  std::string ErrMsg;
481
3
  int RC = sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV,
482
3
                               /*env=*/None, Redirects, /*secondsToWait=*/0,
483
3
                               /*memoryLimit=*/0, &ErrMsg);
484
3
  if (RC) {
485
0
    error(ErrMsg, ViewOpts.DemanglerOpts[0]);
486
0
    return;
487
0
  }
488
3
489
3
  // Parse the demangler's output.
490
3
  auto BufOrError = MemoryBuffer::getFile(OutputPath);
491
3
  if (!BufOrError) {
492
0
    error(OutputPath, BufOrError.getError().message());
493
0
    return;
494
0
  }
495
3
496
3
  std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);
497
3
498
3
  SmallVector<StringRef, 8> Symbols;
499
3
  StringRef DemanglerData = DemanglerBuf->getBuffer();
500
3
  DemanglerData.split(Symbols, '\n', /*MaxSplit=*/NumSymbols,
501
3
                      /*KeepEmpty=*/false);
502
3
  if (Symbols.size() != NumSymbols) {
503
0
    error("Demangler did not provide expected number of symbols");
504
0
    return;
505
0
  }
506
3
507
3
  // Cache the demangled names.
508
3
  unsigned I = 0;
509
3
  for (const auto &Function : Coverage.getCoveredFunctions())
510
9
    // On Windows, lines in the demangler's output file end with "\r\n".
511
9
    // Splitting by '\n' keeps '\r's, so cut them now.
512
9
    DC.DemangledNames[Function.Name] = Symbols[I++].rtrim();
513
3
}
514
515
void CodeCoverageTool::writeSourceFileView(StringRef SourceFile,
516
                                           CoverageMapping *Coverage,
517
                                           CoveragePrinter *Printer,
518
117
                                           bool ShowFilenames) {
519
117
  auto View = createSourceFileView(SourceFile, *Coverage);
520
117
  if (!View) {
521
11
    warning("The file '" + SourceFile + "' isn't covered.");
522
11
    return;
523
11
  }
524
106
525
106
  auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
526
106
  if (Error E = OSOrErr.takeError()) {
527
0
    error("Could not create view file!", toString(std::move(E)));
528
0
    return;
529
0
  }
530
106
  auto OS = std::move(OSOrErr.get());
531
106
532
106
  View->print(*OS.get(), /*Wholefile=*/true,
533
106
              /*ShowSourceName=*/ShowFilenames,
534
106
              /*ShowTitle=*/ViewOpts.hasOutputDirectory());
535
106
  Printer->closeViewFile(std::move(OS));
536
106
}
537
538
124
int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
539
124
  cl::opt<std::string> CovFilename(
540
124
      cl::Positional, cl::desc("Covered executable or object file."));
541
124
542
124
  cl::list<std::string> CovFilenames(
543
124
      "object", cl::desc("Coverage executable or object file"), cl::ZeroOrMore,
544
124
      cl::CommaSeparated);
545
124
546
124
  cl::list<std::string> InputSourceFiles(
547
124
      cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
548
124
549
124
  cl::opt<bool> DebugDumpCollectedPaths(
550
124
      "dump-collected-paths", cl::Optional, cl::Hidden,
551
124
      cl::desc("Show the collected paths to source files"));
552
124
553
124
  cl::opt<std::string, true> PGOFilename(
554
124
      "instr-profile", cl::Required, cl::location(this->PGOFilename),
555
124
      cl::desc(
556
124
          "File with the profile data obtained after an instrumented run"));
557
124
558
124
  cl::list<std::string> Arches(
559
124
      "arch", cl::desc("architectures of the coverage mapping binaries"));
560
124
561
124
  cl::opt<bool> DebugDump("dump", cl::Optional,
562
124
                          cl::desc("Show internal debug dump"));
563
124
564
124
  cl::opt<CoverageViewOptions::OutputFormat> Format(
565
124
      "format", cl::desc("Output format for line-based coverage reports"),
566
124
      cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",
567
124
                            "Text output"),
568
124
                 clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
569
124
                            "HTML output"),
570
124
                 clEnumValN(CoverageViewOptions::OutputFormat::Lcov, "lcov",
571
124
                            "lcov tracefile output")),
572
124
      cl::init(CoverageViewOptions::OutputFormat::Text));
573
124
574
124
  cl::opt<std::string> PathRemap(
575
124
      "path-equivalence", cl::Optional,
576
124
      cl::desc("<from>,<to> Map coverage data paths to local source file "
577
124
               "paths"));
578
124
579
124
  cl::OptionCategory FilteringCategory("Function filtering options");
580
124
581
124
  cl::list<std::string> NameFilters(
582
124
      "name", cl::Optional,
583
124
      cl::desc("Show code coverage only for functions with the given name"),
584
124
      cl::ZeroOrMore, cl::cat(FilteringCategory));
585
124
586
124
  cl::list<std::string> NameFilterFiles(
587
124
      "name-whitelist", cl::Optional,
588
124
      cl::desc("Show code coverage only for functions listed in the given "
589
124
               "file"),
590
124
      cl::ZeroOrMore, cl::cat(FilteringCategory));
591
124
592
124
  cl::list<std::string> NameRegexFilters(
593
124
      "name-regex", cl::Optional,
594
124
      cl::desc("Show code coverage only for functions that match the given "
595
124
               "regular expression"),
596
124
      cl::ZeroOrMore, cl::cat(FilteringCategory));
597
124
598
124
  cl::list<std::string> IgnoreFilenameRegexFilters(
599
124
      "ignore-filename-regex", cl::Optional,
600
124
      cl::desc("Skip source code files with file paths that match the given "
601
124
               "regular expression"),
602
124
      cl::ZeroOrMore, cl::cat(FilteringCategory));
603
124
604
124
  cl::opt<double> RegionCoverageLtFilter(
605
124
      "region-coverage-lt", cl::Optional,
606
124
      cl::desc("Show code coverage only for functions with region coverage "
607
124
               "less than the given threshold"),
608
124
      cl::cat(FilteringCategory));
609
124
610
124
  cl::opt<double> RegionCoverageGtFilter(
611
124
      "region-coverage-gt", cl::Optional,
612
124
      cl::desc("Show code coverage only for functions with region coverage "
613
124
               "greater than the given threshold"),
614
124
      cl::cat(FilteringCategory));
615
124
616
124
  cl::opt<double> LineCoverageLtFilter(
617
124
      "line-coverage-lt", cl::Optional,
618
124
      cl::desc("Show code coverage only for functions with line coverage less "
619
124
               "than the given threshold"),
620
124
      cl::cat(FilteringCategory));
621
124
622
124
  cl::opt<double> LineCoverageGtFilter(
623
124
      "line-coverage-gt", cl::Optional,
624
124
      cl::desc("Show code coverage only for functions with line coverage "
625
124
               "greater than the given threshold"),
626
124
      cl::cat(FilteringCategory));
627
124
628
124
  cl::opt<cl::boolOrDefault> UseColor(
629
124
      "use-color", cl::desc("Emit colored output (default=autodetect)"),
630
124
      cl::init(cl::BOU_UNSET));
631
124
632
124
  cl::list<std::string> DemanglerOpts(
633
124
      "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
634
124
635
124
  cl::opt<bool> RegionSummary(
636
124
      "show-region-summary", cl::Optional,
637
124
      cl::desc("Show region statistics in summary table"),
638
124
      cl::init(true));
639
124
640
124
  cl::opt<bool> InstantiationSummary(
641
124
      "show-instantiation-summary", cl::Optional,
642
124
      cl::desc("Show instantiation statistics in summary table"));
643
124
644
124
  cl::opt<bool> SummaryOnly(
645
124
      "summary-only", cl::Optional,
646
124
      cl::desc("Export only summary information for each source file"));
647
124
648
124
  cl::opt<unsigned> NumThreads(
649
124
      "num-threads", cl::init(0),
650
124
      cl::desc("Number of merge threads to use (default: autodetect)"));
651
124
  cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
652
124
                        cl::aliasopt(NumThreads));
653
124
654
124
  auto commandLineParser = [&, this](int argc, const char **argv) -> int {
655
124
    cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
656
124
    ViewOpts.Debug = DebugDump;
657
124
658
124
    if (!CovFilename.empty())
659
122
      ObjectFilenames.emplace_back(CovFilename);
660
124
    for (const std::string &Filename : CovFilenames)
661
4
      ObjectFilenames.emplace_back(Filename);
662
124
    if (ObjectFilenames.empty()) {
663
1
      errs() << "No filenames specified!\n";
664
1
      ::exit(1);
665
1
    }
666
123
667
123
    ViewOpts.Format = Format;
668
123
    switch (ViewOpts.Format) {
669
123
    case CoverageViewOptions::OutputFormat::Text:
670
94
      ViewOpts.Colors = UseColor == cl::BOU_UNSET
671
94
                            ? sys::Process::StandardOutHasColors()
672
94
                            : 
UseColor == cl::BOU_TRUE0
;
673
94
      break;
674
123
    case CoverageViewOptions::OutputFormat::HTML:
675
26
      if (UseColor == cl::BOU_FALSE)
676
0
        errs() << "Color output cannot be disabled when generating html.\n";
677
26
      ViewOpts.Colors = true;
678
26
      break;
679
123
    case CoverageViewOptions::OutputFormat::Lcov:
680
3
      if (UseColor == cl::BOU_TRUE)
681
0
        errs() << "Color output cannot be enabled when generating lcov.\n";
682
3
      ViewOpts.Colors = false;
683
3
      break;
684
123
    }
685
123
686
123
    // If path-equivalence was given and is a comma seperated pair then set
687
123
    // PathRemapping.
688
123
    auto EquivPair = StringRef(PathRemap).split(',');
689
123
    if (!(EquivPair.first.empty() && 
EquivPair.second.empty()27
))
690
96
      PathRemapping = EquivPair;
691
123
692
123
    // If a demangler is supplied, check if it exists and register it.
693
123
    if (!DemanglerOpts.empty()) {
694
3
      auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
695
3
      if (!DemanglerPathOrErr) {
696
0
        error("Could not find the demangler!",
697
0
              DemanglerPathOrErr.getError().message());
698
0
        return 1;
699
0
      }
700
3
      DemanglerOpts[0] = *DemanglerPathOrErr;
701
3
      ViewOpts.DemanglerOpts.swap(DemanglerOpts);
702
3
    }
703
123
704
123
    // Read in -name-whitelist files.
705
123
    if (!NameFilterFiles.empty()) {
706
2
      std::string SpecialCaseListErr;
707
2
      NameWhitelist =
708
2
          SpecialCaseList::create(NameFilterFiles, SpecialCaseListErr);
709
2
      if (!NameWhitelist)
710
0
        error(SpecialCaseListErr);
711
2
    }
712
123
713
123
    // Create the function filters
714
123
    if (!NameFilters.empty() || 
NameWhitelist107
||
!NameRegexFilters.empty()105
) {
715
20
      auto NameFilterer = llvm::make_unique<CoverageFilters>();
716
20
      for (const auto &Name : NameFilters)
717
20
        NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
718
20
      if (NameWhitelist)
719
2
        NameFilterer->push_back(
720
2
            llvm::make_unique<NameWhitelistCoverageFilter>(*NameWhitelist));
721
20
      for (const auto &Regex : NameRegexFilters)
722
2
        NameFilterer->push_back(
723
2
            llvm::make_unique<NameRegexCoverageFilter>(Regex));
724
20
      Filters.push_back(std::move(NameFilterer));
725
20
    }
726
123
727
123
    if (RegionCoverageLtFilter.getNumOccurrences() ||
728
123
        RegionCoverageGtFilter.getNumOccurrences() ||
729
123
        LineCoverageLtFilter.getNumOccurrences() ||
730
123
        LineCoverageGtFilter.getNumOccurrences()) {
731
0
      auto StatFilterer = llvm::make_unique<CoverageFilters>();
732
0
      if (RegionCoverageLtFilter.getNumOccurrences())
733
0
        StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
734
0
            RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
735
0
      if (RegionCoverageGtFilter.getNumOccurrences())
736
0
        StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
737
0
            RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
738
0
      if (LineCoverageLtFilter.getNumOccurrences())
739
0
        StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
740
0
            LineCoverageFilter::LessThan, LineCoverageLtFilter));
741
0
      if (LineCoverageGtFilter.getNumOccurrences())
742
0
        StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
743
0
            RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
744
0
      Filters.push_back(std::move(StatFilterer));
745
0
    }
746
123
747
123
    // Create the ignore filename filters.
748
123
    for (const auto &RE : IgnoreFilenameRegexFilters)
749
5
      IgnoreFilenameFilters.push_back(
750
5
          llvm::make_unique<NameRegexCoverageFilter>(RE));
751
123
752
123
    if (!Arches.empty()) {
753
11
      for (const std::string &Arch : Arches) {
754
11
        if (Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
755
1
          error("Unknown architecture: " + Arch);
756
1
          return 1;
757
1
        }
758
10
        CoverageArches.emplace_back(Arch);
759
10
      }
760
9
      
if (8
CoverageArches.size() != ObjectFilenames.size()8
) {
761
1
        error("Number of architectures doesn't match the number of objects");
762
1
        return 1;
763
1
      }
764
121
    }
765
121
766
121
    // IgnoreFilenameFilters are applied even when InputSourceFiles specified.
767
121
    for (const std::string &File : InputSourceFiles)
768
87
      collectPaths(File);
769
121
770
121
    if (DebugDumpCollectedPaths) {
771
3
      for (const std::string &SF : SourceFiles)
772
12
        outs() << SF << '\n';
773
3
      ::exit(0);
774
3
    }
775
118
776
118
    ViewOpts.ShowRegionSummary = RegionSummary;
777
118
    ViewOpts.ShowInstantiationSummary = InstantiationSummary;
778
118
    ViewOpts.ExportSummaryOnly = SummaryOnly;
779
118
    ViewOpts.NumThreads = NumThreads;
780
118
781
118
    return 0;
782
118
  };
783
124
784
124
  switch (Cmd) {
785
124
  case Show:
786
84
    return doShow(argc, argv, commandLineParser);
787
124
  case Report:
788
26
    return doReport(argc, argv, commandLineParser);
789
124
  case Export:
790
14
    return doExport(argc, argv, commandLineParser);
791
0
  }
792
0
  return 0;
793
0
}
794
795
int CodeCoverageTool::doShow(int argc, const char **argv,
796
84
                             CommandLineParserType commandLineParser) {
797
84
798
84
  cl::OptionCategory ViewCategory("Viewing options");
799
84
800
84
  cl::opt<bool> ShowLineExecutionCounts(
801
84
      "show-line-counts", cl::Optional,
802
84
      cl::desc("Show the execution counts for each line"), cl::init(true),
803
84
      cl::cat(ViewCategory));
804
84
805
84
  cl::opt<bool> ShowRegions(
806
84
      "show-regions", cl::Optional,
807
84
      cl::desc("Show the execution counts for each region"),
808
84
      cl::cat(ViewCategory));
809
84
810
84
  cl::opt<bool> ShowBestLineRegionsCounts(
811
84
      "show-line-counts-or-regions", cl::Optional,
812
84
      cl::desc("Show the execution counts for each line, or the execution "
813
84
               "counts for each region on lines that have multiple regions"),
814
84
      cl::cat(ViewCategory));
815
84
816
84
  cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
817
84
                               cl::desc("Show expanded source regions"),
818
84
                               cl::cat(ViewCategory));
819
84
820
84
  cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
821
84
                                   cl::desc("Show function instantiations"),
822
84
                                   cl::init(true), cl::cat(ViewCategory));
823
84
824
84
  cl::opt<std::string> ShowOutputDirectory(
825
84
      "output-dir", cl::init(""),
826
84
      cl::desc("Directory in which coverage information is written out"));
827
84
  cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
828
84
                                 cl::aliasopt(ShowOutputDirectory));
829
84
830
84
  cl::opt<uint32_t> TabSize(
831
84
      "tab-size", cl::init(2),
832
84
      cl::desc(
833
84
          "Set tab expansion size for html coverage reports (default = 2)"));
834
84
835
84
  cl::opt<std::string> ProjectTitle(
836
84
      "project-title", cl::Optional,
837
84
      cl::desc("Set project title for the coverage report"));
838
84
839
84
  auto Err = commandLineParser(argc, argv);
840
84
  if (Err)
841
2
    return Err;
842
82
843
82
  if (ViewOpts.Format == CoverageViewOptions::OutputFormat::Lcov) {
844
0
    error("Lcov format should be used with 'llvm-cov export'.");
845
0
    return 1;
846
0
  }
847
82
848
82
  ViewOpts.ShowLineNumbers = true;
849
82
  ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
850
82
                           
!ShowRegions79
||
ShowBestLineRegionsCounts2
;
851
82
  ViewOpts.ShowRegionMarkers = ShowRegions || 
ShowBestLineRegionsCounts77
;
852
82
  ViewOpts.ShowExpandedRegions = ShowExpansions;
853
82
  ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
854
82
  ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
855
82
  ViewOpts.TabSize = TabSize;
856
82
  ViewOpts.ProjectTitle = ProjectTitle;
857
82
858
82
  if (ViewOpts.hasOutputDirectory()) {
859
31
    if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
860
0
      error("Could not create output directory!", E.message());
861
0
      return 1;
862
0
    }
863
82
  }
864
82
865
82
  sys::fs::file_status Status;
866
82
  if (sys::fs::status(PGOFilename, Status)) {
867
0
    error("profdata file error: can not get the file status. \n");
868
0
    return 1;
869
0
  }
870
82
871
82
  auto ModifiedTime = Status.getLastModificationTime();
872
82
  std::string ModifiedTimeStr = to_string(ModifiedTime);
873
82
  size_t found = ModifiedTimeStr.rfind(':');
874
82
  ViewOpts.CreatedTimeStr = (found != std::string::npos)
875
82
                                ? 
"Created: " + ModifiedTimeStr.substr(0, found)79
876
82
                                : 
"Created: " + ModifiedTimeStr3
;
877
82
878
82
  auto Coverage = load();
879
82
  if (!Coverage)
880
1
    return 1;
881
81
882
81
  auto Printer = CoveragePrinter::create(ViewOpts);
883
81
884
81
  if (SourceFiles.empty())
885
28
    // Get the source files from the function coverage mapping.
886
93
    
for (StringRef Filename : Coverage->getUniqueSourceFiles())28
{
887
93
      if (!IgnoreFilenameFilters.matchesFilename(Filename))
888
92
        SourceFiles.push_back(Filename);
889
93
    }
890
81
891
81
  // Create an index out of the source files.
892
81
  if (ViewOpts.hasOutputDirectory()) {
893
31
    if (Error E = Printer->createIndexFile(SourceFiles, *Coverage, Filters)) {
894
1
      error("Could not create index file!", toString(std::move(E)));
895
1
      return 1;
896
1
    }
897
80
  }
898
80
899
80
  if (!Filters.empty()) {
900
20
    // Build the map of filenames to functions.
901
20
    std::map<llvm::StringRef, std::vector<const FunctionRecord *>>
902
20
        FilenameFunctionMap;
903
20
    for (const auto &SourceFile : SourceFiles)
904
26
      for (const auto &Function : Coverage->getCoveredFunctions(SourceFile))
905
57
        if (Filters.matches(*Coverage.get(), Function))
906
30
          FilenameFunctionMap[SourceFile].push_back(&Function);
907
20
908
20
    // Only print filter matching functions for each file.
909
21
    for (const auto &FileFunc : FilenameFunctionMap) {
910
21
      StringRef File = FileFunc.first;
911
21
      const auto &Functions = FileFunc.second;
912
21
913
21
      auto OSOrErr = Printer->createViewFile(File, /*InToplevel=*/false);
914
21
      if (Error E = OSOrErr.takeError()) {
915
0
        error("Could not create view file!", toString(std::move(E)));
916
0
        return 1;
917
0
      }
918
21
      auto OS = std::move(OSOrErr.get());
919
21
920
21
      bool ShowTitle = ViewOpts.hasOutputDirectory();
921
30
      for (const auto *Function : Functions) {
922
30
        auto FunctionView = createFunctionView(*Function, *Coverage);
923
30
        if (!FunctionView) {
924
3
          warning("Could not read coverage for '" + Function->Name + "'.");
925
3
          continue;
926
3
        }
927
27
        FunctionView->print(*OS.get(), /*WholeFile=*/false,
928
27
                            /*ShowSourceName=*/true, ShowTitle);
929
27
        ShowTitle = false;
930
27
      }
931
21
932
21
      Printer->closeViewFile(std::move(OS));
933
21
    }
934
20
    return 0;
935
60
  }
936
60
937
60
  // Show files
938
60
  bool ShowFilenames =
939
60
      (SourceFiles.size() != 1) || 
ViewOpts.hasOutputDirectory()39
||
940
60
      
(ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML)26
;
941
60
942
60
  auto NumThreads = ViewOpts.NumThreads;
943
60
944
60
  // If NumThreads is not specified, auto-detect a good default.
945
60
  if (NumThreads == 0)
946
46
    NumThreads =
947
46
        std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),
948
46
                              unsigned(SourceFiles.size())));
949
60
950
60
  if (!ViewOpts.hasOutputDirectory() || 
NumThreads == 118
) {
951
54
    for (const std::string &SourceFile : SourceFiles)
952
102
      writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
953
102
                          ShowFilenames);
954
54
  } else {
955
6
    // In -output-dir mode, it's safe to use multiple threads to print files.
956
6
    ThreadPool Pool(NumThreads);
957
6
    for (const std::string &SourceFile : SourceFiles)
958
15
      Pool.async(&CodeCoverageTool::writeSourceFileView, this, SourceFile,
959
15
                 Coverage.get(), Printer.get(), ShowFilenames);
960
6
    Pool.wait();
961
6
  }
962
60
963
60
  return 0;
964
60
}
965
966
int CodeCoverageTool::doReport(int argc, const char **argv,
967
26
                               CommandLineParserType commandLineParser) {
968
26
  cl::opt<bool> ShowFunctionSummaries(
969
26
      "show-functions", cl::Optional, cl::init(false),
970
26
      cl::desc("Show coverage summaries for each function"));
971
26
972
26
  auto Err = commandLineParser(argc, argv);
973
26
  if (Err)
974
0
    return Err;
975
26
976
26
  if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML) {
977
1
    error("HTML output for summary reports is not yet supported.");
978
1
    return 1;
979
25
  } else if (ViewOpts.Format == CoverageViewOptions::OutputFormat::Lcov) {
980
0
    error("Lcov format should be used with 'llvm-cov export'.");
981
0
    return 1;
982
0
  }
983
25
984
25
  auto Coverage = load();
985
25
  if (!Coverage)
986
1
    return 1;
987
24
988
24
  CoverageReport Report(ViewOpts, *Coverage.get());
989
24
  if (!ShowFunctionSummaries) {
990
19
    if (SourceFiles.empty())
991
16
      Report.renderFileReports(llvm::outs(), IgnoreFilenameFilters);
992
3
    else
993
3
      Report.renderFileReports(llvm::outs(), SourceFiles);
994
19
  } else {
995
5
    if (SourceFiles.empty()) {
996
1
      error("Source files must be specified when -show-functions=true is "
997
1
            "specified");
998
1
      return 1;
999
1
    }
1000
4
1001
4
    Report.renderFunctionReports(SourceFiles, DC, llvm::outs());
1002
4
  }
1003
24
  
return 023
;
1004
24
}
1005
1006
int CodeCoverageTool::doExport(int argc, const char **argv,
1007
14
                               CommandLineParserType commandLineParser) {
1008
14
1009
14
  cl::OptionCategory ExportCategory("Exporting options");
1010
14
1011
14
  cl::opt<bool> SkipExpansions("skip-expansions", cl::Optional,
1012
14
                               cl::desc("Don't export expanded source regions"),
1013
14
                               cl::cat(ExportCategory));
1014
14
1015
14
  cl::opt<bool> SkipFunctions("skip-functions", cl::Optional,
1016
14
                              cl::desc("Don't export per-function data"),
1017
14
                              cl::cat(ExportCategory));
1018
14
1019
14
  auto Err = commandLineParser(argc, argv);
1020
14
  if (Err)
1021
0
    return Err;
1022
14
1023
14
  ViewOpts.SkipExpansions = SkipExpansions;
1024
14
  ViewOpts.SkipFunctions = SkipFunctions;
1025
14
1026
14
  if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text &&
1027
14
      
ViewOpts.Format != CoverageViewOptions::OutputFormat::Lcov4
) {
1028
1
    error("Coverage data can only be exported as textual JSON or an "
1029
1
          "lcov tracefile.");
1030
1
    return 1;
1031
1
  }
1032
13
1033
13
  auto Coverage = load();
1034
13
  if (!Coverage) {
1035
0
    error("Could not load coverage information");
1036
0
    return 1;
1037
0
  }
1038
13
1039
13
  std::unique_ptr<CoverageExporter> Exporter;
1040
13
1041
13
  switch (ViewOpts.Format) {
1042
13
  case CoverageViewOptions::OutputFormat::Text:
1043
10
    Exporter = llvm::make_unique<CoverageExporterJson>(*Coverage.get(),
1044
10
                                                       ViewOpts, outs());
1045
10
    break;
1046
13
  case CoverageViewOptions::OutputFormat::HTML:
1047
0
    // Unreachable because we should have gracefully terminated with an error
1048
0
    // above.
1049
0
    llvm_unreachable("Export in HTML is not supported!");
1050
13
  case CoverageViewOptions::OutputFormat::Lcov:
1051
3
    Exporter = llvm::make_unique<CoverageExporterLcov>(*Coverage.get(),
1052
3
                                                       ViewOpts, outs());
1053
3
    break;
1054
13
  }
1055
13
1056
13
  if (SourceFiles.empty())
1057
12
    Exporter->renderRoot(IgnoreFilenameFilters);
1058
1
  else
1059
1
    Exporter->renderRoot(SourceFiles);
1060
13
1061
13
  return 0;
1062
13
}
1063
1064
84
int showMain(int argc, const char *argv[]) {
1065
84
  CodeCoverageTool Tool;
1066
84
  return Tool.run(CodeCoverageTool::Show, argc, argv);
1067
84
}
1068
1069
26
int reportMain(int argc, const char *argv[]) {
1070
26
  CodeCoverageTool Tool;
1071
26
  return Tool.run(CodeCoverageTool::Report, argc, argv);
1072
26
}
1073
1074
14
int exportMain(int argc, const char *argv[]) {
1075
14
  CodeCoverageTool Tool;
1076
14
  return Tool.run(CodeCoverageTool::Export, argc, argv);
1077
14
}