Coverage Report

Created: 2018-10-23 15:26

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/llvm-cov/SourceCoverageView.h
Line
Count
Source (jump to first uncovered line)
1
//===- SourceCoverageView.h - Code coverage view for source code ----------===//
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
/// \file This class implements rendering for code coverage of source code.
11
///
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_COV_SOURCECOVERAGEVIEW_H
15
#define LLVM_COV_SOURCECOVERAGEVIEW_H
16
17
#include "CoverageViewOptions.h"
18
#include "CoverageSummaryInfo.h"
19
#include "llvm/ProfileData/Coverage/CoverageMapping.h"
20
#include "llvm/Support/MemoryBuffer.h"
21
#include <vector>
22
23
namespace llvm {
24
25
using namespace coverage;
26
27
class CoverageFiltersMatchAll;
28
class SourceCoverageView;
29
30
/// A view that represents a macro or include expansion.
31
struct ExpansionView {
32
  CounterMappingRegion Region;
33
  std::unique_ptr<SourceCoverageView> View;
34
35
  ExpansionView(const CounterMappingRegion &Region,
36
                std::unique_ptr<SourceCoverageView> View)
37
3
      : Region(Region), View(std::move(View)) {}
38
  ExpansionView(ExpansionView &&RHS)
39
1
      : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {}
40
0
  ExpansionView &operator=(ExpansionView &&RHS) {
41
0
    Region = std::move(RHS.Region);
42
0
    View = std::move(RHS.View);
43
0
    return *this;
44
0
  }
45
46
62
  unsigned getLine() const { return Region.LineStart; }
47
3
  unsigned getStartCol() const { return Region.ColumnStart; }
48
3
  unsigned getEndCol() const { return Region.ColumnEnd; }
49
50
1
  friend bool operator<(const ExpansionView &LHS, const ExpansionView &RHS) {
51
1
    return LHS.Region.startLoc() < RHS.Region.startLoc();
52
1
  }
53
};
54
55
/// A view that represents a function instantiation.
56
struct InstantiationView {
57
  StringRef FunctionName;
58
  unsigned Line;
59
  std::unique_ptr<SourceCoverageView> View;
60
61
  InstantiationView(StringRef FunctionName, unsigned Line,
62
                    std::unique_ptr<SourceCoverageView> View)
63
60
      : FunctionName(FunctionName), Line(Line), View(std::move(View)) {}
64
65
  friend bool operator<(const InstantiationView &LHS,
66
36
                        const InstantiationView &RHS) {
67
36
    return LHS.Line < RHS.Line;
68
36
  }
69
};
70
71
/// A file manager that handles format-aware file creation.
72
class CoveragePrinter {
73
public:
74
  struct StreamDestructor {
75
    void operator()(raw_ostream *OS) const;
76
  };
77
78
  using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
79
80
protected:
81
  const CoverageViewOptions &Opts;
82
83
76
  CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}
84
85
  /// Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
86
  /// false, skip the ToplevelDir component. If \p Relative is false, skip the
87
  /// OutputDir component.
88
  std::string getOutputPath(StringRef Path, StringRef Extension,
89
                            bool InToplevel, bool Relative = true) const;
90
91
  /// If directory output is enabled, create a file in that directory
92
  /// at the path given by getOutputPath(). Otherwise, return stdout.
93
  Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
94
                                           bool InToplevel) const;
95
96
  /// Return the sub-directory name for file coverage reports.
97
112
  static StringRef getCoverageDir() { return "coverage"; }
98
99
public:
100
  static std::unique_ptr<CoveragePrinter>
101
  create(const CoverageViewOptions &Opts);
102
103
76
  virtual ~CoveragePrinter() {}
104
105
  /// @name File Creation Interface
106
  /// @{
107
108
  /// Create a file to print a coverage view into.
109
  virtual Expected<OwnedStream> createViewFile(StringRef Path,
110
                                               bool InToplevel) = 0;
111
112
  /// Close a file which has been used to print a coverage view.
113
  virtual void closeViewFile(OwnedStream OS) = 0;
114
115
  /// Create an index which lists reports for the given source files.
116
  virtual Error createIndexFile(ArrayRef<std::string> SourceFiles,
117
                                const CoverageMapping &Coverage,
118
                                const CoverageFiltersMatchAll &Filters) = 0;
119
120
  /// @}
121
};
122
123
/// A code coverage view of a source file or function.
124
///
125
/// A source coverage view and its nested sub-views form a file-oriented
126
/// representation of code coverage data. This view can be printed out by a
127
/// renderer which implements the Rendering Interface.
128
class SourceCoverageView {
129
  /// A function or file name.
130
  StringRef SourceName;
131
132
  /// A memory buffer backing the source on display.
133
  const MemoryBuffer &File;
134
135
  /// Various options to guide the coverage renderer.
136
  const CoverageViewOptions &Options;
137
138
  /// Complete coverage information about the source on display.
139
  CoverageData CoverageInfo;
140
141
  /// A container for all expansions (e.g macros) in the source on display.
142
  std::vector<ExpansionView> ExpansionSubViews;
143
144
  /// A container for all instantiations (e.g template functions) in the source
145
  /// on display.
146
  std::vector<InstantiationView> InstantiationSubViews;
147
148
  /// Get the first uncovered line number for the source file.
149
  unsigned getFirstUncoveredLineNo();
150
151
protected:
152
  struct LineRef {
153
    StringRef Line;
154
    int64_t LineNo;
155
156
2.96k
    LineRef(StringRef Line, int64_t LineNo) : Line(Line), LineNo(LineNo) {}
157
  };
158
159
  using CoverageSegmentArray = ArrayRef<const CoverageSegment *>;
160
161
  /// @name Rendering Interface
162
  /// @{
163
164
  /// Render a header for the view.
165
  virtual void renderViewHeader(raw_ostream &OS) = 0;
166
167
  /// Render a footer for the view.
168
  virtual void renderViewFooter(raw_ostream &OS) = 0;
169
170
  /// Render the source name for the view.
171
  virtual void renderSourceName(raw_ostream &OS, bool WholeFile) = 0;
172
173
  /// Render the line prefix at the given \p ViewDepth.
174
  virtual void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) = 0;
175
176
  /// Render the line suffix at the given \p ViewDepth.
177
  virtual void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) = 0;
178
179
  /// Render a view divider at the given \p ViewDepth.
180
  virtual void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) = 0;
181
182
  /// Render a source line with highlighting.
183
  virtual void renderLine(raw_ostream &OS, LineRef L,
184
                          const LineCoverageStats &LCS, unsigned ExpansionCol,
185
                          unsigned ViewDepth) = 0;
186
187
  /// Render the line's execution count column.
188
  virtual void renderLineCoverageColumn(raw_ostream &OS,
189
                                        const LineCoverageStats &Line) = 0;
190
191
  /// Render the line number column.
192
  virtual void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) = 0;
193
194
  /// Render all the region's execution counts on a line.
195
  virtual void renderRegionMarkers(raw_ostream &OS,
196
                                   const LineCoverageStats &Line,
197
                                   unsigned ViewDepth) = 0;
198
199
  /// Render the site of an expansion.
200
  virtual void renderExpansionSite(raw_ostream &OS, LineRef L,
201
                                   const LineCoverageStats &LCS,
202
                                   unsigned ExpansionCol,
203
                                   unsigned ViewDepth) = 0;
204
205
  /// Render an expansion view and any nested views.
206
  virtual void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
207
                                   unsigned ViewDepth) = 0;
208
209
  /// Render an instantiation view and any nested views.
210
  virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
211
                                       unsigned ViewDepth) = 0;
212
213
  /// Render \p Title, a project title if one is available, and the
214
  /// created time.
215
  virtual void renderTitle(raw_ostream &OS, StringRef CellText) = 0;
216
217
  /// Render the table header for a given source file.
218
  virtual void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
219
                                 unsigned IndentLevel) = 0;
220
221
  /// @}
222
223
  /// Format a count using engineering notation with 3 significant
224
  /// digits.
225
  static std::string formatCount(uint64_t N);
226
227
  /// Check if region marker output is expected for a line.
228
  bool shouldRenderRegionMarkers(const LineCoverageStats &LCS) const;
229
230
  /// Check if there are any sub-views attached to this view.
231
  bool hasSubViews() const;
232
233
  SourceCoverageView(StringRef SourceName, const MemoryBuffer &File,
234
                     const CoverageViewOptions &Options,
235
                     CoverageData &&CoverageInfo)
236
      : SourceName(SourceName), File(File), Options(Options),
237
184
        CoverageInfo(std::move(CoverageInfo)) {}
238
239
public:
240
  static std::unique_ptr<SourceCoverageView>
241
  create(StringRef SourceName, const MemoryBuffer &File,
242
         const CoverageViewOptions &Options, CoverageData &&CoverageInfo);
243
244
184
  virtual ~SourceCoverageView() {}
245
246
  /// Return the source name formatted for the host OS.
247
  std::string getSourceName() const;
248
249
20.3k
  const CoverageViewOptions &getOptions() const { return Options; }
250
251
  /// Add an expansion subview to this view.
252
  void addExpansion(const CounterMappingRegion &Region,
253
                    std::unique_ptr<SourceCoverageView> View);
254
255
  /// Add a function instantiation subview to this view.
256
  void addInstantiation(StringRef FunctionName, unsigned Line,
257
                        std::unique_ptr<SourceCoverageView> View);
258
259
  /// Print the code coverage information for a specific portion of a
260
  /// source file to the output stream.
261
  void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
262
             bool ShowTitle, unsigned ViewDepth = 0);
263
};
264
265
} // namespace llvm
266
267
#endif // LLVM_COV_SOURCECOVERAGEVIEW_H