1 //===- SampleProfReader.h - Read LLVM sample profile data -------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains definitions needed for reading sample profiles. 10 // 11 // NOTE: If you are making changes to this file format, please remember 12 // to document them in the Clang documentation at 13 // tools/clang/docs/UsersManual.rst. 14 // 15 // Text format 16 // ----------- 17 // 18 // Sample profiles are written as ASCII text. The file is divided into 19 // sections, which correspond to each of the functions executed at runtime. 20 // Each section has the following format 21 // 22 // function1:total_samples:total_head_samples 23 // offset1[.discriminator]: number_of_samples [fn1:num fn2:num ... ] 24 // offset2[.discriminator]: number_of_samples [fn3:num fn4:num ... ] 25 // ... 26 // offsetN[.discriminator]: number_of_samples [fn5:num fn6:num ... ] 27 // offsetA[.discriminator]: fnA:num_of_total_samples 28 // offsetA1[.discriminator]: number_of_samples [fn7:num fn8:num ... ] 29 // ... 30 // !CFGChecksum: num 31 // !Attribute: flags 32 // 33 // This is a nested tree in which the indentation represents the nesting level 34 // of the inline stack. There are no blank lines in the file. And the spacing 35 // within a single line is fixed. Additional spaces will result in an error 36 // while reading the file. 37 // 38 // Any line starting with the '#' character is completely ignored. 39 // 40 // Inlined calls are represented with indentation. The Inline stack is a 41 // stack of source locations in which the top of the stack represents the 42 // leaf function, and the bottom of the stack represents the actual 43 // symbol to which the instruction belongs. 44 // 45 // Function names must be mangled in order for the profile loader to 46 // match them in the current translation unit. The two numbers in the 47 // function header specify how many total samples were accumulated in the 48 // function (first number), and the total number of samples accumulated 49 // in the prologue of the function (second number). This head sample 50 // count provides an indicator of how frequently the function is invoked. 51 // 52 // There are three types of lines in the function body. 53 // 54 // * Sampled line represents the profile information of a source location. 55 // * Callsite line represents the profile information of a callsite. 56 // * Metadata line represents extra metadata of the function. 57 // 58 // Each sampled line may contain several items. Some are optional (marked 59 // below): 60 // 61 // a. Source line offset. This number represents the line number 62 // in the function where the sample was collected. The line number is 63 // always relative to the line where symbol of the function is 64 // defined. So, if the function has its header at line 280, the offset 65 // 13 is at line 293 in the file. 66 // 67 // Note that this offset should never be a negative number. This could 68 // happen in cases like macros. The debug machinery will register the 69 // line number at the point of macro expansion. So, if the macro was 70 // expanded in a line before the start of the function, the profile 71 // converter should emit a 0 as the offset (this means that the optimizers 72 // will not be able to associate a meaningful weight to the instructions 73 // in the macro). 74 // 75 // b. [OPTIONAL] Discriminator. This is used if the sampled program 76 // was compiled with DWARF discriminator support 77 // (http://wiki.dwarfstd.org/index.php?title=Path_Discriminators). 78 // DWARF discriminators are unsigned integer values that allow the 79 // compiler to distinguish between multiple execution paths on the 80 // same source line location. 81 // 82 // For example, consider the line of code ``if (cond) foo(); else bar();``. 83 // If the predicate ``cond`` is true 80% of the time, then the edge 84 // into function ``foo`` should be considered to be taken most of the 85 // time. But both calls to ``foo`` and ``bar`` are at the same source 86 // line, so a sample count at that line is not sufficient. The 87 // compiler needs to know which part of that line is taken more 88 // frequently. 89 // 90 // This is what discriminators provide. In this case, the calls to 91 // ``foo`` and ``bar`` will be at the same line, but will have 92 // different discriminator values. This allows the compiler to correctly 93 // set edge weights into ``foo`` and ``bar``. 94 // 95 // c. Number of samples. This is an integer quantity representing the 96 // number of samples collected by the profiler at this source 97 // location. 98 // 99 // d. [OPTIONAL] Potential call targets and samples. If present, this 100 // line contains a call instruction. This models both direct and 101 // number of samples. For example, 102 // 103 // 130: 7 foo:3 bar:2 baz:7 104 // 105 // The above means that at relative line offset 130 there is a call 106 // instruction that calls one of ``foo()``, ``bar()`` and ``baz()``, 107 // with ``baz()`` being the relatively more frequently called target. 108 // 109 // Each callsite line may contain several items. Some are optional. 110 // 111 // a. Source line offset. This number represents the line number of the 112 // callsite that is inlined in the profiled binary. 113 // 114 // b. [OPTIONAL] Discriminator. Same as the discriminator for sampled line. 115 // 116 // c. Number of samples. This is an integer quantity representing the 117 // total number of samples collected for the inlined instance at this 118 // callsite 119 // 120 // Metadata line can occur in lines with one indent only, containing extra 121 // information for the top-level function. Furthermore, metadata can only 122 // occur after all the body samples and callsite samples. 123 // Each metadata line may contain a particular type of metadata, marked by 124 // the starting characters annotated with !. We process each metadata line 125 // independently, hence each metadata line has to form an independent piece 126 // of information that does not require cross-line reference. 127 // We support the following types of metadata: 128 // 129 // a. CFG Checksum (a.k.a. function hash): 130 // !CFGChecksum: 12345 131 // b. CFG Checksum (see ContextAttributeMask): 132 // !Atribute: 1 133 // 134 // 135 // Binary format 136 // ------------- 137 // 138 // This is a more compact encoding. Numbers are encoded as ULEB128 values 139 // and all strings are encoded in a name table. The file is organized in 140 // the following sections: 141 // 142 // MAGIC (uint64_t) 143 // File identifier computed by function SPMagic() (0x5350524f463432ff) 144 // 145 // VERSION (uint32_t) 146 // File format version number computed by SPVersion() 147 // 148 // SUMMARY 149 // TOTAL_COUNT (uint64_t) 150 // Total number of samples in the profile. 151 // MAX_COUNT (uint64_t) 152 // Maximum value of samples on a line. 153 // MAX_FUNCTION_COUNT (uint64_t) 154 // Maximum number of samples at function entry (head samples). 155 // NUM_COUNTS (uint64_t) 156 // Number of lines with samples. 157 // NUM_FUNCTIONS (uint64_t) 158 // Number of functions with samples. 159 // NUM_DETAILED_SUMMARY_ENTRIES (size_t) 160 // Number of entries in detailed summary 161 // DETAILED_SUMMARY 162 // A list of detailed summary entry. Each entry consists of 163 // CUTOFF (uint32_t) 164 // Required percentile of total sample count expressed as a fraction 165 // multiplied by 1000000. 166 // MIN_COUNT (uint64_t) 167 // The minimum number of samples required to reach the target 168 // CUTOFF. 169 // NUM_COUNTS (uint64_t) 170 // Number of samples to get to the desrired percentile. 171 // 172 // NAME TABLE 173 // SIZE (uint32_t) 174 // Number of entries in the name table. 175 // NAMES 176 // A NUL-separated list of SIZE strings. 177 // 178 // FUNCTION BODY (one for each uninlined function body present in the profile) 179 // HEAD_SAMPLES (uint64_t) [only for top-level functions] 180 // Total number of samples collected at the head (prologue) of the 181 // function. 182 // NOTE: This field should only be present for top-level functions 183 // (i.e., not inlined into any caller). Inlined function calls 184 // have no prologue, so they don't need this. 185 // NAME_IDX (uint32_t) 186 // Index into the name table indicating the function name. 187 // SAMPLES (uint64_t) 188 // Total number of samples collected in this function. 189 // NRECS (uint32_t) 190 // Total number of sampling records this function's profile. 191 // BODY RECORDS 192 // A list of NRECS entries. Each entry contains: 193 // OFFSET (uint32_t) 194 // Line offset from the start of the function. 195 // DISCRIMINATOR (uint32_t) 196 // Discriminator value (see description of discriminators 197 // in the text format documentation above). 198 // SAMPLES (uint64_t) 199 // Number of samples collected at this location. 200 // NUM_CALLS (uint32_t) 201 // Number of non-inlined function calls made at this location. In the 202 // case of direct calls, this number will always be 1. For indirect 203 // calls (virtual functions and function pointers) this will 204 // represent all the actual functions called at runtime. 205 // CALL_TARGETS 206 // A list of NUM_CALLS entries for each called function: 207 // NAME_IDX (uint32_t) 208 // Index into the name table with the callee name. 209 // SAMPLES (uint64_t) 210 // Number of samples collected at the call site. 211 // NUM_INLINED_FUNCTIONS (uint32_t) 212 // Number of callees inlined into this function. 213 // INLINED FUNCTION RECORDS 214 // A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined 215 // callees. 216 // OFFSET (uint32_t) 217 // Line offset from the start of the function. 218 // DISCRIMINATOR (uint32_t) 219 // Discriminator value (see description of discriminators 220 // in the text format documentation above). 221 // FUNCTION BODY 222 // A FUNCTION BODY entry describing the inlined function. 223 //===----------------------------------------------------------------------===// 224 225 #ifndef LLVM_PROFILEDATA_SAMPLEPROFREADER_H 226 #define LLVM_PROFILEDATA_SAMPLEPROFREADER_H 227 228 #include "llvm/ADT/Optional.h" 229 #include "llvm/ADT/SmallVector.h" 230 #include "llvm/ADT/StringRef.h" 231 #include "llvm/IR/DiagnosticInfo.h" 232 #include "llvm/IR/LLVMContext.h" 233 #include "llvm/IR/ProfileSummary.h" 234 #include "llvm/ProfileData/GCOV.h" 235 #include "llvm/ProfileData/SampleProf.h" 236 #include "llvm/Support/Debug.h" 237 #include "llvm/Support/Discriminator.h" 238 #include "llvm/Support/ErrorOr.h" 239 #include "llvm/Support/MemoryBuffer.h" 240 #include "llvm/Support/SymbolRemappingReader.h" 241 #include <cstdint> 242 #include <list> 243 #include <memory> 244 #include <string> 245 #include <system_error> 246 #include <unordered_set> 247 #include <vector> 248 249 namespace llvm { 250 251 class raw_ostream; 252 class Twine; 253 254 namespace sampleprof { 255 256 class SampleProfileReader; 257 258 /// SampleProfileReaderItaniumRemapper remaps the profile data from a 259 /// sample profile data reader, by applying a provided set of equivalences 260 /// between components of the symbol names in the profile. 261 class SampleProfileReaderItaniumRemapper { 262 public: 263 SampleProfileReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> B, 264 std::unique_ptr<SymbolRemappingReader> SRR, 265 SampleProfileReader &R) 266 : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) { 267 assert(Remappings && "Remappings cannot be nullptr"); 268 } 269 270 /// Create a remapper from the given remapping file. The remapper will 271 /// be used for profile read in by Reader. 272 static ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>> 273 create(const std::string Filename, SampleProfileReader &Reader, 274 LLVMContext &C); 275 276 /// Create a remapper from the given Buffer. The remapper will 277 /// be used for profile read in by Reader. 278 static ErrorOr<std::unique_ptr<SampleProfileReaderItaniumRemapper>> 279 create(std::unique_ptr<MemoryBuffer> &B, SampleProfileReader &Reader, 280 LLVMContext &C); 281 282 /// Apply remappings to the profile read by Reader. 283 void applyRemapping(LLVMContext &Ctx); 284 285 bool hasApplied() { return RemappingApplied; } 286 287 /// Insert function name into remapper. 288 void insert(StringRef FunctionName) { Remappings->insert(FunctionName); } 289 290 /// Query whether there is equivalent in the remapper which has been 291 /// inserted. 292 bool exist(StringRef FunctionName) { 293 return Remappings->lookup(FunctionName); 294 } 295 296 /// Return the equivalent name in the profile for \p FunctionName if 297 /// it exists. 298 Optional<StringRef> lookUpNameInProfile(StringRef FunctionName); 299 300 private: 301 // The buffer holding the content read from remapping file. 302 std::unique_ptr<MemoryBuffer> Buffer; 303 std::unique_ptr<SymbolRemappingReader> Remappings; 304 // Map remapping key to the name in the profile. By looking up the 305 // key in the remapper, a given new name can be mapped to the 306 // cannonical name using the NameMap. 307 DenseMap<SymbolRemappingReader::Key, StringRef> NameMap; 308 // The Reader the remapper is servicing. 309 SampleProfileReader &Reader; 310 // Indicate whether remapping has been applied to the profile read 311 // by Reader -- by calling applyRemapping. 312 bool RemappingApplied = false; 313 }; 314 315 /// Sample-based profile reader. 316 /// 317 /// Each profile contains sample counts for all the functions 318 /// executed. Inside each function, statements are annotated with the 319 /// collected samples on all the instructions associated with that 320 /// statement. 321 /// 322 /// For this to produce meaningful data, the program needs to be 323 /// compiled with some debug information (at minimum, line numbers: 324 /// -gline-tables-only). Otherwise, it will be impossible to match IR 325 /// instructions to the line numbers collected by the profiler. 326 /// 327 /// From the profile file, we are interested in collecting the 328 /// following information: 329 /// 330 /// * A list of functions included in the profile (mangled names). 331 /// 332 /// * For each function F: 333 /// 1. The total number of samples collected in F. 334 /// 335 /// 2. The samples collected at each line in F. To provide some 336 /// protection against source code shuffling, line numbers should 337 /// be relative to the start of the function. 338 /// 339 /// The reader supports two file formats: text and binary. The text format 340 /// is useful for debugging and testing, while the binary format is more 341 /// compact and I/O efficient. They can both be used interchangeably. 342 class SampleProfileReader { 343 public: 344 SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C, 345 SampleProfileFormat Format = SPF_None) 346 : Profiles(0), Ctx(C), Buffer(std::move(B)), Format(Format) {} 347 348 virtual ~SampleProfileReader() = default; 349 350 /// Read and validate the file header. 351 virtual std::error_code readHeader() = 0; 352 353 /// Set the bits for FS discriminators. Parameter Pass specify the sequence 354 /// number, Pass == i is for the i-th round of adding FS discriminators. 355 /// Pass == 0 is for using base discriminators. 356 void setDiscriminatorMaskedBitFrom(FSDiscriminatorPass P) { 357 MaskedBitFrom = getFSPassBitEnd(P); 358 } 359 360 /// Get the bitmask the discriminators: For FS profiles, return the bit 361 /// mask for this pass. For non FS profiles, return (unsigned) -1. 362 uint32_t getDiscriminatorMask() const { 363 if (!ProfileIsFS) 364 return 0xFFFFFFFF; 365 assert((MaskedBitFrom != 0) && "MaskedBitFrom is not set properly"); 366 return getN1Bits(MaskedBitFrom); 367 } 368 369 /// The interface to read sample profiles from the associated file. 370 std::error_code read() { 371 if (std::error_code EC = readImpl()) 372 return EC; 373 if (Remapper) 374 Remapper->applyRemapping(Ctx); 375 FunctionSamples::UseMD5 = useMD5(); 376 return sampleprof_error::success; 377 } 378 379 /// The implementaion to read sample profiles from the associated file. 380 virtual std::error_code readImpl() = 0; 381 382 /// Print the profile for \p FContext on stream \p OS. 383 void dumpFunctionProfile(SampleContext FContext, raw_ostream &OS = dbgs()); 384 385 /// Collect functions with definitions in Module M. For reader which 386 /// support loading function profiles on demand, return true when the 387 /// reader has been given a module. Always return false for reader 388 /// which doesn't support loading function profiles on demand. 389 virtual bool collectFuncsFromModule() { return false; } 390 391 /// Print all the profiles on stream \p OS. 392 void dump(raw_ostream &OS = dbgs()); 393 394 /// Return the samples collected for function \p F. 395 FunctionSamples *getSamplesFor(const Function &F) { 396 // The function name may have been updated by adding suffix. Call 397 // a helper to (optionally) strip off suffixes so that we can 398 // match against the original function name in the profile. 399 StringRef CanonName = FunctionSamples::getCanonicalFnName(F); 400 return getSamplesFor(CanonName); 401 } 402 403 /// Return the samples collected for function \p F, create empty 404 /// FunctionSamples if it doesn't exist. 405 FunctionSamples *getOrCreateSamplesFor(const Function &F) { 406 std::string FGUID; 407 StringRef CanonName = FunctionSamples::getCanonicalFnName(F); 408 CanonName = getRepInFormat(CanonName, useMD5(), FGUID); 409 auto It = Profiles.find(CanonName); 410 if (It != Profiles.end()) 411 return &It->second; 412 if (!FGUID.empty()) { 413 assert(useMD5() && "New name should only be generated for md5 profile"); 414 CanonName = *MD5NameBuffer.insert(FGUID).first; 415 } 416 return &Profiles[CanonName]; 417 } 418 419 /// Return the samples collected for function \p F. 420 virtual FunctionSamples *getSamplesFor(StringRef Fname) { 421 std::string FGUID; 422 Fname = getRepInFormat(Fname, useMD5(), FGUID); 423 auto It = Profiles.find(Fname); 424 if (It != Profiles.end()) 425 return &It->second; 426 427 if (Remapper) { 428 if (auto NameInProfile = Remapper->lookUpNameInProfile(Fname)) { 429 auto It = Profiles.find(*NameInProfile); 430 if (It != Profiles.end()) 431 return &It->second; 432 } 433 } 434 return nullptr; 435 } 436 437 /// Return all the profiles. 438 SampleProfileMap &getProfiles() { return Profiles; } 439 440 /// Report a parse error message. 441 void reportError(int64_t LineNumber, const Twine &Msg) const { 442 Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(), 443 LineNumber, Msg)); 444 } 445 446 /// Create a sample profile reader appropriate to the file format. 447 /// Create a remapper underlying if RemapFilename is not empty. 448 /// Parameter P specifies the FSDiscriminatorPass. 449 static ErrorOr<std::unique_ptr<SampleProfileReader>> 450 create(const std::string Filename, LLVMContext &C, 451 FSDiscriminatorPass P = FSDiscriminatorPass::Base, 452 const std::string RemapFilename = ""); 453 454 /// Create a sample profile reader from the supplied memory buffer. 455 /// Create a remapper underlying if RemapFilename is not empty. 456 /// Parameter P specifies the FSDiscriminatorPass. 457 static ErrorOr<std::unique_ptr<SampleProfileReader>> 458 create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C, 459 FSDiscriminatorPass P = FSDiscriminatorPass::Base, 460 const std::string RemapFilename = ""); 461 462 /// Return the profile summary. 463 ProfileSummary &getSummary() const { return *(Summary.get()); } 464 465 MemoryBuffer *getBuffer() const { return Buffer.get(); } 466 467 /// \brief Return the profile format. 468 SampleProfileFormat getFormat() const { return Format; } 469 470 /// Whether input profile is based on pseudo probes. 471 bool profileIsProbeBased() const { return ProfileIsProbeBased; } 472 473 /// Whether input profile is fully context-sensitive. 474 bool profileIsCS() const { return ProfileIsCS; } 475 476 /// Whether input profile contains ShouldBeInlined contexts. 477 bool profileIsPreInlined() const { return ProfileIsPreInlined; } 478 479 virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() { 480 return nullptr; 481 }; 482 483 /// It includes all the names that have samples either in outline instance 484 /// or inline instance. 485 virtual std::vector<StringRef> *getNameTable() { return nullptr; } 486 virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; }; 487 488 /// Return whether names in the profile are all MD5 numbers. 489 virtual bool useMD5() { return false; } 490 491 /// Don't read profile without context if the flag is set. This is only meaningful 492 /// for ExtBinary format. 493 virtual void setSkipFlatProf(bool Skip) {} 494 /// Return whether any name in the profile contains ".__uniq." suffix. 495 virtual bool hasUniqSuffix() { return false; } 496 497 SampleProfileReaderItaniumRemapper *getRemapper() { return Remapper.get(); } 498 499 void setModule(const Module *Mod) { M = Mod; } 500 501 protected: 502 /// Map every function to its associated profile. 503 /// 504 /// The profile of every function executed at runtime is collected 505 /// in the structure FunctionSamples. This maps function objects 506 /// to their corresponding profiles. 507 SampleProfileMap Profiles; 508 509 /// LLVM context used to emit diagnostics. 510 LLVMContext &Ctx; 511 512 /// Memory buffer holding the profile file. 513 std::unique_ptr<MemoryBuffer> Buffer; 514 515 /// Extra name buffer holding names created on demand. 516 /// This should only be needed for md5 profiles. 517 std::unordered_set<std::string> MD5NameBuffer; 518 519 /// Profile summary information. 520 std::unique_ptr<ProfileSummary> Summary; 521 522 /// Take ownership of the summary of this reader. 523 static std::unique_ptr<ProfileSummary> 524 takeSummary(SampleProfileReader &Reader) { 525 return std::move(Reader.Summary); 526 } 527 528 /// Compute summary for this profile. 529 void computeSummary(); 530 531 std::unique_ptr<SampleProfileReaderItaniumRemapper> Remapper; 532 533 /// \brief Whether samples are collected based on pseudo probes. 534 bool ProfileIsProbeBased = false; 535 536 /// Whether function profiles are context-sensitive flat profiles. 537 bool ProfileIsCS = false; 538 539 /// Whether function profile contains ShouldBeInlined contexts. 540 bool ProfileIsPreInlined = false; 541 542 /// Number of context-sensitive profiles. 543 uint32_t CSProfileCount = 0; 544 545 /// Whether the function profiles use FS discriminators. 546 bool ProfileIsFS = false; 547 548 /// \brief The format of sample. 549 SampleProfileFormat Format = SPF_None; 550 551 /// \brief The current module being compiled if SampleProfileReader 552 /// is used by compiler. If SampleProfileReader is used by other 553 /// tools which are not compiler, M is usually nullptr. 554 const Module *M = nullptr; 555 556 /// Zero out the discriminator bits higher than bit MaskedBitFrom (0 based). 557 /// The default is to keep all the bits. 558 uint32_t MaskedBitFrom = 31; 559 }; 560 561 class SampleProfileReaderText : public SampleProfileReader { 562 public: 563 SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C) 564 : SampleProfileReader(std::move(B), C, SPF_Text) {} 565 566 /// Read and validate the file header. 567 std::error_code readHeader() override { return sampleprof_error::success; } 568 569 /// Read sample profiles from the associated file. 570 std::error_code readImpl() override; 571 572 /// Return true if \p Buffer is in the format supported by this class. 573 static bool hasFormat(const MemoryBuffer &Buffer); 574 575 private: 576 /// CSNameTable is used to save full context vectors. This serves as an 577 /// underlying immutable buffer for all clients. 578 std::list<SampleContextFrameVector> CSNameTable; 579 }; 580 581 class SampleProfileReaderBinary : public SampleProfileReader { 582 public: 583 SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C, 584 SampleProfileFormat Format = SPF_None) 585 : SampleProfileReader(std::move(B), C, Format) {} 586 587 /// Read and validate the file header. 588 std::error_code readHeader() override; 589 590 /// Read sample profiles from the associated file. 591 std::error_code readImpl() override; 592 593 /// It includes all the names that have samples either in outline instance 594 /// or inline instance. 595 std::vector<StringRef> *getNameTable() override { return &NameTable; } 596 597 protected: 598 /// Read a numeric value of type T from the profile. 599 /// 600 /// If an error occurs during decoding, a diagnostic message is emitted and 601 /// EC is set. 602 /// 603 /// \returns the read value. 604 template <typename T> ErrorOr<T> readNumber(); 605 606 /// Read a numeric value of type T from the profile. The value is saved 607 /// without encoded. 608 template <typename T> ErrorOr<T> readUnencodedNumber(); 609 610 /// Read a string from the profile. 611 /// 612 /// If an error occurs during decoding, a diagnostic message is emitted and 613 /// EC is set. 614 /// 615 /// \returns the read value. 616 ErrorOr<StringRef> readString(); 617 618 /// Read the string index and check whether it overflows the table. 619 template <typename T> inline ErrorOr<uint32_t> readStringIndex(T &Table); 620 621 /// Return true if we've reached the end of file. 622 bool at_eof() const { return Data >= End; } 623 624 /// Read the next function profile instance. 625 std::error_code readFuncProfile(const uint8_t *Start); 626 627 /// Read the contents of the given profile instance. 628 std::error_code readProfile(FunctionSamples &FProfile); 629 630 /// Read the contents of Magic number and Version number. 631 std::error_code readMagicIdent(); 632 633 /// Read profile summary. 634 std::error_code readSummary(); 635 636 /// Read the whole name table. 637 virtual std::error_code readNameTable(); 638 639 /// Points to the current location in the buffer. 640 const uint8_t *Data = nullptr; 641 642 /// Points to the end of the buffer. 643 const uint8_t *End = nullptr; 644 645 /// Function name table. 646 std::vector<StringRef> NameTable; 647 648 /// Read a string indirectly via the name table. 649 virtual ErrorOr<StringRef> readStringFromTable(); 650 virtual ErrorOr<SampleContext> readSampleContextFromTable(); 651 652 private: 653 std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries); 654 virtual std::error_code verifySPMagic(uint64_t Magic) = 0; 655 }; 656 657 class SampleProfileReaderRawBinary : public SampleProfileReaderBinary { 658 private: 659 std::error_code verifySPMagic(uint64_t Magic) override; 660 661 public: 662 SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C, 663 SampleProfileFormat Format = SPF_Binary) 664 : SampleProfileReaderBinary(std::move(B), C, Format) {} 665 666 /// \brief Return true if \p Buffer is in the format supported by this class. 667 static bool hasFormat(const MemoryBuffer &Buffer); 668 }; 669 670 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines 671 /// the basic structure of the extensible binary format. 672 /// The format is organized in sections except the magic and version number 673 /// at the beginning. There is a section table before all the sections, and 674 /// each entry in the table describes the entry type, start, size and 675 /// attributes. The format in each section is defined by the section itself. 676 /// 677 /// It is easy to add a new section while maintaining the backward 678 /// compatibility of the profile. Nothing extra needs to be done. If we want 679 /// to extend an existing section, like add cache misses information in 680 /// addition to the sample count in the profile body, we can add a new section 681 /// with the extension and retire the existing section, and we could choose 682 /// to keep the parser of the old section if we want the reader to be able 683 /// to read both new and old format profile. 684 /// 685 /// SampleProfileReaderExtBinary/SampleProfileWriterExtBinary define the 686 /// commonly used sections of a profile in extensible binary format. It is 687 /// possible to define other types of profile inherited from 688 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase. 689 class SampleProfileReaderExtBinaryBase : public SampleProfileReaderBinary { 690 private: 691 std::error_code decompressSection(const uint8_t *SecStart, 692 const uint64_t SecSize, 693 const uint8_t *&DecompressBuf, 694 uint64_t &DecompressBufSize); 695 696 BumpPtrAllocator Allocator; 697 698 protected: 699 std::vector<SecHdrTableEntry> SecHdrTable; 700 std::error_code readSecHdrTableEntry(uint32_t Idx); 701 std::error_code readSecHdrTable(); 702 703 std::error_code readFuncMetadata(bool ProfileHasAttribute); 704 std::error_code readFuncMetadata(bool ProfileHasAttribute, 705 FunctionSamples *FProfile); 706 std::error_code readFuncOffsetTable(); 707 std::error_code readFuncProfiles(); 708 std::error_code readMD5NameTable(); 709 std::error_code readNameTableSec(bool IsMD5); 710 std::error_code readCSNameTableSec(); 711 std::error_code readProfileSymbolList(); 712 713 std::error_code readHeader() override; 714 std::error_code verifySPMagic(uint64_t Magic) override = 0; 715 virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size, 716 const SecHdrTableEntry &Entry); 717 // placeholder for subclasses to dispatch their own section readers. 718 virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry) = 0; 719 ErrorOr<StringRef> readStringFromTable() override; 720 ErrorOr<SampleContext> readSampleContextFromTable() override; 721 ErrorOr<SampleContextFrames> readContextFromTable(); 722 723 std::unique_ptr<ProfileSymbolList> ProfSymList; 724 725 /// The table mapping from function context to the offset of its 726 /// FunctionSample towards file start. 727 DenseMap<SampleContext, uint64_t> FuncOffsetTable; 728 729 /// Function offset mapping ordered by contexts. 730 std::unique_ptr<std::vector<std::pair<SampleContext, uint64_t>>> 731 OrderedFuncOffsets; 732 733 /// The set containing the functions to use when compiling a module. 734 DenseSet<StringRef> FuncsToUse; 735 736 /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't 737 /// need to be read in up front and can be directly accessed using index. 738 bool FixedLengthMD5 = false; 739 /// The starting address of NameTable containing fixed length MD5. 740 const uint8_t *MD5NameMemStart = nullptr; 741 742 /// If MD5 is used in NameTable section, the section saves uint64_t data. 743 /// The uint64_t data has to be converted to a string and then the string 744 /// will be used to initialize StringRef in NameTable. 745 /// Note NameTable contains StringRef so it needs another buffer to own 746 /// the string data. MD5StringBuf serves as the string buffer that is 747 /// referenced by NameTable (vector of StringRef). We make sure 748 /// the lifetime of MD5StringBuf is not shorter than that of NameTable. 749 std::unique_ptr<std::vector<std::string>> MD5StringBuf; 750 751 /// CSNameTable is used to save full context vectors. This serves as an 752 /// underlying immutable buffer for all clients. 753 std::unique_ptr<const std::vector<SampleContextFrameVector>> CSNameTable; 754 755 /// If SkipFlatProf is true, skip the sections with 756 /// SecFlagFlat flag. 757 bool SkipFlatProf = false; 758 759 bool FuncOffsetsOrdered = false; 760 761 public: 762 SampleProfileReaderExtBinaryBase(std::unique_ptr<MemoryBuffer> B, 763 LLVMContext &C, SampleProfileFormat Format) 764 : SampleProfileReaderBinary(std::move(B), C, Format) {} 765 766 /// Read sample profiles in extensible format from the associated file. 767 std::error_code readImpl() override; 768 769 /// Get the total size of all \p Type sections. 770 uint64_t getSectionSize(SecType Type); 771 /// Get the total size of header and all sections. 772 uint64_t getFileSize(); 773 bool dumpSectionInfo(raw_ostream &OS = dbgs()) override; 774 775 /// Collect functions with definitions in Module M. Return true if 776 /// the reader has been given a module. 777 bool collectFuncsFromModule() override; 778 779 /// Return whether names in the profile are all MD5 numbers. 780 bool useMD5() override { return MD5StringBuf.get(); } 781 782 std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override { 783 return std::move(ProfSymList); 784 }; 785 786 void setSkipFlatProf(bool Skip) override { SkipFlatProf = Skip; } 787 }; 788 789 class SampleProfileReaderExtBinary : public SampleProfileReaderExtBinaryBase { 790 private: 791 std::error_code verifySPMagic(uint64_t Magic) override; 792 std::error_code readCustomSection(const SecHdrTableEntry &Entry) override { 793 // Update the data reader pointer to the end of the section. 794 Data = End; 795 return sampleprof_error::success; 796 }; 797 798 public: 799 SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C, 800 SampleProfileFormat Format = SPF_Ext_Binary) 801 : SampleProfileReaderExtBinaryBase(std::move(B), C, Format) {} 802 803 /// \brief Return true if \p Buffer is in the format supported by this class. 804 static bool hasFormat(const MemoryBuffer &Buffer); 805 }; 806 807 class SampleProfileReaderCompactBinary : public SampleProfileReaderBinary { 808 private: 809 /// Function name table. 810 std::vector<std::string> NameTable; 811 /// The table mapping from function name to the offset of its FunctionSample 812 /// towards file start. 813 DenseMap<StringRef, uint64_t> FuncOffsetTable; 814 /// The set containing the functions to use when compiling a module. 815 DenseSet<StringRef> FuncsToUse; 816 std::error_code verifySPMagic(uint64_t Magic) override; 817 std::error_code readNameTable() override; 818 /// Read a string indirectly via the name table. 819 ErrorOr<StringRef> readStringFromTable() override; 820 std::error_code readHeader() override; 821 std::error_code readFuncOffsetTable(); 822 823 public: 824 SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B, 825 LLVMContext &C) 826 : SampleProfileReaderBinary(std::move(B), C, SPF_Compact_Binary) {} 827 828 /// \brief Return true if \p Buffer is in the format supported by this class. 829 static bool hasFormat(const MemoryBuffer &Buffer); 830 831 /// Read samples only for functions to use. 832 std::error_code readImpl() override; 833 834 /// Collect functions with definitions in Module M. Return true if 835 /// the reader has been given a module. 836 bool collectFuncsFromModule() override; 837 838 /// Return whether names in the profile are all MD5 numbers. 839 bool useMD5() override { return true; } 840 }; 841 842 using InlineCallStack = SmallVector<FunctionSamples *, 10>; 843 844 // Supported histogram types in GCC. Currently, we only need support for 845 // call target histograms. 846 enum HistType { 847 HIST_TYPE_INTERVAL, 848 HIST_TYPE_POW2, 849 HIST_TYPE_SINGLE_VALUE, 850 HIST_TYPE_CONST_DELTA, 851 HIST_TYPE_INDIR_CALL, 852 HIST_TYPE_AVERAGE, 853 HIST_TYPE_IOR, 854 HIST_TYPE_INDIR_CALL_TOPN 855 }; 856 857 class SampleProfileReaderGCC : public SampleProfileReader { 858 public: 859 SampleProfileReaderGCC(std::unique_ptr<MemoryBuffer> B, LLVMContext &C) 860 : SampleProfileReader(std::move(B), C, SPF_GCC), 861 GcovBuffer(Buffer.get()) {} 862 863 /// Read and validate the file header. 864 std::error_code readHeader() override; 865 866 /// Read sample profiles from the associated file. 867 std::error_code readImpl() override; 868 869 /// Return true if \p Buffer is in the format supported by this class. 870 static bool hasFormat(const MemoryBuffer &Buffer); 871 872 protected: 873 std::error_code readNameTable(); 874 std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack, 875 bool Update, uint32_t Offset); 876 std::error_code readFunctionProfiles(); 877 std::error_code skipNextWord(); 878 template <typename T> ErrorOr<T> readNumber(); 879 ErrorOr<StringRef> readString(); 880 881 /// Read the section tag and check that it's the same as \p Expected. 882 std::error_code readSectionTag(uint32_t Expected); 883 884 /// GCOV buffer containing the profile. 885 GCOVBuffer GcovBuffer; 886 887 /// Function names in this profile. 888 std::vector<std::string> Names; 889 890 /// GCOV tags used to separate sections in the profile file. 891 static const uint32_t GCOVTagAFDOFileNames = 0xaa000000; 892 static const uint32_t GCOVTagAFDOFunction = 0xac000000; 893 }; 894 895 } // end namespace sampleprof 896 897 } // end namespace llvm 898 899 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H 900