contrib/llvm-project/llvm/lib/ProfileData/InstrProfReader.cpp

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