1 //===- SourceCoverageView.cpp - Code coverage view for source code --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 /// \file This class implements rendering for code coverage of source code.
12 //===----------------------------------------------------------------------===//
14 #include "SourceCoverageView.h"
15 #include "SourceCoverageViewHTML.h"
16 #include "SourceCoverageViewText.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/Support/FileSystem.h"
20 #include "llvm/Support/LineIterator.h"
21 #include "llvm/Support/Path.h"
25 void CoveragePrinter::StreamDestructor::operator()(raw_ostream *OS) const {
31 std::string CoveragePrinter::getOutputPath(StringRef Path, StringRef Extension,
33 bool Relative) const {
34 assert(Extension.size() && "The file extension may not be empty");
36 SmallString<256> FullPath;
39 FullPath.append(Opts.ShowOutputDirectory);
42 sys::path::append(FullPath, getCoverageDir());
44 SmallString<256> ParentPath = sys::path::parent_path(Path);
45 sys::path::remove_dots(ParentPath, /*remove_dot_dots=*/true);
46 sys::path::append(FullPath, sys::path::relative_path(ParentPath));
48 auto PathFilename = (sys::path::filename(Path) + "." + Extension).str();
49 sys::path::append(FullPath, PathFilename);
50 sys::path::native(FullPath);
52 return FullPath.str();
55 Expected<CoveragePrinter::OwnedStream>
56 CoveragePrinter::createOutputStream(StringRef Path, StringRef Extension,
57 bool InToplevel) const {
58 if (!Opts.hasOutputDirectory())
59 return OwnedStream(&outs());
61 std::string FullPath = getOutputPath(Path, Extension, InToplevel, false);
63 auto ParentDir = sys::path::parent_path(FullPath);
64 if (auto E = sys::fs::create_directories(ParentDir))
65 return errorCodeToError(E);
68 raw_ostream *RawStream = new raw_fd_ostream(FullPath, E, sys::fs::F_RW);
69 auto OS = CoveragePrinter::OwnedStream(RawStream);
71 return errorCodeToError(E);
75 std::unique_ptr<CoveragePrinter>
76 CoveragePrinter::create(const CoverageViewOptions &Opts) {
77 switch (Opts.Format) {
78 case CoverageViewOptions::OutputFormat::Text:
79 return llvm::make_unique<CoveragePrinterText>(Opts);
80 case CoverageViewOptions::OutputFormat::HTML:
81 return llvm::make_unique<CoveragePrinterHTML>(Opts);
83 llvm_unreachable("Unknown coverage output format!");
86 unsigned SourceCoverageView::getFirstUncoveredLineNo() {
87 auto CheckIfUncovered = [](const coverage::CoverageSegment &S) {
88 return S.HasCount && S.Count == 0;
90 // L is less than R if (1) it's an uncovered segment (has a 0 count), and (2)
91 // either R is not an uncovered segment, or L has a lower line number than R.
93 std::min_element(CoverageInfo.begin(), CoverageInfo.end(),
94 [CheckIfUncovered](const coverage::CoverageSegment &L,
95 const coverage::CoverageSegment &R) {
96 return (CheckIfUncovered(L) &&
97 (!CheckIfUncovered(R) || (L.Line < R.Line)));
99 if (CheckIfUncovered(*MinSegIt))
100 return (*MinSegIt).Line;
101 // There is no uncovered line, return zero.
105 std::string SourceCoverageView::formatCount(uint64_t N) {
106 std::string Number = utostr(N);
107 int Len = Number.size();
110 int IntLen = Len % 3 == 0 ? 3 : Len % 3;
111 std::string Result(Number.data(), IntLen);
113 Result.push_back('.');
114 Result += Number.substr(IntLen, 3 - IntLen);
116 Result.push_back(" kMGTPEZY"[(Len - 1) / 3]);
120 bool SourceCoverageView::shouldRenderRegionMarkers(
121 bool LineHasMultipleRegions) const {
122 return getOptions().ShowRegionMarkers &&
123 (!getOptions().ShowLineStatsOrRegionMarkers || LineHasMultipleRegions);
126 bool SourceCoverageView::hasSubViews() const {
127 return !ExpansionSubViews.empty() || !InstantiationSubViews.empty();
130 std::unique_ptr<SourceCoverageView>
131 SourceCoverageView::create(StringRef SourceName, const MemoryBuffer &File,
132 const CoverageViewOptions &Options,
133 coverage::CoverageData &&CoverageInfo) {
134 switch (Options.Format) {
135 case CoverageViewOptions::OutputFormat::Text:
136 return llvm::make_unique<SourceCoverageViewText>(
137 SourceName, File, Options, std::move(CoverageInfo));
138 case CoverageViewOptions::OutputFormat::HTML:
139 return llvm::make_unique<SourceCoverageViewHTML>(
140 SourceName, File, Options, std::move(CoverageInfo));
142 llvm_unreachable("Unknown coverage output format!");
145 std::string SourceCoverageView::getSourceName() const {
146 SmallString<128> SourceText(SourceName);
147 sys::path::remove_dots(SourceText, /*remove_dot_dots=*/true);
148 sys::path::native(SourceText);
149 return SourceText.str();
152 void SourceCoverageView::addExpansion(
153 const coverage::CounterMappingRegion &Region,
154 std::unique_ptr<SourceCoverageView> View) {
155 ExpansionSubViews.emplace_back(Region, std::move(View));
158 void SourceCoverageView::addInstantiation(
159 StringRef FunctionName, unsigned Line,
160 std::unique_ptr<SourceCoverageView> View) {
161 InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View));
164 void SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
165 bool ShowSourceName, unsigned ViewDepth) {
166 if (WholeFile && getOptions().hasOutputDirectory())
167 renderTitle(OS, "Coverage Report");
169 renderViewHeader(OS);
172 renderSourceName(OS, WholeFile);
174 renderTableHeader(OS, (ViewDepth > 0) ? 0 : getFirstUncoveredLineNo(),
177 // We need the expansions and instantiations sorted so we can go through them
178 // while we iterate lines.
179 std::sort(ExpansionSubViews.begin(), ExpansionSubViews.end());
180 std::sort(InstantiationSubViews.begin(), InstantiationSubViews.end());
181 auto NextESV = ExpansionSubViews.begin();
182 auto EndESV = ExpansionSubViews.end();
183 auto NextISV = InstantiationSubViews.begin();
184 auto EndISV = InstantiationSubViews.end();
186 // Get the coverage information for the file.
187 auto NextSegment = CoverageInfo.begin();
188 auto EndSegment = CoverageInfo.end();
190 unsigned FirstLine = NextSegment != EndSegment ? NextSegment->Line : 0;
191 const coverage::CoverageSegment *WrappedSegment = nullptr;
192 SmallVector<const coverage::CoverageSegment *, 8> LineSegments;
193 for (line_iterator LI(File, /*SkipBlanks=*/false); !LI.is_at_eof(); ++LI) {
194 // If we aren't rendering the whole file, we need to filter out the prologue
197 if (NextSegment == EndSegment)
199 else if (LI.line_number() < FirstLine)
203 // Collect the coverage information relevant to this line.
204 if (LineSegments.size())
205 WrappedSegment = LineSegments.back();
206 LineSegments.clear();
207 while (NextSegment != EndSegment && NextSegment->Line == LI.line_number())
208 LineSegments.push_back(&*NextSegment++);
210 // Calculate a count to be for the line as a whole.
211 LineCoverageStats LineCount;
212 if (WrappedSegment && WrappedSegment->HasCount)
213 LineCount.addRegionCount(WrappedSegment->Count);
214 for (const auto *S : LineSegments)
215 if (S->HasCount && S->IsRegionEntry)
216 LineCount.addRegionStartCount(S->Count);
218 renderLinePrefix(OS, ViewDepth);
219 if (getOptions().ShowLineNumbers)
220 renderLineNumberColumn(OS, LI.line_number());
221 if (getOptions().ShowLineStats)
222 renderLineCoverageColumn(OS, LineCount);
224 // If there are expansion subviews, we want to highlight the first one.
225 unsigned ExpansionColumn = 0;
226 if (NextESV != EndESV && NextESV->getLine() == LI.line_number() &&
228 ExpansionColumn = NextESV->getStartCol();
230 // Display the source code for the current line.
231 renderLine(OS, {*LI, LI.line_number()}, WrappedSegment, LineSegments,
232 ExpansionColumn, ViewDepth);
234 // Show the region markers.
235 if (shouldRenderRegionMarkers(LineCount.hasMultipleRegions()))
236 renderRegionMarkers(OS, LineSegments, ViewDepth);
238 // Show the expansions and instantiations for this line.
239 bool RenderedSubView = false;
240 for (; NextESV != EndESV && NextESV->getLine() == LI.line_number();
242 renderViewDivider(OS, ViewDepth + 1);
244 // Re-render the current line and highlight the expansion range for
246 if (RenderedSubView) {
247 ExpansionColumn = NextESV->getStartCol();
248 renderExpansionSite(OS, {*LI, LI.line_number()}, WrappedSegment,
249 LineSegments, ExpansionColumn, ViewDepth);
250 renderViewDivider(OS, ViewDepth + 1);
253 renderExpansionView(OS, *NextESV, ViewDepth + 1);
254 RenderedSubView = true;
256 for (; NextISV != EndISV && NextISV->Line == LI.line_number(); ++NextISV) {
257 renderViewDivider(OS, ViewDepth + 1);
258 renderInstantiationView(OS, *NextISV, ViewDepth + 1);
259 RenderedSubView = true;
262 renderViewDivider(OS, ViewDepth + 1);
263 renderLineSuffix(OS, ViewDepth);
266 renderViewFooter(OS);