Bug Summary

File:clang/lib/CodeGen/CoverageMappingGen.cpp
Warning:line 212, column 26
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CoverageMappingGen.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-11/lib/clang/11.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp
1//===--- CoverageMappingGen.cpp - Coverage mapping generation ---*- C++ -*-===//
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// Instrumentation-based code coverage mapping generator
10//
11//===----------------------------------------------------------------------===//
12
13#include "CoverageMappingGen.h"
14#include "CodeGenFunction.h"
15#include "clang/AST/StmtVisitor.h"
16#include "clang/Basic/Diagnostic.h"
17#include "clang/Frontend/FrontendDiagnostic.h"
18#include "clang/Lex/Lexer.h"
19#include "llvm/ADT/SmallSet.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/ADT/Optional.h"
22#include "llvm/ProfileData/Coverage/CoverageMapping.h"
23#include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
24#include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
25#include "llvm/ProfileData/InstrProfReader.h"
26#include "llvm/Support/FileSystem.h"
27#include "llvm/Support/Path.h"
28
29// This selects the coverage mapping format defined when `InstrProfData.inc`
30// is textually included.
31#define COVMAP_V3
32
33using namespace clang;
34using namespace CodeGen;
35using namespace llvm::coverage;
36
37void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range, SourceLocation) {
38 SkippedRanges.push_back(Range);
39}
40
41namespace {
42
43/// A region of source code that can be mapped to a counter.
44class SourceMappingRegion {
45 Counter Count;
46
47 /// The region's starting location.
48 Optional<SourceLocation> LocStart;
49
50 /// The region's ending location.
51 Optional<SourceLocation> LocEnd;
52
53 /// Whether this region should be emitted after its parent is emitted.
54 bool DeferRegion;
55
56 /// Whether this region is a gap region. The count from a gap region is set
57 /// as the line execution count if there are no other regions on the line.
58 bool GapRegion;
59
60public:
61 SourceMappingRegion(Counter Count, Optional<SourceLocation> LocStart,
62 Optional<SourceLocation> LocEnd, bool DeferRegion = false,
63 bool GapRegion = false)
64 : Count(Count), LocStart(LocStart), LocEnd(LocEnd),
65 DeferRegion(DeferRegion), GapRegion(GapRegion) {}
66
67 const Counter &getCounter() const { return Count; }
68
69 void setCounter(Counter C) { Count = C; }
70
71 bool hasStartLoc() const { return LocStart.hasValue(); }
72
73 void setStartLoc(SourceLocation Loc) { LocStart = Loc; }
74
75 SourceLocation getBeginLoc() const {
76 assert(LocStart && "Region has no start location")((LocStart && "Region has no start location") ? static_cast
<void> (0) : __assert_fail ("LocStart && \"Region has no start location\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 76, __PRETTY_FUNCTION__))
;
77 return *LocStart;
78 }
79
80 bool hasEndLoc() const { return LocEnd.hasValue(); }
81
82 void setEndLoc(SourceLocation Loc) {
83 assert(Loc.isValid() && "Setting an invalid end location")((Loc.isValid() && "Setting an invalid end location")
? static_cast<void> (0) : __assert_fail ("Loc.isValid() && \"Setting an invalid end location\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 83, __PRETTY_FUNCTION__))
;
84 LocEnd = Loc;
85 }
86
87 SourceLocation getEndLoc() const {
88 assert(LocEnd && "Region has no end location")((LocEnd && "Region has no end location") ? static_cast
<void> (0) : __assert_fail ("LocEnd && \"Region has no end location\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 88, __PRETTY_FUNCTION__))
;
89 return *LocEnd;
90 }
91
92 bool isDeferred() const { return DeferRegion; }
93
94 void setDeferred(bool Deferred) { DeferRegion = Deferred; }
95
96 bool isGap() const { return GapRegion; }
97
98 void setGap(bool Gap) { GapRegion = Gap; }
99};
100
101/// Spelling locations for the start and end of a source region.
102struct SpellingRegion {
103 /// The line where the region starts.
104 unsigned LineStart;
105
106 /// The column where the region starts.
107 unsigned ColumnStart;
108
109 /// The line where the region ends.
110 unsigned LineEnd;
111
112 /// The column where the region ends.
113 unsigned ColumnEnd;
114
115 SpellingRegion(SourceManager &SM, SourceLocation LocStart,
116 SourceLocation LocEnd) {
117 LineStart = SM.getSpellingLineNumber(LocStart);
118 ColumnStart = SM.getSpellingColumnNumber(LocStart);
119 LineEnd = SM.getSpellingLineNumber(LocEnd);
120 ColumnEnd = SM.getSpellingColumnNumber(LocEnd);
121 }
122
123 SpellingRegion(SourceManager &SM, SourceMappingRegion &R)
124 : SpellingRegion(SM, R.getBeginLoc(), R.getEndLoc()) {}
125
126 /// Check if the start and end locations appear in source order, i.e
127 /// top->bottom, left->right.
128 bool isInSourceOrder() const {
129 return (LineStart < LineEnd) ||
130 (LineStart == LineEnd && ColumnStart <= ColumnEnd);
131 }
132};
133
134/// Provides the common functionality for the different
135/// coverage mapping region builders.
136class CoverageMappingBuilder {
137public:
138 CoverageMappingModuleGen &CVM;
139 SourceManager &SM;
140 const LangOptions &LangOpts;
141
142private:
143 /// Map of clang's FileIDs to IDs used for coverage mapping.
144 llvm::SmallDenseMap<FileID, std::pair<unsigned, SourceLocation>, 8>
145 FileIDMapping;
146
147public:
148 /// The coverage mapping regions for this function
149 llvm::SmallVector<CounterMappingRegion, 32> MappingRegions;
150 /// The source mapping regions for this function.
151 std::vector<SourceMappingRegion> SourceRegions;
152
153 /// A set of regions which can be used as a filter.
154 ///
155 /// It is produced by emitExpansionRegions() and is used in
156 /// emitSourceRegions() to suppress producing code regions if
157 /// the same area is covered by expansion regions.
158 typedef llvm::SmallSet<std::pair<SourceLocation, SourceLocation>, 8>
159 SourceRegionFilter;
160
161 CoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM,
162 const LangOptions &LangOpts)
163 : CVM(CVM), SM(SM), LangOpts(LangOpts) {}
164
165 /// Return the precise end location for the given token.
166 SourceLocation getPreciseTokenLocEnd(SourceLocation Loc) {
167 // We avoid getLocForEndOfToken here, because it doesn't do what we want for
168 // macro locations, which we just treat as expanded files.
169 unsigned TokLen =
170 Lexer::MeasureTokenLength(SM.getSpellingLoc(Loc), SM, LangOpts);
171 return Loc.getLocWithOffset(TokLen);
172 }
173
174 /// Return the start location of an included file or expanded macro.
175 SourceLocation getStartOfFileOrMacro(SourceLocation Loc) {
176 if (Loc.isMacroID())
177 return Loc.getLocWithOffset(-SM.getFileOffset(Loc));
178 return SM.getLocForStartOfFile(SM.getFileID(Loc));
179 }
180
181 /// Return the end location of an included file or expanded macro.
182 SourceLocation getEndOfFileOrMacro(SourceLocation Loc) {
183 if (Loc.isMacroID())
184 return Loc.getLocWithOffset(SM.getFileIDSize(SM.getFileID(Loc)) -
185 SM.getFileOffset(Loc));
186 return SM.getLocForEndOfFile(SM.getFileID(Loc));
187 }
188
189 /// Find out where the current file is included or macro is expanded.
190 SourceLocation getIncludeOrExpansionLoc(SourceLocation Loc) {
191 return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).getBegin()
192 : SM.getIncludeLoc(SM.getFileID(Loc));
193 }
194
195 /// Return true if \c Loc is a location in a built-in macro.
196 bool isInBuiltin(SourceLocation Loc) {
197 return SM.getBufferName(SM.getSpellingLoc(Loc)) == "<built-in>";
198 }
199
200 /// Check whether \c Loc is included or expanded from \c Parent.
201 bool isNestedIn(SourceLocation Loc, FileID Parent) {
202 do {
203 Loc = getIncludeOrExpansionLoc(Loc);
204 if (Loc.isInvalid())
205 return false;
206 } while (!SM.isInFileID(Loc, Parent));
207 return true;
208 }
209
210 /// Get the start of \c S ignoring macro arguments and builtin macros.
211 SourceLocation getStart(const Stmt *S) {
212 SourceLocation Loc = S->getBeginLoc();
15
Called C++ object pointer is null
213 while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc))
214 Loc = SM.getImmediateExpansionRange(Loc).getBegin();
215 return Loc;
216 }
217
218 /// Get the end of \c S ignoring macro arguments and builtin macros.
219 SourceLocation getEnd(const Stmt *S) {
220 SourceLocation Loc = S->getEndLoc();
221 while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc))
222 Loc = SM.getImmediateExpansionRange(Loc).getBegin();
223 return getPreciseTokenLocEnd(Loc);
224 }
225
226 /// Find the set of files we have regions for and assign IDs
227 ///
228 /// Fills \c Mapping with the virtual file mapping needed to write out
229 /// coverage and collects the necessary file information to emit source and
230 /// expansion regions.
231 void gatherFileIDs(SmallVectorImpl<unsigned> &Mapping) {
232 FileIDMapping.clear();
233
234 llvm::SmallSet<FileID, 8> Visited;
235 SmallVector<std::pair<SourceLocation, unsigned>, 8> FileLocs;
236 for (const auto &Region : SourceRegions) {
237 SourceLocation Loc = Region.getBeginLoc();
238 FileID File = SM.getFileID(Loc);
239 if (!Visited.insert(File).second)
240 continue;
241
242 // Do not map FileID's associated with system headers.
243 if (SM.isInSystemHeader(SM.getSpellingLoc(Loc)))
244 continue;
245
246 unsigned Depth = 0;
247 for (SourceLocation Parent = getIncludeOrExpansionLoc(Loc);
248 Parent.isValid(); Parent = getIncludeOrExpansionLoc(Parent))
249 ++Depth;
250 FileLocs.push_back(std::make_pair(Loc, Depth));
251 }
252 llvm::stable_sort(FileLocs, llvm::less_second());
253
254 for (const auto &FL : FileLocs) {
255 SourceLocation Loc = FL.first;
256 FileID SpellingFile = SM.getDecomposedSpellingLoc(Loc).first;
257 auto Entry = SM.getFileEntryForID(SpellingFile);
258 if (!Entry)
259 continue;
260
261 FileIDMapping[SM.getFileID(Loc)] = std::make_pair(Mapping.size(), Loc);
262 Mapping.push_back(CVM.getFileID(Entry));
263 }
264 }
265
266 /// Get the coverage mapping file ID for \c Loc.
267 ///
268 /// If such file id doesn't exist, return None.
269 Optional<unsigned> getCoverageFileID(SourceLocation Loc) {
270 auto Mapping = FileIDMapping.find(SM.getFileID(Loc));
271 if (Mapping != FileIDMapping.end())
272 return Mapping->second.first;
273 return None;
274 }
275
276 /// Gather all the regions that were skipped by the preprocessor
277 /// using the constructs like #if.
278 void gatherSkippedRegions() {
279 /// An array of the minimum lineStarts and the maximum lineEnds
280 /// for mapping regions from the appropriate source files.
281 llvm::SmallVector<std::pair<unsigned, unsigned>, 8> FileLineRanges;
282 FileLineRanges.resize(
283 FileIDMapping.size(),
284 std::make_pair(std::numeric_limits<unsigned>::max(), 0));
285 for (const auto &R : MappingRegions) {
286 FileLineRanges[R.FileID].first =
287 std::min(FileLineRanges[R.FileID].first, R.LineStart);
288 FileLineRanges[R.FileID].second =
289 std::max(FileLineRanges[R.FileID].second, R.LineEnd);
290 }
291
292 auto SkippedRanges = CVM.getSourceInfo().getSkippedRanges();
293 for (const auto &I : SkippedRanges) {
294 auto LocStart = I.getBegin();
295 auto LocEnd = I.getEnd();
296 assert(SM.isWrittenInSameFile(LocStart, LocEnd) &&((SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"
) ? static_cast<void> (0) : __assert_fail ("SM.isWrittenInSameFile(LocStart, LocEnd) && \"region spans multiple files\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 297, __PRETTY_FUNCTION__))
297 "region spans multiple files")((SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"
) ? static_cast<void> (0) : __assert_fail ("SM.isWrittenInSameFile(LocStart, LocEnd) && \"region spans multiple files\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 297, __PRETTY_FUNCTION__))
;
298
299 auto CovFileID = getCoverageFileID(LocStart);
300 if (!CovFileID)
301 continue;
302 SpellingRegion SR{SM, LocStart, LocEnd};
303 auto Region = CounterMappingRegion::makeSkipped(
304 *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd);
305 // Make sure that we only collect the regions that are inside
306 // the source code of this function.
307 if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
308 Region.LineEnd <= FileLineRanges[*CovFileID].second)
309 MappingRegions.push_back(Region);
310 }
311 }
312
313 /// Generate the coverage counter mapping regions from collected
314 /// source regions.
315 void emitSourceRegions(const SourceRegionFilter &Filter) {
316 for (const auto &Region : SourceRegions) {
317 assert(Region.hasEndLoc() && "incomplete region")((Region.hasEndLoc() && "incomplete region") ? static_cast
<void> (0) : __assert_fail ("Region.hasEndLoc() && \"incomplete region\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 317, __PRETTY_FUNCTION__))
;
318
319 SourceLocation LocStart = Region.getBeginLoc();
320 assert(SM.getFileID(LocStart).isValid() && "region in invalid file")((SM.getFileID(LocStart).isValid() && "region in invalid file"
) ? static_cast<void> (0) : __assert_fail ("SM.getFileID(LocStart).isValid() && \"region in invalid file\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 320, __PRETTY_FUNCTION__))
;
321
322 // Ignore regions from system headers.
323 if (SM.isInSystemHeader(SM.getSpellingLoc(LocStart)))
324 continue;
325
326 auto CovFileID = getCoverageFileID(LocStart);
327 // Ignore regions that don't have a file, such as builtin macros.
328 if (!CovFileID)
329 continue;
330
331 SourceLocation LocEnd = Region.getEndLoc();
332 assert(SM.isWrittenInSameFile(LocStart, LocEnd) &&((SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"
) ? static_cast<void> (0) : __assert_fail ("SM.isWrittenInSameFile(LocStart, LocEnd) && \"region spans multiple files\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 333, __PRETTY_FUNCTION__))
333 "region spans multiple files")((SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"
) ? static_cast<void> (0) : __assert_fail ("SM.isWrittenInSameFile(LocStart, LocEnd) && \"region spans multiple files\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 333, __PRETTY_FUNCTION__))
;
334
335 // Don't add code regions for the area covered by expansion regions.
336 // This not only suppresses redundant regions, but sometimes prevents
337 // creating regions with wrong counters if, for example, a statement's
338 // body ends at the end of a nested macro.
339 if (Filter.count(std::make_pair(LocStart, LocEnd)))
340 continue;
341
342 // Find the spelling locations for the mapping region.
343 SpellingRegion SR{SM, LocStart, LocEnd};
344 assert(SR.isInSourceOrder() && "region start and end out of order")((SR.isInSourceOrder() && "region start and end out of order"
) ? static_cast<void> (0) : __assert_fail ("SR.isInSourceOrder() && \"region start and end out of order\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 344, __PRETTY_FUNCTION__))
;
345
346 if (Region.isGap()) {
347 MappingRegions.push_back(CounterMappingRegion::makeGapRegion(
348 Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,
349 SR.LineEnd, SR.ColumnEnd));
350 } else {
351 MappingRegions.push_back(CounterMappingRegion::makeRegion(
352 Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,
353 SR.LineEnd, SR.ColumnEnd));
354 }
355 }
356 }
357
358 /// Generate expansion regions for each virtual file we've seen.
359 SourceRegionFilter emitExpansionRegions() {
360 SourceRegionFilter Filter;
361 for (const auto &FM : FileIDMapping) {
362 SourceLocation ExpandedLoc = FM.second.second;
363 SourceLocation ParentLoc = getIncludeOrExpansionLoc(ExpandedLoc);
364 if (ParentLoc.isInvalid())
365 continue;
366
367 auto ParentFileID = getCoverageFileID(ParentLoc);
368 if (!ParentFileID)
369 continue;
370 auto ExpandedFileID = getCoverageFileID(ExpandedLoc);
371 assert(ExpandedFileID && "expansion in uncovered file")((ExpandedFileID && "expansion in uncovered file") ? static_cast
<void> (0) : __assert_fail ("ExpandedFileID && \"expansion in uncovered file\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 371, __PRETTY_FUNCTION__))
;
372
373 SourceLocation LocEnd = getPreciseTokenLocEnd(ParentLoc);
374 assert(SM.isWrittenInSameFile(ParentLoc, LocEnd) &&((SM.isWrittenInSameFile(ParentLoc, LocEnd) && "region spans multiple files"
) ? static_cast<void> (0) : __assert_fail ("SM.isWrittenInSameFile(ParentLoc, LocEnd) && \"region spans multiple files\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 375, __PRETTY_FUNCTION__))
375 "region spans multiple files")((SM.isWrittenInSameFile(ParentLoc, LocEnd) && "region spans multiple files"
) ? static_cast<void> (0) : __assert_fail ("SM.isWrittenInSameFile(ParentLoc, LocEnd) && \"region spans multiple files\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 375, __PRETTY_FUNCTION__))
;
376 Filter.insert(std::make_pair(ParentLoc, LocEnd));
377
378 SpellingRegion SR{SM, ParentLoc, LocEnd};
379 assert(SR.isInSourceOrder() && "region start and end out of order")((SR.isInSourceOrder() && "region start and end out of order"
) ? static_cast<void> (0) : __assert_fail ("SR.isInSourceOrder() && \"region start and end out of order\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 379, __PRETTY_FUNCTION__))
;
380 MappingRegions.push_back(CounterMappingRegion::makeExpansion(
381 *ParentFileID, *ExpandedFileID, SR.LineStart, SR.ColumnStart,
382 SR.LineEnd, SR.ColumnEnd));
383 }
384 return Filter;
385 }
386};
387
388/// Creates unreachable coverage regions for the functions that
389/// are not emitted.
390struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder {
391 EmptyCoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM,
392 const LangOptions &LangOpts)
393 : CoverageMappingBuilder(CVM, SM, LangOpts) {}
394
395 void VisitDecl(const Decl *D) {
396 if (!D->hasBody())
397 return;
398 auto Body = D->getBody();
399 SourceLocation Start = getStart(Body);
400 SourceLocation End = getEnd(Body);
401 if (!SM.isWrittenInSameFile(Start, End)) {
402 // Walk up to find the common ancestor.
403 // Correct the locations accordingly.
404 FileID StartFileID = SM.getFileID(Start);
405 FileID EndFileID = SM.getFileID(End);
406 while (StartFileID != EndFileID && !isNestedIn(End, StartFileID)) {
407 Start = getIncludeOrExpansionLoc(Start);
408 assert(Start.isValid() &&((Start.isValid() && "Declaration start location not nested within a known region"
) ? static_cast<void> (0) : __assert_fail ("Start.isValid() && \"Declaration start location not nested within a known region\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 409, __PRETTY_FUNCTION__))
409 "Declaration start location not nested within a known region")((Start.isValid() && "Declaration start location not nested within a known region"
) ? static_cast<void> (0) : __assert_fail ("Start.isValid() && \"Declaration start location not nested within a known region\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 409, __PRETTY_FUNCTION__))
;
410 StartFileID = SM.getFileID(Start);
411 }
412 while (StartFileID != EndFileID) {
413 End = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(End));
414 assert(End.isValid() &&((End.isValid() && "Declaration end location not nested within a known region"
) ? static_cast<void> (0) : __assert_fail ("End.isValid() && \"Declaration end location not nested within a known region\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 415, __PRETTY_FUNCTION__))
415 "Declaration end location not nested within a known region")((End.isValid() && "Declaration end location not nested within a known region"
) ? static_cast<void> (0) : __assert_fail ("End.isValid() && \"Declaration end location not nested within a known region\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 415, __PRETTY_FUNCTION__))
;
416 EndFileID = SM.getFileID(End);
417 }
418 }
419 SourceRegions.emplace_back(Counter(), Start, End);
420 }
421
422 /// Write the mapping data to the output stream
423 void write(llvm::raw_ostream &OS) {
424 SmallVector<unsigned, 16> FileIDMapping;
425 gatherFileIDs(FileIDMapping);
426 emitSourceRegions(SourceRegionFilter());
427
428 if (MappingRegions.empty())
429 return;
430
431 CoverageMappingWriter Writer(FileIDMapping, None, MappingRegions);
432 Writer.write(OS);
433 }
434};
435
436/// A StmtVisitor that creates coverage mapping regions which map
437/// from the source code locations to the PGO counters.
438struct CounterCoverageMappingBuilder
439 : public CoverageMappingBuilder,
440 public ConstStmtVisitor<CounterCoverageMappingBuilder> {
441 /// The map of statements to count values.
442 llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
443
444 /// A stack of currently live regions.
445 std::vector<SourceMappingRegion> RegionStack;
446
447 /// The currently deferred region: its end location and count can be set once
448 /// its parent has been popped from the region stack.
449 Optional<SourceMappingRegion> DeferredRegion;
450
451 CounterExpressionBuilder Builder;
452
453 /// A location in the most recently visited file or macro.
454 ///
455 /// This is used to adjust the active source regions appropriately when
456 /// expressions cross file or macro boundaries.
457 SourceLocation MostRecentLocation;
458
459 /// Location of the last terminated region.
460 Optional<std::pair<SourceLocation, size_t>> LastTerminatedRegion;
461
462 /// Return a counter for the subtraction of \c RHS from \c LHS
463 Counter subtractCounters(Counter LHS, Counter RHS) {
464 return Builder.subtract(LHS, RHS);
465 }
466
467 /// Return a counter for the sum of \c LHS and \c RHS.
468 Counter addCounters(Counter LHS, Counter RHS) {
469 return Builder.add(LHS, RHS);
470 }
471
472 Counter addCounters(Counter C1, Counter C2, Counter C3) {
473 return addCounters(addCounters(C1, C2), C3);
474 }
475
476 /// Return the region counter for the given statement.
477 ///
478 /// This should only be called on statements that have a dedicated counter.
479 Counter getRegionCounter(const Stmt *S) {
480 return Counter::getCounter(CounterMap[S]);
481 }
482
483 /// Push a region onto the stack.
484 ///
485 /// Returns the index on the stack where the region was pushed. This can be
486 /// used with popRegions to exit a "scope", ending the region that was pushed.
487 size_t pushRegion(Counter Count, Optional<SourceLocation> StartLoc = None,
488 Optional<SourceLocation> EndLoc = None) {
489 if (StartLoc) {
490 MostRecentLocation = *StartLoc;
491 completeDeferred(Count, MostRecentLocation);
492 }
493 RegionStack.emplace_back(Count, StartLoc, EndLoc);
494
495 return RegionStack.size() - 1;
496 }
497
498 /// Complete any pending deferred region by setting its end location and
499 /// count, and then pushing it onto the region stack.
500 size_t completeDeferred(Counter Count, SourceLocation DeferredEndLoc) {
501 size_t Index = RegionStack.size();
502 if (!DeferredRegion)
503 return Index;
504
505 // Consume the pending region.
506 SourceMappingRegion DR = DeferredRegion.getValue();
507 DeferredRegion = None;
508
509 // If the region ends in an expansion, find the expansion site.
510 FileID StartFile = SM.getFileID(DR.getBeginLoc());
511 if (SM.getFileID(DeferredEndLoc) != StartFile) {
512 if (isNestedIn(DeferredEndLoc, StartFile)) {
513 do {
514 DeferredEndLoc = getIncludeOrExpansionLoc(DeferredEndLoc);
515 } while (StartFile != SM.getFileID(DeferredEndLoc));
516 } else {
517 return Index;
518 }
519 }
520
521 // The parent of this deferred region ends where the containing decl ends,
522 // so the region isn't useful.
523 if (DR.getBeginLoc() == DeferredEndLoc)
524 return Index;
525
526 // If we're visiting statements in non-source order (e.g switch cases or
527 // a loop condition) we can't construct a sensible deferred region.
528 if (!SpellingRegion(SM, DR.getBeginLoc(), DeferredEndLoc).isInSourceOrder())
529 return Index;
530
531 DR.setGap(true);
532 DR.setCounter(Count);
533 DR.setEndLoc(DeferredEndLoc);
534 handleFileExit(DeferredEndLoc);
535 RegionStack.push_back(DR);
536 return Index;
537 }
538
539 /// Complete a deferred region created after a terminated region at the
540 /// top-level.
541 void completeTopLevelDeferredRegion(Counter Count,
542 SourceLocation DeferredEndLoc) {
543 if (DeferredRegion || !LastTerminatedRegion)
544 return;
545
546 if (LastTerminatedRegion->second != RegionStack.size())
547 return;
548
549 SourceLocation Start = LastTerminatedRegion->first;
550 if (SM.getFileID(Start) != SM.getMainFileID())
551 return;
552
553 SourceMappingRegion DR = RegionStack.back();
554 DR.setStartLoc(Start);
555 DR.setDeferred(false);
556 DeferredRegion = DR;
557 completeDeferred(Count, DeferredEndLoc);
558 }
559
560 size_t locationDepth(SourceLocation Loc) {
561 size_t Depth = 0;
562 while (Loc.isValid()) {
563 Loc = getIncludeOrExpansionLoc(Loc);
564 Depth++;
565 }
566 return Depth;
567 }
568
569 /// Pop regions from the stack into the function's list of regions.
570 ///
571 /// Adds all regions from \c ParentIndex to the top of the stack to the
572 /// function's \c SourceRegions.
573 void popRegions(size_t ParentIndex) {
574 assert(RegionStack.size() >= ParentIndex && "parent not in stack")((RegionStack.size() >= ParentIndex && "parent not in stack"
) ? static_cast<void> (0) : __assert_fail ("RegionStack.size() >= ParentIndex && \"parent not in stack\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 574, __PRETTY_FUNCTION__))
;
575 bool ParentOfDeferredRegion = false;
576 while (RegionStack.size() > ParentIndex) {
577 SourceMappingRegion &Region = RegionStack.back();
578 if (Region.hasStartLoc()) {
579 SourceLocation StartLoc = Region.getBeginLoc();
580 SourceLocation EndLoc = Region.hasEndLoc()
581 ? Region.getEndLoc()
582 : RegionStack[ParentIndex].getEndLoc();
583 size_t StartDepth = locationDepth(StartLoc);
584 size_t EndDepth = locationDepth(EndLoc);
585 while (!SM.isWrittenInSameFile(StartLoc, EndLoc)) {
586 bool UnnestStart = StartDepth >= EndDepth;
587 bool UnnestEnd = EndDepth >= StartDepth;
588 if (UnnestEnd) {
589 // The region ends in a nested file or macro expansion. Create a
590 // separate region for each expansion.
591 SourceLocation NestedLoc = getStartOfFileOrMacro(EndLoc);
592 assert(SM.isWrittenInSameFile(NestedLoc, EndLoc))((SM.isWrittenInSameFile(NestedLoc, EndLoc)) ? static_cast<
void> (0) : __assert_fail ("SM.isWrittenInSameFile(NestedLoc, EndLoc)"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 592, __PRETTY_FUNCTION__))
;
593
594 if (!isRegionAlreadyAdded(NestedLoc, EndLoc))
595 SourceRegions.emplace_back(Region.getCounter(), NestedLoc, EndLoc);
596
597 EndLoc = getPreciseTokenLocEnd(getIncludeOrExpansionLoc(EndLoc));
598 if (EndLoc.isInvalid())
599 llvm::report_fatal_error("File exit not handled before popRegions");
600 EndDepth--;
601 }
602 if (UnnestStart) {
603 // The region begins in a nested file or macro expansion. Create a
604 // separate region for each expansion.
605 SourceLocation NestedLoc = getEndOfFileOrMacro(StartLoc);
606 assert(SM.isWrittenInSameFile(StartLoc, NestedLoc))((SM.isWrittenInSameFile(StartLoc, NestedLoc)) ? static_cast<
void> (0) : __assert_fail ("SM.isWrittenInSameFile(StartLoc, NestedLoc)"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 606, __PRETTY_FUNCTION__))
;
607
608 if (!isRegionAlreadyAdded(StartLoc, NestedLoc))
609 SourceRegions.emplace_back(Region.getCounter(), StartLoc, NestedLoc);
610
611 StartLoc = getIncludeOrExpansionLoc(StartLoc);
612 if (StartLoc.isInvalid())
613 llvm::report_fatal_error("File exit not handled before popRegions");
614 StartDepth--;
615 }
616 }
617 Region.setStartLoc(StartLoc);
618 Region.setEndLoc(EndLoc);
619
620 MostRecentLocation = EndLoc;
621 // If this region happens to span an entire expansion, we need to make
622 // sure we don't overlap the parent region with it.
623 if (StartLoc == getStartOfFileOrMacro(StartLoc) &&
624 EndLoc == getEndOfFileOrMacro(EndLoc))
625 MostRecentLocation = getIncludeOrExpansionLoc(EndLoc);
626
627 assert(SM.isWrittenInSameFile(Region.getBeginLoc(), EndLoc))((SM.isWrittenInSameFile(Region.getBeginLoc(), EndLoc)) ? static_cast
<void> (0) : __assert_fail ("SM.isWrittenInSameFile(Region.getBeginLoc(), EndLoc)"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 627, __PRETTY_FUNCTION__))
;
628 assert(SpellingRegion(SM, Region).isInSourceOrder())((SpellingRegion(SM, Region).isInSourceOrder()) ? static_cast
<void> (0) : __assert_fail ("SpellingRegion(SM, Region).isInSourceOrder()"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 628, __PRETTY_FUNCTION__))
;
629 SourceRegions.push_back(Region);
630
631 if (ParentOfDeferredRegion) {
632 ParentOfDeferredRegion = false;
633
634 // If there's an existing deferred region, keep the old one, because
635 // it means there are two consecutive returns (or a similar pattern).
636 if (!DeferredRegion.hasValue() &&
637 // File IDs aren't gathered within macro expansions, so it isn't
638 // useful to try and create a deferred region inside of one.
639 !EndLoc.isMacroID())
640 DeferredRegion =
641 SourceMappingRegion(Counter::getZero(), EndLoc, None);
642 }
643 } else if (Region.isDeferred()) {
644 assert(!ParentOfDeferredRegion && "Consecutive deferred regions")((!ParentOfDeferredRegion && "Consecutive deferred regions"
) ? static_cast<void> (0) : __assert_fail ("!ParentOfDeferredRegion && \"Consecutive deferred regions\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 644, __PRETTY_FUNCTION__))
;
645 ParentOfDeferredRegion = true;
646 }
647 RegionStack.pop_back();
648
649 // If the zero region pushed after the last terminated region no longer
650 // exists, clear its cached information.
651 if (LastTerminatedRegion &&
652 RegionStack.size() < LastTerminatedRegion->second)
653 LastTerminatedRegion = None;
654 }
655 assert(!ParentOfDeferredRegion && "Deferred region with no parent")((!ParentOfDeferredRegion && "Deferred region with no parent"
) ? static_cast<void> (0) : __assert_fail ("!ParentOfDeferredRegion && \"Deferred region with no parent\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 655, __PRETTY_FUNCTION__))
;
656 }
657
658 /// Return the currently active region.
659 SourceMappingRegion &getRegion() {
660 assert(!RegionStack.empty() && "statement has no region")((!RegionStack.empty() && "statement has no region") ?
static_cast<void> (0) : __assert_fail ("!RegionStack.empty() && \"statement has no region\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 660, __PRETTY_FUNCTION__))
;
661 return RegionStack.back();
662 }
663
664 /// Propagate counts through the children of \p S if \p VisitChildren is true.
665 /// Otherwise, only emit a count for \p S itself.
666 Counter propagateCounts(Counter TopCount, const Stmt *S,
667 bool VisitChildren = true) {
668 SourceLocation StartLoc = getStart(S);
13
Passing null pointer value via 1st parameter 'S'
14
Calling 'CoverageMappingBuilder::getStart'
669 SourceLocation EndLoc = getEnd(S);
670 size_t Index = pushRegion(TopCount, StartLoc, EndLoc);
671 if (VisitChildren)
672 Visit(S);
673 Counter ExitCount = getRegion().getCounter();
674 popRegions(Index);
675
676 // The statement may be spanned by an expansion. Make sure we handle a file
677 // exit out of this expansion before moving to the next statement.
678 if (SM.isBeforeInTranslationUnit(StartLoc, S->getBeginLoc()))
679 MostRecentLocation = EndLoc;
680
681 return ExitCount;
682 }
683
684 /// Check whether a region with bounds \c StartLoc and \c EndLoc
685 /// is already added to \c SourceRegions.
686 bool isRegionAlreadyAdded(SourceLocation StartLoc, SourceLocation EndLoc) {
687 return SourceRegions.rend() !=
688 std::find_if(SourceRegions.rbegin(), SourceRegions.rend(),
689 [&](const SourceMappingRegion &Region) {
690 return Region.getBeginLoc() == StartLoc &&
691 Region.getEndLoc() == EndLoc;
692 });
693 }
694
695 /// Adjust the most recently visited location to \c EndLoc.
696 ///
697 /// This should be used after visiting any statements in non-source order.
698 void adjustForOutOfOrderTraversal(SourceLocation EndLoc) {
699 MostRecentLocation = EndLoc;
700 // The code region for a whole macro is created in handleFileExit() when
701 // it detects exiting of the virtual file of that macro. If we visited
702 // statements in non-source order, we might already have such a region
703 // added, for example, if a body of a loop is divided among multiple
704 // macros. Avoid adding duplicate regions in such case.
705 if (getRegion().hasEndLoc() &&
706 MostRecentLocation == getEndOfFileOrMacro(MostRecentLocation) &&
707 isRegionAlreadyAdded(getStartOfFileOrMacro(MostRecentLocation),
708 MostRecentLocation))
709 MostRecentLocation = getIncludeOrExpansionLoc(MostRecentLocation);
710 }
711
712 /// Adjust regions and state when \c NewLoc exits a file.
713 ///
714 /// If moving from our most recently tracked location to \c NewLoc exits any
715 /// files, this adjusts our current region stack and creates the file regions
716 /// for the exited file.
717 void handleFileExit(SourceLocation NewLoc) {
718 if (NewLoc.isInvalid() ||
719 SM.isWrittenInSameFile(MostRecentLocation, NewLoc))
720 return;
721
722 // If NewLoc is not in a file that contains MostRecentLocation, walk up to
723 // find the common ancestor.
724 SourceLocation LCA = NewLoc;
725 FileID ParentFile = SM.getFileID(LCA);
726 while (!isNestedIn(MostRecentLocation, ParentFile)) {
727 LCA = getIncludeOrExpansionLoc(LCA);
728 if (LCA.isInvalid() || SM.isWrittenInSameFile(LCA, MostRecentLocation)) {
729 // Since there isn't a common ancestor, no file was exited. We just need
730 // to adjust our location to the new file.
731 MostRecentLocation = NewLoc;
732 return;
733 }
734 ParentFile = SM.getFileID(LCA);
735 }
736
737 llvm::SmallSet<SourceLocation, 8> StartLocs;
738 Optional<Counter> ParentCounter;
739 for (SourceMappingRegion &I : llvm::reverse(RegionStack)) {
740 if (!I.hasStartLoc())
741 continue;
742 SourceLocation Loc = I.getBeginLoc();
743 if (!isNestedIn(Loc, ParentFile)) {
744 ParentCounter = I.getCounter();
745 break;
746 }
747
748 while (!SM.isInFileID(Loc, ParentFile)) {
749 // The most nested region for each start location is the one with the
750 // correct count. We avoid creating redundant regions by stopping once
751 // we've seen this region.
752 if (StartLocs.insert(Loc).second)
753 SourceRegions.emplace_back(I.getCounter(), Loc,
754 getEndOfFileOrMacro(Loc));
755 Loc = getIncludeOrExpansionLoc(Loc);
756 }
757 I.setStartLoc(getPreciseTokenLocEnd(Loc));
758 }
759
760 if (ParentCounter) {
761 // If the file is contained completely by another region and doesn't
762 // immediately start its own region, the whole file gets a region
763 // corresponding to the parent.
764 SourceLocation Loc = MostRecentLocation;
765 while (isNestedIn(Loc, ParentFile)) {
766 SourceLocation FileStart = getStartOfFileOrMacro(Loc);
767 if (StartLocs.insert(FileStart).second) {
768 SourceRegions.emplace_back(*ParentCounter, FileStart,
769 getEndOfFileOrMacro(Loc));
770 assert(SpellingRegion(SM, SourceRegions.back()).isInSourceOrder())((SpellingRegion(SM, SourceRegions.back()).isInSourceOrder())
? static_cast<void> (0) : __assert_fail ("SpellingRegion(SM, SourceRegions.back()).isInSourceOrder()"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 770, __PRETTY_FUNCTION__))
;
771 }
772 Loc = getIncludeOrExpansionLoc(Loc);
773 }
774 }
775
776 MostRecentLocation = NewLoc;
777 }
778
779 /// Ensure that \c S is included in the current region.
780 void extendRegion(const Stmt *S) {
781 SourceMappingRegion &Region = getRegion();
782 SourceLocation StartLoc = getStart(S);
783
784 handleFileExit(StartLoc);
785 if (!Region.hasStartLoc())
786 Region.setStartLoc(StartLoc);
787
788 completeDeferred(Region.getCounter(), StartLoc);
789 }
790
791 /// Mark \c S as a terminator, starting a zero region.
792 void terminateRegion(const Stmt *S) {
793 extendRegion(S);
794 SourceMappingRegion &Region = getRegion();
795 SourceLocation EndLoc = getEnd(S);
796 if (!Region.hasEndLoc())
797 Region.setEndLoc(EndLoc);
798 pushRegion(Counter::getZero());
799 auto &ZeroRegion = getRegion();
800 ZeroRegion.setDeferred(true);
801 LastTerminatedRegion = {EndLoc, RegionStack.size()};
802 }
803
804 /// Find a valid gap range between \p AfterLoc and \p BeforeLoc.
805 Optional<SourceRange> findGapAreaBetween(SourceLocation AfterLoc,
806 SourceLocation BeforeLoc) {
807 // If the start and end locations of the gap are both within the same macro
808 // file, the range may not be in source order.
809 if (AfterLoc.isMacroID() || BeforeLoc.isMacroID())
810 return None;
811 if (!SM.isWrittenInSameFile(AfterLoc, BeforeLoc))
812 return None;
813 return {{AfterLoc, BeforeLoc}};
814 }
815
816 /// Find the source range after \p AfterStmt and before \p BeforeStmt.
817 Optional<SourceRange> findGapAreaBetween(const Stmt *AfterStmt,
818 const Stmt *BeforeStmt) {
819 return findGapAreaBetween(getPreciseTokenLocEnd(getEnd(AfterStmt)),
820 getStart(BeforeStmt));
821 }
822
823 /// Emit a gap region between \p StartLoc and \p EndLoc with the given count.
824 void fillGapAreaWithCount(SourceLocation StartLoc, SourceLocation EndLoc,
825 Counter Count) {
826 if (StartLoc == EndLoc)
827 return;
828 assert(SpellingRegion(SM, StartLoc, EndLoc).isInSourceOrder())((SpellingRegion(SM, StartLoc, EndLoc).isInSourceOrder()) ? static_cast
<void> (0) : __assert_fail ("SpellingRegion(SM, StartLoc, EndLoc).isInSourceOrder()"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 828, __PRETTY_FUNCTION__))
;
829 handleFileExit(StartLoc);
830 size_t Index = pushRegion(Count, StartLoc, EndLoc);
831 getRegion().setGap(true);
832 handleFileExit(EndLoc);
833 popRegions(Index);
834 }
835
836 /// Keep counts of breaks and continues inside loops.
837 struct BreakContinue {
838 Counter BreakCount;
839 Counter ContinueCount;
840 };
841 SmallVector<BreakContinue, 8> BreakContinueStack;
842
843 CounterCoverageMappingBuilder(
844 CoverageMappingModuleGen &CVM,
845 llvm::DenseMap<const Stmt *, unsigned> &CounterMap, SourceManager &SM,
846 const LangOptions &LangOpts)
847 : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap),
848 DeferredRegion(None) {}
849
850 /// Write the mapping data to the output stream
851 void write(llvm::raw_ostream &OS) {
852 llvm::SmallVector<unsigned, 8> VirtualFileMapping;
853 gatherFileIDs(VirtualFileMapping);
854 SourceRegionFilter Filter = emitExpansionRegions();
855 assert(!DeferredRegion && "Deferred region never completed")((!DeferredRegion && "Deferred region never completed"
) ? static_cast<void> (0) : __assert_fail ("!DeferredRegion && \"Deferred region never completed\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 855, __PRETTY_FUNCTION__))
;
856 emitSourceRegions(Filter);
857 gatherSkippedRegions();
858
859 if (MappingRegions.empty())
860 return;
861
862 CoverageMappingWriter Writer(VirtualFileMapping, Builder.getExpressions(),
863 MappingRegions);
864 Writer.write(OS);
865 }
866
867 void VisitStmt(const Stmt *S) {
868 if (S->getBeginLoc().isValid())
869 extendRegion(S);
870 for (const Stmt *Child : S->children())
871 if (Child)
872 this->Visit(Child);
873 handleFileExit(getEnd(S));
874 }
875
876 void VisitDecl(const Decl *D) {
877 assert(!DeferredRegion && "Deferred region never completed")((!DeferredRegion && "Deferred region never completed"
) ? static_cast<void> (0) : __assert_fail ("!DeferredRegion && \"Deferred region never completed\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 877, __PRETTY_FUNCTION__))
;
4
Assuming the condition is true
5
'?' condition is true
878
879 Stmt *Body = D->getBody();
6
'Body' initialized here
880
881 // Do not propagate region counts into system headers.
882 if (Body && SM.isInSystemHeader(SM.getSpellingLoc(getStart(Body))))
7
Assuming 'Body' is null
8
Taking false branch
883 return;
884
885 // Do not visit the artificial children nodes of defaulted methods. The
886 // lexer may not be able to report back precise token end locations for
887 // these children nodes (llvm.org/PR39822), and moreover users will not be
888 // able to see coverage for them.
889 bool Defaulted = false;
890 if (auto *Method
9.1
'Method' is null
= dyn_cast<CXXMethodDecl>(D))
9
Assuming 'D' is not a 'CXXMethodDecl'
10
Taking false branch
891 Defaulted = Method->isDefaulted();
892
893 propagateCounts(getRegionCounter(Body), Body,
11
Passing null pointer value via 2nd parameter 'S'
12
Calling 'CounterCoverageMappingBuilder::propagateCounts'
894 /*VisitChildren=*/!Defaulted);
895 assert(RegionStack.empty() && "Regions entered but never exited")((RegionStack.empty() && "Regions entered but never exited"
) ? static_cast<void> (0) : __assert_fail ("RegionStack.empty() && \"Regions entered but never exited\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 895, __PRETTY_FUNCTION__))
;
896
897 // Discard the last uncompleted deferred region in a decl, if one exists.
898 // This prevents lines at the end of a function containing only whitespace
899 // or closing braces from being marked as uncovered.
900 DeferredRegion = None;
901 }
902
903 void VisitReturnStmt(const ReturnStmt *S) {
904 extendRegion(S);
905 if (S->getRetValue())
906 Visit(S->getRetValue());
907 terminateRegion(S);
908 }
909
910 void VisitCXXThrowExpr(const CXXThrowExpr *E) {
911 extendRegion(E);
912 if (E->getSubExpr())
913 Visit(E->getSubExpr());
914 terminateRegion(E);
915 }
916
917 void VisitGotoStmt(const GotoStmt *S) { terminateRegion(S); }
918
919 void VisitLabelStmt(const LabelStmt *S) {
920 Counter LabelCount = getRegionCounter(S);
921 SourceLocation Start = getStart(S);
922 completeTopLevelDeferredRegion(LabelCount, Start);
923 completeDeferred(LabelCount, Start);
924 // We can't extendRegion here or we risk overlapping with our new region.
925 handleFileExit(Start);
926 pushRegion(LabelCount, Start);
927 Visit(S->getSubStmt());
928 }
929
930 void VisitBreakStmt(const BreakStmt *S) {
931 assert(!BreakContinueStack.empty() && "break not in a loop or switch!")((!BreakContinueStack.empty() && "break not in a loop or switch!"
) ? static_cast<void> (0) : __assert_fail ("!BreakContinueStack.empty() && \"break not in a loop or switch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 931, __PRETTY_FUNCTION__))
;
932 BreakContinueStack.back().BreakCount = addCounters(
933 BreakContinueStack.back().BreakCount, getRegion().getCounter());
934 // FIXME: a break in a switch should terminate regions for all preceding
935 // case statements, not just the most recent one.
936 terminateRegion(S);
937 }
938
939 void VisitContinueStmt(const ContinueStmt *S) {
940 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!")((!BreakContinueStack.empty() && "continue stmt not in a loop!"
) ? static_cast<void> (0) : __assert_fail ("!BreakContinueStack.empty() && \"continue stmt not in a loop!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 940, __PRETTY_FUNCTION__))
;
941 BreakContinueStack.back().ContinueCount = addCounters(
942 BreakContinueStack.back().ContinueCount, getRegion().getCounter());
943 terminateRegion(S);
944 }
945
946 void VisitCallExpr(const CallExpr *E) {
947 VisitStmt(E);
948
949 // Terminate the region when we hit a noreturn function.
950 // (This is helpful dealing with switch statements.)
951 QualType CalleeType = E->getCallee()->getType();
952 if (getFunctionExtInfo(*CalleeType).getNoReturn())
953 terminateRegion(E);
954 }
955
956 void VisitWhileStmt(const WhileStmt *S) {
957 extendRegion(S);
958
959 Counter ParentCount = getRegion().getCounter();
960 Counter BodyCount = getRegionCounter(S);
961
962 // Handle the body first so that we can get the backedge count.
963 BreakContinueStack.push_back(BreakContinue());
964 extendRegion(S->getBody());
965 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
966 BreakContinue BC = BreakContinueStack.pop_back_val();
967
968 // Go back to handle the condition.
969 Counter CondCount =
970 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
971 propagateCounts(CondCount, S->getCond());
972 adjustForOutOfOrderTraversal(getEnd(S));
973
974 // The body count applies to the area immediately after the increment.
975 auto Gap = findGapAreaBetween(S->getCond(), S->getBody());
976 if (Gap)
977 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
978
979 Counter OutCount =
980 addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
981 if (OutCount != ParentCount)
982 pushRegion(OutCount);
983 }
984
985 void VisitDoStmt(const DoStmt *S) {
986 extendRegion(S);
987
988 Counter ParentCount = getRegion().getCounter();
989 Counter BodyCount = getRegionCounter(S);
990
991 BreakContinueStack.push_back(BreakContinue());
992 extendRegion(S->getBody());
993 Counter BackedgeCount =
994 propagateCounts(addCounters(ParentCount, BodyCount), S->getBody());
995 BreakContinue BC = BreakContinueStack.pop_back_val();
996
997 Counter CondCount = addCounters(BackedgeCount, BC.ContinueCount);
998 propagateCounts(CondCount, S->getCond());
999
1000 Counter OutCount =
1001 addCounters(BC.BreakCount, subtractCounters(CondCount, BodyCount));
1002 if (OutCount != ParentCount)
1003 pushRegion(OutCount);
1004 }
1005
1006 void VisitForStmt(const ForStmt *S) {
1007 extendRegion(S);
1008 if (S->getInit())
1009 Visit(S->getInit());
1010
1011 Counter ParentCount = getRegion().getCounter();
1012 Counter BodyCount = getRegionCounter(S);
1013
1014 // The loop increment may contain a break or continue.
1015 if (S->getInc())
1016 BreakContinueStack.emplace_back();
1017
1018 // Handle the body first so that we can get the backedge count.
1019 BreakContinueStack.emplace_back();
1020 extendRegion(S->getBody());
1021 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
1022 BreakContinue BodyBC = BreakContinueStack.pop_back_val();
1023
1024 // The increment is essentially part of the body but it needs to include
1025 // the count for all the continue statements.
1026 BreakContinue IncrementBC;
1027 if (const Stmt *Inc = S->getInc()) {
1028 propagateCounts(addCounters(BackedgeCount, BodyBC.ContinueCount), Inc);
1029 IncrementBC = BreakContinueStack.pop_back_val();
1030 }
1031
1032 // Go back to handle the condition.
1033 Counter CondCount = addCounters(
1034 addCounters(ParentCount, BackedgeCount, BodyBC.ContinueCount),
1035 IncrementBC.ContinueCount);
1036 if (const Expr *Cond = S->getCond()) {
1037 propagateCounts(CondCount, Cond);
1038 adjustForOutOfOrderTraversal(getEnd(S));
1039 }
1040
1041 // The body count applies to the area immediately after the increment.
1042 auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()),
1043 getStart(S->getBody()));
1044 if (Gap)
1045 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
1046
1047 Counter OutCount = addCounters(BodyBC.BreakCount, IncrementBC.BreakCount,
1048 subtractCounters(CondCount, BodyCount));
1049 if (OutCount != ParentCount)
1050 pushRegion(OutCount);
1051 }
1052
1053 void VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
1054 extendRegion(S);
1055 if (S->getInit())
1056 Visit(S->getInit());
1057 Visit(S->getLoopVarStmt());
1058 Visit(S->getRangeStmt());
1059
1060 Counter ParentCount = getRegion().getCounter();
1061 Counter BodyCount = getRegionCounter(S);
1062
1063 BreakContinueStack.push_back(BreakContinue());
1064 extendRegion(S->getBody());
1065 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
1066 BreakContinue BC = BreakContinueStack.pop_back_val();
1067
1068 // The body count applies to the area immediately after the range.
1069 auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()),
1070 getStart(S->getBody()));
1071 if (Gap)
1072 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
1073
1074 Counter LoopCount =
1075 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
1076 Counter OutCount =
1077 addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount));
1078 if (OutCount != ParentCount)
1079 pushRegion(OutCount);
1080 }
1081
1082 void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
1083 extendRegion(S);
1084 Visit(S->getElement());
1085
1086 Counter ParentCount = getRegion().getCounter();
1087 Counter BodyCount = getRegionCounter(S);
1088
1089 BreakContinueStack.push_back(BreakContinue());
1090 extendRegion(S->getBody());
1091 Counter BackedgeCount = propagateCounts(BodyCount, S->getBody());
1092 BreakContinue BC = BreakContinueStack.pop_back_val();
1093
1094 // The body count applies to the area immediately after the collection.
1095 auto Gap = findGapAreaBetween(getPreciseTokenLocEnd(S->getRParenLoc()),
1096 getStart(S->getBody()));
1097 if (Gap)
1098 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), BodyCount);
1099
1100 Counter LoopCount =
1101 addCounters(ParentCount, BackedgeCount, BC.ContinueCount);
1102 Counter OutCount =
1103 addCounters(BC.BreakCount, subtractCounters(LoopCount, BodyCount));
1104 if (OutCount != ParentCount)
1105 pushRegion(OutCount);
1106 }
1107
1108 void VisitSwitchStmt(const SwitchStmt *S) {
1109 extendRegion(S);
1110 if (S->getInit())
1111 Visit(S->getInit());
1112 Visit(S->getCond());
1113
1114 BreakContinueStack.push_back(BreakContinue());
1115
1116 const Stmt *Body = S->getBody();
1117 extendRegion(Body);
1118 if (const auto *CS = dyn_cast<CompoundStmt>(Body)) {
1119 if (!CS->body_empty()) {
1120 // Make a region for the body of the switch. If the body starts with
1121 // a case, that case will reuse this region; otherwise, this covers
1122 // the unreachable code at the beginning of the switch body.
1123 size_t Index = pushRegion(Counter::getZero(), getStart(CS));
1124 getRegion().setGap(true);
1125 for (const auto *Child : CS->children())
1126 Visit(Child);
1127
1128 // Set the end for the body of the switch, if it isn't already set.
1129 for (size_t i = RegionStack.size(); i != Index; --i) {
1130 if (!RegionStack[i - 1].hasEndLoc())
1131 RegionStack[i - 1].setEndLoc(getEnd(CS->body_back()));
1132 }
1133
1134 popRegions(Index);
1135 }
1136 } else
1137 propagateCounts(Counter::getZero(), Body);
1138 BreakContinue BC = BreakContinueStack.pop_back_val();
1139
1140 if (!BreakContinueStack.empty())
1141 BreakContinueStack.back().ContinueCount = addCounters(
1142 BreakContinueStack.back().ContinueCount, BC.ContinueCount);
1143
1144 Counter ExitCount = getRegionCounter(S);
1145 SourceLocation ExitLoc = getEnd(S);
1146 pushRegion(ExitCount);
1147
1148 // Ensure that handleFileExit recognizes when the end location is located
1149 // in a different file.
1150 MostRecentLocation = getStart(S);
1151 handleFileExit(ExitLoc);
1152 }
1153
1154 void VisitSwitchCase(const SwitchCase *S) {
1155 extendRegion(S);
1156
1157 SourceMappingRegion &Parent = getRegion();
1158
1159 Counter Count = addCounters(Parent.getCounter(), getRegionCounter(S));
1160 // Reuse the existing region if it starts at our label. This is typical of
1161 // the first case in a switch.
1162 if (Parent.hasStartLoc() && Parent.getBeginLoc() == getStart(S))
1163 Parent.setCounter(Count);
1164 else
1165 pushRegion(Count, getStart(S));
1166
1167 if (const auto *CS = dyn_cast<CaseStmt>(S)) {
1168 Visit(CS->getLHS());
1169 if (const Expr *RHS = CS->getRHS())
1170 Visit(RHS);
1171 }
1172 Visit(S->getSubStmt());
1173 }
1174
1175 void VisitIfStmt(const IfStmt *S) {
1176 extendRegion(S);
1177 if (S->getInit())
1178 Visit(S->getInit());
1179
1180 // Extend into the condition before we propagate through it below - this is
1181 // needed to handle macros that generate the "if" but not the condition.
1182 extendRegion(S->getCond());
1183
1184 Counter ParentCount = getRegion().getCounter();
1185 Counter ThenCount = getRegionCounter(S);
1186
1187 // Emitting a counter for the condition makes it easier to interpret the
1188 // counter for the body when looking at the coverage.
1189 propagateCounts(ParentCount, S->getCond());
1190
1191 // The 'then' count applies to the area immediately after the condition.
1192 auto Gap = findGapAreaBetween(S->getCond(), S->getThen());
1193 if (Gap)
1194 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ThenCount);
1195
1196 extendRegion(S->getThen());
1197 Counter OutCount = propagateCounts(ThenCount, S->getThen());
1198
1199 Counter ElseCount = subtractCounters(ParentCount, ThenCount);
1200 if (const Stmt *Else = S->getElse()) {
1201 // The 'else' count applies to the area immediately after the 'then'.
1202 Gap = findGapAreaBetween(S->getThen(), Else);
1203 if (Gap)
1204 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), ElseCount);
1205 extendRegion(Else);
1206 OutCount = addCounters(OutCount, propagateCounts(ElseCount, Else));
1207 } else
1208 OutCount = addCounters(OutCount, ElseCount);
1209
1210 if (OutCount != ParentCount)
1211 pushRegion(OutCount);
1212 }
1213
1214 void VisitCXXTryStmt(const CXXTryStmt *S) {
1215 extendRegion(S);
1216 // Handle macros that generate the "try" but not the rest.
1217 extendRegion(S->getTryBlock());
1218
1219 Counter ParentCount = getRegion().getCounter();
1220 propagateCounts(ParentCount, S->getTryBlock());
1221
1222 for (unsigned I = 0, E = S->getNumHandlers(); I < E; ++I)
1223 Visit(S->getHandler(I));
1224
1225 Counter ExitCount = getRegionCounter(S);
1226 pushRegion(ExitCount);
1227 }
1228
1229 void VisitCXXCatchStmt(const CXXCatchStmt *S) {
1230 propagateCounts(getRegionCounter(S), S->getHandlerBlock());
1231 }
1232
1233 void VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
1234 extendRegion(E);
1235
1236 Counter ParentCount = getRegion().getCounter();
1237 Counter TrueCount = getRegionCounter(E);
1238
1239 Visit(E->getCond());
1240
1241 if (!isa<BinaryConditionalOperator>(E)) {
1242 // The 'then' count applies to the area immediately after the condition.
1243 auto Gap =
1244 findGapAreaBetween(E->getQuestionLoc(), getStart(E->getTrueExpr()));
1245 if (Gap)
1246 fillGapAreaWithCount(Gap->getBegin(), Gap->getEnd(), TrueCount);
1247
1248 extendRegion(E->getTrueExpr());
1249 propagateCounts(TrueCount, E->getTrueExpr());
1250 }
1251
1252 extendRegion(E->getFalseExpr());
1253 propagateCounts(subtractCounters(ParentCount, TrueCount),
1254 E->getFalseExpr());
1255 }
1256
1257 void VisitBinLAnd(const BinaryOperator *E) {
1258 extendRegion(E->getLHS());
1259 propagateCounts(getRegion().getCounter(), E->getLHS());
1260 handleFileExit(getEnd(E->getLHS()));
1261
1262 extendRegion(E->getRHS());
1263 propagateCounts(getRegionCounter(E), E->getRHS());
1264 }
1265
1266 void VisitBinLOr(const BinaryOperator *E) {
1267 extendRegion(E->getLHS());
1268 propagateCounts(getRegion().getCounter(), E->getLHS());
1269 handleFileExit(getEnd(E->getLHS()));
1270
1271 extendRegion(E->getRHS());
1272 propagateCounts(getRegionCounter(E), E->getRHS());
1273 }
1274
1275 void VisitLambdaExpr(const LambdaExpr *LE) {
1276 // Lambdas are treated as their own functions for now, so we shouldn't
1277 // propagate counts into them.
1278 }
1279};
1280
1281std::string normalizeFilename(StringRef Filename) {
1282 llvm::SmallString<256> Path(Filename);
1283 llvm::sys::fs::make_absolute(Path);
1284 llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
1285 return std::string(Path);
1286}
1287
1288} // end anonymous namespace
1289
1290static void dump(llvm::raw_ostream &OS, StringRef FunctionName,
1291 ArrayRef<CounterExpression> Expressions,
1292 ArrayRef<CounterMappingRegion> Regions) {
1293 OS << FunctionName << ":\n";
1294 CounterMappingContext Ctx(Expressions);
1295 for (const auto &R : Regions) {
1296 OS.indent(2);
1297 switch (R.Kind) {
1298 case CounterMappingRegion::CodeRegion:
1299 break;
1300 case CounterMappingRegion::ExpansionRegion:
1301 OS << "Expansion,";
1302 break;
1303 case CounterMappingRegion::SkippedRegion:
1304 OS << "Skipped,";
1305 break;
1306 case CounterMappingRegion::GapRegion:
1307 OS << "Gap,";
1308 break;
1309 }
1310
1311 OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart
1312 << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = ";
1313 Ctx.dump(R.Count, OS);
1314 if (R.Kind == CounterMappingRegion::ExpansionRegion)
1315 OS << " (Expanded file = " << R.ExpandedFileID << ")";
1316 OS << "\n";
1317 }
1318}
1319
1320static std::string getInstrProfSection(const CodeGenModule &CGM,
1321 llvm::InstrProfSectKind SK) {
1322 return llvm::getInstrProfSectionName(
1323 SK, CGM.getContext().getTargetInfo().getTriple().getObjectFormat());
1324}
1325
1326void CoverageMappingModuleGen::emitFunctionMappingRecord(
1327 const FunctionInfo &Info, uint64_t FilenamesRef) {
1328 llvm::LLVMContext &Ctx = CGM.getLLVMContext();
1329
1330 // Assign a name to the function record. This is used to merge duplicates.
1331 std::string FuncRecordName = "__covrec_" + llvm::utohexstr(Info.NameHash);
1332
1333 // A dummy description for a function included-but-not-used in a TU can be
1334 // replaced by full description provided by a different TU. The two kinds of
1335 // descriptions play distinct roles: therefore, assign them different names
1336 // to prevent `linkonce_odr` merging.
1337 if (Info.IsUsed)
1338 FuncRecordName += "u";
1339
1340 // Create the function record type.
1341 const uint64_t NameHash = Info.NameHash;
1342 const uint64_t FuncHash = Info.FuncHash;
1343 const std::string &CoverageMapping = Info.CoverageMapping;
1344#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) LLVMType,
1345 llvm::Type *FunctionRecordTypes[] = {
1346#include "llvm/ProfileData/InstrProfData.inc"
1347 };
1348 auto *FunctionRecordTy =
1349 llvm::StructType::get(Ctx, makeArrayRef(FunctionRecordTypes),
1350 /*isPacked=*/true);
1351
1352 // Create the function record constant.
1353#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Init,
1354 llvm::Constant *FunctionRecordVals[] = {
1355 #include "llvm/ProfileData/InstrProfData.inc"
1356 };
1357 auto *FuncRecordConstant = llvm::ConstantStruct::get(
1358 FunctionRecordTy, makeArrayRef(FunctionRecordVals));
1359
1360 // Create the function record global.
1361 auto *FuncRecord = new llvm::GlobalVariable(
1362 CGM.getModule(), FunctionRecordTy, /*isConstant=*/true,
1363 llvm::GlobalValue::LinkOnceODRLinkage, FuncRecordConstant,
1364 FuncRecordName);
1365 FuncRecord->setVisibility(llvm::GlobalValue::HiddenVisibility);
1366 FuncRecord->setSection(getInstrProfSection(CGM, llvm::IPSK_covfun));
1367 FuncRecord->setAlignment(llvm::Align(8));
1368 if (CGM.supportsCOMDAT())
1369 FuncRecord->setComdat(CGM.getModule().getOrInsertComdat(FuncRecordName));
1370
1371 // Make sure the data doesn't get deleted.
1372 CGM.addUsedGlobal(FuncRecord);
1373}
1374
1375void CoverageMappingModuleGen::addFunctionMappingRecord(
1376 llvm::GlobalVariable *NamePtr, StringRef NameValue, uint64_t FuncHash,
1377 const std::string &CoverageMapping, bool IsUsed) {
1378 llvm::LLVMContext &Ctx = CGM.getLLVMContext();
1379 const uint64_t NameHash = llvm::IndexedInstrProf::ComputeHash(NameValue);
1380 FunctionRecords.push_back({NameHash, FuncHash, CoverageMapping, IsUsed});
1381
1382 if (!IsUsed)
1383 FunctionNames.push_back(
1384 llvm::ConstantExpr::getBitCast(NamePtr, llvm::Type::getInt8PtrTy(Ctx)));
1385
1386 if (CGM.getCodeGenOpts().DumpCoverageMapping) {
1387 // Dump the coverage mapping data for this function by decoding the
1388 // encoded data. This allows us to dump the mapping regions which were
1389 // also processed by the CoverageMappingWriter which performs
1390 // additional minimization operations such as reducing the number of
1391 // expressions.
1392 std::vector<StringRef> Filenames;
1393 std::vector<CounterExpression> Expressions;
1394 std::vector<CounterMappingRegion> Regions;
1395 llvm::SmallVector<std::string, 16> FilenameStrs;
1396 llvm::SmallVector<StringRef, 16> FilenameRefs;
1397 FilenameStrs.resize(FileEntries.size());
1398 FilenameRefs.resize(FileEntries.size());
1399 for (const auto &Entry : FileEntries) {
1400 auto I = Entry.second;
1401 FilenameStrs[I] = normalizeFilename(Entry.first->getName());
1402 FilenameRefs[I] = FilenameStrs[I];
1403 }
1404 RawCoverageMappingReader Reader(CoverageMapping, FilenameRefs, Filenames,
1405 Expressions, Regions);
1406 if (Reader.read())
1407 return;
1408 dump(llvm::outs(), NameValue, Expressions, Regions);
1409 }
1410}
1411
1412void CoverageMappingModuleGen::emit() {
1413 if (FunctionRecords.empty())
1414 return;
1415 llvm::LLVMContext &Ctx = CGM.getLLVMContext();
1416 auto *Int32Ty = llvm::Type::getInt32Ty(Ctx);
1417
1418 // Create the filenames and merge them with coverage mappings
1419 llvm::SmallVector<std::string, 16> FilenameStrs;
1420 llvm::SmallVector<StringRef, 16> FilenameRefs;
1421 FilenameStrs.resize(FileEntries.size());
1422 FilenameRefs.resize(FileEntries.size());
1423 for (const auto &Entry : FileEntries) {
1424 auto I = Entry.second;
1425 FilenameStrs[I] = normalizeFilename(Entry.first->getName());
1426 FilenameRefs[I] = FilenameStrs[I];
1427 }
1428
1429 std::string Filenames;
1430 {
1431 llvm::raw_string_ostream OS(Filenames);
1432 CoverageFilenamesSectionWriter(FilenameRefs).write(OS);
1433 }
1434 auto *FilenamesVal =
1435 llvm::ConstantDataArray::getString(Ctx, Filenames, false);
1436 const int64_t FilenamesRef = llvm::IndexedInstrProf::ComputeHash(Filenames);
1437
1438 // Emit the function records.
1439 for (const FunctionInfo &Info : FunctionRecords)
1440 emitFunctionMappingRecord(Info, FilenamesRef);
1441
1442 const unsigned NRecords = 0;
1443 const size_t FilenamesSize = Filenames.size();
1444 const unsigned CoverageMappingSize = 0;
1445 llvm::Type *CovDataHeaderTypes[] = {
1446#define COVMAP_HEADER(Type, LLVMType, Name, Init) LLVMType,
1447#include "llvm/ProfileData/InstrProfData.inc"
1448 };
1449 auto CovDataHeaderTy =
1450 llvm::StructType::get(Ctx, makeArrayRef(CovDataHeaderTypes));
1451 llvm::Constant *CovDataHeaderVals[] = {
1452#define COVMAP_HEADER(Type, LLVMType, Name, Init) Init,
1453#include "llvm/ProfileData/InstrProfData.inc"
1454 };
1455 auto CovDataHeaderVal = llvm::ConstantStruct::get(
1456 CovDataHeaderTy, makeArrayRef(CovDataHeaderVals));
1457
1458 // Create the coverage data record
1459 llvm::Type *CovDataTypes[] = {CovDataHeaderTy, FilenamesVal->getType()};
1460 auto CovDataTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataTypes));
1461 llvm::Constant *TUDataVals[] = {CovDataHeaderVal, FilenamesVal};
1462 auto CovDataVal =
1463 llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals));
1464 auto CovData = new llvm::GlobalVariable(
1465 CGM.getModule(), CovDataTy, true, llvm::GlobalValue::PrivateLinkage,
1466 CovDataVal, llvm::getCoverageMappingVarName());
1467
1468 CovData->setSection(getInstrProfSection(CGM, llvm::IPSK_covmap));
1469 CovData->setAlignment(llvm::Align(8));
1470
1471 // Make sure the data doesn't get deleted.
1472 CGM.addUsedGlobal(CovData);
1473 // Create the deferred function records array
1474 if (!FunctionNames.empty()) {
1475 auto NamesArrTy = llvm::ArrayType::get(llvm::Type::getInt8PtrTy(Ctx),
1476 FunctionNames.size());
1477 auto NamesArrVal = llvm::ConstantArray::get(NamesArrTy, FunctionNames);
1478 // This variable will *NOT* be emitted to the object file. It is used
1479 // to pass the list of names referenced to codegen.
1480 new llvm::GlobalVariable(CGM.getModule(), NamesArrTy, true,
1481 llvm::GlobalValue::InternalLinkage, NamesArrVal,
1482 llvm::getCoverageUnusedNamesVarName());
1483 }
1484}
1485
1486unsigned CoverageMappingModuleGen::getFileID(const FileEntry *File) {
1487 auto It = FileEntries.find(File);
1488 if (It != FileEntries.end())
1489 return It->second;
1490 unsigned FileID = FileEntries.size();
1491 FileEntries.insert(std::make_pair(File, FileID));
1492 return FileID;
1493}
1494
1495void CoverageMappingGen::emitCounterMapping(const Decl *D,
1496 llvm::raw_ostream &OS) {
1497 assert(CounterMap)((CounterMap) ? static_cast<void> (0) : __assert_fail (
"CounterMap", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CoverageMappingGen.cpp"
, 1497, __PRETTY_FUNCTION__))
;
1
Assuming field 'CounterMap' is non-null
2
'?' condition is true
1498 CounterCoverageMappingBuilder Walker(CVM, *CounterMap, SM, LangOpts);
1499 Walker.VisitDecl(D);
3
Calling 'CounterCoverageMappingBuilder::VisitDecl'
1500 Walker.write(OS);
1501}
1502
1503void CoverageMappingGen::emitEmptyMapping(const Decl *D,
1504 llvm::raw_ostream &OS) {
1505 EmptyCoverageMappingBuilder Walker(CVM, SM, LangOpts);
1506 Walker.VisitDecl(D);
1507 Walker.write(OS);
1508}