Bug Summary

File:lib/ProfileData/Coverage/CoverageMappingReader.cpp
Warning:line 704, column 22
The left operand of '==' is a garbage value

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 CoverageMappingReader.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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/lib/ProfileData/Coverage -I /build/llvm-toolchain-snapshot-8~svn345461/lib/ProfileData/Coverage -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/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/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/lib/ProfileData/Coverage -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/lib/ProfileData/Coverage/CoverageMappingReader.cpp -faddrsig
1//===- CoverageMappingReader.cpp - Code coverage mapping reader -----------===//
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// This file contains support for reading coverage mapping data for
11// instrumentation based coverage.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/DenseMap.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/ADT/Triple.h"
22#include "llvm/Object/Binary.h"
23#include "llvm/Object/Error.h"
24#include "llvm/Object/MachOUniversal.h"
25#include "llvm/Object/ObjectFile.h"
26#include "llvm/ProfileData/InstrProf.h"
27#include "llvm/Support/Casting.h"
28#include "llvm/Support/Debug.h"
29#include "llvm/Support/Endian.h"
30#include "llvm/Support/Error.h"
31#include "llvm/Support/ErrorHandling.h"
32#include "llvm/Support/LEB128.h"
33#include "llvm/Support/MathExtras.h"
34#include "llvm/Support/raw_ostream.h"
35#include <vector>
36
37using namespace llvm;
38using namespace coverage;
39using namespace object;
40
41#define DEBUG_TYPE"coverage-mapping" "coverage-mapping"
42
43void CoverageMappingIterator::increment() {
44 if (ReadErr != coveragemap_error::success)
45 return;
46
47 // Check if all the records were read or if an error occurred while reading
48 // the next record.
49 if (auto E = Reader->readNextRecord(Record))
50 handleAllErrors(std::move(E), [&](const CoverageMapError &CME) {
51 if (CME.get() == coveragemap_error::eof)
52 *this = CoverageMappingIterator();
53 else
54 ReadErr = CME.get();
55 });
56}
57
58Error RawCoverageReader::readULEB128(uint64_t &Result) {
59 if (Data.empty())
60 return make_error<CoverageMapError>(coveragemap_error::truncated);
61 unsigned N = 0;
62 Result = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
63 if (N > Data.size())
64 return make_error<CoverageMapError>(coveragemap_error::malformed);
65 Data = Data.substr(N);
66 return Error::success();
67}
68
69Error RawCoverageReader::readIntMax(uint64_t &Result, uint64_t MaxPlus1) {
70 if (auto Err = readULEB128(Result))
71 return Err;
72 if (Result >= MaxPlus1)
73 return make_error<CoverageMapError>(coveragemap_error::malformed);
74 return Error::success();
75}
76
77Error RawCoverageReader::readSize(uint64_t &Result) {
78 if (auto Err = readULEB128(Result))
79 return Err;
80 // Sanity check the number.
81 if (Result > Data.size())
82 return make_error<CoverageMapError>(coveragemap_error::malformed);
83 return Error::success();
84}
85
86Error RawCoverageReader::readString(StringRef &Result) {
87 uint64_t Length;
88 if (auto Err = readSize(Length))
89 return Err;
90 Result = Data.substr(0, Length);
91 Data = Data.substr(Length);
92 return Error::success();
93}
94
95Error RawCoverageFilenamesReader::read() {
96 uint64_t NumFilenames;
97 if (auto Err = readSize(NumFilenames))
98 return Err;
99 for (size_t I = 0; I < NumFilenames; ++I) {
100 StringRef Filename;
101 if (auto Err = readString(Filename))
102 return Err;
103 Filenames.push_back(Filename);
104 }
105 return Error::success();
106}
107
108Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) {
109 auto Tag = Value & Counter::EncodingTagMask;
110 switch (Tag) {
111 case Counter::Zero:
112 C = Counter::getZero();
113 return Error::success();
114 case Counter::CounterValueReference:
115 C = Counter::getCounter(Value >> Counter::EncodingTagBits);
116 return Error::success();
117 default:
118 break;
119 }
120 Tag -= Counter::Expression;
121 switch (Tag) {
122 case CounterExpression::Subtract:
123 case CounterExpression::Add: {
124 auto ID = Value >> Counter::EncodingTagBits;
125 if (ID >= Expressions.size())
126 return make_error<CoverageMapError>(coveragemap_error::malformed);
127 Expressions[ID].Kind = CounterExpression::ExprKind(Tag);
128 C = Counter::getExpression(ID);
129 break;
130 }
131 default:
132 return make_error<CoverageMapError>(coveragemap_error::malformed);
133 }
134 return Error::success();
135}
136
137Error RawCoverageMappingReader::readCounter(Counter &C) {
138 uint64_t EncodedCounter;
139 if (auto Err =
140 readIntMax(EncodedCounter, std::numeric_limits<unsigned>::max()))
141 return Err;
142 if (auto Err = decodeCounter(EncodedCounter, C))
143 return Err;
144 return Error::success();
145}
146
147static const unsigned EncodingExpansionRegionBit = 1
148 << Counter::EncodingTagBits;
149
150/// Read the sub-array of regions for the given inferred file id.
151/// \param NumFileIDs the number of file ids that are defined for this
152/// function.
153Error RawCoverageMappingReader::readMappingRegionsSubArray(
154 std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID,
155 size_t NumFileIDs) {
156 uint64_t NumRegions;
157 if (auto Err = readSize(NumRegions))
158 return Err;
159 unsigned LineStart = 0;
160 for (size_t I = 0; I < NumRegions; ++I) {
161 Counter C;
162 CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion;
163
164 // Read the combined counter + region kind.
165 uint64_t EncodedCounterAndRegion;
166 if (auto Err = readIntMax(EncodedCounterAndRegion,
167 std::numeric_limits<unsigned>::max()))
168 return Err;
169 unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
170 uint64_t ExpandedFileID = 0;
171 if (Tag != Counter::Zero) {
172 if (auto Err = decodeCounter(EncodedCounterAndRegion, C))
173 return Err;
174 } else {
175 // Is it an expansion region?
176 if (EncodedCounterAndRegion & EncodingExpansionRegionBit) {
177 Kind = CounterMappingRegion::ExpansionRegion;
178 ExpandedFileID = EncodedCounterAndRegion >>
179 Counter::EncodingCounterTagAndExpansionRegionTagBits;
180 if (ExpandedFileID >= NumFileIDs)
181 return make_error<CoverageMapError>(coveragemap_error::malformed);
182 } else {
183 switch (EncodedCounterAndRegion >>
184 Counter::EncodingCounterTagAndExpansionRegionTagBits) {
185 case CounterMappingRegion::CodeRegion:
186 // Don't do anything when we have a code region with a zero counter.
187 break;
188 case CounterMappingRegion::SkippedRegion:
189 Kind = CounterMappingRegion::SkippedRegion;
190 break;
191 default:
192 return make_error<CoverageMapError>(coveragemap_error::malformed);
193 }
194 }
195 }
196
197 // Read the source range.
198 uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
199 if (auto Err =
200 readIntMax(LineStartDelta, std::numeric_limits<unsigned>::max()))
201 return Err;
202 if (auto Err = readULEB128(ColumnStart))
203 return Err;
204 if (ColumnStart > std::numeric_limits<unsigned>::max())
205 return make_error<CoverageMapError>(coveragemap_error::malformed);
206 if (auto Err = readIntMax(NumLines, std::numeric_limits<unsigned>::max()))
207 return Err;
208 if (auto Err = readIntMax(ColumnEnd, std::numeric_limits<unsigned>::max()))
209 return Err;
210 LineStart += LineStartDelta;
211
212 // If the high bit of ColumnEnd is set, this is a gap region.
213 if (ColumnEnd & (1U << 31)) {
214 Kind = CounterMappingRegion::GapRegion;
215 ColumnEnd &= ~(1U << 31);
216 }
217
218 // Adjust the column locations for the empty regions that are supposed to
219 // cover whole lines. Those regions should be encoded with the
220 // column range (1 -> std::numeric_limits<unsigned>::max()), but because
221 // the encoded std::numeric_limits<unsigned>::max() is several bytes long,
222 // we set the column range to (0 -> 0) to ensure that the column start and
223 // column end take up one byte each.
224 // The std::numeric_limits<unsigned>::max() is used to represent a column
225 // position at the end of the line without knowing the length of that line.
226 if (ColumnStart == 0 && ColumnEnd == 0) {
227 ColumnStart = 1;
228 ColumnEnd = std::numeric_limits<unsigned>::max();
229 }
230
231 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
232 dbgs() << "Counter in file " << InferredFileID << " " << LineStart << ":"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
233 << ColumnStart << " -> " << (LineStart + NumLines) << ":"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
234 << ColumnEnd << ", ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
235 if (Kind == CounterMappingRegion::ExpansionRegion)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
236 dbgs() << "Expands to file " << ExpandedFileID;do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
237 elsedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
238 CounterMappingContext(Expressions).dump(C, dbgs());do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
239 dbgs() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
240 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("coverage-mapping")) { { dbgs() << "Counter in file " <<
InferredFileID << " " << LineStart << ":" <<
ColumnStart << " -> " << (LineStart + NumLines
) << ":" << ColumnEnd << ", "; if (Kind == CounterMappingRegion
::ExpansionRegion) dbgs() << "Expands to file " <<
ExpandedFileID; else CounterMappingContext(Expressions).dump
(C, dbgs()); dbgs() << "\n"; }; } } while (false)
;
241
242 auto CMR = CounterMappingRegion(C, InferredFileID, ExpandedFileID,
243 LineStart, ColumnStart,
244 LineStart + NumLines, ColumnEnd, Kind);
245 if (CMR.startLoc() > CMR.endLoc())
246 return make_error<CoverageMapError>(coveragemap_error::malformed);
247 MappingRegions.push_back(CMR);
248 }
249 return Error::success();
250}
251
252Error RawCoverageMappingReader::read() {
253 // Read the virtual file mapping.
254 SmallVector<unsigned, 8> VirtualFileMapping;
255 uint64_t NumFileMappings;
256 if (auto Err = readSize(NumFileMappings))
257 return Err;
258 for (size_t I = 0; I < NumFileMappings; ++I) {
259 uint64_t FilenameIndex;
260 if (auto Err = readIntMax(FilenameIndex, TranslationUnitFilenames.size()))
261 return Err;
262 VirtualFileMapping.push_back(FilenameIndex);
263 }
264
265 // Construct the files using unique filenames and virtual file mapping.
266 for (auto I : VirtualFileMapping) {
267 Filenames.push_back(TranslationUnitFilenames[I]);
268 }
269
270 // Read the expressions.
271 uint64_t NumExpressions;
272 if (auto Err = readSize(NumExpressions))
273 return Err;
274 // Create an array of dummy expressions that get the proper counters
275 // when the expressions are read, and the proper kinds when the counters
276 // are decoded.
277 Expressions.resize(
278 NumExpressions,
279 CounterExpression(CounterExpression::Subtract, Counter(), Counter()));
280 for (size_t I = 0; I < NumExpressions; ++I) {
281 if (auto Err = readCounter(Expressions[I].LHS))
282 return Err;
283 if (auto Err = readCounter(Expressions[I].RHS))
284 return Err;
285 }
286
287 // Read the mapping regions sub-arrays.
288 for (unsigned InferredFileID = 0, S = VirtualFileMapping.size();
289 InferredFileID < S; ++InferredFileID) {
290 if (auto Err = readMappingRegionsSubArray(MappingRegions, InferredFileID,
291 VirtualFileMapping.size()))
292 return Err;
293 }
294
295 // Set the counters for the expansion regions.
296 // i.e. Counter of expansion region = counter of the first region
297 // from the expanded file.
298 // Perform multiple passes to correctly propagate the counters through
299 // all the nested expansion regions.
300 SmallVector<CounterMappingRegion *, 8> FileIDExpansionRegionMapping;
301 FileIDExpansionRegionMapping.resize(VirtualFileMapping.size(), nullptr);
302 for (unsigned Pass = 1, S = VirtualFileMapping.size(); Pass < S; ++Pass) {
303 for (auto &R : MappingRegions) {
304 if (R.Kind != CounterMappingRegion::ExpansionRegion)
305 continue;
306 assert(!FileIDExpansionRegionMapping[R.ExpandedFileID])((!FileIDExpansionRegionMapping[R.ExpandedFileID]) ? static_cast
<void> (0) : __assert_fail ("!FileIDExpansionRegionMapping[R.ExpandedFileID]"
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/ProfileData/Coverage/CoverageMappingReader.cpp"
, 306, __PRETTY_FUNCTION__))
;
307 FileIDExpansionRegionMapping[R.ExpandedFileID] = &R;
308 }
309 for (auto &R : MappingRegions) {
310 if (FileIDExpansionRegionMapping[R.FileID]) {
311 FileIDExpansionRegionMapping[R.FileID]->Count = R.Count;
312 FileIDExpansionRegionMapping[R.FileID] = nullptr;
313 }
314 }
315 }
316
317 return Error::success();
318}
319
320Expected<bool> RawCoverageMappingDummyChecker::isDummy() {
321 // A dummy coverage mapping data consists of just one region with zero count.
322 uint64_t NumFileMappings;
323 if (Error Err = readSize(NumFileMappings))
324 return std::move(Err);
325 if (NumFileMappings != 1)
326 return false;
327 // We don't expect any specific value for the filename index, just skip it.
328 uint64_t FilenameIndex;
329 if (Error Err =
330 readIntMax(FilenameIndex, std::numeric_limits<unsigned>::max()))
331 return std::move(Err);
332 uint64_t NumExpressions;
333 if (Error Err = readSize(NumExpressions))
334 return std::move(Err);
335 if (NumExpressions != 0)
336 return false;
337 uint64_t NumRegions;
338 if (Error Err = readSize(NumRegions))
339 return std::move(Err);
340 if (NumRegions != 1)
341 return false;
342 uint64_t EncodedCounterAndRegion;
343 if (Error Err = readIntMax(EncodedCounterAndRegion,
344 std::numeric_limits<unsigned>::max()))
345 return std::move(Err);
346 unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
347 return Tag == Counter::Zero;
348}
349
350Error InstrProfSymtab::create(SectionRef &Section) {
351 if (auto EC = Section.getContents(Data))
352 return errorCodeToError(EC);
353 Address = Section.getAddress();
354 return Error::success();
355}
356
357StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) {
358 if (Pointer < Address)
359 return StringRef();
360 auto Offset = Pointer - Address;
361 if (Offset + Size > Data.size())
362 return StringRef();
363 return Data.substr(Pointer - Address, Size);
364}
365
366// Check if the mapping data is a dummy, i.e. is emitted for an unused function.
367static Expected<bool> isCoverageMappingDummy(uint64_t Hash, StringRef Mapping) {
368 // The hash value of dummy mapping records is always zero.
369 if (Hash)
370 return false;
371 return RawCoverageMappingDummyChecker(Mapping).isDummy();
372}
373
374namespace {
375
376struct CovMapFuncRecordReader {
377 virtual ~CovMapFuncRecordReader() = default;
378
379 // The interface to read coverage mapping function records for a module.
380 //
381 // \p Buf points to the buffer containing the \c CovHeader of the coverage
382 // mapping data associated with the module.
383 //
384 // Returns a pointer to the next \c CovHeader if it exists, or a pointer
385 // greater than \p End if not.
386 virtual Expected<const char *> readFunctionRecords(const char *Buf,
387 const char *End) = 0;
388
389 template <class IntPtrT, support::endianness Endian>
390 static Expected<std::unique_ptr<CovMapFuncRecordReader>>
391 get(CovMapVersion Version, InstrProfSymtab &P,
392 std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
393 std::vector<StringRef> &F);
394};
395
396// A class for reading coverage mapping function records for a module.
397template <CovMapVersion Version, class IntPtrT, support::endianness Endian>
398class VersionedCovMapFuncRecordReader : public CovMapFuncRecordReader {
399 using FuncRecordType =
400 typename CovMapTraits<Version, IntPtrT>::CovMapFuncRecordType;
401 using NameRefType = typename CovMapTraits<Version, IntPtrT>::NameRefType;
402
403 // Maps function's name references to the indexes of their records
404 // in \c Records.
405 DenseMap<NameRefType, size_t> FunctionRecords;
406 InstrProfSymtab &ProfileNames;
407 std::vector<StringRef> &Filenames;
408 std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records;
409
410 // Add the record to the collection if we don't already have a record that
411 // points to the same function name. This is useful to ignore the redundant
412 // records for the functions with ODR linkage.
413 // In addition, prefer records with real coverage mapping data to dummy
414 // records, which were emitted for inline functions which were seen but
415 // not used in the corresponding translation unit.
416 Error insertFunctionRecordIfNeeded(const FuncRecordType *CFR,
417 StringRef Mapping, size_t FilenamesBegin) {
418 uint64_t FuncHash = CFR->template getFuncHash<Endian>();
419 NameRefType NameRef = CFR->template getFuncNameRef<Endian>();
420 auto InsertResult =
421 FunctionRecords.insert(std::make_pair(NameRef, Records.size()));
422 if (InsertResult.second) {
423 StringRef FuncName;
424 if (Error Err = CFR->template getFuncName<Endian>(ProfileNames, FuncName))
425 return Err;
426 if (FuncName.empty())
427 return make_error<InstrProfError>(instrprof_error::malformed);
428 Records.emplace_back(Version, FuncName, FuncHash, Mapping, FilenamesBegin,
429 Filenames.size() - FilenamesBegin);
430 return Error::success();
431 }
432 // Update the existing record if it's a dummy and the new record is real.
433 size_t OldRecordIndex = InsertResult.first->second;
434 BinaryCoverageReader::ProfileMappingRecord &OldRecord =
435 Records[OldRecordIndex];
436 Expected<bool> OldIsDummyExpected = isCoverageMappingDummy(
437 OldRecord.FunctionHash, OldRecord.CoverageMapping);
438 if (Error Err = OldIsDummyExpected.takeError())
439 return Err;
440 if (!*OldIsDummyExpected)
441 return Error::success();
442 Expected<bool> NewIsDummyExpected =
443 isCoverageMappingDummy(FuncHash, Mapping);
444 if (Error Err = NewIsDummyExpected.takeError())
445 return Err;
446 if (*NewIsDummyExpected)
447 return Error::success();
448 OldRecord.FunctionHash = FuncHash;
449 OldRecord.CoverageMapping = Mapping;
450 OldRecord.FilenamesBegin = FilenamesBegin;
451 OldRecord.FilenamesSize = Filenames.size() - FilenamesBegin;
452 return Error::success();
453 }
454
455public:
456 VersionedCovMapFuncRecordReader(
457 InstrProfSymtab &P,
458 std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
459 std::vector<StringRef> &F)
460 : ProfileNames(P), Filenames(F), Records(R) {}
461
462 ~VersionedCovMapFuncRecordReader() override = default;
463
464 Expected<const char *> readFunctionRecords(const char *Buf,
465 const char *End) override {
466 using namespace support;
467
468 if (Buf + sizeof(CovMapHeader) > End)
469 return make_error<CoverageMapError>(coveragemap_error::malformed);
470 auto CovHeader = reinterpret_cast<const CovMapHeader *>(Buf);
471 uint32_t NRecords = CovHeader->getNRecords<Endian>();
472 uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>();
473 uint32_t CoverageSize = CovHeader->getCoverageSize<Endian>();
474 assert((CovMapVersion)CovHeader->getVersion<Endian>() == Version)(((CovMapVersion)CovHeader->getVersion<Endian>() == Version
) ? static_cast<void> (0) : __assert_fail ("(CovMapVersion)CovHeader->getVersion<Endian>() == Version"
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/ProfileData/Coverage/CoverageMappingReader.cpp"
, 474, __PRETTY_FUNCTION__))
;
475 Buf = reinterpret_cast<const char *>(CovHeader + 1);
476
477 // Skip past the function records, saving the start and end for later.
478 const char *FunBuf = Buf;
479 Buf += NRecords * sizeof(FuncRecordType);
480 const char *FunEnd = Buf;
481
482 // Get the filenames.
483 if (Buf + FilenamesSize > End)
484 return make_error<CoverageMapError>(coveragemap_error::malformed);
485 size_t FilenamesBegin = Filenames.size();
486 RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames);
487 if (auto Err = Reader.read())
488 return std::move(Err);
489 Buf += FilenamesSize;
490
491 // We'll read the coverage mapping records in the loop below.
492 const char *CovBuf = Buf;
493 Buf += CoverageSize;
494 const char *CovEnd = Buf;
495
496 if (Buf > End)
497 return make_error<CoverageMapError>(coveragemap_error::malformed);
498 // Each coverage map has an alignment of 8, so we need to adjust alignment
499 // before reading the next map.
500 Buf += alignmentAdjustment(Buf, 8);
501
502 auto CFR = reinterpret_cast<const FuncRecordType *>(FunBuf);
503 while ((const char *)CFR < FunEnd) {
504 // Read the function information
505 uint32_t DataSize = CFR->template getDataSize<Endian>();
506
507 // Now use that to read the coverage data.
508 if (CovBuf + DataSize > CovEnd)
509 return make_error<CoverageMapError>(coveragemap_error::malformed);
510 auto Mapping = StringRef(CovBuf, DataSize);
511 CovBuf += DataSize;
512
513 if (Error Err =
514 insertFunctionRecordIfNeeded(CFR, Mapping, FilenamesBegin))
515 return std::move(Err);
516 CFR++;
517 }
518 return Buf;
519 }
520};
521
522} // end anonymous namespace
523
524template <class IntPtrT, support::endianness Endian>
525Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
526 CovMapVersion Version, InstrProfSymtab &P,
527 std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
528 std::vector<StringRef> &F) {
529 using namespace coverage;
530
531 switch (Version) {
532 case CovMapVersion::Version1:
533 return llvm::make_unique<VersionedCovMapFuncRecordReader<
534 CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F);
535 case CovMapVersion::Version2:
536 case CovMapVersion::Version3:
537 // Decompress the name data.
538 if (Error E = P.create(P.getNameData()))
539 return std::move(E);
540 if (Version == CovMapVersion::Version2)
541 return llvm::make_unique<VersionedCovMapFuncRecordReader<
542 CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F);
543 else
544 return llvm::make_unique<VersionedCovMapFuncRecordReader<
545 CovMapVersion::Version3, IntPtrT, Endian>>(P, R, F);
546 }
547 llvm_unreachable("Unsupported version")::llvm::llvm_unreachable_internal("Unsupported version", "/build/llvm-toolchain-snapshot-8~svn345461/lib/ProfileData/Coverage/CoverageMappingReader.cpp"
, 547)
;
548}
549
550template <typename T, support::endianness Endian>
551static Error readCoverageMappingData(
552 InstrProfSymtab &ProfileNames, StringRef Data,
553 std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
554 std::vector<StringRef> &Filenames) {
555 using namespace coverage;
556
557 // Read the records in the coverage data section.
558 auto CovHeader =
559 reinterpret_cast<const CovMapHeader *>(Data.data());
560 CovMapVersion Version = (CovMapVersion)CovHeader->getVersion<Endian>();
561 if (Version > CovMapVersion::CurrentVersion)
562 return make_error<CoverageMapError>(coveragemap_error::unsupported_version);
563 Expected<std::unique_ptr<CovMapFuncRecordReader>> ReaderExpected =
564 CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames, Records,
565 Filenames);
566 if (Error E = ReaderExpected.takeError())
567 return E;
568 auto Reader = std::move(ReaderExpected.get());
569 for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) {
570 auto NextHeaderOrErr = Reader->readFunctionRecords(Buf, End);
571 if (auto E = NextHeaderOrErr.takeError())
572 return E;
573 Buf = NextHeaderOrErr.get();
574 }
575 return Error::success();
576}
577
578static const char *TestingFormatMagic = "llvmcovmtestdata";
579
580static Error loadTestingFormat(StringRef Data, InstrProfSymtab &ProfileNames,
581 StringRef &CoverageMapping,
582 uint8_t &BytesInAddress,
583 support::endianness &Endian) {
584 BytesInAddress = 8;
585 Endian = support::endianness::little;
586
587 Data = Data.substr(StringRef(TestingFormatMagic).size());
588 if (Data.empty())
589 return make_error<CoverageMapError>(coveragemap_error::truncated);
590 unsigned N = 0;
591 auto ProfileNamesSize =
592 decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
593 if (N > Data.size())
594 return make_error<CoverageMapError>(coveragemap_error::malformed);
595 Data = Data.substr(N);
596 if (Data.empty())
597 return make_error<CoverageMapError>(coveragemap_error::truncated);
598 N = 0;
599 uint64_t Address =
600 decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
601 if (N > Data.size())
602 return make_error<CoverageMapError>(coveragemap_error::malformed);
603 Data = Data.substr(N);
604 if (Data.size() < ProfileNamesSize)
605 return make_error<CoverageMapError>(coveragemap_error::malformed);
606 if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
607 return E;
608 CoverageMapping = Data.substr(ProfileNamesSize);
609 // Skip the padding bytes because coverage map data has an alignment of 8.
610 if (CoverageMapping.empty())
611 return make_error<CoverageMapError>(coveragemap_error::truncated);
612 size_t Pad = alignmentAdjustment(CoverageMapping.data(), 8);
613 if (CoverageMapping.size() < Pad)
614 return make_error<CoverageMapError>(coveragemap_error::malformed);
615 CoverageMapping = CoverageMapping.substr(Pad);
616 return Error::success();
617}
618
619static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
620 StringRef FoundName;
621 for (const auto &Section : OF.sections()) {
622 if (auto EC = Section.getName(FoundName))
623 return errorCodeToError(EC);
624 if (FoundName == Name)
625 return Section;
626 }
627 return make_error<CoverageMapError>(coveragemap_error::no_data_found);
628}
629
630static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer,
631 InstrProfSymtab &ProfileNames,
632 StringRef &CoverageMapping,
633 uint8_t &BytesInAddress,
634 support::endianness &Endian, StringRef Arch) {
635 auto BinOrErr = createBinary(ObjectBuffer);
636 if (!BinOrErr)
5
Taking true branch
637 return BinOrErr.takeError();
6
Returning without writing to 'BytesInAddress'
638 auto Bin = std::move(BinOrErr.get());
639 std::unique_ptr<ObjectFile> OF;
640 if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
641 // If we have a universal binary, try to look up the object for the
642 // appropriate architecture.
643 auto ObjectFileOrErr = Universal->getObjectForArch(Arch);
644 if (!ObjectFileOrErr)
645 return ObjectFileOrErr.takeError();
646 OF = std::move(ObjectFileOrErr.get());
647 } else if (isa<ObjectFile>(Bin.get())) {
648 // For any other object file, upcast and take ownership.
649 OF.reset(cast<ObjectFile>(Bin.release()));
650 // If we've asked for a particular arch, make sure they match.
651 if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch())
652 return errorCodeToError(object_error::arch_not_found);
653 } else
654 // We can only handle object files.
655 return make_error<CoverageMapError>(coveragemap_error::malformed);
656
657 // The coverage uses native pointer sizes for the object it's written in.
658 BytesInAddress = OF->getBytesInAddress();
659 Endian = OF->isLittleEndian() ? support::endianness::little
660 : support::endianness::big;
661
662 // Look for the sections that we are interested in.
663 auto ObjFormat = OF->getTripleObjectFormat();
664 auto NamesSection =
665 lookupSection(*OF, getInstrProfSectionName(IPSK_name, ObjFormat,
666 /*AddSegmentInfo=*/false));
667 if (auto E = NamesSection.takeError())
668 return E;
669 auto CoverageSection =
670 lookupSection(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat,
671 /*AddSegmentInfo=*/false));
672 if (auto E = CoverageSection.takeError())
673 return E;
674
675 // Get the contents of the given sections.
676 if (auto EC = CoverageSection->getContents(CoverageMapping))
677 return errorCodeToError(EC);
678 if (Error E = ProfileNames.create(*NamesSection))
679 return E;
680
681 return Error::success();
682}
683
684Expected<std::unique_ptr<BinaryCoverageReader>>
685BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
686 StringRef Arch) {
687 std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader());
688
689 StringRef Coverage;
690 uint8_t BytesInAddress;
1
'BytesInAddress' declared without an initial value
691 support::endianness Endian;
692 Error E = Error::success();
693 consumeError(std::move(E));
694 if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
2
Assuming the condition is false
3
Taking false branch
695 // This is a special format used for testing.
696 E = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames,
697 Coverage, BytesInAddress, Endian);
698 else
699 E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames,
4
Calling 'loadBinaryFormat'
7
Returning from 'loadBinaryFormat'
700 Coverage, BytesInAddress, Endian, Arch);
701 if (E)
8
Taking false branch
702 return std::move(E);
703
704 if (BytesInAddress == 4 && Endian == support::endianness::little)
9
The left operand of '==' is a garbage value
705 E = readCoverageMappingData<uint32_t, support::endianness::little>(
706 Reader->ProfileNames, Coverage, Reader->MappingRecords,
707 Reader->Filenames);
708 else if (BytesInAddress == 4 && Endian == support::endianness::big)
709 E = readCoverageMappingData<uint32_t, support::endianness::big>(
710 Reader->ProfileNames, Coverage, Reader->MappingRecords,
711 Reader->Filenames);
712 else if (BytesInAddress == 8 && Endian == support::endianness::little)
713 E = readCoverageMappingData<uint64_t, support::endianness::little>(
714 Reader->ProfileNames, Coverage, Reader->MappingRecords,
715 Reader->Filenames);
716 else if (BytesInAddress == 8 && Endian == support::endianness::big)
717 E = readCoverageMappingData<uint64_t, support::endianness::big>(
718 Reader->ProfileNames, Coverage, Reader->MappingRecords,
719 Reader->Filenames);
720 else
721 return make_error<CoverageMapError>(coveragemap_error::malformed);
722 if (E)
723 return std::move(E);
724 return std::move(Reader);
725}
726
727Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
728 if (CurrentRecord >= MappingRecords.size())
729 return make_error<CoverageMapError>(coveragemap_error::eof);
730
731 FunctionsFilenames.clear();
732 Expressions.clear();
733 MappingRegions.clear();
734 auto &R = MappingRecords[CurrentRecord];
735 RawCoverageMappingReader Reader(
736 R.CoverageMapping,
737 makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize),
738 FunctionsFilenames, Expressions, MappingRegions);
739 if (auto Err = Reader.read())
740 return Err;
741
742 Record.FunctionName = R.FunctionName;
743 Record.FunctionHash = R.FunctionHash;
744 Record.Filenames = FunctionsFilenames;
745 Record.Expressions = Expressions;
746 Record.MappingRegions = MappingRegions;
747
748 ++CurrentRecord;
749 return Error::success();
750}