contrib/llvm/lib/ProfileData/SampleProfReader.cpp

   1 //===- SampleProfReader.cpp - Read LLVM sample profile data ---------------===//
   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 implements the class that reads LLVM sample profiles. It
  11 // supports three file formats: text, binary and gcov.
  12 //
  13 // The textual representation is useful for debugging and testing purposes. The
  14 // binary representation is more compact, resulting in smaller file sizes.
  15 //
  16 // The gcov encoding is the one generated by GCC's AutoFDO profile creation
  17 // tool (https://github.com/google/autofdo)
  18 //
  19 // All three encodings can be used interchangeably as an input sample profile.
  20 //
  21 //===----------------------------------------------------------------------===//
  22
  23 #include "llvm/ProfileData/SampleProfReader.h"
  24 #include "llvm/ADT/DenseMap.h"
  25 #include "llvm/ADT/STLExtras.h"
  26 #include "llvm/ADT/StringRef.h"
  27 #include "llvm/IR/ProfileSummary.h"
  28 #include "llvm/ProfileData/ProfileCommon.h"
  29 #include "llvm/ProfileData/SampleProf.h"
  30 #include "llvm/Support/ErrorOr.h"
  31 #include "llvm/Support/LEB128.h"
  32 #include "llvm/Support/LineIterator.h"
  33 #include "llvm/Support/MemoryBuffer.h"
  34 #include "llvm/Support/raw_ostream.h"
  35 #include <algorithm>
  36 #include <cstddef>
  37 #include <cstdint>
  38 #include <limits>
  39 #include <memory>
  40 #include <system_error>
  41 #include <vector>
  42
  43 using namespace llvm;
  44 using namespace sampleprof;
  45
  46 /// Dump the function profile for \p FName.
  47 ///
  48 /// \param FName Name of the function to print.
  49 /// \param OS Stream to emit the output to.
  50 void SampleProfileReader::dumpFunctionProfile(StringRef FName,
  51                                               raw_ostream &OS) {
  52   OS << "Function: " << FName << ": " << Profiles[FName];
  53 }
  54
  55 /// Dump all the function profiles found on stream \p OS.
  56 void SampleProfileReader::dump(raw_ostream &OS) {
  57   for (const auto &I : Profiles)
  58     dumpFunctionProfile(I.getKey(), OS);
  59 }
  60
  61 /// Parse \p Input as function head.
  62 ///
  63 /// Parse one line of \p Input, and update function name in \p FName,
  64 /// function's total sample count in \p NumSamples, function's entry
  65 /// count in \p NumHeadSamples.
  66 ///
  67 /// \returns true if parsing is successful.
  68 static bool ParseHead(const StringRef &Input, StringRef &FName,
  69                       uint64_t &NumSamples, uint64_t &NumHeadSamples) {
  70   if (Input[0] == ' ')
  71     return false;
  72   size_t n2 = Input.rfind(':');
  73   size_t n1 = Input.rfind(':', n2 - 1);
  74   FName = Input.substr(0, n1);
  75   if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
  76     return false;
  77   if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
  78     return false;
  79   return true;
  80 }
  81
  82 /// Returns true if line offset \p L is legal (only has 16 bits).
  83 static bool isOffsetLegal(unsigned L) { return (L & 0xffff) == L; }
  84
  85 /// Parse \p Input as line sample.
  86 ///
  87 /// \param Input input line.
  88 /// \param IsCallsite true if the line represents an inlined callsite.
  89 /// \param Depth the depth of the inline stack.
  90 /// \param NumSamples total samples of the line/inlined callsite.
  91 /// \param LineOffset line offset to the start of the function.
  92 /// \param Discriminator discriminator of the line.
  93 /// \param TargetCountMap map from indirect call target to count.
  94 ///
  95 /// returns true if parsing is successful.
  96 static bool ParseLine(const StringRef &Input, bool &IsCallsite, uint32_t &Depth,
  97                       uint64_t &NumSamples, uint32_t &LineOffset,
  98                       uint32_t &Discriminator, StringRef &CalleeName,
  99                       DenseMap<StringRef, uint64_t> &TargetCountMap) {
 100   for (Depth = 0; Input[Depth] == ' '; Depth++)
 101     ;
 102   if (Depth == 0)
 103     return false;
 104
 105   size_t n1 = Input.find(':');
 106   StringRef Loc = Input.substr(Depth, n1 - Depth);
 107   size_t n2 = Loc.find('.');
 108   if (n2 == StringRef::npos) {
 109     if (Loc.getAsInteger(10, LineOffset) || !isOffsetLegal(LineOffset))
 110       return false;
 111     Discriminator = 0;
 112   } else {
 113     if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
 114       return false;
 115     if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
 116       return false;
 117   }
 118
 119   StringRef Rest = Input.substr(n1 + 2);
 120   if (Rest[0] >= '0' && Rest[0] <= '9') {
 121     IsCallsite = false;
 122     size_t n3 = Rest.find(' ');
 123     if (n3 == StringRef::npos) {
 124       if (Rest.getAsInteger(10, NumSamples))
 125         return false;
 126     } else {
 127       if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
 128         return false;
 129     }
 130     // Find call targets and their sample counts.
 131     // Note: In some cases, there are symbols in the profile which are not
 132     // mangled. To accommodate such cases, use colon + integer pairs as the
 133     // anchor points.
 134     // An example:
 135     // _M_construct<char *>:1000 string_view<std::allocator<char> >:437
 136     // ":1000" and ":437" are used as anchor points so the string above will
 137     // be interpreted as
 138     // target: _M_construct<char *>
 139     // count: 1000
 140     // target: string_view<std::allocator<char> >
 141     // count: 437
 142     while (n3 != StringRef::npos) {
 143       n3 += Rest.substr(n3).find_first_not_of(' ');
 144       Rest = Rest.substr(n3);
 145       n3 = Rest.find_first_of(':');
 146       if (n3 == StringRef::npos || n3 == 0)
 147         return false;
 148
 149       StringRef Target;
 150       uint64_t count, n4;
 151       while (true) {
 152         // Get the segment after the current colon.
 153         StringRef AfterColon = Rest.substr(n3 + 1);
 154         // Get the target symbol before the current colon.
 155         Target = Rest.substr(0, n3);
 156         // Check if the word after the current colon is an integer.
 157         n4 = AfterColon.find_first_of(' ');
 158         n4 = (n4 != StringRef::npos) ? n3 + n4 + 1 : Rest.size();
 159         StringRef WordAfterColon = Rest.substr(n3 + 1, n4 - n3 - 1);
 160         if (!WordAfterColon.getAsInteger(10, count))
 161           break;
 162
 163         // Try to find the next colon.
 164         uint64_t n5 = AfterColon.find_first_of(':');
 165         if (n5 == StringRef::npos)
 166           return false;
 167         n3 += n5 + 1;
 168       }
 169
 170       // An anchor point is found. Save the {target, count} pair
 171       TargetCountMap[Target] = count;
 172       if (n4 == Rest.size())
 173         break;
 174       // Change n3 to the next blank space after colon + integer pair.
 175       n3 = n4;
 176     }
 177   } else {
 178     IsCallsite = true;
 179     size_t n3 = Rest.find_last_of(':');
 180     CalleeName = Rest.substr(0, n3);
 181     if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))
 182       return false;
 183   }
 184   return true;
 185 }
 186
 187 /// Load samples from a text file.
 188 ///
 189 /// See the documentation at the top of the file for an explanation of
 190 /// the expected format.
 191 ///
 192 /// \returns true if the file was loaded successfully, false otherwise.
 193 std::error_code SampleProfileReaderText::read() {
 194   line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
 195   sampleprof_error Result = sampleprof_error::success;
 196
 197   InlineCallStack InlineStack;
 198
 199   for (; !LineIt.is_at_eof(); ++LineIt) {
 200     if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#')
 201       continue;
 202     // Read the header of each function.
 203     //
 204     // Note that for function identifiers we are actually expecting
 205     // mangled names, but we may not always get them. This happens when
 206     // the compiler decides not to emit the function (e.g., it was inlined
 207     // and removed). In this case, the binary will not have the linkage
 208     // name for the function, so the profiler will emit the function's
 209     // unmangled name, which may contain characters like ':' and '>' in its
 210     // name (member functions, templates, etc).
 211     //
 212     // The only requirement we place on the identifier, then, is that it
 213     // should not begin with a number.
 214     if ((*LineIt)[0] != ' ') {
 215       uint64_t NumSamples, NumHeadSamples;
 216       StringRef FName;
 217       if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
 218         reportError(LineIt.line_number(),
 219                     "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
 220         return sampleprof_error::malformed;
 221       }
 222       Profiles[FName] = FunctionSamples();
 223       FunctionSamples &FProfile = Profiles[FName];
 224       FProfile.setName(FName);
 225       MergeResult(Result, FProfile.addTotalSamples(NumSamples));
 226       MergeResult(Result, FProfile.addHeadSamples(NumHeadSamples));
 227       InlineStack.clear();
 228       InlineStack.push_back(&FProfile);
 229     } else {
 230       uint64_t NumSamples;
 231       StringRef FName;
 232       DenseMap<StringRef, uint64_t> TargetCountMap;
 233       bool IsCallsite;
 234       uint32_t Depth, LineOffset, Discriminator;
 235       if (!ParseLine(*LineIt, IsCallsite, Depth, NumSamples, LineOffset,
 236                      Discriminator, FName, TargetCountMap)) {
 237         reportError(LineIt.line_number(),
 238                     "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " +
 239                         *LineIt);
 240         return sampleprof_error::malformed;
 241       }
 242       if (IsCallsite) {
 243         while (InlineStack.size() > Depth) {
 244           InlineStack.pop_back();
 245         }
 246         FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt(
 247             LineLocation(LineOffset, Discriminator))[FName];
 248         FSamples.setName(FName);
 249         MergeResult(Result, FSamples.addTotalSamples(NumSamples));
 250         InlineStack.push_back(&FSamples);
 251       } else {
 252         while (InlineStack.size() > Depth) {
 253           InlineStack.pop_back();
 254         }
 255         FunctionSamples &FProfile = *InlineStack.back();
 256         for (const auto &name_count : TargetCountMap) {
 257           MergeResult(Result, FProfile.addCalledTargetSamples(
 258                                   LineOffset, Discriminator, name_count.first,
 259                                   name_count.second));
 260         }
 261         MergeResult(Result, FProfile.addBodySamples(LineOffset, Discriminator,
 262                                                     NumSamples));
 263       }
 264     }
 265   }
 266   if (Result == sampleprof_error::success)
 267     computeSummary();
 268
 269   return Result;
 270 }
 271
 272 bool SampleProfileReaderText::hasFormat(const MemoryBuffer &Buffer) {
 273   bool result = false;
 274
 275   // Check that the first non-comment line is a valid function header.
 276   line_iterator LineIt(Buffer, /*SkipBlanks=*/true, '#');
 277   if (!LineIt.is_at_eof()) {
 278     if ((*LineIt)[0] != ' ') {
 279       uint64_t NumSamples, NumHeadSamples;
 280       StringRef FName;
 281       result = ParseHead(*LineIt, FName, NumSamples, NumHeadSamples);
 282     }
 283   }
 284
 285   return result;
 286 }
 287
 288 template <typename T> ErrorOr<T> SampleProfileReaderBinary::readNumber() {
 289   unsigned NumBytesRead = 0;
 290   std::error_code EC;
 291   uint64_t Val = decodeULEB128(Data, &NumBytesRead);
 292
 293   if (Val > std::numeric_limits<T>::max())
 294     EC = sampleprof_error::malformed;
 295   else if (Data + NumBytesRead > End)
 296     EC = sampleprof_error::truncated;
 297   else
 298     EC = sampleprof_error::success;
 299
 300   if (EC) {
 301     reportError(0, EC.message());
 302     return EC;
 303   }
 304
 305   Data += NumBytesRead;
 306   return static_cast<T>(Val);
 307 }
 308
 309 ErrorOr<StringRef> SampleProfileReaderBinary::readString() {
 310   std::error_code EC;
 311   StringRef Str(reinterpret_cast<const char *>(Data));
 312   if (Data + Str.size() + 1 > End) {
 313     EC = sampleprof_error::truncated;
 314     reportError(0, EC.message());
 315     return EC;
 316   }
 317
 318   Data += Str.size() + 1;
 319   return Str;
 320 }
 321
 322 template <typename T>
 323 inline ErrorOr<uint32_t> SampleProfileReaderBinary::readStringIndex(T &Table) {
 324   std::error_code EC;
 325   auto Idx = readNumber<uint32_t>();
 326   if (std::error_code EC = Idx.getError())
 327     return EC;
 328   if (*Idx >= Table.size())
 329     return sampleprof_error::truncated_name_table;
 330   return *Idx;
 331 }
 332
 333 ErrorOr<StringRef> SampleProfileReaderRawBinary::readStringFromTable() {
 334   auto Idx = readStringIndex(NameTable);
 335   if (std::error_code EC = Idx.getError())
 336     return EC;
 337
 338   return NameTable[*Idx];
 339 }
 340
 341 ErrorOr<StringRef> SampleProfileReaderCompactBinary::readStringFromTable() {
 342   auto Idx = readStringIndex(NameTable);
 343   if (std::error_code EC = Idx.getError())
 344     return EC;
 345
 346   return StringRef(NameTable[*Idx]);
 347 }
 348
 349 std::error_code
 350 SampleProfileReaderBinary::readProfile(FunctionSamples &FProfile) {
 351   auto NumSamples = readNumber<uint64_t>();
 352   if (std::error_code EC = NumSamples.getError())
 353     return EC;
 354   FProfile.addTotalSamples(*NumSamples);
 355
 356   // Read the samples in the body.
 357   auto NumRecords = readNumber<uint32_t>();
 358   if (std::error_code EC = NumRecords.getError())
 359     return EC;
 360
 361   for (uint32_t I = 0; I < *NumRecords; ++I) {
 362     auto LineOffset = readNumber<uint64_t>();
 363     if (std::error_code EC = LineOffset.getError())
 364       return EC;
 365
 366     if (!isOffsetLegal(*LineOffset)) {
 367       return std::error_code();
 368     }
 369
 370     auto Discriminator = readNumber<uint64_t>();
 371     if (std::error_code EC = Discriminator.getError())
 372       return EC;
 373
 374     auto NumSamples = readNumber<uint64_t>();
 375     if (std::error_code EC = NumSamples.getError())
 376       return EC;
 377
 378     auto NumCalls = readNumber<uint32_t>();
 379     if (std::error_code EC = NumCalls.getError())
 380       return EC;
 381
 382     for (uint32_t J = 0; J < *NumCalls; ++J) {
 383       auto CalledFunction(readStringFromTable());
 384       if (std::error_code EC = CalledFunction.getError())
 385         return EC;
 386
 387       auto CalledFunctionSamples = readNumber<uint64_t>();
 388       if (std::error_code EC = CalledFunctionSamples.getError())
 389         return EC;
 390
 391       FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
 392                                       *CalledFunction, *CalledFunctionSamples);
 393     }
 394
 395     FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
 396   }
 397
 398   // Read all the samples for inlined function calls.
 399   auto NumCallsites = readNumber<uint32_t>();
 400   if (std::error_code EC = NumCallsites.getError())
 401     return EC;
 402
 403   for (uint32_t J = 0; J < *NumCallsites; ++J) {
 404     auto LineOffset = readNumber<uint64_t>();
 405     if (std::error_code EC = LineOffset.getError())
 406       return EC;
 407
 408     auto Discriminator = readNumber<uint64_t>();
 409     if (std::error_code EC = Discriminator.getError())
 410       return EC;
 411
 412     auto FName(readStringFromTable());
 413     if (std::error_code EC = FName.getError())
 414       return EC;
 415
 416     FunctionSamples &CalleeProfile = FProfile.functionSamplesAt(
 417         LineLocation(*LineOffset, *Discriminator))[*FName];
 418     CalleeProfile.setName(*FName);
 419     if (std::error_code EC = readProfile(CalleeProfile))
 420       return EC;
 421   }
 422
 423   return sampleprof_error::success;
 424 }
 425
 426 std::error_code SampleProfileReaderBinary::read() {
 427   while (!at_eof()) {
 428     auto NumHeadSamples = readNumber<uint64_t>();
 429     if (std::error_code EC = NumHeadSamples.getError())
 430       return EC;
 431
 432     auto FName(readStringFromTable());
 433     if (std::error_code EC = FName.getError())
 434       return EC;
 435
 436     Profiles[*FName] = FunctionSamples();
 437     FunctionSamples &FProfile = Profiles[*FName];
 438     FProfile.setName(*FName);
 439
 440     FProfile.addHeadSamples(*NumHeadSamples);
 441
 442     if (std::error_code EC = readProfile(FProfile))
 443       return EC;
 444   }
 445
 446   return sampleprof_error::success;
 447 }
 448
 449 std::error_code SampleProfileReaderRawBinary::verifySPMagic(uint64_t Magic) {
 450   if (Magic == SPMagic())
 451     return sampleprof_error::success;
 452   return sampleprof_error::bad_magic;
 453 }
 454
 455 std::error_code
 456 SampleProfileReaderCompactBinary::verifySPMagic(uint64_t Magic) {
 457   if (Magic == SPMagic(SPF_Compact_Binary))
 458     return sampleprof_error::success;
 459   return sampleprof_error::bad_magic;
 460 }
 461
 462 std::error_code SampleProfileReaderRawBinary::readNameTable() {
 463   auto Size = readNumber<uint32_t>();
 464   if (std::error_code EC = Size.getError())
 465     return EC;
 466   NameTable.reserve(*Size);
 467   for (uint32_t I = 0; I < *Size; ++I) {
 468     auto Name(readString());
 469     if (std::error_code EC = Name.getError())
 470       return EC;
 471     NameTable.push_back(*Name);
 472   }
 473
 474   return sampleprof_error::success;
 475 }
 476
 477 std::error_code SampleProfileReaderCompactBinary::readNameTable() {
 478   auto Size = readNumber<uint64_t>();
 479   if (std::error_code EC = Size.getError())
 480     return EC;
 481   NameTable.reserve(*Size);
 482   for (uint32_t I = 0; I < *Size; ++I) {
 483     auto FID = readNumber<uint64_t>();
 484     if (std::error_code EC = FID.getError())
 485       return EC;
 486     NameTable.push_back(std::to_string(*FID));
 487   }
 488   return sampleprof_error::success;
 489 }
 490
 491 std::error_code SampleProfileReaderBinary::readHeader() {
 492   Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
 493   End = Data + Buffer->getBufferSize();
 494
 495   // Read and check the magic identifier.
 496   auto Magic = readNumber<uint64_t>();
 497   if (std::error_code EC = Magic.getError())
 498     return EC;
 499   else if (std::error_code EC = verifySPMagic(*Magic))
 500     return EC;
 501
 502   // Read the version number.
 503   auto Version = readNumber<uint64_t>();
 504   if (std::error_code EC = Version.getError())
 505     return EC;
 506   else if (*Version != SPVersion())
 507     return sampleprof_error::unsupported_version;
 508
 509   if (std::error_code EC = readSummary())
 510     return EC;
 511
 512   if (std::error_code EC = readNameTable())
 513     return EC;
 514   return sampleprof_error::success;
 515 }
 516
 517 std::error_code SampleProfileReaderBinary::readSummaryEntry(
 518     std::vector<ProfileSummaryEntry> &Entries) {
 519   auto Cutoff = readNumber<uint64_t>();
 520   if (std::error_code EC = Cutoff.getError())
 521     return EC;
 522
 523   auto MinBlockCount = readNumber<uint64_t>();
 524   if (std::error_code EC = MinBlockCount.getError())
 525     return EC;
 526
 527   auto NumBlocks = readNumber<uint64_t>();
 528   if (std::error_code EC = NumBlocks.getError())
 529     return EC;
 530
 531   Entries.emplace_back(*Cutoff, *MinBlockCount, *NumBlocks);
 532   return sampleprof_error::success;
 533 }
 534
 535 std::error_code SampleProfileReaderBinary::readSummary() {
 536   auto TotalCount = readNumber<uint64_t>();
 537   if (std::error_code EC = TotalCount.getError())
 538     return EC;
 539
 540   auto MaxBlockCount = readNumber<uint64_t>();
 541   if (std::error_code EC = MaxBlockCount.getError())
 542     return EC;
 543
 544   auto MaxFunctionCount = readNumber<uint64_t>();
 545   if (std::error_code EC = MaxFunctionCount.getError())
 546     return EC;
 547
 548   auto NumBlocks = readNumber<uint64_t>();
 549   if (std::error_code EC = NumBlocks.getError())
 550     return EC;
 551
 552   auto NumFunctions = readNumber<uint64_t>();
 553   if (std::error_code EC = NumFunctions.getError())
 554     return EC;
 555
 556   auto NumSummaryEntries = readNumber<uint64_t>();
 557   if (std::error_code EC = NumSummaryEntries.getError())
 558     return EC;
 559
 560   std::vector<ProfileSummaryEntry> Entries;
 561   for (unsigned i = 0; i < *NumSummaryEntries; i++) {
 562     std::error_code EC = readSummaryEntry(Entries);
 563     if (EC != sampleprof_error::success)
 564       return EC;
 565   }
 566   Summary = llvm::make_unique<ProfileSummary>(
 567       ProfileSummary::PSK_Sample, Entries, *TotalCount, *MaxBlockCount, 0,
 568       *MaxFunctionCount, *NumBlocks, *NumFunctions);
 569
 570   return sampleprof_error::success;
 571 }
 572
 573 bool SampleProfileReaderRawBinary::hasFormat(const MemoryBuffer &Buffer) {
 574   const uint8_t *Data =
 575       reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
 576   uint64_t Magic = decodeULEB128(Data);
 577   return Magic == SPMagic();
 578 }
 579
 580 bool SampleProfileReaderCompactBinary::hasFormat(const MemoryBuffer &Buffer) {
 581   const uint8_t *Data =
 582       reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
 583   uint64_t Magic = decodeULEB128(Data);
 584   return Magic == SPMagic(SPF_Compact_Binary);
 585 }
 586
 587 std::error_code SampleProfileReaderGCC::skipNextWord() {
 588   uint32_t dummy;
 589   if (!GcovBuffer.readInt(dummy))
 590     return sampleprof_error::truncated;
 591   return sampleprof_error::success;
 592 }
 593
 594 template <typename T> ErrorOr<T> SampleProfileReaderGCC::readNumber() {
 595   if (sizeof(T) <= sizeof(uint32_t)) {
 596     uint32_t Val;
 597     if (GcovBuffer.readInt(Val) && Val <= std::numeric_limits<T>::max())
 598       return static_cast<T>(Val);
 599   } else if (sizeof(T) <= sizeof(uint64_t)) {
 600     uint64_t Val;
 601     if (GcovBuffer.readInt64(Val) && Val <= std::numeric_limits<T>::max())
 602       return static_cast<T>(Val);
 603   }
 604
 605   std::error_code EC = sampleprof_error::malformed;
 606   reportError(0, EC.message());
 607   return EC;
 608 }
 609
 610 ErrorOr<StringRef> SampleProfileReaderGCC::readString() {
 611   StringRef Str;
 612   if (!GcovBuffer.readString(Str))
 613     return sampleprof_error::truncated;
 614   return Str;
 615 }
 616
 617 std::error_code SampleProfileReaderGCC::readHeader() {
 618   // Read the magic identifier.
 619   if (!GcovBuffer.readGCDAFormat())
 620     return sampleprof_error::unrecognized_format;
 621
 622   // Read the version number. Note - the GCC reader does not validate this
 623   // version, but the profile creator generates v704.
 624   GCOV::GCOVVersion version;
 625   if (!GcovBuffer.readGCOVVersion(version))
 626     return sampleprof_error::unrecognized_format;
 627
 628   if (version != GCOV::V704)
 629     return sampleprof_error::unsupported_version;
 630
 631   // Skip the empty integer.
 632   if (std::error_code EC = skipNextWord())
 633     return EC;
 634
 635   return sampleprof_error::success;
 636 }
 637
 638 std::error_code SampleProfileReaderGCC::readSectionTag(uint32_t Expected) {
 639   uint32_t Tag;
 640   if (!GcovBuffer.readInt(Tag))
 641     return sampleprof_error::truncated;
 642
 643   if (Tag != Expected)
 644     return sampleprof_error::malformed;
 645
 646   if (std::error_code EC = skipNextWord())
 647     return EC;
 648
 649   return sampleprof_error::success;
 650 }
 651
 652 std::error_code SampleProfileReaderGCC::readNameTable() {
 653   if (std::error_code EC = readSectionTag(GCOVTagAFDOFileNames))
 654     return EC;
 655
 656   uint32_t Size;
 657   if (!GcovBuffer.readInt(Size))
 658     return sampleprof_error::truncated;
 659
 660   for (uint32_t I = 0; I < Size; ++I) {
 661     StringRef Str;
 662     if (!GcovBuffer.readString(Str))
 663       return sampleprof_error::truncated;
 664     Names.push_back(Str);
 665   }
 666
 667   return sampleprof_error::success;
 668 }
 669
 670 std::error_code SampleProfileReaderGCC::readFunctionProfiles() {
 671   if (std::error_code EC = readSectionTag(GCOVTagAFDOFunction))
 672     return EC;
 673
 674   uint32_t NumFunctions;
 675   if (!GcovBuffer.readInt(NumFunctions))
 676     return sampleprof_error::truncated;
 677
 678   InlineCallStack Stack;
 679   for (uint32_t I = 0; I < NumFunctions; ++I)
 680     if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
 681       return EC;
 682
 683   computeSummary();
 684   return sampleprof_error::success;
 685 }
 686
 687 std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
 688     const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
 689   uint64_t HeadCount = 0;
 690   if (InlineStack.size() == 0)
 691     if (!GcovBuffer.readInt64(HeadCount))
 692       return sampleprof_error::truncated;
 693
 694   uint32_t NameIdx;
 695   if (!GcovBuffer.readInt(NameIdx))
 696     return sampleprof_error::truncated;
 697
 698   StringRef Name(Names[NameIdx]);
 699
 700   uint32_t NumPosCounts;
 701   if (!GcovBuffer.readInt(NumPosCounts))
 702     return sampleprof_error::truncated;
 703
 704   uint32_t NumCallsites;
 705   if (!GcovBuffer.readInt(NumCallsites))
 706     return sampleprof_error::truncated;
 707
 708   FunctionSamples *FProfile = nullptr;
 709   if (InlineStack.size() == 0) {
 710     // If this is a top function that we have already processed, do not
 711     // update its profile again.  This happens in the presence of
 712     // function aliases.  Since these aliases share the same function
 713     // body, there will be identical replicated profiles for the
 714     // original function.  In this case, we simply not bother updating
 715     // the profile of the original function.
 716     FProfile = &Profiles[Name];
 717     FProfile->addHeadSamples(HeadCount);
 718     if (FProfile->getTotalSamples() > 0)
 719       Update = false;
 720   } else {
 721     // Otherwise, we are reading an inlined instance. The top of the
 722     // inline stack contains the profile of the caller. Insert this
 723     // callee in the caller's CallsiteMap.
 724     FunctionSamples *CallerProfile = InlineStack.front();
 725     uint32_t LineOffset = Offset >> 16;
 726     uint32_t Discriminator = Offset & 0xffff;
 727     FProfile = &CallerProfile->functionSamplesAt(
 728         LineLocation(LineOffset, Discriminator))[Name];
 729   }
 730   FProfile->setName(Name);
 731
 732   for (uint32_t I = 0; I < NumPosCounts; ++I) {
 733     uint32_t Offset;
 734     if (!GcovBuffer.readInt(Offset))
 735       return sampleprof_error::truncated;
 736
 737     uint32_t NumTargets;
 738     if (!GcovBuffer.readInt(NumTargets))
 739       return sampleprof_error::truncated;
 740
 741     uint64_t Count;
 742     if (!GcovBuffer.readInt64(Count))
 743       return sampleprof_error::truncated;
 744
 745     // The line location is encoded in the offset as:
 746     //   high 16 bits: line offset to the start of the function.
 747     //   low 16 bits: discriminator.
 748     uint32_t LineOffset = Offset >> 16;
 749     uint32_t Discriminator = Offset & 0xffff;
 750
 751     InlineCallStack NewStack;
 752     NewStack.push_back(FProfile);
 753     NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
 754     if (Update) {
 755       // Walk up the inline stack, adding the samples on this line to
 756       // the total sample count of the callers in the chain.
 757       for (auto CallerProfile : NewStack)
 758         CallerProfile->addTotalSamples(Count);
 759
 760       // Update the body samples for the current profile.
 761       FProfile->addBodySamples(LineOffset, Discriminator, Count);
 762     }
 763
 764     // Process the list of functions called at an indirect call site.
 765     // These are all the targets that a function pointer (or virtual
 766     // function) resolved at runtime.
 767     for (uint32_t J = 0; J < NumTargets; J++) {
 768       uint32_t HistVal;
 769       if (!GcovBuffer.readInt(HistVal))
 770         return sampleprof_error::truncated;
 771
 772       if (HistVal != HIST_TYPE_INDIR_CALL_TOPN)
 773         return sampleprof_error::malformed;
 774
 775       uint64_t TargetIdx;
 776       if (!GcovBuffer.readInt64(TargetIdx))
 777         return sampleprof_error::truncated;
 778       StringRef TargetName(Names[TargetIdx]);
 779
 780       uint64_t TargetCount;
 781       if (!GcovBuffer.readInt64(TargetCount))
 782         return sampleprof_error::truncated;
 783
 784       if (Update)
 785         FProfile->addCalledTargetSamples(LineOffset, Discriminator,
 786                                          TargetName, TargetCount);
 787     }
 788   }
 789
 790   // Process all the inlined callers into the current function. These
 791   // are all the callsites that were inlined into this function.
 792   for (uint32_t I = 0; I < NumCallsites; I++) {
 793     // The offset is encoded as:
 794     //   high 16 bits: line offset to the start of the function.
 795     //   low 16 bits: discriminator.
 796     uint32_t Offset;
 797     if (!GcovBuffer.readInt(Offset))
 798       return sampleprof_error::truncated;
 799     InlineCallStack NewStack;
 800     NewStack.push_back(FProfile);
 801     NewStack.insert(NewStack.end(), InlineStack.begin(), InlineStack.end());
 802     if (std::error_code EC = readOneFunctionProfile(NewStack, Update, Offset))
 803       return EC;
 804   }
 805
 806   return sampleprof_error::success;
 807 }
 808
 809 /// Read a GCC AutoFDO profile.
 810 ///
 811 /// This format is generated by the Linux Perf conversion tool at
 812 /// https://github.com/google/autofdo.
 813 std::error_code SampleProfileReaderGCC::read() {
 814   // Read the string table.
 815   if (std::error_code EC = readNameTable())
 816     return EC;
 817
 818   // Read the source profile.
 819   if (std::error_code EC = readFunctionProfiles())
 820     return EC;
 821
 822   return sampleprof_error::success;
 823 }
 824
 825 bool SampleProfileReaderGCC::hasFormat(const MemoryBuffer &Buffer) {
 826   StringRef Magic(reinterpret_cast<const char *>(Buffer.getBufferStart()));
 827   return Magic == "adcg*704";
 828 }
 829
 830 /// Prepare a memory buffer for the contents of \p Filename.
 831 ///
 832 /// \returns an error code indicating the status of the buffer.
 833 static ErrorOr<std::unique_ptr<MemoryBuffer>>
 834 setupMemoryBuffer(const Twine &Filename) {
 835   auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
 836   if (std::error_code EC = BufferOrErr.getError())
 837     return EC;
 838   auto Buffer = std::move(BufferOrErr.get());
 839
 840   // Sanity check the file.
 841   if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint32_t>::max())
 842     return sampleprof_error::too_large;
 843
 844   return std::move(Buffer);
 845 }
 846
 847 /// Create a sample profile reader based on the format of the input file.
 848 ///
 849 /// \param Filename The file to open.
 850 ///
 851 /// \param C The LLVM context to use to emit diagnostics.
 852 ///
 853 /// \returns an error code indicating the status of the created reader.
 854 ErrorOr<std::unique_ptr<SampleProfileReader>>
 855 SampleProfileReader::create(const Twine &Filename, LLVMContext &C) {
 856   auto BufferOrError = setupMemoryBuffer(Filename);
 857   if (std::error_code EC = BufferOrError.getError())
 858     return EC;
 859   return create(BufferOrError.get(), C);
 860 }
 861
 862 /// Create a sample profile reader based on the format of the input data.
 863 ///
 864 /// \param B The memory buffer to create the reader from (assumes ownership).
 865 ///
 866 /// \param C The LLVM context to use to emit diagnostics.
 867 ///
 868 /// \returns an error code indicating the status of the created reader.
 869 ErrorOr<std::unique_ptr<SampleProfileReader>>
 870 SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {
 871   std::unique_ptr<SampleProfileReader> Reader;
 872   if (SampleProfileReaderRawBinary::hasFormat(*B))
 873     Reader.reset(new SampleProfileReaderRawBinary(std::move(B), C));
 874   else if (SampleProfileReaderCompactBinary::hasFormat(*B))
 875     Reader.reset(new SampleProfileReaderCompactBinary(std::move(B), C));
 876   else if (SampleProfileReaderGCC::hasFormat(*B))
 877     Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
 878   else if (SampleProfileReaderText::hasFormat(*B))
 879     Reader.reset(new SampleProfileReaderText(std::move(B), C));
 880   else
 881     return sampleprof_error::unrecognized_format;
 882
 883   if (std::error_code EC = Reader->readHeader())
 884     return EC;
 885
 886   return std::move(Reader);
 887 }
 888
 889 // For text and GCC file formats, we compute the summary after reading the
 890 // profile. Binary format has the profile summary in its header.
 891 void SampleProfileReader::computeSummary() {
 892   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
 893   for (const auto &I : Profiles) {
 894     const FunctionSamples &Profile = I.second;
 895     Builder.addRecord(Profile);
 896   }
 897   Summary = Builder.getSummary();
 898 }