1 //===- InstrProfReader.cpp - Instrumented profiling reader ----------------===//
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 // This file contains support for reading profiling data for clang's
10 // instrumentation based PGO and coverage.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/ProfileData/InstrProfReader.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/IR/ProfileSummary.h"
21 #include "llvm/ProfileData/InstrProf.h"
22 #include "llvm/ProfileData/ProfileCommon.h"
23 #include "llvm/Support/Endian.h"
24 #include "llvm/Support/Error.h"
25 #include "llvm/Support/ErrorOr.h"
26 #include "llvm/Support/MemoryBuffer.h"
27 #include "llvm/Support/SwapByteOrder.h"
28 #include "llvm/Support/SymbolRemappingReader.h"
29 #include <algorithm>
30 #include <cctype>
31 #include <cstddef>
32 #include <cstdint>
33 #include <limits>
34 #include <memory>
35 #include <system_error>
36 #include <utility>
37 #include <vector>
38
39 using namespace llvm;
40
41 static Expected<std::unique_ptr<MemoryBuffer>>
setupMemoryBuffer(const Twine & Path)42 setupMemoryBuffer(const Twine &Path) {
43 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
44 MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/true);
45 if (std::error_code EC = BufferOrErr.getError())
46 return errorCodeToError(EC);
47 return std::move(BufferOrErr.get());
48 }
49
initializeReader(InstrProfReader & Reader)50 static Error initializeReader(InstrProfReader &Reader) {
51 return Reader.readHeader();
52 }
53
54 Expected<std::unique_ptr<InstrProfReader>>
create(const Twine & Path)55 InstrProfReader::create(const Twine &Path) {
56 // Set up the buffer to read.
57 auto BufferOrError = setupMemoryBuffer(Path);
58 if (Error E = BufferOrError.takeError())
59 return std::move(E);
60 return InstrProfReader::create(std::move(BufferOrError.get()));
61 }
62
63 Expected<std::unique_ptr<InstrProfReader>>
create(std::unique_ptr<MemoryBuffer> Buffer)64 InstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
65 // Sanity check the buffer.
66 if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint64_t>::max())
67 return make_error<InstrProfError>(instrprof_error::too_large);
68
69 if (Buffer->getBufferSize() == 0)
70 return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
71
72 std::unique_ptr<InstrProfReader> Result;
73 // Create the reader.
74 if (IndexedInstrProfReader::hasFormat(*Buffer))
75 Result.reset(new IndexedInstrProfReader(std::move(Buffer)));
76 else if (RawInstrProfReader64::hasFormat(*Buffer))
77 Result.reset(new RawInstrProfReader64(std::move(Buffer)));
78 else if (RawInstrProfReader32::hasFormat(*Buffer))
79 Result.reset(new RawInstrProfReader32(std::move(Buffer)));
80 else if (TextInstrProfReader::hasFormat(*Buffer))
81 Result.reset(new TextInstrProfReader(std::move(Buffer)));
82 else
83 return make_error<InstrProfError>(instrprof_error::unrecognized_format);
84
85 // Initialize the reader and return the result.
86 if (Error E = initializeReader(*Result))
87 return std::move(E);
88
89 return std::move(Result);
90 }
91
92 Expected<std::unique_ptr<IndexedInstrProfReader>>
create(const Twine & Path,const Twine & RemappingPath)93 IndexedInstrProfReader::create(const Twine &Path, const Twine &RemappingPath) {
94 // Set up the buffer to read.
95 auto BufferOrError = setupMemoryBuffer(Path);
96 if (Error E = BufferOrError.takeError())
97 return std::move(E);
98
99 // Set up the remapping buffer if requested.
100 std::unique_ptr<MemoryBuffer> RemappingBuffer;
101 std::string RemappingPathStr = RemappingPath.str();
102 if (!RemappingPathStr.empty()) {
103 auto RemappingBufferOrError = setupMemoryBuffer(RemappingPathStr);
104 if (Error E = RemappingBufferOrError.takeError())
105 return std::move(E);
106 RemappingBuffer = std::move(RemappingBufferOrError.get());
107 }
108
109 return IndexedInstrProfReader::create(std::move(BufferOrError.get()),
110 std::move(RemappingBuffer));
111 }
112
113 Expected<std::unique_ptr<IndexedInstrProfReader>>
create(std::unique_ptr<MemoryBuffer> Buffer,std::unique_ptr<MemoryBuffer> RemappingBuffer)114 IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer,
115 std::unique_ptr<MemoryBuffer> RemappingBuffer) {
116 // Sanity check the buffer.
117 if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint64_t>::max())
118 return make_error<InstrProfError>(instrprof_error::too_large);
119
120 // Create the reader.
121 if (!IndexedInstrProfReader::hasFormat(*Buffer))
122 return make_error<InstrProfError>(instrprof_error::bad_magic);
123 auto Result = std::make_unique<IndexedInstrProfReader>(
124 std::move(Buffer), std::move(RemappingBuffer));
125
126 // Initialize the reader and return the result.
127 if (Error E = initializeReader(*Result))
128 return std::move(E);
129
130 return std::move(Result);
131 }
132
Increment()133 void InstrProfIterator::Increment() {
134 if (auto E = Reader->readNextRecord(Record)) {
135 // Handle errors in the reader.
136 InstrProfError::take(std::move(E));
137 *this = InstrProfIterator();
138 }
139 }
140
hasFormat(const MemoryBuffer & Buffer)141 bool TextInstrProfReader::hasFormat(const MemoryBuffer &Buffer) {
142 // Verify that this really looks like plain ASCII text by checking a
143 // 'reasonable' number of characters (up to profile magic size).
144 size_t count = std::min(Buffer.getBufferSize(), sizeof(uint64_t));
145 StringRef buffer = Buffer.getBufferStart();
146 return count == 0 ||
147 std::all_of(buffer.begin(), buffer.begin() + count,
148 [](char c) { return isPrint(c) || isSpace(c); });
149 }
150
151 // Read the profile variant flag from the header: ":FE" means this is a FE
152 // generated profile. ":IR" means this is an IR level profile. Other strings
153 // with a leading ':' will be reported an error format.
readHeader()154 Error TextInstrProfReader::readHeader() {
155 Symtab.reset(new InstrProfSymtab());
156 bool IsIRInstr = false;
157 bool IsEntryFirst = false;
158 bool IsCS = false;
159
160 while (Line->startswith(":")) {
161 StringRef Str = Line->substr(1);
162 if (Str.equals_insensitive("ir"))
163 IsIRInstr = true;
164 else if (Str.equals_insensitive("fe"))
165 IsIRInstr = false;
166 else if (Str.equals_insensitive("csir")) {
167 IsIRInstr = true;
168 IsCS = true;
169 } else if (Str.equals_insensitive("entry_first"))
170 IsEntryFirst = true;
171 else if (Str.equals_insensitive("not_entry_first"))
172 IsEntryFirst = false;
173 else
174 return error(instrprof_error::bad_header);
175 ++Line;
176 }
177 IsIRLevelProfile = IsIRInstr;
178 InstrEntryBBEnabled = IsEntryFirst;
179 HasCSIRLevelProfile = IsCS;
180 return success();
181 }
182
183 Error
readValueProfileData(InstrProfRecord & Record)184 TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
185
186 #define CHECK_LINE_END(Line) \
187 if (Line.is_at_end()) \
188 return error(instrprof_error::truncated);
189 #define READ_NUM(Str, Dst) \
190 if ((Str).getAsInteger(10, (Dst))) \
191 return error(instrprof_error::malformed);
192 #define VP_READ_ADVANCE(Val) \
193 CHECK_LINE_END(Line); \
194 uint32_t Val; \
195 READ_NUM((*Line), (Val)); \
196 Line++;
197
198 if (Line.is_at_end())
199 return success();
200
201 uint32_t NumValueKinds;
202 if (Line->getAsInteger(10, NumValueKinds)) {
203 // No value profile data
204 return success();
205 }
206 if (NumValueKinds == 0 || NumValueKinds > IPVK_Last + 1)
207 return error(instrprof_error::malformed);
208 Line++;
209
210 for (uint32_t VK = 0; VK < NumValueKinds; VK++) {
211 VP_READ_ADVANCE(ValueKind);
212 if (ValueKind > IPVK_Last)
213 return error(instrprof_error::malformed);
214 VP_READ_ADVANCE(NumValueSites);
215 if (!NumValueSites)
216 continue;
217
218 Record.reserveSites(VK, NumValueSites);
219 for (uint32_t S = 0; S < NumValueSites; S++) {
220 VP_READ_ADVANCE(NumValueData);
221
222 std::vector<InstrProfValueData> CurrentValues;
223 for (uint32_t V = 0; V < NumValueData; V++) {
224 CHECK_LINE_END(Line);
225 std::pair<StringRef, StringRef> VD = Line->rsplit(':');
226 uint64_t TakenCount, Value;
227 if (ValueKind == IPVK_IndirectCallTarget) {
228 if (InstrProfSymtab::isExternalSymbol(VD.first)) {
229 Value = 0;
230 } else {
231 if (Error E = Symtab->addFuncName(VD.first))
232 return E;
233 Value = IndexedInstrProf::ComputeHash(VD.first);
234 }
235 } else {
236 READ_NUM(VD.first, Value);
237 }
238 READ_NUM(VD.second, TakenCount);
239 CurrentValues.push_back({Value, TakenCount});
240 Line++;
241 }
242 Record.addValueData(ValueKind, S, CurrentValues.data(), NumValueData,
243 nullptr);
244 }
245 }
246 return success();
247
248 #undef CHECK_LINE_END
249 #undef READ_NUM
250 #undef VP_READ_ADVANCE
251 }
252
readNextRecord(NamedInstrProfRecord & Record)253 Error TextInstrProfReader::readNextRecord(NamedInstrProfRecord &Record) {
254 // Skip empty lines and comments.
255 while (!Line.is_at_end() && (Line->empty() || Line->startswith("#")))
256 ++Line;
257 // If we hit EOF while looking for a name, we're done.
258 if (Line.is_at_end()) {
259 return error(instrprof_error::eof);
260 }
261
262 // Read the function name.
263 Record.Name = *Line++;
264 if (Error E = Symtab->addFuncName(Record.Name))
265 return error(std::move(E));
266
267 // Read the function hash.
268 if (Line.is_at_end())
269 return error(instrprof_error::truncated);
270 if ((Line++)->getAsInteger(0, Record.Hash))
271 return error(instrprof_error::malformed);
272
273 // Read the number of counters.
274 uint64_t NumCounters;
275 if (Line.is_at_end())
276 return error(instrprof_error::truncated);
277 if ((Line++)->getAsInteger(10, NumCounters))
278 return error(instrprof_error::malformed);
279 if (NumCounters == 0)
280 return error(instrprof_error::malformed);
281
282 // Read each counter and fill our internal storage with the values.
283 Record.Clear();
284 Record.Counts.reserve(NumCounters);
285 for (uint64_t I = 0; I < NumCounters; ++I) {
286 if (Line.is_at_end())
287 return error(instrprof_error::truncated);
288 uint64_t Count;
289 if ((Line++)->getAsInteger(10, Count))
290 return error(instrprof_error::malformed);
291 Record.Counts.push_back(Count);
292 }
293
294 // Check if value profile data exists and read it if so.
295 if (Error E = readValueProfileData(Record))
296 return error(std::move(E));
297
298 return success();
299 }
300
301 template <class IntPtrT>
hasFormat(const MemoryBuffer & DataBuffer)302 bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
303 if (DataBuffer.getBufferSize() < sizeof(uint64_t))
304 return false;
305 uint64_t Magic =
306 *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
307 return RawInstrProf::getMagic<IntPtrT>() == Magic ||
308 sys::getSwappedBytes(RawInstrProf::getMagic<IntPtrT>()) == Magic;
309 }
310
311 template <class IntPtrT>
readHeader()312 Error RawInstrProfReader<IntPtrT>::readHeader() {
313 if (!hasFormat(*DataBuffer))
314 return error(instrprof_error::bad_magic);
315 if (DataBuffer->getBufferSize() < sizeof(RawInstrProf::Header))
316 return error(instrprof_error::bad_header);
317 auto *Header = reinterpret_cast<const RawInstrProf::Header *>(
318 DataBuffer->getBufferStart());
319 ShouldSwapBytes = Header->Magic != RawInstrProf::getMagic<IntPtrT>();
320 return readHeader(*Header);
321 }
322
323 template <class IntPtrT>
readNextHeader(const char * CurrentPos)324 Error RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
325 const char *End = DataBuffer->getBufferEnd();
326 // Skip zero padding between profiles.
327 while (CurrentPos != End && *CurrentPos == 0)
328 ++CurrentPos;
329 // If there's nothing left, we're done.
330 if (CurrentPos == End)
331 return make_error<InstrProfError>(instrprof_error::eof);
332 // If there isn't enough space for another header, this is probably just
333 // garbage at the end of the file.
334 if (CurrentPos + sizeof(RawInstrProf::Header) > End)
335 return make_error<InstrProfError>(instrprof_error::malformed);
336 // The writer ensures each profile is padded to start at an aligned address.
337 if (reinterpret_cast<size_t>(CurrentPos) % alignof(uint64_t))
338 return make_error<InstrProfError>(instrprof_error::malformed);
339 // The magic should have the same byte order as in the previous header.
340 uint64_t Magic = *reinterpret_cast<const uint64_t *>(CurrentPos);
341 if (Magic != swap(RawInstrProf::getMagic<IntPtrT>()))
342 return make_error<InstrProfError>(instrprof_error::bad_magic);
343
344 // There's another profile to read, so we need to process the header.
345 auto *Header = reinterpret_cast<const RawInstrProf::Header *>(CurrentPos);
346 return readHeader(*Header);
347 }
348
349 template <class IntPtrT>
createSymtab(InstrProfSymtab & Symtab)350 Error RawInstrProfReader<IntPtrT>::createSymtab(InstrProfSymtab &Symtab) {
351 if (Error E = Symtab.create(StringRef(NamesStart, NamesSize)))
352 return error(std::move(E));
353 for (const RawInstrProf::ProfileData<IntPtrT> *I = Data; I != DataEnd; ++I) {
354 const IntPtrT FPtr = swap(I->FunctionPointer);
355 if (!FPtr)
356 continue;
357 Symtab.mapAddress(FPtr, I->NameRef);
358 }
359 return success();
360 }
361
362 template <class IntPtrT>
readHeader(const RawInstrProf::Header & Header)363 Error RawInstrProfReader<IntPtrT>::readHeader(
364 const RawInstrProf::Header &Header) {
365 Version = swap(Header.Version);
366 if (GET_VERSION(Version) != RawInstrProf::Version)
367 return error(instrprof_error::unsupported_version);
368
369 BinaryIdsSize = swap(Header.BinaryIdsSize);
370 CountersDelta = swap(Header.CountersDelta);
371 NamesDelta = swap(Header.NamesDelta);
372 auto DataSize = swap(Header.DataSize);
373 auto PaddingBytesBeforeCounters = swap(Header.PaddingBytesBeforeCounters);
374 auto CountersSize = swap(Header.CountersSize);
375 auto PaddingBytesAfterCounters = swap(Header.PaddingBytesAfterCounters);
376 NamesSize = swap(Header.NamesSize);
377 ValueKindLast = swap(Header.ValueKindLast);
378
379 auto DataSizeInBytes = DataSize * sizeof(RawInstrProf::ProfileData<IntPtrT>);
380 auto PaddingSize = getNumPaddingBytes(NamesSize);
381
382 // Profile data starts after profile header and binary ids if exist.
383 ptrdiff_t DataOffset = sizeof(RawInstrProf::Header) + BinaryIdsSize;
384 ptrdiff_t CountersOffset =
385 DataOffset + DataSizeInBytes + PaddingBytesBeforeCounters;
386 ptrdiff_t NamesOffset = CountersOffset + (sizeof(uint64_t) * CountersSize) +
387 PaddingBytesAfterCounters;
388 ptrdiff_t ValueDataOffset = NamesOffset + NamesSize + PaddingSize;
389
390 auto *Start = reinterpret_cast<const char *>(&Header);
391 if (Start + ValueDataOffset > DataBuffer->getBufferEnd())
392 return error(instrprof_error::bad_header);
393
394 Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
395 Start + DataOffset);
396 DataEnd = Data + DataSize;
397
398 // Binary ids start just after the header.
399 BinaryIdsStart =
400 reinterpret_cast<const uint8_t *>(&Header) + sizeof(RawInstrProf::Header);
401 CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
402 NamesStart = Start + NamesOffset;
403 ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
404
405 std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
406 if (Error E = createSymtab(*NewSymtab.get()))
407 return E;
408
409 Symtab = std::move(NewSymtab);
410 return success();
411 }
412
413 template <class IntPtrT>
readName(NamedInstrProfRecord & Record)414 Error RawInstrProfReader<IntPtrT>::readName(NamedInstrProfRecord &Record) {
415 Record.Name = getName(Data->NameRef);
416 return success();
417 }
418
419 template <class IntPtrT>
readFuncHash(NamedInstrProfRecord & Record)420 Error RawInstrProfReader<IntPtrT>::readFuncHash(NamedInstrProfRecord &Record) {
421 Record.Hash = swap(Data->FuncHash);
422 return success();
423 }
424
425 template <class IntPtrT>
readRawCounts(InstrProfRecord & Record)426 Error RawInstrProfReader<IntPtrT>::readRawCounts(
427 InstrProfRecord &Record) {
428 uint32_t NumCounters = swap(Data->NumCounters);
429 IntPtrT CounterPtr = Data->CounterPtr;
430 if (NumCounters == 0)
431 return error(instrprof_error::malformed);
432
433 auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
434 ptrdiff_t MaxNumCounters = NamesStartAsCounter - CountersStart;
435
436 // Check bounds. Note that the counter pointer embedded in the data record
437 // may itself be corrupt.
438 if (MaxNumCounters < 0 || NumCounters > (uint32_t)MaxNumCounters)
439 return error(instrprof_error::malformed);
440 ptrdiff_t CounterOffset = getCounterOffset(CounterPtr);
441 if (CounterOffset < 0 || CounterOffset > MaxNumCounters ||
442 ((uint32_t)CounterOffset + NumCounters) > (uint32_t)MaxNumCounters)
443 return error(instrprof_error::malformed);
444
445 auto RawCounts = makeArrayRef(getCounter(CounterOffset), NumCounters);
446
447 if (ShouldSwapBytes) {
448 Record.Counts.clear();
449 Record.Counts.reserve(RawCounts.size());
450 for (uint64_t Count : RawCounts)
451 Record.Counts.push_back(swap(Count));
452 } else
453 Record.Counts = RawCounts;
454
455 return success();
456 }
457
458 template <class IntPtrT>
readValueProfilingData(InstrProfRecord & Record)459 Error RawInstrProfReader<IntPtrT>::readValueProfilingData(
460 InstrProfRecord &Record) {
461 Record.clearValueData();
462 CurValueDataSize = 0;
463 // Need to match the logic in value profile dumper code in compiler-rt:
464 uint32_t NumValueKinds = 0;
465 for (uint32_t I = 0; I < IPVK_Last + 1; I++)
466 NumValueKinds += (Data->NumValueSites[I] != 0);
467
468 if (!NumValueKinds)
469 return success();
470
471 Expected<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
472 ValueProfData::getValueProfData(
473 ValueDataStart, (const unsigned char *)DataBuffer->getBufferEnd(),
474 getDataEndianness());
475
476 if (Error E = VDataPtrOrErr.takeError())
477 return E;
478
479 // Note that besides deserialization, this also performs the conversion for
480 // indirect call targets. The function pointers from the raw profile are
481 // remapped into function name hashes.
482 VDataPtrOrErr.get()->deserializeTo(Record, Symtab.get());
483 CurValueDataSize = VDataPtrOrErr.get()->getSize();
484 return success();
485 }
486
487 template <class IntPtrT>
readNextRecord(NamedInstrProfRecord & Record)488 Error RawInstrProfReader<IntPtrT>::readNextRecord(NamedInstrProfRecord &Record) {
489 if (atEnd())
490 // At this point, ValueDataStart field points to the next header.
491 if (Error E = readNextHeader(getNextHeaderPos()))
492 return error(std::move(E));
493
494 // Read name ad set it in Record.
495 if (Error E = readName(Record))
496 return error(std::move(E));
497
498 // Read FuncHash and set it in Record.
499 if (Error E = readFuncHash(Record))
500 return error(std::move(E));
501
502 // Read raw counts and set Record.
503 if (Error E = readRawCounts(Record))
504 return error(std::move(E));
505
506 // Read value data and set Record.
507 if (Error E = readValueProfilingData(Record))
508 return error(std::move(E));
509
510 // Iterate.
511 advanceData();
512 return success();
513 }
514
515 template <class IntPtrT>
printBinaryIds(raw_ostream & OS)516 Error RawInstrProfReader<IntPtrT>::printBinaryIds(raw_ostream &OS) {
517 if (BinaryIdsSize == 0)
518 return success();
519
520 OS << "Binary IDs: \n";
521 const uint8_t *BI = BinaryIdsStart;
522 while (BI < BinaryIdsStart + BinaryIdsSize) {
523 uint64_t BinaryIdLen = swap(*reinterpret_cast<const uint64_t *>(BI));
524 // Increment by binary id length data type size.
525 BI += sizeof(BinaryIdLen);
526 if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
527 return make_error<InstrProfError>(instrprof_error::malformed);
528
529 for (uint64_t I = 0; I < BinaryIdLen; I++)
530 OS << format("%02x", BI[I]);
531 OS << "\n";
532
533 // Increment by binary id data length.
534 BI += BinaryIdLen;
535 if (BI > (const uint8_t *)DataBuffer->getBufferEnd())
536 return make_error<InstrProfError>(instrprof_error::malformed);
537 }
538
539 return success();
540 }
541
542 namespace llvm {
543
544 template class RawInstrProfReader<uint32_t>;
545 template class RawInstrProfReader<uint64_t>;
546
547 } // end namespace llvm
548
549 InstrProfLookupTrait::hash_value_type
ComputeHash(StringRef K)550 InstrProfLookupTrait::ComputeHash(StringRef K) {
551 return IndexedInstrProf::ComputeHash(HashType, K);
552 }
553
554 using data_type = InstrProfLookupTrait::data_type;
555 using offset_type = InstrProfLookupTrait::offset_type;
556
readValueProfilingData(const unsigned char * & D,const unsigned char * const End)557 bool InstrProfLookupTrait::readValueProfilingData(
558 const unsigned char *&D, const unsigned char *const End) {
559 Expected<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
560 ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
561
562 if (VDataPtrOrErr.takeError())
563 return false;
564
565 VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
566 D += VDataPtrOrErr.get()->TotalSize;
567
568 return true;
569 }
570
ReadData(StringRef K,const unsigned char * D,offset_type N)571 data_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
572 offset_type N) {
573 using namespace support;
574
575 // Check if the data is corrupt. If so, don't try to read it.
576 if (N % sizeof(uint64_t))
577 return data_type();
578
579 DataBuffer.clear();
580 std::vector<uint64_t> CounterBuffer;
581
582 const unsigned char *End = D + N;
583 while (D < End) {
584 // Read hash.
585 if (D + sizeof(uint64_t) >= End)
586 return data_type();
587 uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
588
589 // Initialize number of counters for GET_VERSION(FormatVersion) == 1.
590 uint64_t CountsSize = N / sizeof(uint64_t) - 1;
591 // If format version is different then read the number of counters.
592 if (GET_VERSION(FormatVersion) != IndexedInstrProf::ProfVersion::Version1) {
593 if (D + sizeof(uint64_t) > End)
594 return data_type();
595 CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
596 }
597 // Read counter values.
598 if (D + CountsSize * sizeof(uint64_t) > End)
599 return data_type();
600
601 CounterBuffer.clear();
602 CounterBuffer.reserve(CountsSize);
603 for (uint64_t J = 0; J < CountsSize; ++J)
604 CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
605
606 DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
607
608 // Read value profiling data.
609 if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
610 !readValueProfilingData(D, End)) {
611 DataBuffer.clear();
612 return data_type();
613 }
614 }
615 return DataBuffer;
616 }
617
618 template <typename HashTableImpl>
getRecords(StringRef FuncName,ArrayRef<NamedInstrProfRecord> & Data)619 Error InstrProfReaderIndex<HashTableImpl>::getRecords(
620 StringRef FuncName, ArrayRef<NamedInstrProfRecord> &Data) {
621 auto Iter = HashTable->find(FuncName);
622 if (Iter == HashTable->end())
623 return make_error<InstrProfError>(instrprof_error::unknown_function);
624
625 Data = (*Iter);
626 if (Data.empty())
627 return make_error<InstrProfError>(instrprof_error::malformed);
628
629 return Error::success();
630 }
631
632 template <typename HashTableImpl>
getRecords(ArrayRef<NamedInstrProfRecord> & Data)633 Error InstrProfReaderIndex<HashTableImpl>::getRecords(
634 ArrayRef<NamedInstrProfRecord> &Data) {
635 if (atEnd())
636 return make_error<InstrProfError>(instrprof_error::eof);
637
638 Data = *RecordIterator;
639
640 if (Data.empty())
641 return make_error<InstrProfError>(instrprof_error::malformed);
642
643 return Error::success();
644 }
645
646 template <typename HashTableImpl>
InstrProfReaderIndex(const unsigned char * Buckets,const unsigned char * const Payload,const unsigned char * const Base,IndexedInstrProf::HashT HashType,uint64_t Version)647 InstrProfReaderIndex<HashTableImpl>::InstrProfReaderIndex(
648 const unsigned char *Buckets, const unsigned char *const Payload,
649 const unsigned char *const Base, IndexedInstrProf::HashT HashType,
650 uint64_t Version) {
651 FormatVersion = Version;
652 HashTable.reset(HashTableImpl::Create(
653 Buckets, Payload, Base,
654 typename HashTableImpl::InfoType(HashType, Version)));
655 RecordIterator = HashTable->data_begin();
656 }
657
658 namespace {
659 /// A remapper that does not apply any remappings.
660 class InstrProfReaderNullRemapper : public InstrProfReaderRemapper {
661 InstrProfReaderIndexBase &Underlying;
662
663 public:
InstrProfReaderNullRemapper(InstrProfReaderIndexBase & Underlying)664 InstrProfReaderNullRemapper(InstrProfReaderIndexBase &Underlying)
665 : Underlying(Underlying) {}
666
getRecords(StringRef FuncName,ArrayRef<NamedInstrProfRecord> & Data)667 Error getRecords(StringRef FuncName,
668 ArrayRef<NamedInstrProfRecord> &Data) override {
669 return Underlying.getRecords(FuncName, Data);
670 }
671 };
672 }
673
674 /// A remapper that applies remappings based on a symbol remapping file.
675 template <typename HashTableImpl>
676 class llvm::InstrProfReaderItaniumRemapper
677 : public InstrProfReaderRemapper {
678 public:
InstrProfReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> RemapBuffer,InstrProfReaderIndex<HashTableImpl> & Underlying)679 InstrProfReaderItaniumRemapper(
680 std::unique_ptr<MemoryBuffer> RemapBuffer,
681 InstrProfReaderIndex<HashTableImpl> &Underlying)
682 : RemapBuffer(std::move(RemapBuffer)), Underlying(Underlying) {
683 }
684
685 /// Extract the original function name from a PGO function name.
extractName(StringRef Name)686 static StringRef extractName(StringRef Name) {
687 // We can have multiple :-separated pieces; there can be pieces both
688 // before and after the mangled name. Find the first part that starts
689 // with '_Z'; we'll assume that's the mangled name we want.
690 std::pair<StringRef, StringRef> Parts = {StringRef(), Name};
691 while (true) {
692 Parts = Parts.second.split(':');
693 if (Parts.first.startswith("_Z"))
694 return Parts.first;
695 if (Parts.second.empty())
696 return Name;
697 }
698 }
699
700 /// Given a mangled name extracted from a PGO function name, and a new
701 /// form for that mangled name, reconstitute the name.
reconstituteName(StringRef OrigName,StringRef ExtractedName,StringRef Replacement,SmallVectorImpl<char> & Out)702 static void reconstituteName(StringRef OrigName, StringRef ExtractedName,
703 StringRef Replacement,
704 SmallVectorImpl<char> &Out) {
705 Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());
706 Out.insert(Out.end(), OrigName.begin(), ExtractedName.begin());
707 Out.insert(Out.end(), Replacement.begin(), Replacement.end());
708 Out.insert(Out.end(), ExtractedName.end(), OrigName.end());
709 }
710
populateRemappings()711 Error populateRemappings() override {
712 if (Error E = Remappings.read(*RemapBuffer))
713 return E;
714 for (StringRef Name : Underlying.HashTable->keys()) {
715 StringRef RealName = extractName(Name);
716 if (auto Key = Remappings.insert(RealName)) {
717 // FIXME: We could theoretically map the same equivalence class to
718 // multiple names in the profile data. If that happens, we should
719 // return NamedInstrProfRecords from all of them.
720 MappedNames.insert({Key, RealName});
721 }
722 }
723 return Error::success();
724 }
725
getRecords(StringRef FuncName,ArrayRef<NamedInstrProfRecord> & Data)726 Error getRecords(StringRef FuncName,
727 ArrayRef<NamedInstrProfRecord> &Data) override {
728 StringRef RealName = extractName(FuncName);
729 if (auto Key = Remappings.lookup(RealName)) {
730 StringRef Remapped = MappedNames.lookup(Key);
731 if (!Remapped.empty()) {
732 if (RealName.begin() == FuncName.begin() &&
733 RealName.end() == FuncName.end())
734 FuncName = Remapped;
735 else {
736 // Try rebuilding the name from the given remapping.
737 SmallString<256> Reconstituted;
738 reconstituteName(FuncName, RealName, Remapped, Reconstituted);
739 Error E = Underlying.getRecords(Reconstituted, Data);
740 if (!E)
741 return E;
742
743 // If we failed because the name doesn't exist, fall back to asking
744 // about the original name.
745 if (Error Unhandled = handleErrors(
746 std::move(E), [](std::unique_ptr<InstrProfError> Err) {
747 return Err->get() == instrprof_error::unknown_function
748 ? Error::success()
749 : Error(std::move(Err));
750 }))
751 return Unhandled;
752 }
753 }
754 }
755 return Underlying.getRecords(FuncName, Data);
756 }
757
758 private:
759 /// The memory buffer containing the remapping configuration. Remappings
760 /// holds pointers into this buffer.
761 std::unique_ptr<MemoryBuffer> RemapBuffer;
762
763 /// The mangling remapper.
764 SymbolRemappingReader Remappings;
765
766 /// Mapping from mangled name keys to the name used for the key in the
767 /// profile data.
768 /// FIXME: Can we store a location within the on-disk hash table instead of
769 /// redoing lookup?
770 DenseMap<SymbolRemappingReader::Key, StringRef> MappedNames;
771
772 /// The real profile data reader.
773 InstrProfReaderIndex<HashTableImpl> &Underlying;
774 };
775
hasFormat(const MemoryBuffer & DataBuffer)776 bool IndexedInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
777 using namespace support;
778
779 if (DataBuffer.getBufferSize() < 8)
780 return false;
781 uint64_t Magic =
782 endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
783 // Verify that it's magical.
784 return Magic == IndexedInstrProf::Magic;
785 }
786
787 const unsigned char *
readSummary(IndexedInstrProf::ProfVersion Version,const unsigned char * Cur,bool UseCS)788 IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
789 const unsigned char *Cur, bool UseCS) {
790 using namespace IndexedInstrProf;
791 using namespace support;
792
793 if (Version >= IndexedInstrProf::Version4) {
794 const IndexedInstrProf::Summary *SummaryInLE =
795 reinterpret_cast<const IndexedInstrProf::Summary *>(Cur);
796 uint64_t NFields =
797 endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
798 uint64_t NEntries =
799 endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
800 uint32_t SummarySize =
801 IndexedInstrProf::Summary::getSize(NFields, NEntries);
802 std::unique_ptr<IndexedInstrProf::Summary> SummaryData =
803 IndexedInstrProf::allocSummary(SummarySize);
804
805 const uint64_t *Src = reinterpret_cast<const uint64_t *>(SummaryInLE);
806 uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
807 for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
808 Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
809
810 SummaryEntryVector DetailedSummary;
811 for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
812 const IndexedInstrProf::Summary::Entry &Ent = SummaryData->getEntry(I);
813 DetailedSummary.emplace_back((uint32_t)Ent.Cutoff, Ent.MinBlockCount,
814 Ent.NumBlocks);
815 }
816 std::unique_ptr<llvm::ProfileSummary> &Summary =
817 UseCS ? this->CS_Summary : this->Summary;
818
819 // initialize InstrProfSummary using the SummaryData from disk.
820 Summary = std::make_unique<ProfileSummary>(
821 UseCS ? ProfileSummary::PSK_CSInstr : ProfileSummary::PSK_Instr,
822 DetailedSummary, SummaryData->get(Summary::TotalBlockCount),
823 SummaryData->get(Summary::MaxBlockCount),
824 SummaryData->get(Summary::MaxInternalBlockCount),
825 SummaryData->get(Summary::MaxFunctionCount),
826 SummaryData->get(Summary::TotalNumBlocks),
827 SummaryData->get(Summary::TotalNumFunctions));
828 return Cur + SummarySize;
829 } else {
830 // The older versions do not support a profile summary. This just computes
831 // an empty summary, which will not result in accurate hot/cold detection.
832 // We would need to call addRecord for all NamedInstrProfRecords to get the
833 // correct summary. However, this version is old (prior to early 2016) and
834 // has not been supporting an accurate summary for several years.
835 InstrProfSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
836 Summary = Builder.getSummary();
837 return Cur;
838 }
839 }
840
readHeader()841 Error IndexedInstrProfReader::readHeader() {
842 using namespace support;
843
844 const unsigned char *Start =
845 (const unsigned char *)DataBuffer->getBufferStart();
846 const unsigned char *Cur = Start;
847 if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
848 return error(instrprof_error::truncated);
849
850 auto *Header = reinterpret_cast<const IndexedInstrProf::Header *>(Cur);
851 Cur += sizeof(IndexedInstrProf::Header);
852
853 // Check the magic number.
854 uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
855 if (Magic != IndexedInstrProf::Magic)
856 return error(instrprof_error::bad_magic);
857
858 // Read the version.
859 uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
860 if (GET_VERSION(FormatVersion) >
861 IndexedInstrProf::ProfVersion::CurrentVersion)
862 return error(instrprof_error::unsupported_version);
863
864 Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
865 /* UseCS */ false);
866 if (FormatVersion & VARIANT_MASK_CSIR_PROF)
867 Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
868 /* UseCS */ true);
869
870 // Read the hash type and start offset.
871 IndexedInstrProf::HashT HashType = static_cast<IndexedInstrProf::HashT>(
872 endian::byte_swap<uint64_t, little>(Header->HashType));
873 if (HashType > IndexedInstrProf::HashT::Last)
874 return error(instrprof_error::unsupported_hash_type);
875
876 uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
877
878 // The rest of the file is an on disk hash table.
879 auto IndexPtr =
880 std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
881 Start + HashOffset, Cur, Start, HashType, FormatVersion);
882
883 // Load the remapping table now if requested.
884 if (RemappingBuffer) {
885 Remapper = std::make_unique<
886 InstrProfReaderItaniumRemapper<OnDiskHashTableImplV3>>(
887 std::move(RemappingBuffer), *IndexPtr);
888 if (Error E = Remapper->populateRemappings())
889 return E;
890 } else {
891 Remapper = std::make_unique<InstrProfReaderNullRemapper>(*IndexPtr);
892 }
893 Index = std::move(IndexPtr);
894
895 return success();
896 }
897
getSymtab()898 InstrProfSymtab &IndexedInstrProfReader::getSymtab() {
899 if (Symtab.get())
900 return *Symtab.get();
901
902 std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
903 if (Error E = Index->populateSymtab(*NewSymtab.get())) {
904 consumeError(error(InstrProfError::take(std::move(E))));
905 }
906
907 Symtab = std::move(NewSymtab);
908 return *Symtab.get();
909 }
910
911 Expected<InstrProfRecord>
getInstrProfRecord(StringRef FuncName,uint64_t FuncHash)912 IndexedInstrProfReader::getInstrProfRecord(StringRef FuncName,
913 uint64_t FuncHash) {
914 ArrayRef<NamedInstrProfRecord> Data;
915 Error Err = Remapper->getRecords(FuncName, Data);
916 if (Err)
917 return std::move(Err);
918 // Found it. Look for counters with the right hash.
919 for (unsigned I = 0, E = Data.size(); I < E; ++I) {
920 // Check for a match and fill the vector if there is one.
921 if (Data[I].Hash == FuncHash) {
922 return std::move(Data[I]);
923 }
924 }
925 return error(instrprof_error::hash_mismatch);
926 }
927
getFunctionCounts(StringRef FuncName,uint64_t FuncHash,std::vector<uint64_t> & Counts)928 Error IndexedInstrProfReader::getFunctionCounts(StringRef FuncName,
929 uint64_t FuncHash,
930 std::vector<uint64_t> &Counts) {
931 Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
932 if (Error E = Record.takeError())
933 return error(std::move(E));
934
935 Counts = Record.get().Counts;
936 return success();
937 }
938
readNextRecord(NamedInstrProfRecord & Record)939 Error IndexedInstrProfReader::readNextRecord(NamedInstrProfRecord &Record) {
940 ArrayRef<NamedInstrProfRecord> Data;
941
942 Error E = Index->getRecords(Data);
943 if (E)
944 return error(std::move(E));
945
946 Record = Data[RecordIndex++];
947 if (RecordIndex >= Data.size()) {
948 Index->advanceToNextKey();
949 RecordIndex = 0;
950 }
951 return success();
952 }
953
accumulateCounts(CountSumOrPercent & Sum,bool IsCS)954 void InstrProfReader::accumulateCounts(CountSumOrPercent &Sum, bool IsCS) {
955 uint64_t NumFuncs = 0;
956 for (const auto &Func : *this) {
957 if (isIRLevelProfile()) {
958 bool FuncIsCS = NamedInstrProfRecord::hasCSFlagInHash(Func.Hash);
959 if (FuncIsCS != IsCS)
960 continue;
961 }
962 Func.accumulateCounts(Sum);
963 ++NumFuncs;
964 }
965 Sum.NumEntries = NumFuncs;
966 }
967