Coverage Report

Created: 2018-06-18 20:01

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/llvm-cov/CoverageSummaryInfo.h
Line
Count
Source (jump to first uncovered line)
1
//===- CoverageSummaryInfo.h - Coverage summary for function/file ---------===//
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
// These structures are used to represent code coverage metrics
11
// for functions/files.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_COV_COVERAGESUMMARYINFO_H
16
#define LLVM_COV_COVERAGESUMMARYINFO_H
17
18
#include "llvm/ProfileData/Coverage/CoverageMapping.h"
19
#include "llvm/Support/raw_ostream.h"
20
21
namespace llvm {
22
23
/// Provides information about region coverage for a function/file.
24
class RegionCoverageInfo {
25
  /// The number of regions that were executed at least once.
26
  size_t Covered;
27
28
  /// The total number of regions in a function/file.
29
  size_t NumRegions;
30
31
public:
32
351
  RegionCoverageInfo() : Covered(0), NumRegions(0) {}
33
34
  RegionCoverageInfo(size_t Covered, size_t NumRegions)
35
200
      : Covered(Covered), NumRegions(NumRegions) {
36
200
    assert(Covered <= NumRegions && "Covered regions over-counted");
37
200
  }
38
39
299
  RegionCoverageInfo &operator+=(const RegionCoverageInfo &RHS) {
40
299
    Covered += RHS.Covered;
41
299
    NumRegions += RHS.NumRegions;
42
299
    return *this;
43
299
  }
44
45
34
  void merge(const RegionCoverageInfo &RHS) {
46
34
    Covered = std::max(Covered, RHS.Covered);
47
34
    NumRegions = std::max(NumRegions, RHS.NumRegions);
48
34
  }
49
50
246
  size_t getCovered() const { return Covered; }
51
52
470
  size_t getNumRegions() const { return NumRegions; }
53
54
133
  bool isFullyCovered() const { return Covered == NumRegions; }
55
56
273
  double getPercentCovered() const {
57
273
    assert(Covered <= NumRegions && "Covered regions over-counted");
58
273
    if (NumRegions == 0)
59
0
      return 0.0;
60
273
    return double(Covered) / double(NumRegions) * 100.0;
61
273
  }
62
};
63
64
/// Provides information about line coverage for a function/file.
65
class LineCoverageInfo {
66
  /// The number of lines that were executed at least once.
67
  size_t Covered;
68
69
  /// The total number of lines in a function/file.
70
  size_t NumLines;
71
72
public:
73
352
  LineCoverageInfo() : Covered(0), NumLines(0) {}
74
75
  LineCoverageInfo(size_t Covered, size_t NumLines)
76
200
      : Covered(Covered), NumLines(NumLines) {
77
200
    assert(Covered <= NumLines && "Covered lines over-counted");
78
200
  }
79
80
299
  LineCoverageInfo &operator+=(const LineCoverageInfo &RHS) {
81
299
    Covered += RHS.Covered;
82
299
    NumLines += RHS.NumLines;
83
299
    return *this;
84
299
  }
85
86
34
  void merge(const LineCoverageInfo &RHS) {
87
34
    Covered = std::max(Covered, RHS.Covered);
88
34
    NumLines = std::max(NumLines, RHS.NumLines);
89
34
  }
90
91
206
  size_t getCovered() const { return Covered; }
92
93
430
  size_t getNumLines() const { return NumLines; }
94
95
133
  bool isFullyCovered() const { return Covered == NumLines; }
96
97
265
  double getPercentCovered() const {
98
265
    assert(Covered <= NumLines && "Covered lines over-counted");
99
265
    if (NumLines == 0)
100
0
      return 0.0;
101
265
    return double(Covered) / double(NumLines) * 100.0;
102
265
  }
103
};
104
105
/// Provides information about function coverage for a file.
106
class FunctionCoverageInfo {
107
  /// The number of functions that were executed.
108
  size_t Executed;
109
110
  /// The total number of functions in this file.
111
  size_t NumFunctions;
112
113
public:
114
390
  FunctionCoverageInfo() : Executed(0), NumFunctions(0) {}
115
116
  FunctionCoverageInfo(size_t Executed, size_t NumFunctions)
117
0
      : Executed(Executed), NumFunctions(NumFunctions) {}
118
119
272
  FunctionCoverageInfo &operator+=(const FunctionCoverageInfo &RHS) {
120
272
    Executed += RHS.Executed;
121
272
    NumFunctions += RHS.NumFunctions;
122
272
    return *this;
123
272
  }
124
125
341
  void addFunction(bool Covered) {
126
341
    if (Covered)
127
302
      ++Executed;
128
341
    ++NumFunctions;
129
341
  }
130
131
236
  size_t getExecuted() const { return Executed; }
132
133
565
  size_t getNumFunctions() const { return NumFunctions; }
134
135
210
  bool isFullyCovered() const { return Executed == NumFunctions; }
136
137
282
  double getPercentCovered() const {
138
282
    assert(Executed <= NumFunctions && "Covered functions over-counted");
139
282
    if (NumFunctions == 0)
140
0
      return 0.0;
141
282
    return double(Executed) / double(NumFunctions) * 100.0;
142
282
  }
143
};
144
145
/// A summary of function's code coverage.
146
struct FunctionCoverageSummary {
147
  std::string Name;
148
  uint64_t ExecutionCount;
149
  RegionCoverageInfo RegionCoverage;
150
  LineCoverageInfo LineCoverage;
151
152
  FunctionCoverageSummary(const std::string &Name)
153
155
      : Name(Name), ExecutionCount(0), RegionCoverage(), LineCoverage() {}
154
155
  FunctionCoverageSummary(const std::string &Name, uint64_t ExecutionCount,
156
                          const RegionCoverageInfo &RegionCoverage,
157
                          const LineCoverageInfo &LineCoverage)
158
      : Name(Name), ExecutionCount(ExecutionCount),
159
200
        RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) {}
160
161
  /// Compute the code coverage summary for the given function coverage
162
  /// mapping record.
163
  static FunctionCoverageSummary get(const coverage::CoverageMapping &CM,
164
                                     const coverage::FunctionRecord &Function);
165
166
  /// Compute the code coverage summary for an instantiation group \p Group,
167
  /// given a list of summaries for each instantiation in \p Summaries.
168
  static FunctionCoverageSummary
169
  get(const coverage::InstantiationGroup &Group,
170
      ArrayRef<FunctionCoverageSummary> Summaries);
171
};
172
173
/// A summary of file's code coverage.
174
struct FileCoverageSummary {
175
  StringRef Name;
176
  RegionCoverageInfo RegionCoverage;
177
  LineCoverageInfo LineCoverage;
178
  FunctionCoverageInfo FunctionCoverage;
179
  FunctionCoverageInfo InstantiationCoverage;
180
181
  FileCoverageSummary(StringRef Name)
182
      : Name(Name), RegionCoverage(), LineCoverage(), FunctionCoverage(),
183
195
        InstantiationCoverage() {}
184
185
136
  FileCoverageSummary &operator+=(const FileCoverageSummary &RHS) {
186
136
    RegionCoverage += RHS.RegionCoverage;
187
136
    LineCoverage += RHS.LineCoverage;
188
136
    FunctionCoverage += RHS.FunctionCoverage;
189
136
    InstantiationCoverage += RHS.InstantiationCoverage;
190
136
    return *this;
191
136
  }
192
193
151
  void addFunction(const FunctionCoverageSummary &Function) {
194
151
    RegionCoverage += Function.RegionCoverage;
195
151
    LineCoverage += Function.LineCoverage;
196
151
    FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
197
151
  }
198
199
189
  void addInstantiation(const FunctionCoverageSummary &Function) {
200
189
    InstantiationCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
201
189
  }
202
};
203
204
/// A cache for demangled symbols.
205
struct DemangleCache {
206
  StringMap<std::string> DemangledNames;
207
208
  /// Demangle \p Sym if possible. Otherwise, just return \p Sym.
209
112
  StringRef demangle(StringRef Sym) const {
210
112
    const auto DemangledName = DemangledNames.find(Sym);
211
112
    if (DemangledName == DemangledNames.end())
212
102
      return Sym;
213
10
    return DemangledName->getValue();
214
10
  }
215
};
216
217
} // namespace llvm
218
219
#endif // LLVM_COV_COVERAGESUMMARYINFO_H